mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-28 17:26:06 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/libcxx/include/regex

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

6848 lines
224 KiB
Plaintext
Raw Normal View History

Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
// -*- C++ -*-
[runtimes][NFC] Remove filenames at the top of the license notice We've stopped doing it in libc++ for a while now because these names would end up rotting as we move things around and copy/paste stuff. This cleans up all the existing files so as to stop the spreading as people copy-paste headers around.
2021-11-17 16:25:01 -05:00
//===----------------------------------------------------------------------===//
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
//
Update more file headers across all of the LLVM projects in the monorepo to reflect the new license. These used slightly different spellings that defeated my regular expressions. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351648
2019-01-19 10:56:40 +00:00
// 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
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_REGEX
#define _LIBCPP_REGEX
/*
regex synopsis
#include <initializer_list>
namespace std
{
namespace regex_constants
{
[libc++] Fix some typos in the comment header for <regex> No functional change because all the changed "code" is actually inside comments. Differential Revision: https://reviews.llvm.org/D82589
2020-06-25 15:31:03 -04:00
enum syntax_option_type
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
{
icase = unspecified,
nosubs = unspecified,
optimize = unspecified,
collate = unspecified,
ECMAScript = unspecified,
basic = unspecified,
extended = unspecified,
awk = unspecified,
grep = unspecified,
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
egrep = unspecified,
multiline = unspecified
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
};
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 <class charT>
struct regex_traits
{
public:
typedef charT char_type;
typedef basic_string<char_type> 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 <class ForwardIterator>
string_type
transform(ForwardIterator first, ForwardIterator last) const;
template <class ForwardIterator>
string_type
transform_primary( ForwardIterator first, ForwardIterator last) const;
template <class ForwardIterator>
string_type
lookup_collatename(ForwardIterator first, ForwardIterator last) const;
template <class ForwardIterator>
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 charT, class traits = regex_traits<charT>>
class basic_regex
{
public:
// types:
typedef charT value_type;
[libcxx] basic_regex: add traits_type, string_type Summary: In the synopsis in C++11 subclause 28.8 [re.regex], `basic_regex` is specified to have member typedefs `traits_type` and `string_type`. This change adds them to libc++. Reviewers: mclow.lists, rsmith, hubert.reinterpretcast Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D22698 Patch by Jason Liu! llvm-svn: 277526
2016-08-02 21:34:48 +00:00
typedef traits traits_type;
typedef typename traits::string_type string_type;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
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;
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
static constexpr regex_constants::syntax_option_type multiline = regex_constants::multiline;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
// construct/copy/destroy:
basic_regex();
explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript);
[libcxx] Add "flag" default arg: basic_regex ptr_size_flag ctor Summary: The synopsis in C++11 subclause 28.8 [re.regex] has: ``` basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript); ``` The default argument is added to libc++ by this change. Reviewers: mclow.lists, rsmith, hubert.reinterpretcast Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D22702 Reapplies r277966. Patch by Jason Liu! llvm-svn: 277968
2016-08-07 22:26:04 +00:00
basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript);
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
basic_regex(const basic_regex&);
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
basic_regex(basic_regex&&) noexcept;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
template <class ST, class SA>
explicit basic_regex(const basic_string<charT, ST, SA>& p,
flag_type f = regex_constants::ECMAScript);
template <class ForwardIterator>
basic_regex(ForwardIterator first, ForwardIterator last,
flag_type f = regex_constants::ECMAScript);
basic_regex(initializer_list<charT>, flag_type = regex_constants::ECMAScript);
~basic_regex();
basic_regex& operator=(const basic_regex&);
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
basic_regex& operator=(basic_regex&&) noexcept;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
basic_regex& operator=(const charT* ptr);
basic_regex& operator=(initializer_list<charT> il);
template <class ST, class SA>
basic_regex& operator=(const basic_string<charT, ST, SA>& p);
// assign:
basic_regex& assign(const basic_regex& that);
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
basic_regex& assign(basic_regex&& that) noexcept;
Add a missing default parameter to regex::assign. This is LWG3296; reviewed as https://reviews.llvm.org/D67944 llvm-svn: 372896
2019-09-25 16:40:30 +00:00
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);
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
template <class string_traits, class A>
basic_regex& assign(const basic_string<charT, string_traits, A>& s,
Add a missing default parameter to regex::assign. This is LWG3296; reviewed as https://reviews.llvm.org/D67944 llvm-svn: 372896
2019-09-25 16:40:30 +00:00
flag_type f = regex_constants::ECMAScript);
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
template <class InputIterator>
basic_regex& assign(InputIterator first, InputIterator last,
Add a missing default parameter to regex::assign. This is LWG3296; reviewed as https://reviews.llvm.org/D67944 llvm-svn: 372896
2019-09-25 16:40:30 +00:00
flag_type f = regex_constants::ECMAScript);
basic_regex& assign(initializer_list<charT>, flag_type f = regex_constants::ECMAScript);
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
// 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&);
};
Implement deduction guides for basic_regex llvm-svn: 333050
2018-05-23 01:57:02 +00:00
template<class ForwardIterator>
basic_regex(ForwardIterator, ForwardIterator,
regex_constants::syntax_option_type = regex_constants::ECMAScript)
-> basic_regex<typename iterator_traits<ForwardIterator>::value_type>; // C++17
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
typedef basic_regex<char> regex;
typedef basic_regex<wchar_t> wregex;
template <class charT, class traits>
void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2);
template <class BidirectionalIterator>
class sub_match
: public pair<BidirectionalIterator, BidirectionalIterator>
{
public:
typedef typename iterator_traits<BidirectionalIterator>::value_type value_type;
typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
typedef BidirectionalIterator iterator;
typedef basic_string<value_type> string_type;
bool matched;
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-08 21:07:55 +00:00
constexpr sub_match();
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
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<const char*> csub_match;
typedef sub_match<const wchar_t*> wcsub_match;
typedef sub_match<string::const_iterator> ssub_match;
typedef sub_match<wstring::const_iterator> wssub_match;
template <class BiIter>
bool
operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator<(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator<=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
template <class BiIter, class ST, class SA>
bool
operator==(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
const sub_match<BiIter>& rhs);
template <class BiIter, class ST, class SA>
bool
operator!=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
const sub_match<BiIter>& rhs);
template <class BiIter, class ST, class SA>
bool
operator<(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
const sub_match<BiIter>& rhs);
template <class BiIter, class ST, class SA>
bool
operator>(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
const sub_match<BiIter>& rhs);
template <class BiIter, class ST, class SA>
bool operator>=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
const sub_match<BiIter>& rhs);
template <class BiIter, class ST, class SA>
bool
operator<=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
const sub_match<BiIter>& rhs);
template <class BiIter, class ST, class SA>
bool
operator==(const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
template <class BiIter, class ST, class SA>
bool
operator!=(const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
template <class BiIter, class ST, class SA>
bool
operator<(const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
template <class BiIter, class ST, class SA>
bool operator>(const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
template <class BiIter, class ST, class SA>
bool
operator>=(const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
template <class BiIter, class ST, class SA>
bool
operator<=(const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
template <class BiIter>
bool
operator==(typename iterator_traits<BiIter>::value_type const* lhs,
const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator!=(typename iterator_traits<BiIter>::value_type const* lhs,
const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator<(typename iterator_traits<BiIter>::value_type const* lhs,
const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator>(typename iterator_traits<BiIter>::value_type const* lhs,
const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator>=(typename iterator_traits<BiIter>::value_type const* lhs,
const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator<=(typename iterator_traits<BiIter>::value_type const* lhs,
const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator==(const sub_match<BiIter>& lhs,
typename iterator_traits<BiIter>::value_type const* rhs);
template <class BiIter>
bool
operator!=(const sub_match<BiIter>& lhs,
typename iterator_traits<BiIter>::value_type const* rhs);
template <class BiIter>
bool
operator<(const sub_match<BiIter>& lhs,
typename iterator_traits<BiIter>::value_type const* rhs);
template <class BiIter>
bool
operator>(const sub_match<BiIter>& lhs,
typename iterator_traits<BiIter>::value_type const* rhs);
template <class BiIter>
bool
operator>=(const sub_match<BiIter>& lhs,
typename iterator_traits<BiIter>::value_type const* rhs);
template <class BiIter>
bool
operator<=(const sub_match<BiIter>& lhs,
typename iterator_traits<BiIter>::value_type const* rhs);
template <class BiIter>
bool
operator==(typename iterator_traits<BiIter>::value_type const& lhs,
const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator!=(typename iterator_traits<BiIter>::value_type const& lhs,
const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator<(typename iterator_traits<BiIter>::value_type const& lhs,
const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator>(typename iterator_traits<BiIter>::value_type const& lhs,
const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator>=(typename iterator_traits<BiIter>::value_type const& lhs,
const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator<=(typename iterator_traits<BiIter>::value_type const& lhs,
const sub_match<BiIter>& rhs);
template <class BiIter>
bool
operator==(const sub_match<BiIter>& lhs,
typename iterator_traits<BiIter>::value_type const& rhs);
template <class BiIter>
bool
operator!=(const sub_match<BiIter>& lhs,
typename iterator_traits<BiIter>::value_type const& rhs);
template <class BiIter>
bool
operator<(const sub_match<BiIter>& lhs,
typename iterator_traits<BiIter>::value_type const& rhs);
template <class BiIter>
bool
operator>(const sub_match<BiIter>& lhs,
typename iterator_traits<BiIter>::value_type const& rhs);
template <class BiIter>
bool
operator>=(const sub_match<BiIter>& lhs,
typename iterator_traits<BiIter>::value_type const& rhs);
template <class BiIter>
bool
operator<=(const sub_match<BiIter>& lhs,
typename iterator_traits<BiIter>::value_type const& rhs);
template <class charT, class ST, class BiIter>
basic_ostream<charT, ST>&
operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
template <class BidirectionalIterator,
class Allocator = allocator<sub_match<BidirectionalIterator>>>
class match_results
{
public:
typedef sub_match<BidirectionalIterator> value_type;
typedef const value_type& const_reference;
Implement LWG issue 2306: match_results::reference should be value_type&, not const value_type&. This is a general move by the LWG to have the reference type of read-only containers be a non-const reference; however, there are no methods that return a non-const reference to a match_result entry, so there's no worries about getting a non-const reference to a constant object. llvm-svn: 202214
2014-02-26 01:56:31 +00:00
typedef value_type& reference;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
typedef /implementation-defined/ const_iterator;
typedef const_iterator iterator;
typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
typedef typename allocator_traits<Allocator>::size_type size_type;
typedef Allocator allocator_type;
typedef typename iterator_traits<BidirectionalIterator>::value_type char_type;
typedef basic_string<char_type> string_type;
// construct/copy/destroy:
[libc++] [P0935] [C++20] Eradicating unnecessarily explicit default constructors from the standard library. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0935r0.html Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D91292
2021-01-19 08:21:09 +01:00
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
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
match_results(const match_results& m);
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
match_results(match_results&& m) noexcept;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
match_results& operator=(const match_results& m);
match_results& operator=(match_results&& m);
~match_results();
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-08 21:07:55 +00:00
bool ready() const;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
// 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 <class OutputIter>
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 <class OutputIter, class ST, class SA>
OutputIter
format(OutputIter out, const basic_string<char_type, ST, SA>& fmt,
regex_constants::match_flag_type flags = regex_constants::format_default) const;
template <class ST, class SA>
basic_string<char_type, ST, SA>
format(const basic_string<char_type, ST, SA>& 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<const char*> cmatch;
typedef match_results<const wchar_t*> wcmatch;
typedef match_results<string::const_iterator> smatch;
typedef match_results<wstring::const_iterator> wsmatch;
template <class BidirectionalIterator, class Allocator>
bool
operator==(const match_results<BidirectionalIterator, Allocator>& m1,
const match_results<BidirectionalIterator, Allocator>& m2);
template <class BidirectionalIterator, class Allocator>
bool
operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
const match_results<BidirectionalIterator, Allocator>& m2);
template <class BidirectionalIterator, class Allocator>
void
swap(match_results<BidirectionalIterator, Allocator>& m1,
match_results<BidirectionalIterator, Allocator>& m2);
template <class BidirectionalIterator, class Allocator, class charT, class traits>
bool
regex_match(BidirectionalIterator first, BidirectionalIterator last,
match_results<BidirectionalIterator, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class BidirectionalIterator, class charT, class traits>
bool
regex_match(BidirectionalIterator first, BidirectionalIterator last,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class charT, class Allocator, class traits>
bool
regex_match(const charT* str, match_results<const charT*, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class ST, class SA, class Allocator, class charT, class traits>
bool
regex_match(const basic_string<charT, ST, SA>& s,
match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
template <class ST, class SA, class Allocator, class charT, class traits>
bool
regex_match(const basic_string<charT, ST, SA>&& s,
match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
template <class charT, class traits>
bool
regex_match(const charT* str, const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class ST, class SA, class charT, class traits>
bool
regex_match(const basic_string<charT, ST, SA>& s,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class BidirectionalIterator, class Allocator, class charT, class traits>
bool
regex_search(BidirectionalIterator first, BidirectionalIterator last,
match_results<BidirectionalIterator, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class BidirectionalIterator, class charT, class traits>
bool
regex_search(BidirectionalIterator first, BidirectionalIterator last,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class charT, class Allocator, class traits>
bool
regex_search(const charT* str, match_results<const charT*, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class charT, class traits>
bool
regex_search(const charT* str, const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class ST, class SA, class charT, class traits>
bool
regex_search(const basic_string<charT, ST, SA>& s,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class ST, class SA, class Allocator, class charT, class traits>
bool
regex_search(const basic_string<charT, ST, SA>& s,
match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
template <class ST, class SA, class Allocator, class charT, class traits>
bool
regex_search(const basic_string<charT, ST, SA>&& s,
match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
template <class OutputIterator, class BidirectionalIterator,
class traits, class charT, class ST, class SA>
OutputIterator
regex_replace(OutputIterator out,
BidirectionalIterator first, BidirectionalIterator last,
const basic_regex<charT, traits>& e,
const basic_string<charT, ST, SA>& fmt,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class OutputIterator, class BidirectionalIterator,
class traits, class charT>
OutputIterator
regex_replace(OutputIterator out,
BidirectionalIterator first, BidirectionalIterator last,
const basic_regex<charT, traits>& e, const charT* fmt,
regex_constants::match_flag_type flags = regex_constants::match_default);
[libc++] Fix some typos in the comment header for <regex> No functional change because all the changed "code" is actually inside comments. Differential Revision: https://reviews.llvm.org/D82589
2020-06-25 15:31:03 -04:00
template <class traits, class charT, class ST, class SA, class FST, class FSA>
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
basic_string<charT, ST, SA>
regex_replace(const basic_string<charT, ST, SA>& s,
const basic_regex<charT, traits>& e,
const basic_string<charT, FST, FSA>& fmt,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class traits, class charT, class ST, class SA>
basic_string<charT, ST, SA>
regex_replace(const basic_string<charT, ST, SA>& s,
const basic_regex<charT, traits>& e, const charT* fmt,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class traits, class charT, class ST, class SA>
basic_string<charT>
regex_replace(const charT* s,
const basic_regex<charT, traits>& e,
const basic_string<charT, ST, SA>& fmt,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class traits, class charT>
basic_string<charT>
regex_replace(const charT* s,
const basic_regex<charT, traits>& e,
const charT* fmt,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class BidirectionalIterator,
class charT = typename iterator_traits< BidirectionalIterator>::value_type,
class traits = regex_traits<charT>>
class regex_iterator
{
public:
typedef basic_regex<charT, traits> regex_type;
typedef match_results<BidirectionalIterator> 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);
[libc++] Fix some typos in the comment header for <regex> No functional change because all the changed "code" is actually inside comments. Differential Revision: https://reviews.llvm.org/D82589
2020-06-25 15:31:03 -04:00
regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
const regex_type&& re,
regex_constants::match_flag_type m
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
= regex_constants::match_default) = delete; // C++14
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
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<const char*> cregex_iterator;
typedef regex_iterator<const wchar_t*> wcregex_iterator;
typedef regex_iterator<string::const_iterator> sregex_iterator;
typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
template <class BidirectionalIterator,
[libc++] Fix some typos in the comment header for <regex> No functional change because all the changed "code" is actually inside comments. Differential Revision: https://reviews.llvm.org/D82589
2020-06-25 15:31:03 -04:00
class charT = typename iterator_traits<BidirectionalIterator>::value_type,
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
class traits = regex_traits<charT>>
class regex_token_iterator
{
public:
typedef basic_regex<charT, traits> regex_type;
typedef sub_match<BidirectionalIterator> 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);
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
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
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
const regex_type& re, const vector<int>& submatches,
regex_constants::match_flag_type m = regex_constants::match_default);
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
const regex_type&& re, const vector<int>& submatches,
regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
const regex_type& re, initializer_list<int> submatches,
regex_constants::match_flag_type m = regex_constants::match_default);
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
const regex_type&& re, initializer_list<int> submatches,
regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
template <size_t N>
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);
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
template <size_t N>
regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
[libc++] Fix some typos in the comment header for <regex> No functional change because all the changed "code" is actually inside comments. Differential Revision: https://reviews.llvm.org/D82589
2020-06-25 15:31:03 -04:00
const regex_type&& re, const int (&submatches)[N],
regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
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<const char*> cregex_token_iterator;
typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
} // std
*/
[libc++] Granularize algorithm includes Reviewed By: Mordante, ldionne, Quuxplusone, #libc, #libc_abi Spies: #libc_vendors, libcxx-commits, miyuki Differential Revision: https://reviews.llvm.org/D119667
2022-02-15 18:18:08 +01:00
#include <__algorithm/find.h>
[libc++] Granularize <functional> includes Reviewed By: Mordante, #libc Spies: libcxx-commits, miyuki Differential Revision: https://reviews.llvm.org/D123912
2022-04-17 16:01:38 +02:00
#include <__algorithm/search.h>
[libc++] Ensure that all public C++ headers include <__assert> This patch changes the requirement for getting the declaration of the assertion handler from including <__assert> to including any public C++ header of the library. Note that C compatibility headers are excluded because we don't implement all the C headers ourselves -- some of them are taken straight from the C library, like assert.h. It also adds a generated test to check it. Furthermore, this new generated test is designed in a way that will make it possible to replace almost all the existing test-generation scripts with this system in upcoming patches. Differential Revision: https://reviews.llvm.org/D122506
2022-03-25 12:55:36 -04:00
#include <__assert> // all public C++ headers provide the assertion handler
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
#include <__config>
[libc++] Granularize <iterator> includes Reviewed By: ldionne, #libc Spies: libcxx-commits, wenlei Differential Revision: https://reviews.llvm.org/D127445
2022-06-10 19:53:10 +02:00
#include <__iterator/back_insert_iterator.h>
[libc++] Split the various iterator types out of <iterator> Differential Revision: https://reviews.llvm.org/D104669
2021-06-11 09:55:11 -04:00
#include <__iterator/wrap_iter.h>
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
#include <__locale>
[libc++] Granularize <utility> includes Reviewed By: ldionne, #libc Spies: EricWF, libcxx-commits, arphaman Differential Revision: https://reviews.llvm.org/D120466
2022-03-05 19:17:07 +01:00
#include <__utility/move.h>
#include <__utility/swap.h>
[libc++] Alphabetize header inclusions and include-what-you-use <__debug>. NFCI.
2021-05-12 23:04:03 -04:00
#include <deque>
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
#include <memory>
[libc++] Alphabetize header inclusions and include-what-you-use <__debug>. NFCI.
2021-05-12 23:04:03 -04:00
#include <stdexcept>
#include <string>
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
#include <vector>
Implement the infrastructure for feature-test macros. Very few actual feature test macros, though. Reviewed as: https://reviews.llvm.org/D51955 llvm-svn: 342073
2018-09-12 19:41:40 +00:00
#include <version>
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
[libc++] Re-add transitive includes that had been removed since LLVM 14 This commit re-adds transitive includes that had been removed by 4cd04d1687f1, c36870c8e79c, a83f4b9cda57, 1458458b558d, 2e2f3158c604, and 489637e66dd3. This should cover almost all the includes that had been removed since LLVM 14 and that would contribute to breaking user code when releasing LLVM 15. It is possible to disable the inclusion of these headers by defining _LIBCPP_REMOVE_TRANSITIVE_INCLUDES. The intent is that vendors will enable that macro and start fixing downstream issues immediately. We can then remove the macro (and the transitive includes) by default in a future release. That way, we will break users only once by removing transitive includes in bulk instead of doing it bit by bit a every release, which is more disruptive for users. Note 1: The set of headers to re-add was found by re-generating the transitive include test on a checkout of release/14.x, which provided the list of all transitive includes we used to provide. Note 2: Several includes of <vector>, <optional>, <array> and <unordered_map> have been added in this commit. These transitive inclusions were added when we implemented boyer_moore_searcher in <functional>. Note 3: This is a best effort patch to try and resolve downstream breakage caused since branching LLVM 14. I wasn't able to perfectly mirror transitive includes in LLVM 14 for a few headers, so I added a release note explaining it. To summarize, adding boyer_moore_searcher created a bunch of circular dependencies, so we have to break backwards compatibility in a few cases. Differential Revision: https://reviews.llvm.org/D128661
2022-06-27 15:53:41 -04:00
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iterator>
# include <utility>
#endif
[libc++] Mark standard-mandated includes as such Reviewed By: ldionne, Mordante, #libc, saugustine Spies: saugustine, MaskRay, arichardson, mstorsjo, jloser, libcxx-commits, arphaman Differential Revision: https://reviews.llvm.org/D127953
2022-06-16 22:43:46 +02:00
// standard-mandated includes
// [iterator.range]
#include <__iterator/access.h>
#include <__iterator/data.h>
#include <__iterator/empty.h>
#include <__iterator/reverse_access.h>
#include <__iterator/size.h>
// [re.syn]
#include <compare>
#include <initializer_list>
Windows support by Ruben Van Boxem. llvm-svn: 142235
2011-10-17 20:05:10 +00:00
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
[libc++] Normalize all our '#pragma GCC system_header', and regression-test. Now we'll notice if a header forgets to include this magic phrase. Differential Revision: https://reviews.llvm.org/D118800
2022-02-01 20:16:40 -05:00
# pragma GCC system_header
Windows support by Ruben Van Boxem. llvm-svn: 142235
2011-10-17 20:05:10 +00:00
#endif
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
[Libc++] Use #pragma push_macro/pop_macro to better handle min/max on Windows Summary: This patch improves how libc++ handles min/max macros within the headers. Previously libc++ would undef them and emit a warning. This patch changes libc++ to use `#pragma push_macro` to save the macro before undefining it, and `#pragma pop_macro` to restore the macros and the end of the header. Reviewers: mclow.lists, bcraig, compnerd, EricWF Reviewed By: EricWF Subscribers: cfe-commits, krytarowski Differential Revision: https://reviews.llvm.org/D33080 llvm-svn: 304357
2017-05-31 22:07:49 +00:00
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
Apply D28224: 'Throw exception after too many steps' Fixes PR#20291. Thanks to Tim Shen for the patch llvm-svn: 313056
2017-09-12 17:56:59 +00:00
#define _LIBCPP_REGEX_COMPLEXITY_FACTOR 4096
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
_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,
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
#ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
ECMAScript = 1 << 9,
#else
continued regex development... llvm-svn: 109512
2010-07-27 17:24:17 +00:00
ECMAScript = 0,
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
#endif
continued regex development... llvm-svn: 109512
2010-07-27 17:24:17 +00:00
basic = 1 << 4,
extended = 1 << 5,
awk = 1 << 6,
grep = 1 << 7,
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
egrep = 1 << 8,
// 1 << 9 may be used by ECMAScript
multiline = 1 << 10
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
};
[libc++] Add a bunch of missing _LIBCPP_HIDE_FROM_ABI Reviewed By: ldionne, Mordante, var-const, huixie90, #libc Spies: jloser, libcxx-commits, arichardson, miyuki Differential Revision: https://reviews.llvm.org/D129968
2022-08-13 13:23:16 +02:00
_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
syntax_option_type __get_grammar(syntax_option_type __g)
{
#ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
return static_cast<syntax_option_type>(__g & 0x3F0);
#else
return static_cast<syntax_option_type>(__g & 0x1F0);
#endif
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
syntax_option_type
operator~(syntax_option_type __x)
{
Fix undefined behavior in syntax_option_type::operator~ and match_flag_type::operator./a.out Found by UBSan llvm-svn: 177693
2013-03-22 02:13:55 +00:00
return syntax_option_type(~int(__x) & 0x1FF);
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
syntax_option_type
operator&(syntax_option_type __x, syntax_option_type __y)
{
return syntax_option_type(int(__x) & int(__y));
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
syntax_option_type
operator|(syntax_option_type __x, syntax_option_type __y)
{
return syntax_option_type(int(__x) | int(__y));
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
syntax_option_type
operator^(syntax_option_type __x, syntax_option_type __y)
{
return syntax_option_type(int(__x) ^ int(__y));
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
inline _LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
syntax_option_type&
operator&=(syntax_option_type& __x, syntax_option_type __y)
{
__x = __x & __y;
return __x;
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
inline _LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
syntax_option_type&
operator|=(syntax_option_type& __x, syntax_option_type __y)
{
__x = __x | __y;
return __x;
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
inline _LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
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,
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
format_first_only = 1 << 10,
[libcxx] Make regex_match backtrack when search fails Summary: Fixes PR19851. alg.re.match/ecma.pass.cpp still XFAILS on linux, but after commenting out locale-related tests, it passes. I don't have a freebsd machine to produce a full pass. Reviewers: mclow.lists Subscribers: cfe-commits, emaste Differential Revision: https://reviews.llvm.org/D26026 llvm-svn: 285352
2016-10-27 21:40:34 +00:00
__no_update_pos = 1 << 11,
__full_match = 1 << 12
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
};
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
match_flag_type
operator~(match_flag_type __x)
{
Fix undefined behavior in syntax_option_type::operator~ and match_flag_type::operator./a.out Found by UBSan llvm-svn: 177693
2013-03-22 02:13:55 +00:00
return match_flag_type(~int(__x) & 0x0FFF);
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
match_flag_type
operator&(match_flag_type __x, match_flag_type __y)
{
return match_flag_type(int(__x) & int(__y));
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
match_flag_type
operator|(match_flag_type __x, match_flag_type __y)
{
return match_flag_type(int(__x) | int(__y));
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
match_flag_type
operator^(match_flag_type __x, match_flag_type __y)
{
return match_flag_type(int(__x) ^ int(__y));
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
inline _LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
match_flag_type&
operator&=(match_flag_type& __x, match_flag_type __y)
{
__x = __x & __y;
return __x;
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
inline _LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
match_flag_type&
operator|=(match_flag_type& __x, match_flag_type __y)
{
__x = __x | __y;
return __x;
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
inline _LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
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,
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
error_stack,
continued regex development... llvm-svn: 109512
2010-07-27 17:24:17 +00:00
__re_err_grammar,
__re_err_empty,
[libc++] Validate the entire regex is consumed This change would have warned about the bug found in D62451. No unit tests since the exception should never throw. Differential Revision: https://reviews.llvm.org/D62452
2019-11-09 17:01:37 +01:00
__re_err_unknown,
__re_err_parse
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
};
[libc++][NFC] Update namespace comments in include/ update the namspace comments in include/ Reviewed By: ldionne, #libc Spies: smeenai, libcxx-commits Differential Revision: https://reviews.llvm.org/D114947
2021-12-02 14:12:51 +01:00
} // namespace regex_constants
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
class _LIBCPP_EXCEPTION_ABI regex_error
: public runtime_error
{
regex_constants::error_type __code_;
public:
explicit regex_error(regex_constants::error_type __ecode);
Fix -Wdeprecated-copy-dtor and -Wdeprecated-dynamic-exception-spec warnings. Summary: The former are like: libcxx/include/typeinfo:322:11: warning: definition of implicit copy constructor for 'bad_cast' is deprecated because it has a user-declared destructor [-Wdeprecated-copy-dtor] virtual ~bad_cast() _NOEXCEPT; ^ libcxx/include/typeinfo:344:11: note: in implicit copy constructor for 'std::bad_cast' first required here throw bad_cast(); ^ Fix these by adding an explicitly defaulted copy constructor. The latter are like: libcxx/include/codecvt:105:37: warning: dynamic exception specifications are deprecated [-Wdeprecated-dynamic-exception-spec] virtual int do_encoding() const throw(); ^~~~~~~ Fix these by using the _NOEXCEPT macro instead. Reviewers: EricWF, mclow.lists, ldionne, #libc Reviewed By: EricWF, #libc Subscribers: dexonsmith, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D76150
2020-03-13 19:36:26 +01:00
regex_error(const regex_error&) _NOEXCEPT = default;
virtual ~regex_error() _NOEXCEPT;
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
regex_constants::error_type code() const {return __code_;}
};
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
template <regex_constants::error_type _Ev>
[libc++] Take 2: Replace uses of _LIBCPP_ALWAYS_INLINE by _LIBCPP_INLINE_VISIBILITY Summary: We never actually mean to always inline a function -- all the uses of the macro I could find are actually attempts to control the visibility of symbols. This is better described by _LIBCPP_INLINE_VISIBILITY, which is actually always defined the same. This change is orthogonal to the decision of what we're actually going to do with _LIBCPP_INLINE_VISIBILITY -- it just simplifies things by having one canonical way of doing things. Note that this commit had originally been applied in r336369 and then reverted in r336382 because of unforeseen problems. Both of these problems have now been fixed. Reviewers: EricWF, mclow.lists Subscribers: christof, dexonsmith, erikvanderpoel Differential Revision: https://reviews.llvm.org/D48892 llvm-svn: 336866
2018-07-11 23:14:33 +00:00
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
void __throw_regex_error()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
Make regex and any assert when they should throw an exception _but_ the user has decreed 'no exceptions'. This matches the behavior of string and vector llvm-svn: 245239
2015-08-17 21:14:16 +00:00
throw regex_error(_Ev);
#else
Add an _LIBCPP_NORETURN inline function named __throw_XXX for each exception type we define. They either construct and throw the exception, or abort() (if exceptions are disabled). Use these functions everywhere instead of assert()ing when exceptions are disabled. WARNING: This is a behavior change - but only with exceptions disabled. Reviewed as: https://reviews.llvm.org/D23855. llvm-svn: 279744
2016-08-25 15:09:01 +00:00
_VSTD::abort();
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
#endif
}
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
template <class _CharT>
[NFC] Rename _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS The name _LIBCPP_TYPE_VIS_ONLY is no longer accurate because both _LIBCPP_TYPE_VIS and _LIBCPP_TYPE_VIS_ONLY expand to __attribute__((__type_visibility__)) with Clang. The only remaining difference is that _LIBCPP_TYPE_VIS_ONLY can be applied to templates whereas _LIBCPP_TYPE_VIS cannot (due to dllimport/dllexport not being allowed on templates). This patch renames _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS. llvm-svn: 291035
2017-01-04 23:56:00 +00:00
struct _LIBCPP_TEMPLATE_VIS regex_traits
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
{
public:
typedef _CharT char_type;
typedef basic_string<char_type> string_type;
typedef locale locale_type;
Upstream Bionic definitions of ctype_base/regex. Summary: This is a patch that Android has been carrying in its tree for several years. This patch upstreams the existing ABI. There's some historical cruft here. __regex_word used to be a part of regex_traits rather than ctype_base. Bionic also used to use its own ctype implementation because the libc++ builtin one wasn't available yet. Bionic's ctype masks were 8 bits wide and already saturated, so a wider type needed to be used for the regex mask, and the existing value was already used so Android needed to specify its own. Since then Android has migrated to the builtin ctype implementation and this patch probably should have been dropped then. Unfortunately that was not noticed at the time, so now we need to keep this to maintain the current ABI. Reviewers: EricWF, #libc, ldionne Reviewed By: #libc, ldionne Subscribers: dexonsmith, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D76171
2020-04-06 13:34:27 -07:00
#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
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
typedef ctype_base::mask char_class_type;
Upstream Bionic definitions of ctype_base/regex. Summary: This is a patch that Android has been carrying in its tree for several years. This patch upstreams the existing ABI. There's some historical cruft here. __regex_word used to be a part of regex_traits rather than ctype_base. Bionic also used to use its own ctype implementation because the libc++ builtin one wasn't available yet. Bionic's ctype masks were 8 bits wide and already saturated, so a wider type needed to be used for the regex mask, and the existing value was already used so Android needed to specify its own. Since then Android has migrated to the builtin ctype implementation and this patch probably should have been dropped then. Unfortunately that was not noticed at the time, so now we need to keep this to maintain the current ABI. Reviewers: EricWF, #libc, ldionne Reviewed By: #libc, ldionne Subscribers: dexonsmith, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D76171
2020-04-06 13:34:27 -07:00
#endif
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
[libc++] Keep __regex_word in sync with ctype_base Summary: The class ctype_base in the header <__locale> contains masks for character classification functions, which are kept in sync with platform's C library, hence it contains many special cases. The value of the bit mask __regex_word in the header <regex> must not clash with those bit masks. Currently the default case (i.e. unknown platform/C library) is handled incorrectly: the __regex_word clashes with ctype_base::punct. To avoid replicating the whole list of platforms in <regex> this patch defines __regex_word in <__locale>, so that it is always kept in sync with other masks. Reviewers: ldionne, mclow.lists, EricWF Reviewed By: ldionne Subscribers: krytarowski, christof, dexonsmith, pbarrio, simon_tatham, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D63284 llvm-svn: 363363
2019-06-14 09:04:16 +00:00
static const char_class_type __regex_word = ctype_base::__regex_word;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
private:
locale __loc_;
const ctype<char_type>* __ct_;
const collate<char_type>* __col_;
public:
regex_traits();
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
static size_t length(const char_type* __p)
{return char_traits<char_type>::length(__p);}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
char_type translate(char_type __c) const {return __c;}
char_type translate_nocase(char_type __c) const;
template <class _ForwardIterator>
string_type
transform(_ForwardIterator __f, _ForwardIterator __l) const;
template <class _ForwardIterator>
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
string_type
transform_primary( _ForwardIterator __f, _ForwardIterator __l) const
{return __transform_primary(__f, __l, char_type());}
template <class _ForwardIterator>
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
string_type
lookup_collatename(_ForwardIterator __f, _ForwardIterator __l) const
{return __lookup_collatename(__f, __l, char_type());}
template <class _ForwardIterator>
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
char_class_type
lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
bool __icase = false) const
{return __lookup_classname(__f, __l, __icase, char_type());}
bool isctype(char_type __c, char_class_type __m) const;
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
int value(char_type __ch, int __radix) const
Patch by GM: apparently '__value' (two underscores) is a special name in Visual Studio, so rename the private method in <regex> with that name. GM's patch used '___value' (three underscores), but I changed that to '__regex_traits_value' because I've been burned in the past by identifiers that appear identical but are not. llvm-svn: 193087
2013-10-21 15:43:25 +00:00
{return __regex_traits_value(__ch, __radix);}
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
locale_type imbue(locale_type __l);
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
locale_type getloc()const {return __loc_;}
private:
void __init();
template <class _ForwardIterator>
string_type
__transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
template <class _ForwardIterator>
string_type
__transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#endif
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
template <class _ForwardIterator>
string_type
__lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
template <class _ForwardIterator>
string_type
__lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#endif
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
template <class _ForwardIterator>
char_class_type
__lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
bool __icase, char) const;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
template <class _ForwardIterator>
char_class_type
__lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
bool __icase, wchar_t) const;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#endif
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
Patch by GM: apparently '__value' (two underscores) is a special name in Visual Studio, so rename the private method in <regex> with that name. GM's patch used '___value' (three underscores), but I changed that to '__regex_traits_value' because I've been burned in the past by identifiers that appear identical but are not. llvm-svn: 193087
2013-10-21 15:43:25 +00:00
static int __regex_traits_value(unsigned char __ch, int __radix);
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Patch by GM: apparently '__value' (two underscores) is a special name in Visual Studio, so rename the private method in <regex> with that name. GM's patch used '___value' (three underscores), but I changed that to '__regex_traits_value' because I've been burned in the past by identifiers that appear identical but are not. llvm-svn: 193087
2013-10-21 15:43:25 +00:00
int __regex_traits_value(char __ch, int __radix) const
{return __regex_traits_value(static_cast<unsigned char>(__ch), __radix);}
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
Cleanup: move visibility/linkage attributes to the first declaration. This change moves visibility attributes from out-of-class method definitions to in-class declaration. This is needed for a switch to attribute((internal_linkage)) (see http://reviews.llvm.org/D13925) which can only appear on the first declaration. This change does not touch istream/ostream/streambuf. They are handled separately in http://reviews.llvm.org/D14409. llvm-svn: 252385
2015-11-07 01:22:13 +00:00
_LIBCPP_INLINE_VISIBILITY
Patch by GM: apparently '__value' (two underscores) is a special name in Visual Studio, so rename the private method in <regex> with that name. GM's patch used '___value' (three underscores), but I changed that to '__regex_traits_value' because I've been burned in the past by identifiers that appear identical but are not. llvm-svn: 193087
2013-10-21 15:43:25 +00:00
int __regex_traits_value(wchar_t __ch, int __radix) const;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#endif
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
};
Albert Wong: definition for regex_traits<_CharT>::__regex_word. llvm-svn: 176640
2013-03-07 19:38:08 +00:00
template <class _CharT>
const typename regex_traits<_CharT>::char_class_type
regex_traits<_CharT>::__regex_word;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
template <class _CharT>
regex_traits<_CharT>::regex_traits()
{
__init();
}
template <class _CharT>
typename regex_traits<_CharT>::char_type
regex_traits<_CharT>::translate_nocase(char_type __c) const
{
return __ct_->tolower(__c);
}
template <class _CharT>
template <class _ForwardIterator>
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 <class _CharT>
void
regex_traits<_CharT>::__init()
{
__ct_ = &use_facet<ctype<char_type> >(__loc_);
__col_ = &use_facet<collate<char_type> >(__loc_);
}
template <class _CharT>
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 <class _CharT>
template <class _ForwardIterator>
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;
}
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
template <class _CharT>
template <class _ForwardIterator>
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;
}
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#endif
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
// lookup_collatename is very FreeBSD-specific
Nico Rieck: this patch series fixes visibility issues on Windows as explained in <http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-August/031214.html>. llvm-svn: 188192
2013-08-12 18:38:34 +00:00
_LIBCPP_FUNC_VIS string __get_collation_name(const char* __s);
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
template <class _CharT>
template <class _ForwardIterator>
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;
}
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
template <class _CharT>
template <class _ForwardIterator>
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<unsigned>(*__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;
}
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
// lookup_classname
Base regex code on char_class_type. __get_classname() and __bracket_expression were assuming that char_class_type was ctype_base::mask rather than using regex_traits<_CharT>::char_class_type. This change allows char_class_type to be defined to something other than ctype_base::mask so that the implementation will still work for platforms with an 8-bit ctype mask (such as Android and OpenBSD). llvm-svn: 214201
2014-07-29 19:23:39 +00:00
regex_traits<char>::char_class_type _LIBCPP_FUNC_VIS
__get_classname(const char* __s, bool __icase);
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
template <class _CharT>
template <class _ForwardIterator>
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);
}
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
template <class _CharT>
template <class _ForwardIterator>
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<unsigned>(*__i) >= 127)
return char_class_type();
__n.push_back(char(*__i));
}
return __get_classname(__n.c_str(), __icase);
}
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
template <class _CharT>
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));
}
[SystemZ][z/OS] ASCII/EBCDIC support with no coexistence The aim of this patch is to break up the larger patch (https://reviews.llvm.org/D111323) to be more upstream friendly. In particular, this patch adds the char encoding sensitive changes but does not use inline namespaces as before. The use of namespaces to build both versions of the library, and localization of error messages will follow in a subsequent patch. Differential Revision: https://reviews.llvm.org/D114813
2022-01-14 11:35:53 -05:00
inline _LIBCPP_INLINE_VISIBILITY
[libc++] Make parameter names consistent and enforce the naming style using readability-identifier-naming Ensure that parameter names have the style `__lower_case` Reviewed By: ldionne, #libc Spies: aheejin, sstefan1, libcxx-commits, miyuki Differential Revision: https://reviews.llvm.org/D129051
2022-07-08 18:17:26 +02:00
bool __is_07(unsigned char __c)
[SystemZ][z/OS] ASCII/EBCDIC support with no coexistence The aim of this patch is to break up the larger patch (https://reviews.llvm.org/D111323) to be more upstream friendly. In particular, this patch adds the char encoding sensitive changes but does not use inline namespaces as before. The use of namespaces to build both versions of the library, and localization of error messages will follow in a subsequent patch. Differential Revision: https://reviews.llvm.org/D114813
2022-01-14 11:35:53 -05:00
{
[libc++] Make parameter names consistent and enforce the naming style using readability-identifier-naming Ensure that parameter names have the style `__lower_case` Reviewed By: ldionne, #libc Spies: aheejin, sstefan1, libcxx-commits, miyuki Differential Revision: https://reviews.llvm.org/D129051
2022-07-08 18:17:26 +02:00
return (__c & 0xF8u) ==
[SystemZ][z/OS] ASCII/EBCDIC support with no coexistence The aim of this patch is to break up the larger patch (https://reviews.llvm.org/D111323) to be more upstream friendly. In particular, this patch adds the char encoding sensitive changes but does not use inline namespaces as before. The use of namespaces to build both versions of the library, and localization of error messages will follow in a subsequent patch. Differential Revision: https://reviews.llvm.org/D114813
2022-01-14 11:35:53 -05:00
#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
0xF0;
#else
0x30;
#endif
}
inline _LIBCPP_INLINE_VISIBILITY
[libc++] Make parameter names consistent and enforce the naming style using readability-identifier-naming Ensure that parameter names have the style `__lower_case` Reviewed By: ldionne, #libc Spies: aheejin, sstefan1, libcxx-commits, miyuki Differential Revision: https://reviews.llvm.org/D129051
2022-07-08 18:17:26 +02:00
bool __is_89(unsigned char __c)
[SystemZ][z/OS] ASCII/EBCDIC support with no coexistence The aim of this patch is to break up the larger patch (https://reviews.llvm.org/D111323) to be more upstream friendly. In particular, this patch adds the char encoding sensitive changes but does not use inline namespaces as before. The use of namespaces to build both versions of the library, and localization of error messages will follow in a subsequent patch. Differential Revision: https://reviews.llvm.org/D114813
2022-01-14 11:35:53 -05:00
{
[libc++] Make parameter names consistent and enforce the naming style using readability-identifier-naming Ensure that parameter names have the style `__lower_case` Reviewed By: ldionne, #libc Spies: aheejin, sstefan1, libcxx-commits, miyuki Differential Revision: https://reviews.llvm.org/D129051
2022-07-08 18:17:26 +02:00
return (__c & 0xFEu) ==
[SystemZ][z/OS] ASCII/EBCDIC support with no coexistence The aim of this patch is to break up the larger patch (https://reviews.llvm.org/D111323) to be more upstream friendly. In particular, this patch adds the char encoding sensitive changes but does not use inline namespaces as before. The use of namespaces to build both versions of the library, and localization of error messages will follow in a subsequent patch. Differential Revision: https://reviews.llvm.org/D114813
2022-01-14 11:35:53 -05:00
#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
0xF8;
#else
0x38;
#endif
}
inline _LIBCPP_INLINE_VISIBILITY
[libc++] Make parameter names consistent and enforce the naming style using readability-identifier-naming Ensure that parameter names have the style `__lower_case` Reviewed By: ldionne, #libc Spies: aheejin, sstefan1, libcxx-commits, miyuki Differential Revision: https://reviews.llvm.org/D129051
2022-07-08 18:17:26 +02:00
unsigned char __to_lower(unsigned char __c)
[SystemZ][z/OS] ASCII/EBCDIC support with no coexistence The aim of this patch is to break up the larger patch (https://reviews.llvm.org/D111323) to be more upstream friendly. In particular, this patch adds the char encoding sensitive changes but does not use inline namespaces as before. The use of namespaces to build both versions of the library, and localization of error messages will follow in a subsequent patch. Differential Revision: https://reviews.llvm.org/D114813
2022-01-14 11:35:53 -05:00
{
#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
return c & 0xBF;
#else
[libc++] Make parameter names consistent and enforce the naming style using readability-identifier-naming Ensure that parameter names have the style `__lower_case` Reviewed By: ldionne, #libc Spies: aheejin, sstefan1, libcxx-commits, miyuki Differential Revision: https://reviews.llvm.org/D129051
2022-07-08 18:17:26 +02:00
return __c | 0x20;
[SystemZ][z/OS] ASCII/EBCDIC support with no coexistence The aim of this patch is to break up the larger patch (https://reviews.llvm.org/D111323) to be more upstream friendly. In particular, this patch adds the char encoding sensitive changes but does not use inline namespaces as before. The use of namespaces to build both versions of the library, and localization of error messages will follow in a subsequent patch. Differential Revision: https://reviews.llvm.org/D114813
2022-01-14 11:35:53 -05:00
#endif
}
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
template <class _CharT>
int
Patch by GM: apparently '__value' (two underscores) is a special name in Visual Studio, so rename the private method in <regex> with that name. GM's patch used '___value' (three underscores), but I changed that to '__regex_traits_value' because I've been burned in the past by identifiers that appear identical but are not. llvm-svn: 193087
2013-10-21 15:43:25 +00:00
regex_traits<_CharT>::__regex_traits_value(unsigned char __ch, int __radix)
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
{
[SystemZ][z/OS] ASCII/EBCDIC support with no coexistence The aim of this patch is to break up the larger patch (https://reviews.llvm.org/D111323) to be more upstream friendly. In particular, this patch adds the char encoding sensitive changes but does not use inline namespaces as before. The use of namespaces to build both versions of the library, and localization of error messages will follow in a subsequent patch. Differential Revision: https://reviews.llvm.org/D114813
2022-01-14 11:35:53 -05:00
if (__is_07(__ch)) // '0' <= __ch && __ch <= '7'
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
return __ch - '0';
if (__radix != 8)
{
[SystemZ][z/OS] ASCII/EBCDIC support with no coexistence The aim of this patch is to break up the larger patch (https://reviews.llvm.org/D111323) to be more upstream friendly. In particular, this patch adds the char encoding sensitive changes but does not use inline namespaces as before. The use of namespaces to build both versions of the library, and localization of error messages will follow in a subsequent patch. Differential Revision: https://reviews.llvm.org/D114813
2022-01-14 11:35:53 -05:00
if (__is_89(__ch)) // '8' <= __ch && __ch <= '9'
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
return __ch - '0';
if (__radix == 16)
{
[SystemZ][z/OS] ASCII/EBCDIC support with no coexistence The aim of this patch is to break up the larger patch (https://reviews.llvm.org/D111323) to be more upstream friendly. In particular, this patch adds the char encoding sensitive changes but does not use inline namespaces as before. The use of namespaces to build both versions of the library, and localization of error messages will follow in a subsequent patch. Differential Revision: https://reviews.llvm.org/D114813
2022-01-14 11:35:53 -05:00
__ch = __to_lower(__ch); // tolower
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
if ('a' <= __ch && __ch <= 'f')
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
return __ch - ('a' - 10);
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
}
}
return -1;
}
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
template <class _CharT>
Cleanup: move visibility/linkage attributes to the first declaration. This change moves visibility attributes from out-of-class method definitions to in-class declaration. This is needed for a switch to attribute((internal_linkage)) (see http://reviews.llvm.org/D13925) which can only appear on the first declaration. This change does not touch istream/ostream/streambuf. They are handled separately in http://reviews.llvm.org/D14409. llvm-svn: 252385
2015-11-07 01:22:13 +00:00
inline
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
int
Patch by GM: apparently '__value' (two underscores) is a special name in Visual Studio, so rename the private method in <regex> with that name. GM's patch used '___value' (three underscores), but I changed that to '__regex_traits_value' because I've been burned in the past by identifiers that appear identical but are not. llvm-svn: 193087
2013-10-21 15:43:25 +00:00
regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
{
Patch by GM: apparently '__value' (two underscores) is a special name in Visual Studio, so rename the private method in <regex> with that name. GM's patch used '___value' (three underscores), but I changed that to '__regex_traits_value' because I've been burned in the past by identifiers that appear identical but are not. llvm-svn: 193087
2013-10-21 15:43:25 +00:00
return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix);
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
}
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#endif
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-21 21:01:43 +00:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
template <class _CharT> class __node;
[NFC] Rename _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS The name _LIBCPP_TYPE_VIS_ONLY is no longer accurate because both _LIBCPP_TYPE_VIS and _LIBCPP_TYPE_VIS_ONLY expand to __attribute__((__type_visibility__)) with Clang. The only remaining difference is that _LIBCPP_TYPE_VIS_ONLY can be applied to templates whereas _LIBCPP_TYPE_VIS cannot (due to dllimport/dllexport not being allowed on templates). This patch renames _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS. llvm-svn: 291035
2017-01-04 23:56:00 +00:00
template <class _BidirectionalIterator> class _LIBCPP_TEMPLATE_VIS sub_match;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
template <class _BidirectionalIterator,
class _Allocator = allocator<sub_match<_BidirectionalIterator> > >
[NFC] Rename _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS The name _LIBCPP_TYPE_VIS_ONLY is no longer accurate because both _LIBCPP_TYPE_VIS and _LIBCPP_TYPE_VIS_ONLY expand to __attribute__((__type_visibility__)) with Clang. The only remaining difference is that _LIBCPP_TYPE_VIS_ONLY can be applied to templates whereas _LIBCPP_TYPE_VIS cannot (due to dllimport/dllexport not being allowed on templates). This patch renames _LIBCPP_TYPE_VIS_ONLY to _LIBCPP_TEMPLATE_VIS. llvm-svn: 291035
2017-01-04 23:56:00 +00:00
class _LIBCPP_TEMPLATE_VIS match_results;
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
struct __state
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
{
enum
{
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
__end_state = -1000,
__consume_input, // -999
__begin_marked_expr, // -998
__end_marked_expr, // -997
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
__pop_state, // -996
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
__accept_and_consume, // -995
__accept_but_not_consume, // -994
__reject, // -993
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__split,
__repeat
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
};
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
int __do_;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
const _CharT* __first_;
const _CharT* __current_;
const _CharT* __last_;
vector<sub_match<const _CharT*> > __sub_matches_;
vector<pair<size_t, const _CharT*> > __loop_data_;
const __node<_CharT>* __node_;
regex_constants::match_flag_type __flags_;
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
bool __at_first_;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__state()
: __do_(0), __first_(nullptr), __current_(nullptr), __last_(nullptr),
__node_(nullptr), __flags_() {}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
};
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
// __node
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
class __node
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__node(const __node&);
__node& operator=(const __node&);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__node() {}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
virtual ~__node() {}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Fix even more Clang warnings. This patch disables shift-sign-overflow warnings for now. It also fixes most -Wfloat-equal warnings and -Wextra-semi warnings. llvm-svn: 343438
2018-10-01 01:59:37 +00:00
virtual void __exec(__state&) const {}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Fix even more Clang warnings. This patch disables shift-sign-overflow warnings for now. It also fixes most -Wfloat-equal warnings and -Wextra-semi warnings. llvm-svn: 343438
2018-10-01 01:59:37 +00:00
virtual void __exec_split(bool, __state&) const {}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
};
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
// __end_state
template <class _CharT>
class __end_state
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
: public __node<_CharT>
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
__end_state() {}
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
virtual void __exec(__state&) const;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
};
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
void
__end_state<_CharT>::__exec(__state& __s) const
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__s.__do_ = __state::__end_state;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
// __has_one_state
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
template <class _CharT>
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
class __has_one_state
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
: public __node<_CharT>
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__node<_CharT>* __first_;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
public:
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
explicit __has_one_state(__node<_CharT>* __s)
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
: __first_(__s) {}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__node<_CharT>* first() const {return __first_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__node<_CharT>*& first() {return __first_;}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
};
// __owns_one_state
template <class _CharT>
class __owns_one_state
: public __has_one_state<_CharT>
{
typedef __has_one_state<_CharT> base;
public:
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
explicit __owns_one_state(__node<_CharT>* __s)
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
: base(__s) {}
virtual ~__owns_one_state();
};
template <class _CharT>
__owns_one_state<_CharT>::~__owns_one_state()
{
delete this->first();
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
// __empty_state
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
template <class _CharT>
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
class __empty_state
: public __owns_one_state<_CharT>
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
{
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
typedef __owns_one_state<_CharT> base;
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
explicit __empty_state(__node<_CharT>* __s)
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
: base(__s) {}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
virtual void __exec(__state&) const;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
};
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
void
__empty_state<_CharT>::__exec(__state& __s) const
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__s.__do_ = __state::__accept_but_not_consume;
__s.__node_ = this->first();
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
// __empty_non_own_state
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
template <class _CharT>
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
class __empty_non_own_state
: public __has_one_state<_CharT>
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
{
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
typedef __has_one_state<_CharT> base;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
explicit __empty_non_own_state(__node<_CharT>* __s)
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
: base(__s) {}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
virtual void __exec(__state&) const;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
};
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
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 _CharT>
class __repeat_one_loop
: public __has_one_state<_CharT>
{
typedef __has_one_state<_CharT> base;
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
explicit __repeat_one_loop(__node<_CharT>* __s)
: base(__s) {}
virtual void __exec(__state&) const;
};
template <class _CharT>
void
__repeat_one_loop<_CharT>::__exec(__state& __s) const
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__s.__do_ = __state::__repeat;
__s.__node_ = this->first();
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
}
// __owns_two_states
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
template <class _CharT>
class __owns_two_states
: public __owns_one_state<_CharT>
{
typedef __owns_one_state<_CharT> base;
base* __second_;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
public:
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
explicit __owns_two_states(__node<_CharT>* __s1, base* __s2)
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
: base(__s1), __second_(__s2) {}
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
virtual ~__owns_two_states();
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
base* second() const {return __second_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
base*& second() {return __second_;}
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
};
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
template <class _CharT>
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
__owns_two_states<_CharT>::~__owns_two_states()
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
{
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
delete __second_;
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
// __loop
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
template <class _CharT>
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
class __loop
: public __owns_two_states<_CharT>
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
{
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
typedef __owns_two_states<_CharT> base;
size_t __min_;
size_t __max_;
unsigned __loop_id_;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
unsigned __mexp_begin_;
unsigned __mexp_end_;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
bool __greedy_;
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
explicit __loop(unsigned __loop_id,
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__node<_CharT>* __s1, __owns_one_state<_CharT>* __s2,
unsigned __mexp_begin, unsigned __mexp_end,
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
bool __greedy = true,
size_t __min = 0,
size_t __max = numeric_limits<size_t>::max())
: base(__s1, __s2), __min_(__min), __max_(__max), __loop_id_(__loop_id),
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__mexp_begin_(__mexp_begin), __mexp_end_(__mexp_end),
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
__greedy_(__greedy) {}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
virtual void __exec(__state& __s) const;
virtual void __exec_split(bool __second, __state& __s) const;
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
private:
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
void __init_repeat(__state& __s) const
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__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;
}
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
}
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
};
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
void
__loop<_CharT>::__exec(__state& __s) const
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
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
{
continued regex development... llvm-svn: 109512
2010-07-27 17:24:17 +00:00
__s.__loop_data_[__loop_id_].first = 0;
bool __do_repeat = 0 < __max_;
bool __do_alt = 0 >= __min_;
if (__do_repeat && __do_alt)
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__s.__do_ = __state::__split;
continued regex development... llvm-svn: 109512
2010-07-27 17:24:17 +00:00
else if (__do_repeat)
{
__s.__do_ = __state::__accept_but_not_consume;
__s.__node_ = this->first();
__init_repeat(__s);
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
else
{
__s.__do_ = __state::__accept_but_not_consume;
__s.__node_ = this->second();
}
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
}
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
void
__loop<_CharT>::__exec_split(bool __second, __state& __s) const
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__s.__do_ = __state::__accept_but_not_consume;
if (__greedy_ != __second)
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__s.__node_ = this->first();
__init_repeat(__s);
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
else
__s.__node_ = this->second();
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
}
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
// __alternate
template <class _CharT>
class __alternate
: public __owns_two_states<_CharT>
{
typedef __owns_two_states<_CharT> base;
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
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 <class _CharT>
void
__alternate<_CharT>::__exec(__state& __s) const
{
__s.__do_ = __state::__split;
}
template <class _CharT>
void
__alternate<_CharT>::__exec_split(bool __second, __state& __s) const
{
__s.__do_ = __state::__accept_but_not_consume;
A few more tests for posix extended alternation llvm-svn: 109107
2010-07-22 14:12:20 +00:00
if (__second)
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
__s.__node_ = this->second();
A few more tests for posix extended alternation llvm-svn: 109107
2010-07-22 14:12:20 +00:00
else
__s.__node_ = this->first();
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
// __begin_marked_subexpression
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
class __begin_marked_subexpression
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
: public __owns_one_state<_CharT>
{
typedef __owns_one_state<_CharT> base;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
unsigned __mexp_;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
explicit __begin_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
: base(__s), __mexp_(__mexp) {}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
virtual void __exec(__state&) const;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
};
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
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();
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
// __end_marked_subexpression
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
class __end_marked_subexpression
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
: public __owns_one_state<_CharT>
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
{
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
typedef __owns_one_state<_CharT> base;
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
unsigned __mexp_;
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
explicit __end_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
: base(__s), __mexp_(__mexp) {}
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
virtual void __exec(__state&) const;
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
};
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
void
__end_marked_subexpression<_CharT>::__exec(__state& __s) const
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__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();
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
back references for BRE llvm-svn: 108168
2010-07-12 18:16:05 +00:00
// __back_ref
template <class _CharT>
class __back_ref
: public __owns_one_state<_CharT>
{
typedef __owns_one_state<_CharT> base;
unsigned __mexp_;
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
back references for BRE llvm-svn: 108168
2010-07-12 18:16:05 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
back references for BRE llvm-svn: 108168
2010-07-12 18:16:05 +00:00
explicit __back_ref(unsigned __mexp, __node<_CharT>* __s)
: base(__s), __mexp_(__mexp) {}
virtual void __exec(__state&) const;
};
template <class _CharT>
void
__back_ref<_CharT>::__exec(__state& __s) const
{
Fix a crasher found by libFuzzer llvm-svn: 245849
2015-08-24 15:57:09 +00:00
if (__mexp_ > __s.__sub_matches_.size())
__throw_regex_error<regex_constants::error_backref>();
back references for BRE llvm-svn: 108168
2010-07-12 18:16:05 +00:00
sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1];
if (__sm.matched)
{
ptrdiff_t __len = __sm.second - __sm.first;
if (__s.__last_ - __s.__current_ >= __len &&
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_VSTD::equal(__sm.first, __sm.second, __s.__current_))
back references for BRE llvm-svn: 108168
2010-07-12 18:16:05 +00:00
{
__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;
}
}
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-12 19:11:27 +00:00
// __back_ref_icase
template <class _CharT, class _Traits>
class __back_ref_icase
: public __owns_one_state<_CharT>
{
typedef __owns_one_state<_CharT> base;
_Traits __traits_;
unsigned __mexp_;
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-12 19:11:27 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-12 19:11:27 +00:00
explicit __back_ref_icase(const _Traits& __traits, unsigned __mexp,
__node<_CharT>* __s)
: base(__s), __traits_(__traits), __mexp_(__mexp) {}
virtual void __exec(__state&) const;
};
template <class _CharT, class _Traits>
void
__back_ref_icase<_CharT, _Traits>::__exec(__state& __s) const
{
sub_match<const _CharT*>& __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 _CharT, class _Traits>
class __back_ref_collate
: public __owns_one_state<_CharT>
{
typedef __owns_one_state<_CharT> base;
_Traits __traits_;
unsigned __mexp_;
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-12 19:11:27 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-12 19:11:27 +00:00
explicit __back_ref_collate(const _Traits& __traits, unsigned __mexp,
__node<_CharT>* __s)
: base(__s), __traits_(__traits), __mexp_(__mexp) {}
virtual void __exec(__state&) const;
};
template <class _CharT, class _Traits>
void
__back_ref_collate<_CharT, _Traits>::__exec(__state& __s) const
{
sub_match<const _CharT*>& __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;
}
}
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
// __word_boundary
template <class _CharT, class _Traits>
class __word_boundary
: public __owns_one_state<_CharT>
{
typedef __owns_one_state<_CharT> base;
_Traits __traits_;
bool __invert_;
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
explicit __word_boundary(const _Traits& __traits, bool __invert,
__node<_CharT>* __s)
: base(__s), __traits_(__traits), __invert_(__invert) {}
virtual void __exec(__state&) const;
};
template <class _CharT, class _Traits>
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);
}
}
bug fix concerning search not at beginning of string and word boundaries llvm-svn: 109750
2010-07-29 15:17:28 +00:00
else if (__s.__current_ == __s.__first_ &&
!(__s.__flags_ & regex_constants::match_prev_avail))
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
{
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;
}
}
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
// __l_anchor
template <class _CharT>
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
[libc++] Make parameter names consistent and enforce the naming style using readability-identifier-naming Ensure that parameter names have the style `__lower_case` Reviewed By: ldionne, #libc Spies: aheejin, sstefan1, libcxx-commits, miyuki Differential Revision: https://reviews.llvm.org/D129051
2022-07-08 18:17:26 +02:00
bool __is_eol(_CharT __c)
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
{
[libc++] Make parameter names consistent and enforce the naming style using readability-identifier-naming Ensure that parameter names have the style `__lower_case` Reviewed By: ldionne, #libc Spies: aheejin, sstefan1, libcxx-commits, miyuki Differential Revision: https://reviews.llvm.org/D129051
2022-07-08 18:17:26 +02:00
return __c == '\r' || __c == '\n';
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
}
template <class _CharT>
class __l_anchor_multiline
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
: public __owns_one_state<_CharT>
{
typedef __owns_one_state<_CharT> base;
[libc++] Fix a few warnings in system headers with GCC This isn't fixing all of them, but at least it's making some progress. Differential Revision: https://reviews.llvm.org/D106283
2021-07-27 17:30:47 -04:00
bool __multiline_;
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
_LIBCPP_INLINE_VISIBILITY
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
__l_anchor_multiline(bool __multiline, __node<_CharT>* __s)
[libc++] Fix a few warnings in system headers with GCC This isn't fixing all of them, but at least it's making some progress. Differential Revision: https://reviews.llvm.org/D106283
2021-07-27 17:30:47 -04:00
: base(__s), __multiline_(__multiline) {}
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
virtual void __exec(__state&) const;
};
template <class _CharT>
void
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
__l_anchor_multiline<_CharT>::__exec(__state& __s) const
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
{
Add code to honor the match_not_bol and match_not_eol regex flats. Fixes PR#22651. Thanks to Jim Porter for the report and suggested fix. llvm-svn: 232733
2015-03-19 17:05:59 +00:00
if (__s.__at_first_ && __s.__current_ == __s.__first_ &&
!(__s.__flags_ & regex_constants::match_not_bol))
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
{
__s.__do_ = __state::__accept_but_not_consume;
__s.__node_ = this->first();
}
[libc++] Fix a few warnings in system headers with GCC This isn't fixing all of them, but at least it's making some progress. Differential Revision: https://reviews.llvm.org/D106283
2021-07-27 17:30:47 -04:00
else if (__multiline_ &&
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
!__s.__at_first_ &&
__is_eol(*_VSTD::prev(__s.__current_)))
{
__s.__do_ = __state::__accept_but_not_consume;
__s.__node_ = this->first();
}
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
else
{
__s.__do_ = __state::__reject;
__s.__node_ = nullptr;
}
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
// __r_anchor
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
template <class _CharT>
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
class __r_anchor_multiline
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
: public __owns_one_state<_CharT>
{
typedef __owns_one_state<_CharT> base;
[libc++] Define _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER whenever we enable warnings in the test suite This should make CI consistent on all the compilers we support. Most of this patch is working around various warnings emitted by GCC in our code base, which are now being shown when we compile the tests. After this patch, the whole test suite should be warning free on all compilers we support and test, except for a few warnings on GCC that we silence explicitly until we figure out the proper fix for them. Differential Revision: https://reviews.llvm.org/D120684
2022-03-03 13:39:12 -05:00
bool __multiline_;
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
__r_anchor_multiline(bool __multiline, __node<_CharT>* __s)
[libc++] Define _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER whenever we enable warnings in the test suite This should make CI consistent on all the compilers we support. Most of this patch is working around various warnings emitted by GCC in our code base, which are now being shown when we compile the tests. After this patch, the whole test suite should be warning free on all compilers we support and test, except for a few warnings on GCC that we silence explicitly until we figure out the proper fix for them. Differential Revision: https://reviews.llvm.org/D120684
2022-03-03 13:39:12 -05:00
: base(__s), __multiline_(__multiline) {}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
virtual void __exec(__state&) const;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
};
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
void
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
__r_anchor_multiline<_CharT>::__exec(__state& __s) const
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{
Add code to honor the match_not_bol and match_not_eol regex flats. Fixes PR#22651. Thanks to Jim Porter for the report and suggested fix. llvm-svn: 232733
2015-03-19 17:05:59 +00:00
if (__s.__current_ == __s.__last_ &&
!(__s.__flags_ & regex_constants::match_not_eol))
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
{
__s.__do_ = __state::__accept_but_not_consume;
__s.__node_ = this->first();
}
[libc++] Define _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER whenever we enable warnings in the test suite This should make CI consistent on all the compilers we support. Most of this patch is working around various warnings emitted by GCC in our code base, which are now being shown when we compile the tests. After this patch, the whole test suite should be warning free on all compilers we support and test, except for a few warnings on GCC that we silence explicitly until we figure out the proper fix for them. Differential Revision: https://reviews.llvm.org/D120684
2022-03-03 13:39:12 -05:00
else if (__multiline_ && __is_eol(*__s.__current_))
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
{
__s.__do_ = __state::__accept_but_not_consume;
__s.__node_ = this->first();
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
else
{
__s.__do_ = __state::__reject;
__s.__node_ = nullptr;
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
// __match_any
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
class __match_any
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
: public __owns_one_state<_CharT>
{
typedef __owns_one_state<_CharT> base;
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__match_any(__node<_CharT>* __s)
weekly update to by-chapter-summary, plus left and right anchor support in basic posix. llvm-svn: 107938
2010-07-09 00:15:26 +00:00
: base(__s) {}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
virtual void __exec(__state&) const;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
};
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
void
__match_any<_CharT>::__exec(__state& __s) const
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
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;
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
}
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
// __match_any_but_newline
template <class _CharT>
class __match_any_but_newline
: public __owns_one_state<_CharT>
{
typedef __owns_one_state<_CharT> base;
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__match_any_but_newline(__node<_CharT>* __s)
: base(__s) {}
virtual void __exec(__state&) const;
};
Nico Rieck: this patch series fixes visibility issues on Windows as explained in <http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-August/031214.html>. llvm-svn: 188192
2013-08-12 18:38:34 +00:00
template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<char>::__exec(__state&) const;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
Nico Rieck: this patch series fixes visibility issues on Windows as explained in <http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-August/031214.html>. llvm-svn: 188192
2013-08-12 18:38:34 +00:00
template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<wchar_t>::__exec(__state&) const;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#endif
Nico Rieck: this patch series fixes visibility issues on Windows as explained in <http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-August/031214.html>. llvm-svn: 188192
2013-08-12 18:38:34 +00:00
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
// __match_char
template <class _CharT>
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&);
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__match_char(_CharT __c, __node<_CharT>* __s)
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
: base(__s), __c_(__c) {}
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
virtual void __exec(__state&) const;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
};
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
template <class _CharT>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
void
__match_char<_CharT>::__exec(__state& __s) const
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
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;
}
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-12 19:11:27 +00:00
// __match_char_icase
template <class _CharT, class _Traits>
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:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-12 19:11:27 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-12 19:11:27 +00:00
__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 <class _CharT, class _Traits>
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 _CharT, class _Traits>
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:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-12 19:11:27 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-12 19:11:27 +00:00
__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 <class _CharT, class _Traits>
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 expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
// __bracket_expression
template <class _CharT, class _Traits>
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_;
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
vector<_CharT> __neg_chars_;
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
vector<pair<string_type, string_type> > __ranges_;
vector<pair<_CharT, _CharT> > __digraphs_;
vector<string_type> __equivalences_;
Base regex code on char_class_type. __get_classname() and __bracket_expression were assuming that char_class_type was ctype_base::mask rather than using regex_traits<_CharT>::char_class_type. This change allows char_class_type to be defined to something other than ctype_base::mask so that the implementation will still work for platforms with an 8-bit ctype mask (such as Android and OpenBSD). llvm-svn: 214201
2014-07-29 19:23:39 +00:00
typename regex_traits<_CharT>::char_class_type __mask_;
typename regex_traits<_CharT>::char_class_type __neg_mask_;
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
bool __negate_;
bool __icase_;
bool __collate_;
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
bool __might_have_digraph_;
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__bracket_expression(const __bracket_expression&);
__bracket_expression& operator=(const __bracket_expression&);
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__bracket_expression(const _Traits& __traits, __node<_CharT>* __s,
bool __negate, bool __icase, bool __collate)
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
: base(__s), __traits_(__traits), __mask_(), __neg_mask_(),
__negate_(__negate), __icase_(__icase), __collate_(__collate),
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
__might_have_digraph_(__traits_.getloc().name() != "C") {}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
virtual void __exec(__state&) const;
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
bool __negated() const {return __negate_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
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);
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
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);
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
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)
Fix an incorrect 'Throws' in the regex code. Add a test for the new behavior. Reviewed as https://reviews.llvm.org/D61828. Thanks to Mark for the catch and the fix. llvm-svn: 361887
2019-05-28 22:42:32 +00:00
__throw_regex_error<regex_constants::error_range>();
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
if (__icase_)
{
__b[0] = __traits_.translate_nocase(__b[0]);
__e[0] = __traits_.translate_nocase(__e[0]);
}
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__ranges_.push_back(make_pair(_VSTD::move(__b), _VSTD::move(__e)));
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
}
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
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));
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
void __add_equivalence(const string_type& __s)
{__equivalences_.push_back(__s);}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Base regex code on char_class_type. __get_classname() and __bracket_expression were assuming that char_class_type was ctype_base::mask rather than using regex_traits<_CharT>::char_class_type. This change allows char_class_type to be defined to something other than ctype_base::mask so that the implementation will still work for platforms with an 8-bit ctype mask (such as Android and OpenBSD). llvm-svn: 214201
2014-07-29 19:23:39 +00:00
void __add_class(typename regex_traits<_CharT>::char_class_type __mask)
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
{__mask_ |= __mask;}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Base regex code on char_class_type. __get_classname() and __bracket_expression were assuming that char_class_type was ctype_base::mask rather than using regex_traits<_CharT>::char_class_type. This change allows char_class_type to be defined to something other than ctype_base::mask so that the implementation will still work for platforms with an 8-bit ctype mask (such as Android and OpenBSD). llvm-svn: 214201
2014-07-29 19:23:39 +00:00
void __add_neg_class(typename regex_traits<_CharT>::char_class_type __mask)
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
{__neg_mask_ |= __mask;}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
};
template <class _CharT, class _Traits>
void
__bracket_expression<_CharT, _Traits>::__exec(__state& __s) const
{
bool __found = false;
unsigned __consumed = 0;
if (__s.__current_ != __s.__last_)
{
++__consumed;
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
if (__might_have_digraph_)
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
const _CharT* __next = _VSTD::next(__s.__current_);
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
if (__next != __s.__last_)
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
{
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
pair<_CharT, _CharT> __ch2(*__s.__current_, *__next);
if (__icase_)
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
{
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
__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);
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
}
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
if (!__traits_.lookup_collatename(&__ch2.first, &__ch2.first+2).empty())
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
{
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
// __ch2 is a digraph in this locale
++__consumed;
for (size_t __i = 0; __i < __digraphs_.size(); ++__i)
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
{
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
if (__ch2 == __digraphs_[__i])
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
{
__found = true;
goto __exit;
}
}
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
if (__collate_ && !__ranges_.empty())
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
{
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
string_type __s2 = __traits_.transform(&__ch2.first,
&__ch2.first + 2);
for (size_t __i = 0; __i < __ranges_.size(); ++__i)
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
{
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
if (__ranges_[__i].first <= __s2 &&
__s2 <= __ranges_[__i].second)
{
__found = true;
goto __exit;
}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
}
}
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
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;
}
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
if (!__traits_.isctype(__ch2.first, __neg_mask_) &&
!__traits_.isctype(__ch2.second, __neg_mask_))
{
__found = true;
goto __exit;
}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
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;
}
}
[libc++] Fix handling of negated character classes in regex Summary: This commit fixes a regression introduced in r316095, where we don't match inverted character classes when there's no negated characrers in the []'s. rdar://problem/43060054 Reviewers: mclow.lists, timshen, EricWF Subscribers: christof, dexonsmith, cfe-commits Differential Revision: https://reviews.llvm.org/D50534 llvm-svn: 340609
2018-08-24 14:10:28 +00:00
// When there's at least one of __neg_chars_ and __neg_mask_, the set
// of "__found" chars is
Fix regex bug with ^\W. Thanks to Tim Shen for the patch. Reviewed as https://reviews.llvm.org/D37955 llvm-svn: 316095
2017-10-18 16:49:22 +00:00
// union(complement(union(__neg_chars_, __neg_mask_)),
// other cases...)
//
[libc++] Fix handling of negated character classes in regex Summary: This commit fixes a regression introduced in r316095, where we don't match inverted character classes when there's no negated characrers in the []'s. rdar://problem/43060054 Reviewers: mclow.lists, timshen, EricWF Subscribers: christof, dexonsmith, cfe-commits Differential Revision: https://reviews.llvm.org/D50534 llvm-svn: 340609
2018-08-24 14:10:28 +00:00
// 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()))
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
{
[libc++] Fix handling of negated character classes in regex Summary: This commit fixes a regression introduced in r316095, where we don't match inverted character classes when there's no negated characrers in the []'s. rdar://problem/43060054 Reviewers: mclow.lists, timshen, EricWF Subscribers: christof, dexonsmith, cfe-commits Differential Revision: https://reviews.llvm.org/D50534 llvm-svn: 340609
2018-08-24 14:10:28 +00:00
const bool __in_neg_mask = __traits_.isctype(__ch, __neg_mask_);
Fix regex bug with ^\W. Thanks to Tim Shen for the patch. Reviewed as https://reviews.llvm.org/D37955 llvm-svn: 316095
2017-10-18 16:49:22 +00:00
const bool __in_neg_chars =
[libc++] Consistently replace `std::` qualification with `_VSTD::` or nothing. NFCI. I used a lot of `git grep` to find places where `std::` was being used outside of comments and assert-messages. There were three outcomes: - Qualified function calls, e.g. `std::move` becomes `_VSTD::move`. This is the most common case. - Typenames that don't need qualification, e.g. `std::allocator` becomes `allocator`. Leaving these as `_VSTD::allocator` would also be fine, but I decided that removing the qualification is more consistent with existing practice. - Names that specifically need un-versioned `std::` qualification, or that I wasn't sure about. For example, I didn't touch any code in <atomic>, <math.h>, <new>, or any ext/ or experimental/ headers; and I didn't touch any instances of `std::type_info`. In some deduction guides, we were accidentally using `class Alloc = typename std::allocator<T>`, despite `std::allocator<T>`'s type-ness not being template-dependent. Because `std::allocator` is a qualified name, this did parse as we intended; but what we meant was simply `class Alloc = allocator<T>`. Differential Revision: https://reviews.llvm.org/D92250
2020-11-27 11:02:06 -05:00
_VSTD::find(__neg_chars_.begin(), __neg_chars_.end(), __ch) !=
Fix regex bug with ^\W. Thanks to Tim Shen for the patch. Reviewed as https://reviews.llvm.org/D37955 llvm-svn: 316095
2017-10-18 16:49:22 +00:00
__neg_chars_.end();
if (!(__in_neg_mask || __in_neg_chars))
{
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
__found = true;
goto __exit;
Fix regex bug with ^\W. Thanks to Tim Shen for the patch. Reviewed as https://reviews.llvm.org/D37955 llvm-svn: 316095
2017-10-18 16:49:22 +00:00
}
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
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_))
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
{
__found = true;
goto __exit;
}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
}
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;
}
}
Provide names for template and function parameters in forward declarations. The purpose is to aid automated documentation tools. llvm-svn: 133008
2011-06-14 19:58:17 +00:00
template <class _CharT, class _Traits> class __lookahead;
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
template <class _CharT, class _Traits = regex_traits<_CharT> >
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
class _LIBCPP_TEMPLATE_VIS basic_regex;
typedef basic_regex<char> regex;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
typedef basic_regex<wchar_t> wregex;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#endif
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
template <class _CharT, class _Traits>
class
_LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(regex)
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wregex))
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
basic_regex
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
{
public:
// types:
typedef _CharT value_type;
[libcxx] basic_regex: add traits_type, string_type Summary: In the synopsis in C++11 subclause 28.8 [re.regex], `basic_regex` is specified to have member typedefs `traits_type` and `string_type`. This change adds them to libc++. Reviewers: mclow.lists, rsmith, hubert.reinterpretcast Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D22698 Patch by Jason Liu! llvm-svn: 277526
2016-08-02 21:34:48 +00:00
typedef _Traits traits_type;
typedef typename _Traits::string_type string_type;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
typedef regex_constants::syntax_option_type flag_type;
typedef typename _Traits::locale_type locale_type;
private:
_Traits __traits_;
flag_type __flags_;
unsigned __marked_count_;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
unsigned __loop_count_;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
int __open_count_;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
shared_ptr<__empty_state<_CharT> > __start_;
__owns_one_state<_CharT>* __end_;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
typedef _VSTD::__node<_CharT> __node;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
public:
// constants:
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
static const regex_constants::syntax_option_type icase = regex_constants::icase;
static const regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
static const regex_constants::syntax_option_type optimize = regex_constants::optimize;
static const regex_constants::syntax_option_type collate = regex_constants::collate;
static const regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
static const regex_constants::syntax_option_type basic = regex_constants::basic;
static const regex_constants::syntax_option_type extended = regex_constants::extended;
static const regex_constants::syntax_option_type awk = regex_constants::awk;
static const regex_constants::syntax_option_type grep = regex_constants::grep;
static const regex_constants::syntax_option_type egrep = regex_constants::egrep;
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
static const regex_constants::syntax_option_type multiline = regex_constants::multiline;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
// construct/copy/destroy:
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
basic_regex()
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
: __flags_(regex_constants::ECMAScript), __marked_count_(0), __loop_count_(0), __open_count_(0),
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-24 12:53:53 -05:00
__end_(nullptr)
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
explicit basic_regex(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
weekly update to by-chapter-summary, plus left and right anchor support in basic posix. llvm-svn: 107938
2010-07-09 00:15:26 +00:00
: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-24 12:53:53 -05:00
__end_(nullptr)
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
{
[libc++] Validate the entire regex is consumed This change would have warned about the bug found in D62451. No unit tests since the exception should never throw. Differential Revision: https://reviews.llvm.org/D62452
2019-11-09 17:01:37 +01:00
__init(__p, __p + __traits_.length(__p));
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[libcxx] Add "flag" default arg: basic_regex ptr_size_flag ctor Summary: The synopsis in C++11 subclause 28.8 [re.regex] has: ``` basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript); ``` The default argument is added to libc++ by this change. Reviewers: mclow.lists, rsmith, hubert.reinterpretcast Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D22702 Reapplies r277966. Patch by Jason Liu! llvm-svn: 277968
2016-08-07 22:26:04 +00:00
basic_regex(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript)
weekly update to by-chapter-summary, plus left and right anchor support in basic posix. llvm-svn: 107938
2010-07-09 00:15:26 +00:00
: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-24 12:53:53 -05:00
__end_(nullptr)
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
{
[libc++] Validate the entire regex is consumed This change would have warned about the bug found in D62451. No unit tests since the exception should never throw. Differential Revision: https://reviews.llvm.org/D62452
2019-11-09 17:01:37 +01:00
__init(__p, __p + __len);
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
}
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
// basic_regex(const basic_regex&) = default;
// basic_regex(basic_regex&&) = default;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
template <class _ST, class _SA>
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
explicit basic_regex(const basic_string<value_type, _ST, _SA>& __p,
flag_type __f = regex_constants::ECMAScript)
weekly update to by-chapter-summary, plus left and right anchor support in basic posix. llvm-svn: 107938
2010-07-09 00:15:26 +00:00
: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-24 12:53:53 -05:00
__end_(nullptr)
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
{
[libc++] Validate the entire regex is consumed This change would have warned about the bug found in D62451. No unit tests since the exception should never throw. Differential Revision: https://reviews.llvm.org/D62452
2019-11-09 17:01:37 +01:00
__init(__p.begin(), __p.end());
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
}
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
template <class _ForwardIterator>
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
basic_regex(_ForwardIterator __first, _ForwardIterator __last,
flag_type __f = regex_constants::ECMAScript)
weekly update to by-chapter-summary, plus left and right anchor support in basic posix. llvm-svn: 107938
2010-07-09 00:15:26 +00:00
: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-24 12:53:53 -05:00
__end_(nullptr)
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
{
[libc++] Validate the entire regex is consumed This change would have warned about the bug found in D62451. No unit tests since the exception should never throw. Differential Revision: https://reviews.llvm.org/D62452
2019-11-09 17:01:37 +01:00
__init(__first, __last);
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
}
Cleanup _LIBCPP_HAS_NO_<c++11-features> macro usage in regex llvm-svn: 300627
2017-04-18 23:42:15 +00:00
#ifndef _LIBCPP_CXX03_LANG
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
basic_regex(initializer_list<value_type> __il,
flag_type __f = regex_constants::ECMAScript)
weekly update to by-chapter-summary, plus left and right anchor support in basic posix. llvm-svn: 107938
2010-07-09 00:15:26 +00:00
: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
[libc++] Replace several uses of 0 by nullptr Differential Revision: https://reviews.llvm.org/D43159
2020-11-24 12:53:53 -05:00
__end_(nullptr)
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
{
[libc++] Validate the entire regex is consumed This change would have warned about the bug found in D62451. No unit tests since the exception should never throw. Differential Revision: https://reviews.llvm.org/D62452
2019-11-09 17:01:37 +01:00
__init(__il.begin(), __il.end());
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
}
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-20 12:03:32 -04:00
#endif // _LIBCPP_CXX03_LANG
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
// ~basic_regex() = default;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
// basic_regex& operator=(const basic_regex&) = default;
// basic_regex& operator=(basic_regex&&) = default;
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
basic_regex& operator=(const value_type* __p)
{return assign(__p);}
Cleanup _LIBCPP_HAS_NO_<c++11-features> macro usage in regex llvm-svn: 300627
2017-04-18 23:42:15 +00:00
#ifndef _LIBCPP_CXX03_LANG
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
basic_regex& operator=(initializer_list<value_type> __il)
{return assign(__il);}
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-20 12:03:32 -04:00
#endif // _LIBCPP_CXX03_LANG
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
template <class _ST, class _SA>
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
basic_regex& operator=(const basic_string<value_type, _ST, _SA>& __p)
{return assign(__p);}
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
// assign:
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
basic_regex& assign(const basic_regex& __that)
{return *this = __that;}
Cleanup _LIBCPP_HAS_NO_<c++11-features> macro usage in regex llvm-svn: 300627
2017-04-18 23:42:15 +00:00
#ifndef _LIBCPP_CXX03_LANG
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
_LIBCPP_INLINE_VISIBILITY
basic_regex& assign(basic_regex&& __that) _NOEXCEPT
{return *this = _VSTD::move(__that);}
#endif
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
basic_regex& assign(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
{return assign(__p, __p + __traits_.length(__p), __f);}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Add a missing default parameter to regex::assign. This is LWG3296; reviewed as https://reviews.llvm.org/D67944 llvm-svn: 372896
2019-09-25 16:40:30 +00:00
basic_regex& assign(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript)
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
{return assign(__p, __p + __len, __f);}
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
template <class _ST, class _SA>
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
basic_regex& assign(const basic_string<value_type, _ST, _SA>& __s,
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
flag_type __f = regex_constants::ECMAScript)
{return assign(__s.begin(), __s.end(), __f);}
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
template <class _InputIterator>
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[libc++] Use __is_exactly_{input, forward}_iterator Reviewed By: ldionne, #libc Spies: libcxx-commits Differential Revision: https://reviews.llvm.org/D128646
2022-07-04 22:45:49 +02:00
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value, basic_regex&>::type
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
assign(_InputIterator __first, _InputIterator __last,
flag_type __f = regex_constants::ECMAScript)
{
basic_string<_CharT> __t(__first, __last);
return assign(__t.begin(), __t.end(), __f);
}
private:
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
void __member_init(flag_type __f)
{
__flags_ = __f;
__marked_count_ = 0;
__loop_count_ = 0;
__open_count_ = 0;
__end_ = nullptr;
}
public:
template <class _ForwardIterator>
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
typename enable_if
<
Rename __is_foo_iterator traits to reflect their Cpp17 nature. With the upcoming introduction of iterator concepts in ranges, the meaning of "__is_contiguous_iterator" changes drastically. Currently we intend it to mean "does it have this iterator category", but it could now also mean "does it meet the requirements of this concept", and these can be different.
2019-11-18 01:46:58 -05:00
__is_cpp17_forward_iterator<_ForwardIterator>::value,
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
basic_regex&
>::type
assign(_ForwardIterator __first, _ForwardIterator __last,
flag_type __f = regex_constants::ECMAScript)
{
Make regex::assign not clobber the regex in case of failure. Fixes PR#22213 llvm-svn: 225799
2015-01-13 16:49:52 +00:00
return assign(basic_regex(__first, __last, __f));
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
}
Cleanup _LIBCPP_HAS_NO_<c++11-features> macro usage in regex llvm-svn: 300627
2017-04-18 23:42:15 +00:00
#ifndef _LIBCPP_CXX03_LANG
Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574 llvm-svn: 137522
2011-08-12 21:56:02 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
basic_regex& assign(initializer_list<value_type> __il,
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
flag_type __f = regex_constants::ECMAScript)
{return assign(__il.begin(), __il.end(), __f);}
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-20 12:03:32 -04:00
#endif // _LIBCPP_CXX03_LANG
Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574 llvm-svn: 137522
2011-08-12 21:56:02 +00:00
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
// const operations:
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
unsigned mark_count() const {return __marked_count_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
flag_type flags() const {return __flags_;}
// locale:
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
locale_type imbue(locale_type __loc)
{
__member_init(ECMAScript);
__start_.reset();
return __traits_.imbue(__loc);
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
locale_type getloc() const {return __traits_.getloc();}
// swap:
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
void swap(basic_regex& __r);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
private:
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
unsigned __loop_count() const {return __loop_count_;}
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
_LIBCPP_INLINE_VISIBILITY
bool __use_multiline() const
{
return __get_grammar(__flags_) == ECMAScript && (__flags_ & multiline);
}
[libc++] Validate the entire regex is consumed This change would have warned about the bug found in D62451. No unit tests since the exception should never throw. Differential Revision: https://reviews.llvm.org/D62452
2019-11-09 17:01:37 +01:00
template <class _ForwardIterator>
void
__init(_ForwardIterator __first, _ForwardIterator __last);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
template <class _ForwardIterator>
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
_ForwardIterator
__parse(_ForwardIterator __first, _ForwardIterator __last);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
template <class _ForwardIterator>
_ForwardIterator
__parse_basic_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_RE_expression(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_simple_RE(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_nondupl_RE(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_one_char_or_coll_elem_RE(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_Back_open_paren(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_Back_close_paren(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_Back_open_brace(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_Back_close_brace(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_BACKREF(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_ORD_CHAR(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_QUOTED_CHAR(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
__parse_RE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last,
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
__owns_one_state<_CharT>* __s,
unsigned __mexp_begin, unsigned __mexp_end);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
template <class _ForwardIterator>
_ForwardIterator
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
__parse_ERE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last,
__owns_one_state<_CharT>* __s,
unsigned __mexp_begin, unsigned __mexp_end);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
template <class _ForwardIterator>
_ForwardIterator
__parse_bracket_expression(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__parse_follow_list(_ForwardIterator __first, _ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
template <class _ForwardIterator>
_ForwardIterator
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__parse_expression_term(_ForwardIterator __first, _ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
template <class _ForwardIterator>
_ForwardIterator
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__parse_equivalence_class(_ForwardIterator __first, _ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
template <class _ForwardIterator>
_ForwardIterator
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__parse_character_class(_ForwardIterator __first, _ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
template <class _ForwardIterator>
_ForwardIterator
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__parse_collating_symbol(_ForwardIterator __first, _ForwardIterator __last,
basic_string<_CharT>& __col_sym);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
template <class _ForwardIterator>
_ForwardIterator
__parse_DUP_COUNT(_ForwardIterator __first, _ForwardIterator __last, int& __c);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
template <class _ForwardIterator>
_ForwardIterator
__parse_extended_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_ERE_branch(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_ERE_expression(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_one_char_or_coll_elem_ERE(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_ORD_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_QUOTED_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-22 17:53:24 +00:00
template <class _ForwardIterator>
_ForwardIterator
__parse_ecma_exp(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_alternative(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_term(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_assertion(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_atom(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__parse_atom_escape(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_decimal_escape(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_character_class_escape(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
__parse_character_escape(_ForwardIterator __first, _ForwardIterator __last,
basic_string<_CharT>* __str = nullptr);
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
template <class _ForwardIterator>
_ForwardIterator
__parse_pattern_character(_ForwardIterator __first, _ForwardIterator __last);
grep and egrep grammars llvm-svn: 109534
2010-07-27 19:53:10 +00:00
template <class _ForwardIterator>
_ForwardIterator
__parse_grep(_ForwardIterator __first, _ForwardIterator __last);
template <class _ForwardIterator>
_ForwardIterator
__parse_egrep(_ForwardIterator __first, _ForwardIterator __last);
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
template <class _ForwardIterator>
_ForwardIterator
__parse_class_escape(_ForwardIterator __first, _ForwardIterator __last,
basic_string<_CharT>& __str,
__bracket_expression<_CharT, _Traits>* __ml);
template <class _ForwardIterator>
_ForwardIterator
__parse_awk_escape(_ForwardIterator __first, _ForwardIterator __last,
basic_string<_CharT>* __str = nullptr);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
[libc++] Make parameter names consistent and enforce the naming style using readability-identifier-naming Ensure that parameter names have the style `__lower_case` Reviewed By: ldionne, #libc Spies: aheejin, sstefan1, libcxx-commits, miyuki Differential Revision: https://reviews.llvm.org/D129051
2022-07-08 18:17:26 +02:00
bool __test_back_ref(_CharT);
[libc++] Fixes backreferences for extended grammar. The regex backreferences were not properly parsed and used when using the extended grammar. This change parses them. The issue was found while working on PR34297. Thanks to Mark de Wever for the patch! Differential Revision: https://reviews.llvm.org/D62451
2020-02-19 15:56:15 -05:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
void __push_l_anchor();
weekly update to by-chapter-summary, plus left and right anchor support in basic posix. llvm-svn: 107938
2010-07-09 00:15:26 +00:00
void __push_r_anchor();
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
void __push_match_any();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
void __push_match_any_but_newline();
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
void __push_greedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s,
unsigned __mexp_begin = 0, unsigned __mexp_end = 0)
{__push_loop(__min, numeric_limits<size_t>::max(), __s,
__mexp_begin, __mexp_end);}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
void __push_nongreedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s,
unsigned __mexp_begin = 0, unsigned __mexp_end = 0)
{__push_loop(__min, numeric_limits<size_t>::max(), __s,
__mexp_begin, __mexp_end, false);}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
void __push_loop(size_t __min, size_t __max, __owns_one_state<_CharT>* __s,
size_t __mexp_begin = 0, size_t __mexp_end = 0,
bool __greedy = true);
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__bracket_expression<_CharT, _Traits>* __start_matching_list(bool __negate);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
void __push_char(value_type __c);
back references for BRE llvm-svn: 108168
2010-07-12 18:16:05 +00:00
void __push_back_ref(int __i);
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
void __push_alternation(__owns_one_state<_CharT>* __sa,
__owns_one_state<_CharT>* __sb);
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
void __push_begin_marked_subexpression();
void __push_end_marked_subexpression(unsigned);
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-22 17:53:24 +00:00
void __push_empty();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
void __push_word_boundary(bool);
Bill Fisher: This patch fixes a bug where std::regex in ECMAScript mode was ignoring capture groups inside lookahead assertions. For example, matching /(?=(a))(a)/ to "a" should yield two captures: \1 = "a", \2 = "a" llvm-svn: 186954
2013-07-23 16:18:04 +00:00
void __push_lookahead(const basic_regex&, bool, unsigned);
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
template <class _Allocator>
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
bool
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
__search(const _CharT* __first, const _CharT* __last,
match_results<const _CharT*, _Allocator>& __m,
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
regex_constants::match_flag_type __flags) const;
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
template <class _Allocator>
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
bool
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
__match_at_start(const _CharT* __first, const _CharT* __last,
match_results<const _CharT*, _Allocator>& __m,
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
regex_constants::match_flag_type __flags, bool) const;
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
template <class _Allocator>
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
bool
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__match_at_start_ecma(const _CharT* __first, const _CharT* __last,
match_results<const _CharT*, _Allocator>& __m,
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
regex_constants::match_flag_type __flags, bool) const;
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
template <class _Allocator>
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
bool
__match_at_start_posix_nosubs(const _CharT* __first, const _CharT* __last,
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
match_results<const _CharT*, _Allocator>& __m,
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
regex_constants::match_flag_type __flags, bool) const;
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
template <class _Allocator>
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
bool
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
__match_at_start_posix_subs(const _CharT* __first, const _CharT* __last,
match_results<const _CharT*, _Allocator>& __m,
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
regex_constants::match_flag_type __flags, bool) const;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
template <class _Bp, class _Ap, class _Cp, class _Tp>
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
regex_search(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&,
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
regex_constants::match_flag_type);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
template <class _Ap, class _Cp, class _Tp>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
regex_search(const _Cp*, const _Cp*, match_results<const _Cp*, _Ap>&,
const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
template <class _Bp, class _Cp, class _Tp>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
regex_search(_Bp, _Bp, const basic_regex<_Cp, _Tp>&,
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
regex_constants::match_flag_type);
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
template <class _Cp, class _Tp>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
regex_search(const _Cp*, const _Cp*,
const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
template <class _Cp, class _Ap, class _Tp>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
regex_search(const _Cp*, match_results<const _Cp*, _Ap>&, const basic_regex<_Cp, _Tp>&,
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
regex_constants::match_flag_type);
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
template <class _ST, class _SA, class _Cp, class _Tp>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
regex_search(const basic_string<_Cp, _ST, _SA>& __s,
const basic_regex<_Cp, _Tp>& __e,
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
regex_constants::match_flag_type __flags);
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
regex_search(const basic_string<_Cp, _ST, _SA>& __s,
match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
const basic_regex<_Cp, _Tp>& __e,
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
regex_constants::match_flag_type __flags);
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
Prevent '\b' from backing up into invalid memory. Fixes http://llvm.org/bugs/show_bug.cgi?id=16240. Sorry, I can not think of a good test case for this one, except by running valgrind as reported in the bug. llvm-svn: 185273
2013-06-29 23:45:43 +00:00
template <class _Iter, class _Ap, class _Cp, class _Tp>
friend
bool
regex_search(__wrap_iter<_Iter> __first,
__wrap_iter<_Iter> __last,
match_results<__wrap_iter<_Iter>, _Ap>& __m,
const basic_regex<_Cp, _Tp>& __e,
regex_constants::match_flag_type __flags);
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
template <class, class> friend class __lookahead;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
};
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
[libc++] Remove workarounds for the lack of deduction guides in C++17 All supported compilers have supported deduction guides in C++17 for a while, so this isn't necessary anymore. Differential Revision: https://reviews.llvm.org/D108213
2021-08-17 11:59:07 -04:00
#if _LIBCPP_STD_VER >= 17
Implement deduction guides for basic_regex llvm-svn: 333050
2018-05-23 01:57:02 +00:00
template <class _ForwardIterator,
Rename __is_foo_iterator traits to reflect their Cpp17 nature. With the upcoming introduction of iterator concepts in ranges, the meaning of "__is_contiguous_iterator" changes drastically. Currently we intend it to mean "does it have this iterator category", but it could now also mean "does it meet the requirements of this concept", and these can be different.
2019-11-18 01:46:58 -05:00
class = typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value, nullptr_t>::type
Implement deduction guides for basic_regex llvm-svn: 333050
2018-05-23 01:57:02 +00:00
>
basic_regex(_ForwardIterator, _ForwardIterator,
regex_constants::syntax_option_type = regex_constants::ECMAScript)
-> basic_regex<typename iterator_traits<_ForwardIterator>::value_type>;
#endif
Zhang Xiongpang: Add definitions for const data members. Fixes http://llvm.org/bugs/show_bug.cgi?id=14585. llvm-svn: 170026
2012-12-12 21:14:28 +00:00
template <class _CharT, class _Traits>
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::icase;
template <class _CharT, class _Traits>
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::nosubs;
template <class _CharT, class _Traits>
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::optimize;
template <class _CharT, class _Traits>
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::collate;
template <class _CharT, class _Traits>
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::ECMAScript;
template <class _CharT, class _Traits>
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::basic;
template <class _CharT, class _Traits>
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::extended;
template <class _CharT, class _Traits>
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::awk;
template <class _CharT, class _Traits>
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::grep;
template <class _CharT, class _Traits>
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::egrep;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
template <class _CharT, class _Traits>
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
void
basic_regex<_CharT, _Traits>::swap(basic_regex& __r)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
using _VSTD::swap;
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
swap(__traits_, __r.__traits_);
swap(__flags_, __r.__flags_);
swap(__marked_count_, __r.__marked_count_);
swap(__loop_count_, __r.__loop_count_);
swap(__open_count_, __r.__open_count_);
swap(__start_, __r.__start_);
swap(__end_, __r.__end_);
}
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(basic_regex<_CharT, _Traits>& __x, basic_regex<_CharT, _Traits>& __y)
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
{
Everything under [re.regex] llvm-svn: 111024
2010-08-13 18:11:23 +00:00
return __x.swap(__y);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
}
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
// __lookahead
template <class _CharT, class _Traits>
class __lookahead
: public __owns_one_state<_CharT>
{
typedef __owns_one_state<_CharT> base;
basic_regex<_CharT, _Traits> __exp_;
Bill Fisher: This patch fixes a bug where std::regex in ECMAScript mode was ignoring capture groups inside lookahead assertions. For example, matching /(?=(a))(a)/ to "a" should yield two captures: \1 = "a", \2 = "a" llvm-svn: 186954
2013-07-23 16:18:04 +00:00
unsigned __mexp_;
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
bool __invert_;
__lookahead(const __lookahead&);
__lookahead& operator=(const __lookahead&);
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
typedef _VSTD::__state<_CharT> __state;
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Bill Fisher: This patch fixes a bug where std::regex in ECMAScript mode was ignoring capture groups inside lookahead assertions. For example, matching /(?=(a))(a)/ to "a" should yield two captures: \1 = "a", \2 = "a" llvm-svn: 186954
2013-07-23 16:18:04 +00:00
__lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s, unsigned __mexp)
Fix initializer list order in <regex> to be correct llvm-svn: 242864
2015-07-22 01:29:41 +00:00
: base(__s), __exp_(__exp), __mexp_(__mexp), __invert_(__invert) {}
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
virtual void __exec(__state&) const;
};
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
template <class _CharT, class _Traits>
void
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
__lookahead<_CharT, _Traits>::__exec(__state& __s) const
{
match_results<const _CharT*> __m;
__m.__init(1 + __exp_.mark_count(), __s.__current_, __s.__last_);
[libcxx] Make regex_match backtrack when search fails Summary: Fixes PR19851. alg.re.match/ecma.pass.cpp still XFAILS on linux, but after commenting out locale-related tests, it passes. I don't have a freebsd machine to produce a full pass. Reviewers: mclow.lists Subscribers: cfe-commits, emaste Differential Revision: https://reviews.llvm.org/D26026 llvm-svn: 285352
2016-10-27 21:40:34 +00:00
bool __matched = __exp_.__match_at_start_ecma(
__s.__current_, __s.__last_,
__m,
(__s.__flags_ | regex_constants::match_continuous) &
~regex_constants::__full_match,
__s.__at_first_ && __s.__current_ == __s.__first_);
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
if (__matched != __invert_)
{
__s.__do_ = __state::__accept_but_not_consume;
__s.__node_ = this->first();
Bill Fisher: This patch fixes a bug where std::regex in ECMAScript mode was ignoring capture groups inside lookahead assertions. For example, matching /(?=(a))(a)/ to "a" should yield two captures: \1 = "a", \2 = "a" llvm-svn: 186954
2013-07-23 16:18:04 +00:00
for (unsigned __i = 1; __i < __m.size(); ++__i) {
__s.__sub_matches_[__mexp_ + __i - 1] = __m.__matches_[__i];
}
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
}
else
{
__s.__do_ = __state::__reject;
__s.__node_ = nullptr;
}
}
[libc++] Validate the entire regex is consumed This change would have warned about the bug found in D62451. No unit tests since the exception should never throw. Differential Revision: https://reviews.llvm.org/D62452
2019-11-09 17:01:37 +01:00
template <class _CharT, class _Traits>
template <class _ForwardIterator>
void
basic_regex<_CharT, _Traits>::__init(_ForwardIterator __first, _ForwardIterator __last)
{
if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
_ForwardIterator __temp = __parse(__first, __last);
if ( __temp != __last)
__throw_regex_error<regex_constants::__re_err_parse>();
}
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
basic_regex<_CharT, _Traits>::__parse(_ForwardIterator __first,
_ForwardIterator __last)
{
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
unique_ptr<__node> __h(new __end_state<_CharT>);
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
__start_.reset(new __empty_state<_CharT>(__h.get()));
__h.release();
__end_ = __start_.get();
}
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
switch (__get_grammar(__flags_))
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
{
case ECMAScript:
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
__first = __parse_ecma_exp(__first, __last);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
break;
case basic:
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
__first = __parse_basic_reg_exp(__first, __last);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
break;
case extended:
case awk:
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
__first = __parse_extended_reg_exp(__first, __last);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
break;
case grep:
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
__first = __parse_grep(__first, __last);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
break;
case egrep:
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
__first = __parse_egrep(__first, __last);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
break;
default:
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::__re_err_grammar>();
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
}
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
return __first;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
if (*__first == '^')
{
__push_l_anchor();
++__first;
}
if (__first != __last)
{
__first = __parse_RE_expression(__first, __last);
if (__first != __last)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::next(__first);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
if (__temp == __last && *__first == '$')
{
__push_r_anchor();
++__first;
}
}
}
if (__first != __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::__re_err_empty>();
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
}
return __first;
}
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_extended_reg_exp(_ForwardIterator __first,
_ForwardIterator __last)
{
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
__owns_one_state<_CharT>* __sa = __end_;
_ForwardIterator __temp = __parse_ERE_branch(__first, __last);
if (__temp == __first)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::__re_err_empty>();
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
__first = __temp;
while (__first != __last && *__first == '|')
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
{
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
__owns_one_state<_CharT>* __sb = __end_;
__temp = __parse_ERE_branch(++__first, __last);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
if (__temp == __first)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::__re_err_empty>();
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
__push_alternation(__sa, __sb);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
__first = __temp;
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_ERE_branch(_ForwardIterator __first,
_ForwardIterator __last)
{
_ForwardIterator __temp = __parse_ERE_expression(__first, __last);
if (__temp == __first)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::__re_err_empty>();
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
do
{
__first = __temp;
__temp = __parse_ERE_expression(__first, __last);
} while (__temp != __first);
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_ERE_expression(_ForwardIterator __first,
_ForwardIterator __last)
{
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
__owns_one_state<_CharT>* __e = __end_;
unsigned __mexp_begin = __marked_count_;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
_ForwardIterator __temp = __parse_one_char_or_coll_elem_ERE(__first, __last);
if (__temp == __first && __temp != __last)
{
switch (*__temp)
{
case '^':
__push_l_anchor();
++__temp;
break;
case '$':
__push_r_anchor();
++__temp;
break;
case '(':
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
__push_begin_marked_subexpression();
unsigned __temp_count = __marked_count_;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
++__open_count_;
__temp = __parse_extended_reg_exp(++__temp, __last);
if (__temp == __last || *__temp != ')')
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_paren>();
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
__push_end_marked_subexpression(__temp_count);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
--__open_count_;
++__temp;
break;
}
}
if (__temp != __first)
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
__temp = __parse_ERE_dupl_symbol(__temp, __last, __e, __mexp_begin+1,
__marked_count_+1);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
__first = __temp;
return __first;
}
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_RE_expression(_ForwardIterator __first,
_ForwardIterator __last)
{
while (true)
{
_ForwardIterator __temp = __parse_simple_RE(__first, __last);
if (__temp == __first)
break;
__first = __temp;
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_simple_RE(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
__owns_one_state<_CharT>* __e = __end_;
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
unsigned __mexp_begin = __marked_count_;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
_ForwardIterator __temp = __parse_nondupl_RE(__first, __last);
if (__temp != __first)
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
__first = __parse_RE_dupl_symbol(__temp, __last, __e,
__mexp_begin+1, __marked_count_+1);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_nondupl_RE(_ForwardIterator __first,
_ForwardIterator __last)
{
_ForwardIterator __temp = __first;
__first = __parse_one_char_or_coll_elem_RE(__first, __last);
if (__temp == __first)
{
__temp = __parse_Back_open_paren(__first, __last);
if (__temp != __first)
{
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
__push_begin_marked_subexpression();
unsigned __temp_count = __marked_count_;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
__first = __parse_RE_expression(__temp, __last);
__temp = __parse_Back_close_paren(__first, __last);
if (__temp == __first)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_paren>();
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
__push_end_marked_subexpression(__temp_count);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
__first = __temp;
}
else
__first = __parse_BACKREF(__first, __last);
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_RE(
_ForwardIterator __first,
_ForwardIterator __last)
{
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
_ForwardIterator __temp = __parse_ORD_CHAR(__first, __last);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
if (__temp == __first)
{
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
__temp = __parse_QUOTED_CHAR(__first, __last);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
if (__temp == __first)
{
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
if (__temp != __last && *__temp == '.')
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
{
__push_match_any();
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
++__temp;
}
else
__temp = __parse_bracket_expression(__first, __last);
}
}
__first = __temp;
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_ERE(
_ForwardIterator __first,
_ForwardIterator __last)
{
_ForwardIterator __temp = __parse_ORD_CHAR_ERE(__first, __last);
if (__temp == __first)
{
__temp = __parse_QUOTED_CHAR_ERE(__first, __last);
if (__temp == __first)
{
if (__temp != __last && *__temp == '.')
{
__push_match_any();
++__temp;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
}
else
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
__temp = __parse_bracket_expression(__first, __last);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
}
}
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
__first = __temp;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::next(__first);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
if (__temp != __last)
{
if (*__first == '\\' && *__temp == '(')
__first = ++__temp;
}
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::next(__first);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
if (__temp != __last)
{
if (*__first == '\\' && *__temp == ')')
__first = ++__temp;
}
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::next(__first);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
if (__temp != __last)
{
if (*__first == '\\' && *__temp == '{')
__first = ++__temp;
}
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::next(__first);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
if (__temp != __last)
{
if (*__first == '\\' && *__temp == '}')
__first = ++__temp;
}
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::next(__first);
[libc++] Fixes backreferences for extended grammar. The regex backreferences were not properly parsed and used when using the extended grammar. This change parses them. The issue was found while working on PR34297. Thanks to Mark de Wever for the patch! Differential Revision: https://reviews.llvm.org/D62451
2020-02-19 15:56:15 -05:00
if (__temp != __last && *__first == '\\' && __test_back_ref(*__temp))
__first = ++__temp;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::next(__first);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
if (__temp == __last && *__first == '$')
return __first;
// Not called inside a bracket
if (*__first == '.' || *__first == '\\' || *__first == '[')
return __first;
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
__push_char(*__first);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
++__first;
}
return __first;
}
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_ORD_CHAR_ERE(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
switch (*__first)
{
case '^':
case '.':
case '[':
case '$':
case '(':
case '|':
case '*':
case '+':
case '?':
case '{':
case '\\':
break;
case ')':
if (__open_count_ == 0)
{
__push_char(*__first);
++__first;
}
break;
default:
__push_char(*__first);
++__first;
break;
}
}
return __first;
}
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::next(__first);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
if (__temp != __last)
{
if (*__first == '\\')
{
switch (*__temp)
{
case '^':
case '.':
case '*':
case '[':
case '$':
case '\\':
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
__push_char(*__temp);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
__first = ++__temp;
break;
}
}
}
}
return __first;
}
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::next(__first);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
if (__temp != __last)
{
if (*__first == '\\')
{
switch (*__temp)
{
case '^':
case '.':
case '*':
case '[':
case '$':
case '\\':
case '(':
case ')':
case '|':
case '+':
case '?':
case '{':
Provide missing '{' in parsing extended quoted characters. This fixes http://llvm.org/bugs/show_bug.cgi?id=16135 llvm-svn: 185211
2013-06-28 20:31:05 +00:00
case '}':
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
__push_char(*__temp);
__first = ++__temp;
break;
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
default:
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
if (__get_grammar(__flags_) == awk)
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
__first = __parse_awk_escape(++__first, __last);
[libc++] Fixes backreferences for extended grammar. The regex backreferences were not properly parsed and used when using the extended grammar. This change parses them. The issue was found while working on PR34297. Thanks to Mark de Wever for the patch! Differential Revision: https://reviews.llvm.org/D62451
2020-02-19 15:56:15 -05:00
else if(__test_back_ref(*__temp))
__first = ++__temp;
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
break;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
}
}
}
}
return __first;
}
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_RE_dupl_symbol(_ForwardIterator __first,
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
_ForwardIterator __last,
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
__owns_one_state<_CharT>* __s,
unsigned __mexp_begin,
unsigned __mexp_end)
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
{
if (__first != __last)
{
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
if (*__first == '*')
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
{
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
__push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
++__first;
}
else
{
_ForwardIterator __temp = __parse_Back_open_brace(__first, __last);
if (__temp != __first)
{
int __min = 0;
__first = __temp;
__temp = __parse_DUP_COUNT(__first, __last, __min);
if (__temp == __first)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_badbrace>();
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
__first = __temp;
if (__first == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_brace>();
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
if (*__first != ',')
{
__temp = __parse_Back_close_brace(__first, __last);
if (__temp == __first)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_brace>();
back references for BRE llvm-svn: 108168
2010-07-12 18:16:05 +00:00
__push_loop(__min, __min, __s, __mexp_begin, __mexp_end,
true);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
__first = __temp;
}
else
{
++__first; // consume ','
int __max = -1;
__first = __parse_DUP_COUNT(__first, __last, __max);
__temp = __parse_Back_close_brace(__first, __last);
if (__temp == __first)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_brace>();
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
if (__max == -1)
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
__push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
else
{
if (__max < __min)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_badbrace>();
back references for BRE llvm-svn: 108168
2010-07-12 18:16:05 +00:00
__push_loop(__min, __max, __s, __mexp_begin, __mexp_end,
true);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-24 21:28:00 +00:00
}
__first = __temp;
}
}
}
}
return __first;
}
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_ERE_dupl_symbol(_ForwardIterator __first,
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
_ForwardIterator __last,
__owns_one_state<_CharT>* __s,
unsigned __mexp_begin,
unsigned __mexp_end)
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
{
if (__first != __last)
{
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
unsigned __grammar = __get_grammar(__flags_);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
switch (*__first)
{
case '*':
++__first;
fix parse bug in ecma non-greedy loop llvm-svn: 109711
2010-07-29 00:36:00 +00:00
if (__grammar == ECMAScript && __first != __last && *__first == '?')
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
{
++__first;
__push_nongreedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
}
else
__push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
break;
case '+':
++__first;
fix parse bug in ecma non-greedy loop llvm-svn: 109711
2010-07-29 00:36:00 +00:00
if (__grammar == ECMAScript && __first != __last && *__first == '?')
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
{
++__first;
__push_nongreedy_inf_repeat(1, __s, __mexp_begin, __mexp_end);
}
else
__push_greedy_inf_repeat(1, __s, __mexp_begin, __mexp_end);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
break;
case '?':
++__first;
fix parse bug in ecma non-greedy loop llvm-svn: 109711
2010-07-29 00:36:00 +00:00
if (__grammar == ECMAScript && __first != __last && *__first == '?')
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
{
++__first;
__push_loop(0, 1, __s, __mexp_begin, __mexp_end, false);
}
else
__push_loop(0, 1, __s, __mexp_begin, __mexp_end);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
break;
case '{':
{
int __min;
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
_ForwardIterator __temp = __parse_DUP_COUNT(++__first, __last, __min);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
if (__temp == __first)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_badbrace>();
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
__first = __temp;
if (__first == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_brace>();
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
switch (*__first)
{
case '}':
++__first;
fix parse bug in ecma non-greedy loop llvm-svn: 109711
2010-07-29 00:36:00 +00:00
if (__grammar == ECMAScript && __first != __last && *__first == '?')
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
{
++__first;
__push_loop(__min, __min, __s, __mexp_begin, __mexp_end, false);
}
else
__push_loop(__min, __min, __s, __mexp_begin, __mexp_end);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
break;
case ',':
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-11 17:04:31 +00:00
++__first;
if (__first == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_badbrace>();
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
if (*__first == '}')
{
++__first;
fix parse bug in ecma non-greedy loop llvm-svn: 109711
2010-07-29 00:36:00 +00:00
if (__grammar == ECMAScript && __first != __last && *__first == '?')
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
{
++__first;
__push_nongreedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
}
else
__push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
}
else
{
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
int __max = -1;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
__temp = __parse_DUP_COUNT(__first, __last, __max);
if (__temp == __first)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_brace>();
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
__first = __temp;
if (__first == __last || *__first != '}')
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_brace>();
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
++__first;
if (__max < __min)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_badbrace>();
fix parse bug in ecma non-greedy loop llvm-svn: 109711
2010-07-29 00:36:00 +00:00
if (__grammar == ECMAScript && __first != __last && *__first == '?')
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
{
++__first;
__push_loop(__min, __max, __s, __mexp_begin, __mexp_end, false);
}
else
__push_loop(__min, __max, __s, __mexp_begin, __mexp_end);
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
}
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
break;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
default:
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_badbrace>();
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
}
}
break;
}
}
return __first;
}
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_bracket_expression(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last && *__first == '[')
{
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-11 17:04:31 +00:00
++__first;
if (__first == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_brack>();
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
bool __negate = false;
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
if (*__first == '^')
{
++__first;
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__negate = true;
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__bracket_expression<_CharT, _Traits>* __ml = __start_matching_list(__negate);
// __ml owned by *this
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
if (__first == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_brack>();
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
if (__get_grammar(__flags_) != ECMAScript && *__first == ']')
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
{
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__ml->__add_char(']');
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
++__first;
}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__first = __parse_follow_list(__first, __last, __ml);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
if (__first == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_brack>();
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
if (*__first == '-')
{
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__ml->__add_char('-');
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
++__first;
}
if (__first == __last || *__first != ']')
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_brack>();
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
++__first;
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_follow_list(_ForwardIterator __first,
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
_ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml)
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
{
if (__first != __last)
{
while (true)
{
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
_ForwardIterator __temp = __parse_expression_term(__first, __last,
__ml);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
if (__temp == __first)
break;
__first = __temp;
}
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
_ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml)
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
{
if (__first != __last && *__first != ']')
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::next(__first);
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
basic_string<_CharT> __start_range;
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
if (__temp != __last && *__first == '[')
{
if (*__temp == '=')
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
return __parse_equivalence_class(++__temp, __last, __ml);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
else if (*__temp == ':')
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
return __parse_character_class(++__temp, __last, __ml);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
else if (*__temp == '.')
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__first = __parse_collating_symbol(++__temp, __last, __start_range);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
}
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
unsigned __grammar = __get_grammar(__flags_);
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
if (__start_range.empty())
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
{
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\')
{
if (__grammar == ECMAScript)
__first = __parse_class_escape(++__first, __last, __start_range, __ml);
else
__first = __parse_awk_escape(++__first, __last, &__start_range);
}
else
{
__start_range = *__first;
++__first;
}
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
}
if (__first != __last && *__first != ']')
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__temp = _VSTD::next(__first);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
if (__temp != __last && *__first == '-' && *__temp != ']')
{
// parse a range
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
basic_string<_CharT> __end_range;
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
__first = __temp;
++__temp;
if (__temp != __last && *__first == '[' && *__temp == '.')
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__first = __parse_collating_symbol(++__temp, __last, __end_range);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
else
{
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\')
{
if (__grammar == ECMAScript)
__first = __parse_class_escape(++__first, __last,
__end_range, __ml);
else
__first = __parse_awk_escape(++__first, __last,
&__end_range);
}
else
{
__end_range = *__first;
++__first;
}
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
}
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__ml->__add_range(_VSTD::move(__start_range), _VSTD::move(__end_range));
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
}
Debug mode for string. This commit also marks the first time libc++ debug-mode has found a bug (found one in regex). Had to play with extern templates a bit to get this to work since string is heavily used within libc++.dylib. llvm-svn: 189114
2013-08-23 17:37:05 +00:00
else if (!__start_range.empty())
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
{
if (__start_range.size() == 1)
__ml->__add_char(__start_range[0]);
else
__ml->__add_digraph(__start_range[0], __start_range[1]);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
}
}
Debug mode for string. This commit also marks the first time libc++ debug-mode has found a bug (found one in regex). Had to play with extern templates a bit to get this to work since string is heavily used within libc++.dylib. llvm-svn: 189114
2013-08-23 17:37:05 +00:00
else if (!__start_range.empty())
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
{
if (__start_range.size() == 1)
__ml->__add_char(__start_range[0]);
else
__ml->__add_digraph(__start_range[0], __start_range[1]);
}
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
}
return __first;
}
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_class_escape(_ForwardIterator __first,
_ForwardIterator __last,
basic_string<_CharT>& __str,
__bracket_expression<_CharT, _Traits>* __ml)
{
if (__first == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_escape>();
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
switch (*__first)
{
case 0:
__str = *__first;
return ++__first;
case 'b':
__str = _CharT(8);
return ++__first;
case 'd':
__ml->__add_class(ctype_base::digit);
return ++__first;
case 'D':
__ml->__add_neg_class(ctype_base::digit);
return ++__first;
case 's':
__ml->__add_class(ctype_base::space);
return ++__first;
case 'S':
__ml->__add_neg_class(ctype_base::space);
return ++__first;
case 'w':
__ml->__add_class(ctype_base::alnum);
__ml->__add_char('_');
return ++__first;
case 'W':
__ml->__add_neg_class(ctype_base::alnum);
__ml->__add_neg_char('_');
return ++__first;
}
__first = __parse_character_escape(__first, __last, &__str);
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_awk_escape(_ForwardIterator __first,
_ForwardIterator __last,
basic_string<_CharT>* __str)
{
if (__first == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_escape>();
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
switch (*__first)
{
case '\\':
case '"':
case '/':
if (__str)
*__str = *__first;
else
__push_char(*__first);
return ++__first;
case 'a':
if (__str)
*__str = _CharT(7);
else
__push_char(_CharT(7));
return ++__first;
case 'b':
if (__str)
*__str = _CharT(8);
else
__push_char(_CharT(8));
return ++__first;
case 'f':
if (__str)
*__str = _CharT(0xC);
else
__push_char(_CharT(0xC));
return ++__first;
case 'n':
if (__str)
*__str = _CharT(0xA);
else
__push_char(_CharT(0xA));
return ++__first;
case 'r':
if (__str)
*__str = _CharT(0xD);
else
__push_char(_CharT(0xD));
return ++__first;
case 't':
if (__str)
*__str = _CharT(0x9);
else
__push_char(_CharT(0x9));
return ++__first;
case 'v':
if (__str)
*__str = _CharT(0xB);
else
__push_char(_CharT(0xB));
return ++__first;
}
if ('0' <= *__first && *__first <= '7')
{
unsigned __val = *__first - '0';
if (++__first != __last && ('0' <= *__first && *__first <= '7'))
{
__val = 8 * __val + *__first - '0';
if (++__first != __last && ('0' <= *__first && *__first <= '7'))
Bill Fisher: This patch fixes a bug where the regex parser doesn't advance the pointer after reading the third character of an octal escape (in awk mode). That is, regex{"\141", awk} results in the regular expression /a1/ instead of just /a/. llvm-svn: 185449
2013-07-02 17:43:31 +00:00
__val = 8 * __val + *__first++ - '0';
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
}
if (__str)
*__str = _CharT(__val);
else
__push_char(_CharT(__val));
}
else
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_escape>();
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
return __first;
}
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first,
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
_ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml)
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
{
// Found [=
// This means =] must exist
value_type _Equal_close[2] = {'=', ']'};
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::search(__first, __last, _Equal_close,
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
_Equal_close+2);
if (__temp == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_brack>();
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
// [__first, __temp) contains all text in [= ... =]
string_type __collate_name =
__traits_.lookup_collatename(__first, __temp);
if (__collate_name.empty())
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_collate>();
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
string_type __equiv_name =
__traits_.transform_primary(__collate_name.begin(),
__collate_name.end());
if (!__equiv_name.empty())
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__ml->__add_equivalence(__equiv_name);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
else
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
{
switch (__collate_name.size())
{
case 1:
__ml->__add_char(__collate_name[0]);
break;
case 2:
__ml->__add_digraph(__collate_name[0], __collate_name[1]);
break;
default:
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_collate>();
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
}
}
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__first = _VSTD::next(__temp, 2);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_character_class(_ForwardIterator __first,
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
_ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml)
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
{
// Found [:
// This means :] must exist
value_type _Colon_close[2] = {':', ']'};
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::search(__first, __last, _Colon_close,
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
_Colon_close+2);
if (__temp == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_brack>();
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
// [__first, __temp) contains all text in [: ... :]
typedef typename _Traits::char_class_type char_class_type;
char_class_type __class_type =
__traits_.lookup_classname(__first, __temp, __flags_ & icase);
if (__class_type == 0)
[libcxx] Correctly handle invalid regex character class names Summary: Currently when a regular expression contains an invalid character class name std::regex constructors throw an std::regex_error with std::regex_constants::error_brack code. This patch changes the code to std::regex_constants::error_ctype and adds a test. Reviewers: EricWF, mclow.lists Reviewed By: mclow.lists Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D42291 llvm-svn: 323322
2018-01-24 12:45:18 +00:00
__throw_regex_error<regex_constants::error_ctype>();
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__ml->__add_class(__class_type);
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__first = _VSTD::next(__temp, 2);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first,
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
_ForwardIterator __last,
basic_string<_CharT>& __col_sym)
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
{
// Found [.
// This means .] must exist
value_type _Dot_close[2] = {'.', ']'};
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::search(__first, __last, _Dot_close,
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
_Dot_close+2);
if (__temp == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_brack>();
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
// [__first, __temp) contains all text in [. ... .]
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
__col_sym = __traits_.lookup_collatename(__first, __temp);
switch (__col_sym.size())
{
case 1:
case 2:
break;
default:
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_collate>();
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
}
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__first = _VSTD::next(__temp, 2);
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_DUP_COUNT(_ForwardIterator __first,
_ForwardIterator __last,
int& __c)
{
Update __parse_DUP_COUNT and __parse_BACKREF to use the traits class to recognize digits. Fixes PR18514 llvm-svn: 199541
2014-01-18 03:40:03 +00:00
if (__first != __last )
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
{
Update __parse_DUP_COUNT and __parse_BACKREF to use the traits class to recognize digits. Fixes PR18514 llvm-svn: 199541
2014-01-18 03:40:03 +00:00
int __val = __traits_.value(*__first, 10);
if ( __val != -1 )
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
{
Update __parse_DUP_COUNT and __parse_BACKREF to use the traits class to recognize digits. Fixes PR18514 llvm-svn: 199541
2014-01-18 03:40:03 +00:00
__c = __val;
[NFC][libcxx] Remove trailing whitespace It's incredibly annoying when trying to create diffs llvm-svn: 361981
2019-05-29 16:01:36 +00:00
for (++__first;
Update __parse_DUP_COUNT and __parse_BACKREF to use the traits class to recognize digits. Fixes PR18514 llvm-svn: 199541
2014-01-18 03:40:03 +00:00
__first != __last && ( __val = __traits_.value(*__first, 10)) != -1;
++__first)
{
[libc++] Consistently replace `std::` qualification with `_VSTD::` or nothing. NFCI. I used a lot of `git grep` to find places where `std::` was being used outside of comments and assert-messages. There were three outcomes: - Qualified function calls, e.g. `std::move` becomes `_VSTD::move`. This is the most common case. - Typenames that don't need qualification, e.g. `std::allocator` becomes `allocator`. Leaving these as `_VSTD::allocator` would also be fine, but I decided that removing the qualification is more consistent with existing practice. - Names that specifically need un-versioned `std::` qualification, or that I wasn't sure about. For example, I didn't touch any code in <atomic>, <math.h>, <new>, or any ext/ or experimental/ headers; and I didn't touch any instances of `std::type_info`. In some deduction guides, we were accidentally using `class Alloc = typename std::allocator<T>`, despite `std::allocator<T>`'s type-ness not being template-dependent. Because `std::allocator` is a qualified name, this did parse as we intended; but what we meant was simply `class Alloc = allocator<T>`. Differential Revision: https://reviews.llvm.org/D92250
2020-11-27 11:02:06 -05:00
if (__c >= numeric_limits<int>::max() / 10)
Fix UB - signed integer overflow in regex. Thanks to Tim Shen for the patch. Reviewed as https://reviews.llvm.org/D39066 llvm-svn: 316172
2017-10-19 17:39:16 +00:00
__throw_regex_error<regex_constants::error_badbrace>();
Update __parse_DUP_COUNT and __parse_BACKREF to use the traits class to recognize digits. Fixes PR18514 llvm-svn: 199541
2014-01-18 03:40:03 +00:00
__c *= 10;
__c += __val;
}
regex: learning to crawl llvm-svn: 106882
2010-06-25 20:56:08 +00:00
}
}
return __first;
}
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-22 17:53:24 +00:00
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_ecma_exp(_ForwardIterator __first,
_ForwardIterator __last)
{
__owns_one_state<_CharT>* __sa = __end_;
_ForwardIterator __temp = __parse_alternative(__first, __last);
if (__temp == __first)
__push_empty();
__first = __temp;
while (__first != __last && *__first == '|')
{
__owns_one_state<_CharT>* __sb = __end_;
__temp = __parse_alternative(++__first, __last);
if (__temp == __first)
__push_empty();
__push_alternation(__sa, __sb);
__first = __temp;
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_alternative(_ForwardIterator __first,
_ForwardIterator __last)
{
while (true)
{
_ForwardIterator __temp = __parse_term(__first, __last);
if (__temp == __first)
break;
__first = __temp;
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_term(_ForwardIterator __first,
_ForwardIterator __last)
{
_ForwardIterator __temp = __parse_assertion(__first, __last);
if (__temp == __first)
{
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__owns_one_state<_CharT>* __e = __end_;
unsigned __mexp_begin = __marked_count_;
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-22 17:53:24 +00:00
__temp = __parse_atom(__first, __last);
if (__temp != __first)
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__first = __parse_ERE_dupl_symbol(__temp, __last, __e,
__mexp_begin+1, __marked_count_+1);
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-22 17:53:24 +00:00
}
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
else
__first = __temp;
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-22 17:53:24 +00:00
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
switch (*__first)
{
case '^':
__push_l_anchor();
++__first;
break;
case '$':
__push_r_anchor();
++__first;
break;
case '\\':
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::next(__first);
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-22 17:53:24 +00:00
if (__temp != __last)
{
if (*__temp == 'b')
{
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__push_word_boundary(false);
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-22 17:53:24 +00:00
__first = ++__temp;
}
else if (*__temp == 'B')
{
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__push_word_boundary(true);
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-22 17:53:24 +00:00
__first = ++__temp;
}
}
}
break;
case '(':
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::next(__first);
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-22 17:53:24 +00:00
if (__temp != __last && *__temp == '?')
{
if (++__temp != __last)
{
switch (*__temp)
{
case '=':
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
{
basic_regex __exp;
__exp.__flags_ = __flags_;
__temp = __exp.__parse(++__temp, __last);
Bill Fisher: This patch fixes a bug where std::regex in ECMAScript mode was ignoring capture groups inside lookahead assertions. For example, matching /(?=(a))(a)/ to "a" should yield two captures: \1 = "a", \2 = "a" llvm-svn: 186954
2013-07-23 16:18:04 +00:00
unsigned __mexp = __exp.__marked_count_;
__push_lookahead(_VSTD::move(__exp), false, __marked_count_);
__marked_count_ += __mexp;
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
if (__temp == __last || *__temp != ')')
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_paren>();
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
__first = ++__temp;
}
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-22 17:53:24 +00:00
break;
case '!':
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
{
basic_regex __exp;
__exp.__flags_ = __flags_;
__temp = __exp.__parse(++__temp, __last);
Bill Fisher: This patch fixes a bug where std::regex in ECMAScript mode was ignoring capture groups inside lookahead assertions. For example, matching /(?=(a))(a)/ to "a" should yield two captures: \1 = "a", \2 = "a" llvm-svn: 186954
2013-07-23 16:18:04 +00:00
unsigned __mexp = __exp.__marked_count_;
__push_lookahead(_VSTD::move(__exp), true, __marked_count_);
__marked_count_ += __mexp;
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
if (__temp == __last || *__temp != ')')
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_paren>();
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
__first = ++__temp;
}
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-22 17:53:24 +00:00
break;
}
}
}
}
break;
}
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_atom(_ForwardIterator __first,
_ForwardIterator __last)
{
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
if (__first != __last)
{
switch (*__first)
{
case '.':
__push_match_any_but_newline();
++__first;
break;
case '\\':
__first = __parse_atom_escape(__first, __last);
break;
case '[':
__first = __parse_bracket_expression(__first, __last);
break;
case '(':
{
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-11 17:04:31 +00:00
++__first;
if (__first == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_paren>();
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __temp = _VSTD::next(__first);
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
if (__temp != __last && *__first == '?' && *__temp == ':')
{
++__open_count_;
__first = __parse_ecma_exp(++__temp, __last);
if (__first == __last || *__first != ')')
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_paren>();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
--__open_count_;
++__first;
}
else
{
__push_begin_marked_subexpression();
unsigned __temp_count = __marked_count_;
++__open_count_;
__first = __parse_ecma_exp(__first, __last);
if (__first == __last || *__first != ')')
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_paren>();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__push_end_marked_subexpression(__temp_count);
--__open_count_;
++__first;
}
}
break;
Detect and throw on a class of bad regexes that we mistakenly accepted before. Thanks to Trevor Smigiel for the report llvm-svn: 243030
2015-07-23 18:27:51 +00:00
case '*':
case '+':
case '?':
case '{':
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_badrepeat>();
Detect and throw on a class of bad regexes that we mistakenly accepted before. Thanks to Trevor Smigiel for the report llvm-svn: 243030
2015-07-23 18:27:51 +00:00
break;
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
default:
__first = __parse_pattern_character(__first, __last);
break;
}
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_atom_escape(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last && *__first == '\\')
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __t1 = _VSTD::next(__first);
Fix PR#26175. Thanks to Josh Petrie for the report and the patch. Reviewed as http://reviews.llvm.org/D16262 llvm-svn: 258107
2016-01-19 00:50:37 +00:00
if (__t1 == __last)
__throw_regex_error<regex_constants::error_escape>();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
_ForwardIterator __t2 = __parse_decimal_escape(__t1, __last);
if (__t2 != __t1)
__first = __t2;
else
{
__t2 = __parse_character_class_escape(__t1, __last);
if (__t2 != __t1)
__first = __t2;
else
{
__t2 = __parse_character_escape(__t1, __last);
if (__t2 != __t1)
__first = __t2;
}
}
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_decimal_escape(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
if (*__first == '0')
{
__push_char(_CharT());
++__first;
}
else if ('1' <= *__first && *__first <= '9')
{
unsigned __v = *__first - '0';
Fix bug #31387 - not checking end iterator when parsing decimal escape. Thanks to Karen for the report. llvm-svn: 290500
2016-12-24 17:21:03 +00:00
for (++__first;
__first != __last && '0' <= *__first && *__first <= '9'; ++__first)
Fix an unsigned integer overflow in regex that lead to a bad memory access. Found by OSS-Fuzz llvm-svn: 316191
2017-10-19 22:10:41 +00:00
{
[libc++] Consistently replace `std::` qualification with `_VSTD::` or nothing. NFCI. I used a lot of `git grep` to find places where `std::` was being used outside of comments and assert-messages. There were three outcomes: - Qualified function calls, e.g. `std::move` becomes `_VSTD::move`. This is the most common case. - Typenames that don't need qualification, e.g. `std::allocator` becomes `allocator`. Leaving these as `_VSTD::allocator` would also be fine, but I decided that removing the qualification is more consistent with existing practice. - Names that specifically need un-versioned `std::` qualification, or that I wasn't sure about. For example, I didn't touch any code in <atomic>, <math.h>, <new>, or any ext/ or experimental/ headers; and I didn't touch any instances of `std::type_info`. In some deduction guides, we were accidentally using `class Alloc = typename std::allocator<T>`, despite `std::allocator<T>`'s type-ness not being template-dependent. Because `std::allocator` is a qualified name, this did parse as we intended; but what we meant was simply `class Alloc = allocator<T>`. Differential Revision: https://reviews.llvm.org/D92250
2020-11-27 11:02:06 -05:00
if (__v >= numeric_limits<unsigned>::max() / 10)
Fix an unsigned integer overflow in regex that lead to a bad memory access. Found by OSS-Fuzz llvm-svn: 316191
2017-10-19 22:10:41 +00:00
__throw_regex_error<regex_constants::error_backref>();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__v = 10 * __v + *__first - '0';
Fix an unsigned integer overflow in regex that lead to a bad memory access. Found by OSS-Fuzz llvm-svn: 316191
2017-10-19 22:10:41 +00:00
}
if (__v == 0 || __v > mark_count())
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_backref>();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__push_back_ref(__v);
}
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_character_class_escape(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
__bracket_expression<_CharT, _Traits>* __ml;
switch (*__first)
{
case 'd':
__ml = __start_matching_list(false);
__ml->__add_class(ctype_base::digit);
++__first;
break;
case 'D':
__ml = __start_matching_list(true);
__ml->__add_class(ctype_base::digit);
++__first;
break;
case 's':
__ml = __start_matching_list(false);
__ml->__add_class(ctype_base::space);
++__first;
break;
case 'S':
__ml = __start_matching_list(true);
__ml->__add_class(ctype_base::space);
++__first;
break;
case 'w':
__ml = __start_matching_list(false);
__ml->__add_class(ctype_base::alnum);
__ml->__add_char('_');
++__first;
break;
case 'W':
__ml = __start_matching_list(true);
__ml->__add_class(ctype_base::alnum);
__ml->__add_char('_');
++__first;
break;
}
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_character_escape(_ForwardIterator __first,
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
_ForwardIterator __last,
basic_string<_CharT>* __str)
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
{
if (__first != __last)
{
_ForwardIterator __t;
unsigned __sum = 0;
int __hd;
switch (*__first)
{
case 'f':
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
if (__str)
*__str = _CharT(0xC);
else
__push_char(_CharT(0xC));
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
++__first;
break;
case 'n':
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
if (__str)
*__str = _CharT(0xA);
else
__push_char(_CharT(0xA));
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
++__first;
break;
case 'r':
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
if (__str)
*__str = _CharT(0xD);
else
__push_char(_CharT(0xD));
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
++__first;
break;
case 't':
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
if (__str)
*__str = _CharT(0x9);
else
__push_char(_CharT(0x9));
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
++__first;
break;
case 'v':
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
if (__str)
*__str = _CharT(0xB);
else
__push_char(_CharT(0xB));
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
++__first;
break;
case 'c':
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
if ((__t = _VSTD::next(__first)) != __last)
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
{
[NFC][libcxx] Remove trailing whitespace It's incredibly annoying when trying to create diffs llvm-svn: 361981
2019-05-29 16:01:36 +00:00
if (('A' <= *__t && *__t <= 'Z') ||
Bill Fisher: This patch fixes an ill-formed comparison when parsing control escapes, e.g. "\cA\ca". The code will now throw an error_escape exception for invalid control sequences like "\c:" or "\c". I've added the test cases to bad_escape.pass.cpp. llvm-svn: 186335
2013-07-15 18:21:11 +00:00
('a' <= *__t && *__t <= 'z'))
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
{
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
if (__str)
*__str = _CharT(*__t % 32);
else
__push_char(_CharT(*__t % 32));
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__first = ++__t;
}
[NFC][libcxx] Remove trailing whitespace It's incredibly annoying when trying to create diffs llvm-svn: 361981
2019-05-29 16:01:36 +00:00
else
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_escape>();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
}
Bill Fisher: This patch fixes an ill-formed comparison when parsing control escapes, e.g. "\cA\ca". The code will now throw an error_escape exception for invalid control sequences like "\c:" or "\c". I've added the test cases to bad_escape.pass.cpp. llvm-svn: 186335
2013-07-15 18:21:11 +00:00
else
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_escape>();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
break;
case 'u':
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-11 17:04:31 +00:00
++__first;
if (__first == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_escape>();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__hd = __traits_.value(*__first, 16);
if (__hd == -1)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_escape>();
Quash a whole bunch of warnings llvm-svn: 145624
2011-12-01 20:21:04 +00:00
__sum = 16 * __sum + static_cast<unsigned>(__hd);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-11 17:04:31 +00:00
++__first;
if (__first == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_escape>();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__hd = __traits_.value(*__first, 16);
if (__hd == -1)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_escape>();
Quash a whole bunch of warnings llvm-svn: 145624
2011-12-01 20:21:04 +00:00
__sum = 16 * __sum + static_cast<unsigned>(__hd);
[libc++] Fix a few warnings in system headers with GCC This isn't fixing all of them, but at least it's making some progress. Differential Revision: https://reviews.llvm.org/D106283
2021-07-27 17:30:47 -04:00
// fallthrough
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
case 'x':
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-11 17:04:31 +00:00
++__first;
if (__first == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_escape>();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__hd = __traits_.value(*__first, 16);
if (__hd == -1)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_escape>();
Quash a whole bunch of warnings llvm-svn: 145624
2011-12-01 20:21:04 +00:00
__sum = 16 * __sum + static_cast<unsigned>(__hd);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-11 17:04:31 +00:00
++__first;
if (__first == __last)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_escape>();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__hd = __traits_.value(*__first, 16);
if (__hd == -1)
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_escape>();
Quash a whole bunch of warnings llvm-svn: 145624
2011-12-01 20:21:04 +00:00
__sum = 16 * __sum + static_cast<unsigned>(__hd);
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
if (__str)
*__str = _CharT(__sum);
else
__push_char(_CharT(__sum));
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
++__first;
break;
Fix Bug 19678 - libc++ does not correctly handle the regex: '[^\0]*' llvm-svn: 209307
2014-05-21 16:29:50 +00:00
case '0':
if (__str)
*__str = _CharT(0);
else
__push_char(_CharT(0));
++__first;
break;
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
default:
if (*__first != '_' && !__traits_.isctype(*__first, ctype_base::alnum))
{
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-28 17:35:27 +00:00
if (__str)
*__str = *__first;
else
__push_char(*__first);
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
++__first;
}
Bill Fisher: Fix for failing to throw an exception in regex when parsing an invalid escape sequence. This fixes http://llvm.org/bugs/show_bug.cgi?id=16023 llvm-svn: 185192
2013-06-28 18:57:30 +00:00
else
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::error_escape>();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
break;
}
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_pattern_character(_ForwardIterator __first,
_ForwardIterator __last)
{
if (__first != __last)
{
switch (*__first)
{
case '^':
case '$':
case '\\':
case '.':
case '*':
case '+':
case '?':
case '(':
case ')':
case '[':
case ']':
case '{':
case '}':
case '|':
break;
default:
__push_char(*__first);
++__first;
break;
}
}
return __first;
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-22 17:53:24 +00:00
}
grep and egrep grammars llvm-svn: 109534
2010-07-27 19:53:10 +00:00
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first,
_ForwardIterator __last)
{
__owns_one_state<_CharT>* __sa = __end_;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
grep and egrep grammars llvm-svn: 109534
2010-07-27 19:53:10 +00:00
if (__t1 != __first)
__parse_basic_reg_exp(__first, __t1);
else
__push_empty();
__first = __t1;
if (__first != __last)
++__first;
while (__first != __last)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__t1 = _VSTD::find(__first, __last, _CharT('\n'));
grep and egrep grammars llvm-svn: 109534
2010-07-27 19:53:10 +00:00
__owns_one_state<_CharT>* __sb = __end_;
if (__t1 != __first)
__parse_basic_reg_exp(__first, __t1);
else
__push_empty();
__push_alternation(__sa, __sb);
__first = __t1;
if (__first != __last)
++__first;
}
return __first;
}
template <class _CharT, class _Traits>
template <class _ForwardIterator>
_ForwardIterator
basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first,
_ForwardIterator __last)
{
__owns_one_state<_CharT>* __sa = __end_;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
grep and egrep grammars llvm-svn: 109534
2010-07-27 19:53:10 +00:00
if (__t1 != __first)
__parse_extended_reg_exp(__first, __t1);
else
__push_empty();
__first = __t1;
if (__first != __last)
++__first;
while (__first != __last)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__t1 = _VSTD::find(__first, __last, _CharT('\n'));
grep and egrep grammars llvm-svn: 109534
2010-07-27 19:53:10 +00:00
__owns_one_state<_CharT>* __sb = __end_;
if (__t1 != __first)
__parse_extended_reg_exp(__first, __t1);
else
__push_empty();
__push_alternation(__sa, __sb);
__first = __t1;
if (__first != __last)
++__first;
}
return __first;
}
[libc++] Fixes backreferences for extended grammar. The regex backreferences were not properly parsed and used when using the extended grammar. This change parses them. The issue was found while working on PR34297. Thanks to Mark de Wever for the patch! Differential Revision: https://reviews.llvm.org/D62451
2020-02-19 15:56:15 -05:00
template <class _CharT, class _Traits>
bool
[libc++] Make parameter names consistent and enforce the naming style using readability-identifier-naming Ensure that parameter names have the style `__lower_case` Reviewed By: ldionne, #libc Spies: aheejin, sstefan1, libcxx-commits, miyuki Differential Revision: https://reviews.llvm.org/D129051
2022-07-08 18:17:26 +02:00
basic_regex<_CharT, _Traits>::__test_back_ref(_CharT __c)
[libc++] Fixes backreferences for extended grammar. The regex backreferences were not properly parsed and used when using the extended grammar. This change parses them. The issue was found while working on PR34297. Thanks to Mark de Wever for the patch! Differential Revision: https://reviews.llvm.org/D62451
2020-02-19 15:56:15 -05:00
{
[libc++] Make parameter names consistent and enforce the naming style using readability-identifier-naming Ensure that parameter names have the style `__lower_case` Reviewed By: ldionne, #libc Spies: aheejin, sstefan1, libcxx-commits, miyuki Differential Revision: https://reviews.llvm.org/D129051
2022-07-08 18:17:26 +02:00
unsigned __val = __traits_.value(__c, 10);
[libc++] Fixes backreferences for extended grammar. The regex backreferences were not properly parsed and used when using the extended grammar. This change parses them. The issue was found while working on PR34297. Thanks to Mark de Wever for the patch! Differential Revision: https://reviews.llvm.org/D62451
2020-02-19 15:56:15 -05:00
if (__val >= 1 && __val <= 9)
{
[libc++][regex] Validate backreferences in the constructor. This patch enables throwing exceptions for invalid backreferences in the constructor when using the basic, extended, grep, or egrep grammar. This fixes bug 34297. Differential Revision: https://reviews.llvm.org/D62453
2020-02-20 18:13:38 -05:00
if (__val > mark_count())
__throw_regex_error<regex_constants::error_backref>();
[libc++] Fixes backreferences for extended grammar. The regex backreferences were not properly parsed and used when using the extended grammar. This change parses them. The issue was found while working on PR34297. Thanks to Mark de Wever for the patch! Differential Revision: https://reviews.llvm.org/D62451
2020-02-19 15:56:15 -05:00
__push_back_ref(__val);
return true;
}
return false;
}
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
template <class _CharT, class _Traits>
void
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
basic_regex<_CharT, _Traits>::__push_loop(size_t __min, size_t __max,
__owns_one_state<_CharT>* __s, size_t __mexp_begin, size_t __mexp_end,
bool __greedy)
{
unique_ptr<__empty_state<_CharT> > __e1(new __empty_state<_CharT>(__end_->first()));
__end_->first() = nullptr;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
unique_ptr<__loop<_CharT> > __e2(new __loop<_CharT>(__loop_count_,
__s->first(), __e1.get(), __mexp_begin, __mexp_end, __greedy,
__min, __max));
__s->first() = nullptr;
__e1.release();
__end_->first() = new __repeat_one_loop<_CharT>(__e2.get());
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
__end_ = __e2->second();
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__s->first() = __e2.release();
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
++__loop_count_;
}
template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::__push_char(value_type __c)
{
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
if (flags() & icase)
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-12 19:11:27 +00:00
__end_->first() = new __match_char_icase<_CharT, _Traits>
(__traits_, __c, __end_->first());
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
else if (flags() & collate)
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-12 19:11:27 +00:00
__end_->first() = new __match_char_collate<_CharT, _Traits>
(__traits_, __c, __end_->first());
else
__end_->first() = new __match_char<_CharT>(__c, __end_->first());
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
}
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::__push_begin_marked_subexpression()
{
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
if (!(__flags_ & nosubs))
{
__end_->first() =
new __begin_marked_subexpression<_CharT>(++__marked_count_,
__end_->first());
__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
}
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
}
template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::__push_end_marked_subexpression(unsigned __sub)
{
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
if (!(__flags_ & nosubs))
{
__end_->first() =
new __end_marked_subexpression<_CharT>(__sub, __end_->first());
__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
}
First test for marked subexpressions llvm-svn: 107317
2010-06-30 20:30:19 +00:00
}
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::__push_l_anchor()
{
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
__end_->first() = new __l_anchor_multiline<_CharT>(__use_multiline(), __end_->first());
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
}
weekly update to by-chapter-summary, plus left and right anchor support in basic posix. llvm-svn: 107938
2010-07-09 00:15:26 +00:00
template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::__push_r_anchor()
{
[libc++] Implements multiline regex support. This resolves LWG2503.
2020-11-18 18:09:13 +01:00
__end_->first() = new __r_anchor_multiline<_CharT>(__use_multiline(), __end_->first());
weekly update to by-chapter-summary, plus left and right anchor support in basic posix. llvm-svn: 107938
2010-07-09 00:15:26 +00:00
__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::__push_match_any()
{
__end_->first() = new __match_any<_CharT>(__end_->first());
__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
}
weekly update to by-chapter-summary, plus left and right anchor support in basic posix. llvm-svn: 107938
2010-07-09 00:15:26 +00:00
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::__push_match_any_but_newline()
{
__end_->first() = new __match_any_but_newline<_CharT>(__end_->first());
__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
}
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-22 17:53:24 +00:00
template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::__push_empty()
{
__end_->first() = new __empty_state<_CharT>(__end_->first());
__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
}
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::__push_word_boundary(bool __invert)
{
__end_->first() = new __word_boundary<_CharT, _Traits>(__traits_, __invert,
__end_->first());
__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
}
back references for BRE llvm-svn: 108168
2010-07-12 18:16:05 +00:00
template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::__push_back_ref(int __i)
{
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
if (flags() & icase)
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-12 19:11:27 +00:00
__end_->first() = new __back_ref_icase<_CharT, _Traits>
(__traits_, __i, __end_->first());
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
else if (flags() & collate)
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-12 19:11:27 +00:00
__end_->first() = new __back_ref_collate<_CharT, _Traits>
(__traits_, __i, __end_->first());
else
__end_->first() = new __back_ref<_CharT>(__i, __end_->first());
back references for BRE llvm-svn: 108168
2010-07-12 18:16:05 +00:00
__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-16 19:08:36 +00:00
}
template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::__push_alternation(__owns_one_state<_CharT>* __sa,
__owns_one_state<_CharT>* __ea)
{
__sa->first() = new __alternate<_CharT>(
static_cast<__owns_one_state<_CharT>*>(__sa->first()),
static_cast<__owns_one_state<_CharT>*>(__ea->first()));
__ea->first() = nullptr;
__ea->first() = new __empty_state<_CharT>(__end_->first());
__end_->first() = nullptr;
__end_->first() = new __empty_non_own_state<_CharT>(__ea->first());
__end_ = static_cast<__owns_one_state<_CharT>*>(__ea->first());
back references for BRE llvm-svn: 108168
2010-07-12 18:16:05 +00:00
}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-13 21:48:06 +00:00
template <class _CharT, class _Traits>
__bracket_expression<_CharT, _Traits>*
basic_regex<_CharT, _Traits>::__start_matching_list(bool __negate)
{
__bracket_expression<_CharT, _Traits>* __r =
new __bracket_expression<_CharT, _Traits>(__traits_, __end_->first(),
__negate, __flags_ & icase,
__flags_ & collate);
__end_->first() = __r;
__end_ = __r;
return __r;
}
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::__push_lookahead(const basic_regex& __exp,
Bill Fisher: This patch fixes a bug where std::regex in ECMAScript mode was ignoring capture groups inside lookahead assertions. For example, matching /(?=(a))(a)/ to "a" should yield two captures: \1 = "a", \2 = "a" llvm-svn: 186954
2013-07-23 16:18:04 +00:00
bool __invert,
unsigned __mexp)
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
{
__end_->first() = new __lookahead<_CharT, _Traits>(__exp, __invert,
Bill Fisher: This patch fixes a bug where std::regex in ECMAScript mode was ignoring capture groups inside lookahead assertions. For example, matching /(?=(a))(a)/ to "a" should yield two captures: \1 = "a", \2 = "a" llvm-svn: 186954
2013-07-23 16:18:04 +00:00
__end_->first(), __mexp);
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
}
Revert "Add new 'preferred_name' attribute." This change exposed a pre-existing issue with deserialization cycles caused by a combination of attributes and template instantiations violating the deserialization ordering restrictions; see PR48434 for details. A previous commit attempted to work around PR48434, but appears to have only been a partial fix, and fixing this properly seems non-trivial. Backing out for now to unblock things. This reverts commit 98f76adf4e941738c0b9fe3b9965fa63603e9c89 and commit a64c26a47a81b1b44e36d235ff3bc6a74a0bad9f.
2020-12-08 00:42:26 -08:00
// sub_match
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
typedef sub_match<const char*> csub_match;
typedef sub_match<string::const_iterator> ssub_match;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef sub_match<const wchar_t*> wcsub_match;
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
typedef sub_match<wstring::const_iterator> wssub_match;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#endif
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
template <class _BidirectionalIterator>
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
class
_LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(csub_match)
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcsub_match))
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
_LIBCPP_PREFERRED_NAME(ssub_match)
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wssub_match))
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
sub_match
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
: public pair<_BidirectionalIterator, _BidirectionalIterator>
{
public:
typedef _BidirectionalIterator iterator;
typedef typename iterator_traits<iterator>::value_type value_type;
typedef typename iterator_traits<iterator>::difference_type difference_type;
typedef basic_string<value_type> string_type;
bool matched;
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-08 21:07:55 +00:00
_LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 01:31:58 +00:00
_LIBCPP_CONSTEXPR sub_match() : matched() {}
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-08 21:07:55 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
difference_type length() const
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
{return matched ? _VSTD::distance(this->first, this->second) : 0;}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
string_type str() const
{return matched ? string_type(this->first, this->second) : string_type();}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
operator string_type() const
{return str();}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
int compare(const sub_match& __s) const
{return str().compare(__s.str());}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
int compare(const string_type& __s) const
{return str().compare(__s);}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
int compare(const value_type* __s) const
{return str().compare(__s);}
};
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
{
return __x.compare(__y) == 0;
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
{
return !(__x == __y);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
{
return __x.compare(__y) < 0;
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
{
return !(__y < __x);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
{
return !(__x < __y);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
{
return __y < __x;
}
template <class _BiIter, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
const sub_match<_BiIter>& __y)
{
Implement LWG 2217 - operator==(sub_match, string) slices on embedded '\0's llvm-svn: 224292
2014-12-15 23:57:56 +00:00
return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) == 0;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
}
template <class _BiIter, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
const sub_match<_BiIter>& __y)
{
return !(__x == __y);
}
template <class _BiIter, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
const sub_match<_BiIter>& __y)
{
Implement LWG 2217 - operator==(sub_match, string) slices on embedded '\0's llvm-svn: 224292
2014-12-15 23:57:56 +00:00
return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) > 0;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
}
template <class _BiIter, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
const sub_match<_BiIter>& __y)
{
return __y < __x;
}
template <class _BiIter, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
bool operator>=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
const sub_match<_BiIter>& __y)
{
return !(__x < __y);
}
template <class _BiIter, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
const sub_match<_BiIter>& __y)
{
return !(__y < __x);
}
template <class _BiIter, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(const sub_match<_BiIter>& __x,
const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
{
Implement LWG 2217 - operator==(sub_match, string) slices on embedded '\0's llvm-svn: 224292
2014-12-15 23:57:56 +00:00
return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) == 0;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
}
template <class _BiIter, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(const sub_match<_BiIter>& __x,
const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
{
return !(__x == __y);
}
template <class _BiIter, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<(const sub_match<_BiIter>& __x,
const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
{
Implement LWG 2217 - operator==(sub_match, string) slices on embedded '\0's llvm-svn: 224292
2014-12-15 23:57:56 +00:00
return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) < 0;
[re.submatch] llvm-svn: 107187
2010-06-29 18:37:43 +00:00
}
template <class _BiIter, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
bool operator>(const sub_match<_BiIter>& __x,
const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
{
return __y < __x;
}
template <class _BiIter, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>=(const sub_match<_BiIter>& __x,
const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
{
return !(__x < __y);
}
template <class _BiIter, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<=(const sub_match<_BiIter>& __x,
const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
{
return !(__y < __x);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(typename iterator_traits<_BiIter>::value_type const* __x,
const sub_match<_BiIter>& __y)
{
return __y.compare(__x) == 0;
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(typename iterator_traits<_BiIter>::value_type const* __x,
const sub_match<_BiIter>& __y)
{
return !(__x == __y);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<(typename iterator_traits<_BiIter>::value_type const* __x,
const sub_match<_BiIter>& __y)
{
return __y.compare(__x) > 0;
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>(typename iterator_traits<_BiIter>::value_type const* __x,
const sub_match<_BiIter>& __y)
{
return __y < __x;
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>=(typename iterator_traits<_BiIter>::value_type const* __x,
const sub_match<_BiIter>& __y)
{
return !(__x < __y);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<=(typename iterator_traits<_BiIter>::value_type const* __x,
const sub_match<_BiIter>& __y)
{
return !(__y < __x);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(const sub_match<_BiIter>& __x,
typename iterator_traits<_BiIter>::value_type const* __y)
{
return __x.compare(__y) == 0;
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(const sub_match<_BiIter>& __x,
typename iterator_traits<_BiIter>::value_type const* __y)
{
return !(__x == __y);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<(const sub_match<_BiIter>& __x,
typename iterator_traits<_BiIter>::value_type const* __y)
{
return __x.compare(__y) < 0;
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>(const sub_match<_BiIter>& __x,
typename iterator_traits<_BiIter>::value_type const* __y)
{
return __y < __x;
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>=(const sub_match<_BiIter>& __x,
typename iterator_traits<_BiIter>::value_type const* __y)
{
return !(__x < __y);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<=(const sub_match<_BiIter>& __x,
typename iterator_traits<_BiIter>::value_type const* __y)
{
return !(__y < __x);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(typename iterator_traits<_BiIter>::value_type const& __x,
const sub_match<_BiIter>& __y)
{
typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
return __y.compare(string_type(1, __x)) == 0;
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(typename iterator_traits<_BiIter>::value_type const& __x,
const sub_match<_BiIter>& __y)
{
return !(__x == __y);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<(typename iterator_traits<_BiIter>::value_type const& __x,
const sub_match<_BiIter>& __y)
{
typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
return __y.compare(string_type(1, __x)) > 0;
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>(typename iterator_traits<_BiIter>::value_type const& __x,
const sub_match<_BiIter>& __y)
{
return __y < __x;
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>=(typename iterator_traits<_BiIter>::value_type const& __x,
const sub_match<_BiIter>& __y)
{
return !(__x < __y);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<=(typename iterator_traits<_BiIter>::value_type const& __x,
const sub_match<_BiIter>& __y)
{
return !(__y < __x);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator==(const sub_match<_BiIter>& __x,
typename iterator_traits<_BiIter>::value_type const& __y)
{
typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
return __x.compare(string_type(1, __y)) == 0;
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(const sub_match<_BiIter>& __x,
typename iterator_traits<_BiIter>::value_type const& __y)
{
return !(__x == __y);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<(const sub_match<_BiIter>& __x,
typename iterator_traits<_BiIter>::value_type const& __y)
{
typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
return __x.compare(string_type(1, __y)) < 0;
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>(const sub_match<_BiIter>& __x,
typename iterator_traits<_BiIter>::value_type const& __y)
{
return __y < __x;
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator>=(const sub_match<_BiIter>& __x,
typename iterator_traits<_BiIter>::value_type const& __y)
{
return !(__x < __y);
}
template <class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<=(const sub_match<_BiIter>& __x,
typename iterator_traits<_BiIter>::value_type const& __y)
{
return !(__y < __x);
}
template <class _CharT, class _ST, class _BiIter>
inline _LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _ST>&
operator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m)
{
return __os << __m.str();
}
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
typedef match_results<const char*> cmatch;
typedef match_results<string::const_iterator> smatch;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef match_results<const wchar_t*> wcmatch;
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
typedef match_results<wstring::const_iterator> wsmatch;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#endif
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
template <class _BidirectionalIterator, class _Allocator>
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
class
_LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(cmatch)
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcmatch))
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
_LIBCPP_PREFERRED_NAME(smatch)
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsmatch))
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
match_results
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
{
public:
typedef _Allocator allocator_type;
typedef sub_match<_BidirectionalIterator> value_type;
private:
typedef vector<value_type, allocator_type> __container_type;
__container_type __matches_;
value_type __unmatched_;
value_type __prefix_;
value_type __suffix_;
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-08 21:07:55 +00:00
bool __ready_;
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
public:
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
_BidirectionalIterator __position_start_;
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
typedef const value_type& const_reference;
Implement LWG issue 2306: match_results::reference should be value_type&, not const value_type&. This is a general move by the LWG to have the reference type of read-only containers be a non-const reference; however, there are no methods that return a non-const reference to a match_result entry, so there's no worries about getting a non-const reference to a constant object. llvm-svn: 202214
2014-02-26 01:56:31 +00:00
typedef value_type& reference;
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
typedef typename __container_type::const_iterator const_iterator;
typedef const_iterator iterator;
typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
typedef typename allocator_traits<allocator_type>::size_type size_type;
typedef typename iterator_traits<_BidirectionalIterator>::value_type char_type;
typedef basic_string<char_type> string_type;
// construct/copy/destroy:
[libc++] [P0935] [C++20] Eradicating unnecessarily explicit default constructors from the standard library. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0935r0.html Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D91292
2021-01-19 08:21:09 +01:00
#ifndef _LIBCPP_CXX03_LANG
match_results() : match_results(allocator_type()) {}
explicit match_results(const allocator_type& __a);
#else
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
explicit match_results(const allocator_type& __a = allocator_type());
[libc++] [P0935] [C++20] Eradicating unnecessarily explicit default constructors from the standard library. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0935r0.html Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D91292
2021-01-19 08:21:09 +01:00
#endif
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
// match_results(const match_results&) = default;
// match_results& operator=(const match_results&) = default;
// match_results(match_results&& __m) = default;
// match_results& operator=(match_results&& __m) = default;
// ~match_results() = default;
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-08 21:07:55 +00:00
_LIBCPP_INLINE_VISIBILITY
bool ready() const {return __ready_;}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
// size:
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
More of P0600 - '[[nodiscard]] in the Library' mark empty() as nodiscard in match_results. <regex> llvm-svn: 318375
2017-11-16 04:48:34 +00:00
size_type size() const _NOEXCEPT {return __matches_.size();}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
More of P0600 - '[[nodiscard]] in the Library' mark empty() as nodiscard in match_results. <regex> llvm-svn: 318375
2017-11-16 04:48:34 +00:00
size_type max_size() const _NOEXCEPT {return __matches_.max_size();}
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
bool empty() const _NOEXCEPT {return size() == 0;}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
// element access:
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
difference_type length(size_type __sub = 0) const
Add '_LIBCPP_ASSERT(ready())' to several match_results method that have this precondtion. Fix several tests which did not honor this precondition. Thanks to Andrey Maksimov for pointing this out. llvm-svn: 359324
2019-04-26 17:10:03 +00:00
{
_LIBCPP_ASSERT(ready(), "match_results::length() called when not ready");
return (*this)[__sub].length();
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
difference_type position(size_type __sub = 0) const
Add '_LIBCPP_ASSERT(ready())' to several match_results method that have this precondtion. Fix several tests which did not honor this precondition. Thanks to Andrey Maksimov for pointing this out. llvm-svn: 359324
2019-04-26 17:10:03 +00:00
{
_LIBCPP_ASSERT(ready(), "match_results::position() called when not ready");
return _VSTD::distance(__position_start_, (*this)[__sub].first);
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
string_type str(size_type __sub = 0) const
Add '_LIBCPP_ASSERT(ready())' to several match_results method that have this precondtion. Fix several tests which did not honor this precondition. Thanks to Andrey Maksimov for pointing this out. llvm-svn: 359324
2019-04-26 17:10:03 +00:00
{
_LIBCPP_ASSERT(ready(), "match_results::str() called when not ready");
return (*this)[__sub].str();
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
const_reference operator[](size_type __n) const
Add '_LIBCPP_ASSERT(ready())' to several match_results method that have this precondtion. Fix several tests which did not honor this precondition. Thanks to Andrey Maksimov for pointing this out. llvm-svn: 359324
2019-04-26 17:10:03 +00:00
{
_LIBCPP_ASSERT(ready(), "match_results::operator[]() called when not ready");
return __n < __matches_.size() ? __matches_[__n] : __unmatched_;
}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Add '_LIBCPP_ASSERT(ready())' to several match_results method that have this precondtion. Fix several tests which did not honor this precondition. Thanks to Andrey Maksimov for pointing this out. llvm-svn: 359324
2019-04-26 17:10:03 +00:00
const_reference prefix() const
{
_LIBCPP_ASSERT(ready(), "match_results::prefix() called when not ready");
return __prefix_;
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Add '_LIBCPP_ASSERT(ready())' to several match_results method that have this precondtion. Fix several tests which did not honor this precondition. Thanks to Andrey Maksimov for pointing this out. llvm-svn: 359324
2019-04-26 17:10:03 +00:00
const_reference suffix() const
{
_LIBCPP_ASSERT(ready(), "match_results::suffix() called when not ready");
return __suffix_;
}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Fix <rdar://problem/10255403> match_results::begin() is off by one llvm-svn: 141494
2011-10-08 14:36:16 +00:00
const_iterator begin() const {return empty() ? __matches_.end() : __matches_.begin();}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
const_iterator end() const {return __matches_.end();}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Fix <rdar://problem/10255403> match_results::begin() is off by one llvm-svn: 141494
2011-10-08 14:36:16 +00:00
const_iterator cbegin() const {return empty() ? __matches_.end() : __matches_.begin();}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
const_iterator cend() const {return __matches_.end();}
// format:
template <class _OutputIter>
_OutputIter
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
format(_OutputIter __output_iter, const char_type* __fmt_first,
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
const char_type* __fmt_last,
regex_constants::match_flag_type __flags = regex_constants::format_default) const;
template <class _OutputIter, class _ST, class _SA>
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
_OutputIter
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
format(_OutputIter __output_iter, const basic_string<char_type, _ST, _SA>& __fmt,
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
regex_constants::match_flag_type __flags = regex_constants::format_default) const
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
{return format(__output_iter, __fmt.data(), __fmt.data() + __fmt.size(), __flags);}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
template <class _ST, class _SA>
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
basic_string<char_type, _ST, _SA>
format(const basic_string<char_type, _ST, _SA>& __fmt,
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
regex_constants::match_flag_type __flags = regex_constants::format_default) const
{
basic_string<char_type, _ST, _SA> __r;
format(back_inserter(__r), __fmt.data(), __fmt.data() + __fmt.size(),
__flags);
return __r;
}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
string_type
format(const char_type* __fmt,
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
regex_constants::match_flag_type __flags = regex_constants::format_default) const
{
string_type __r;
format(back_inserter(__r), __fmt,
__fmt + char_traits<char_type>::length(__fmt), __flags);
return __r;
}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
// allocator:
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
allocator_type get_allocator() const {return __matches_.get_allocator();}
// swap:
void swap(match_results& __m);
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
template <class _Bp, class _Ap>
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
void __assign(_BidirectionalIterator __f, _BidirectionalIterator __l,
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
const match_results<_Bp, _Ap>& __m, bool __no_update_pos)
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
{
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
_Bp __mf = __m.prefix().first;
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
__matches_.resize(__m.size());
for (size_type __i = 0; __i < __matches_.size(); ++__i)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__matches_[__i].first = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].first));
__matches_[__i].second = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].second));
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
__matches_[__i].matched = __m[__i].matched;
}
__unmatched_.first = __l;
__unmatched_.second = __l;
__unmatched_.matched = false;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__prefix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().first));
__prefix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().second));
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
__prefix_.matched = __m.prefix().matched;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__suffix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().first));
__suffix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().second));
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
__suffix_.matched = __m.suffix().matched;
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
if (!__no_update_pos)
__position_start_ = __prefix_.first;
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-08 21:07:55 +00:00
__ready_ = __m.ready();
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
}
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
private:
void __init(unsigned __s,
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
_BidirectionalIterator __f, _BidirectionalIterator __l,
bool __no_update_pos = false);
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
template <class, class> friend class basic_regex;
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
template <class _Bp, class _Ap, class _Cp, class _Tp>
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
regex_match(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&,
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
regex_constants::match_flag_type);
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
template <class _Bp, class _Ap>
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
operator==(const match_results<_Bp, _Ap>&, const match_results<_Bp, _Ap>&);
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
lookahead for ecma llvm-svn: 109548
2010-07-27 22:20:32 +00:00
template <class, class> friend class __lookahead;
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
};
template <class _BidirectionalIterator, class _Allocator>
match_results<_BidirectionalIterator, _Allocator>::match_results(
const allocator_type& __a)
: __matches_(__a),
__unmatched_(),
__prefix_(),
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
__suffix_(),
Fix initializer list order in <regex> to be correct llvm-svn: 242864
2015-07-22 01:29:41 +00:00
__ready_(false),
__position_start_()
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
{
}
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
template <class _BidirectionalIterator, class _Allocator>
void
match_results<_BidirectionalIterator, _Allocator>::__init(unsigned __s,
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
_BidirectionalIterator __f, _BidirectionalIterator __l,
bool __no_update_pos)
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
{
__unmatched_.first = __l;
__unmatched_.second = __l;
__unmatched_.matched = false;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
__matches_.assign(__s, __unmatched_);
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
__prefix_.first = __f;
__prefix_.second = __f;
__prefix_.matched = false;
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
__suffix_ = __unmatched_;
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
if (!__no_update_pos)
__position_start_ = __prefix_.first;
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-08 21:07:55 +00:00
__ready_ = true;
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
}
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
template <class _BidirectionalIterator, class _Allocator>
template <class _OutputIter>
_OutputIter
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __output_iter,
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
const char_type* __fmt_first, const char_type* __fmt_last,
regex_constants::match_flag_type __flags) const
{
Add '_LIBCPP_ASSERT(ready())' to several match_results method that have this precondtion. Fix several tests which did not honor this precondition. Thanks to Andrey Maksimov for pointing this out. llvm-svn: 359324
2019-04-26 17:10:03 +00:00
_LIBCPP_ASSERT(ready(), "match_results::format() called when not ready");
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
if (__flags & regex_constants::format_sed)
{
for (; __fmt_first != __fmt_last; ++__fmt_first)
{
if (*__fmt_first == '&')
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
__output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second,
__output_iter);
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last)
{
++__fmt_first;
if ('0' <= *__fmt_first && *__fmt_first <= '9')
{
size_t __i = *__fmt_first - '0';
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
__output_iter = _VSTD::copy((*this)[__i].first,
(*this)[__i].second, __output_iter);
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
}
else
{
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
*__output_iter = *__fmt_first;
++__output_iter;
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
}
}
else
{
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
*__output_iter = *__fmt_first;
++__output_iter;
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
}
}
}
else
{
for (; __fmt_first != __fmt_last; ++__fmt_first)
{
if (*__fmt_first == '$' && __fmt_first + 1 != __fmt_last)
{
switch (__fmt_first[1])
{
case '$':
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
*__output_iter = *++__fmt_first;
++__output_iter;
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
break;
case '&':
++__fmt_first;
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
__output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second,
__output_iter);
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
break;
case '`':
++__fmt_first;
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
__output_iter = _VSTD::copy(__prefix_.first, __prefix_.second, __output_iter);
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
break;
case '\'':
++__fmt_first;
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
__output_iter = _VSTD::copy(__suffix_.first, __suffix_.second, __output_iter);
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
break;
default:
if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9')
{
++__fmt_first;
Fix an unsigned integer overflow in regex that lead to a bad memory access. Found by OSS-Fuzz llvm-svn: 316191
2017-10-19 22:10:41 +00:00
size_t __idx = *__fmt_first - '0';
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
if (__fmt_first + 1 != __fmt_last &&
'0' <= __fmt_first[1] && __fmt_first[1] <= '9')
{
++__fmt_first;
[libc++] Consistently replace `std::` qualification with `_VSTD::` or nothing. NFCI. I used a lot of `git grep` to find places where `std::` was being used outside of comments and assert-messages. There were three outcomes: - Qualified function calls, e.g. `std::move` becomes `_VSTD::move`. This is the most common case. - Typenames that don't need qualification, e.g. `std::allocator` becomes `allocator`. Leaving these as `_VSTD::allocator` would also be fine, but I decided that removing the qualification is more consistent with existing practice. - Names that specifically need un-versioned `std::` qualification, or that I wasn't sure about. For example, I didn't touch any code in <atomic>, <math.h>, <new>, or any ext/ or experimental/ headers; and I didn't touch any instances of `std::type_info`. In some deduction guides, we were accidentally using `class Alloc = typename std::allocator<T>`, despite `std::allocator<T>`'s type-ness not being template-dependent. Because `std::allocator` is a qualified name, this did parse as we intended; but what we meant was simply `class Alloc = allocator<T>`. Differential Revision: https://reviews.llvm.org/D92250
2020-11-27 11:02:06 -05:00
if (__idx >= numeric_limits<size_t>::max() / 10)
Fix an unsigned integer overflow in regex that lead to a bad memory access. Found by OSS-Fuzz llvm-svn: 316191
2017-10-19 22:10:41 +00:00
__throw_regex_error<regex_constants::error_escape>();
__idx = 10 * __idx + *__fmt_first - '0';
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
}
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
__output_iter = _VSTD::copy((*this)[__idx].first,
(*this)[__idx].second, __output_iter);
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
}
else
{
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
*__output_iter = *__fmt_first;
++__output_iter;
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
}
break;
}
}
else
{
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
*__output_iter = *__fmt_first;
++__output_iter;
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
}
}
}
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
return __output_iter;
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
}
template <class _BidirectionalIterator, class _Allocator>
void
match_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
using _VSTD::swap;
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
swap(__matches_, __m.__matches_);
swap(__unmatched_, __m.__unmatched_);
swap(__prefix_, __m.__prefix_);
swap(__suffix_, __m.__suffix_);
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
swap(__position_start_, __m.__position_start_);
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-08 21:07:55 +00:00
swap(__ready_, __m.__ready_);
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
template <class _BidirectionalIterator, class _Allocator>
[libc++] Add a bunch of missing _LIBCPP_HIDE_FROM_ABI Reviewed By: ldionne, Mordante, var-const, huixie90, #libc Spies: jloser, libcxx-commits, arichardson, miyuki Differential Revision: https://reviews.llvm.org/D129968
2022-08-13 13:23:16 +02:00
_LIBCPP_HIDE_FROM_ABI bool
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
operator==(const match_results<_BidirectionalIterator, _Allocator>& __x,
const match_results<_BidirectionalIterator, _Allocator>& __y)
{
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-08 21:07:55 +00:00
if (__x.__ready_ != __y.__ready_)
return false;
if (!__x.__ready_)
return true;
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
return __x.__matches_ == __y.__matches_ &&
__x.__prefix_ == __y.__prefix_ &&
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-08 21:07:55 +00:00
__x.__suffix_ == __y.__suffix_;
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
template <class _BidirectionalIterator, class _Allocator>
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(const match_results<_BidirectionalIterator, _Allocator>& __x,
const match_results<_BidirectionalIterator, _Allocator>& __y)
{
return !(__x == __y);
}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
template <class _BidirectionalIterator, class _Allocator>
Everything under [re.results] llvm-svn: 111074
2010-08-14 18:14:02 +00:00
inline _LIBCPP_INLINE_VISIBILITY
void
swap(match_results<_BidirectionalIterator, _Allocator>& __x,
match_results<_BidirectionalIterator, _Allocator>& __y)
{
__x.swap(__y);
}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
// regex_search
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
template <class _CharT, class _Traits>
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
template <class _Allocator>
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
bool
basic_regex<_CharT, _Traits>::__match_at_start_ecma(
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
const _CharT* __first, const _CharT* __last,
match_results<const _CharT*, _Allocator>& __m,
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
regex_constants::match_flag_type __flags, bool __at_first) const
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
vector<__state> __states;
__node* __st = __start_.get();
if (__st)
{
Fix for PR22061 by K-ballo llvm-svn: 227384
2015-01-28 22:22:35 +00:00
sub_match<const _CharT*> __unmatched;
__unmatched.first = __last;
__unmatched.second = __last;
__unmatched.matched = false;
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__states.push_back(__state());
__states.back().__do_ = 0;
__states.back().__first_ = __first;
__states.back().__current_ = __first;
__states.back().__last_ = __last;
Fix for PR22061 by K-ballo llvm-svn: 227384
2015-01-28 22:22:35 +00:00
__states.back().__sub_matches_.resize(mark_count(), __unmatched);
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__states.back().__loop_data_.resize(__loop_count());
__states.back().__node_ = __st;
__states.back().__flags_ = __flags;
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
__states.back().__at_first_ = __at_first;
Apply D28224: 'Throw exception after too many steps' Fixes PR#20291. Thanks to Tim Shen for the patch llvm-svn: 313056
2017-09-12 17:56:59 +00:00
int __counter = 0;
int __length = __last - __first;
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
do
{
Apply D28224: 'Throw exception after too many steps' Fixes PR#20291. Thanks to Tim Shen for the patch llvm-svn: 313056
2017-09-12 17:56:59 +00:00
++__counter;
if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
__counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
__throw_regex_error<regex_constants::error_complexity>();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__state& __s = __states.back();
if (__s.__node_)
__s.__node_->__exec(__s);
switch (__s.__do_)
{
case __state::__end_state:
[libcxx] Make regex_match backtrack when search fails Summary: Fixes PR19851. alg.re.match/ecma.pass.cpp still XFAILS on linux, but after commenting out locale-related tests, it passes. I don't have a freebsd machine to produce a full pass. Reviewers: mclow.lists Subscribers: cfe-commits, emaste Differential Revision: https://reviews.llvm.org/D26026 llvm-svn: 285352
2016-10-27 21:40:34 +00:00
if ((__flags & regex_constants::match_not_null) &&
[libcxx] Support std::regex_constants::match_not_null Summary: Fixes PR21597. Reviewers: mclow.lists, EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D25595 llvm-svn: 284881
2016-10-21 20:41:47 +00:00
__s.__current_ == __first)
{
__states.pop_back();
break;
}
[libcxx] Make regex_match backtrack when search fails Summary: Fixes PR19851. alg.re.match/ecma.pass.cpp still XFAILS on linux, but after commenting out locale-related tests, it passes. I don't have a freebsd machine to produce a full pass. Reviewers: mclow.lists Subscribers: cfe-commits, emaste Differential Revision: https://reviews.llvm.org/D26026 llvm-svn: 285352
2016-10-27 21:40:34 +00:00
if ((__flags & regex_constants::__full_match) &&
__s.__current_ != __last)
{
__states.pop_back();
break;
}
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__m.__matches_[0].first = __first;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__m.__matches_[0].second = _VSTD::next(__first, __s.__current_ - __first);
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
__m.__matches_[0].matched = true;
for (unsigned __i = 0; __i < __s.__sub_matches_.size(); ++__i)
__m.__matches_[__i+1] = __s.__sub_matches_[__i];
return true;
case __state::__accept_and_consume:
case __state::__repeat:
case __state::__accept_but_not_consume:
break;
case __state::__split:
{
__state __snext = __s;
__s.__node_->__exec_split(true, __s);
__snext.__node_->__exec_split(false, __snext);
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__states.push_back(_VSTD::move(__snext));
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
}
break;
case __state::__reject:
__states.pop_back();
break;
default:
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::__re_err_unknown>();
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
break;
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-11 17:04:31 +00:00
A good start on ecma regex's. Maybe even feature complete, not sure yet. Also an unrelated fix to is_constructible thanks to Daniel Krugler. llvm-svn: 109479
2010-07-27 01:25:38 +00:00
}
} while (!__states.empty());
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
return false;
}
template <class _CharT, class _Traits>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
template <class _Allocator>
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
bool
basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
const _CharT* __first, const _CharT* __last,
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
match_results<const _CharT*, _Allocator>& __m,
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
regex_constants::match_flag_type __flags, bool __at_first) const
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
deque<__state> __states;
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
ptrdiff_t __highest_j = 0;
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
ptrdiff_t _Np = _VSTD::distance(__first, __last);
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__node* __st = __start_.get();
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
if (__st)
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__states.push_back(__state());
__states.back().__do_ = 0;
__states.back().__first_ = __first;
__states.back().__current_ = __first;
__states.back().__last_ = __last;
__states.back().__loop_data_.resize(__loop_count());
__states.back().__node_ = __st;
__states.back().__flags_ = __flags;
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
__states.back().__at_first_ = __at_first;
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
bool __matched = false;
Apply D28224: 'Throw exception after too many steps' Fixes PR#20291. Thanks to Tim Shen for the patch llvm-svn: 313056
2017-09-12 17:56:59 +00:00
int __counter = 0;
int __length = __last - __first;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
do
{
Apply D28224: 'Throw exception after too many steps' Fixes PR#20291. Thanks to Tim Shen for the patch llvm-svn: 313056
2017-09-12 17:56:59 +00:00
++__counter;
if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
__counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
__throw_regex_error<regex_constants::error_complexity>();
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__state& __s = __states.back();
if (__s.__node_)
__s.__node_->__exec(__s);
switch (__s.__do_)
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
case __state::__end_state:
[libcxx] Make regex_match backtrack when search fails Summary: Fixes PR19851. alg.re.match/ecma.pass.cpp still XFAILS on linux, but after commenting out locale-related tests, it passes. I don't have a freebsd machine to produce a full pass. Reviewers: mclow.lists Subscribers: cfe-commits, emaste Differential Revision: https://reviews.llvm.org/D26026 llvm-svn: 285352
2016-10-27 21:40:34 +00:00
if ((__flags & regex_constants::match_not_null) &&
[libcxx] Support std::regex_constants::match_not_null Summary: Fixes PR21597. Reviewers: mclow.lists, EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D25595 llvm-svn: 284881
2016-10-21 20:41:47 +00:00
__s.__current_ == __first)
{
__states.pop_back();
break;
}
[libcxx] Make regex_match backtrack when search fails Summary: Fixes PR19851. alg.re.match/ecma.pass.cpp still XFAILS on linux, but after commenting out locale-related tests, it passes. I don't have a freebsd machine to produce a full pass. Reviewers: mclow.lists Subscribers: cfe-commits, emaste Differential Revision: https://reviews.llvm.org/D26026 llvm-svn: 285352
2016-10-27 21:40:34 +00:00
if ((__flags & regex_constants::__full_match) &&
__s.__current_ != __last)
{
__states.pop_back();
break;
}
continued regex development... llvm-svn: 109512
2010-07-27 17:24:17 +00:00
if (!__matched || __highest_j < __s.__current_ - __s.__first_)
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
__highest_j = __s.__current_ - __s.__first_;
continued regex development... llvm-svn: 109512
2010-07-27 17:24:17 +00:00
__matched = true;
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
if (__highest_j == _Np)
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__states.clear();
else
__states.pop_back();
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
break;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
case __state::__consume_input:
break;
case __state::__accept_and_consume:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__states.push_front(_VSTD::move(__s));
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__states.pop_back();
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
break;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
case __state::__repeat:
case __state::__accept_but_not_consume:
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
break;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
case __state::__split:
{
__state __snext = __s;
__s.__node_->__exec_split(true, __s);
__snext.__node_->__exec_split(false, __snext);
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__states.push_back(_VSTD::move(__snext));
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
break;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
case __state::__reject:
__states.pop_back();
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
break;
default:
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::__re_err_unknown>();
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
break;
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
} while (!__states.empty());
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 15:45:11 +00:00
if (__matched)
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{
__m.__matches_[0].first = __first;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__m.__matches_[0].second = _VSTD::next(__first, __highest_j);
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
__m.__matches_[0].matched = true;
return true;
}
}
return false;
}
template <class _CharT, class _Traits>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
template <class _Allocator>
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
bool
basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
const _CharT* __first, const _CharT* __last,
match_results<const _CharT*, _Allocator>& __m,
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
regex_constants::match_flag_type __flags, bool __at_first) const
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
vector<__state> __states;
__state __best_state;
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
ptrdiff_t __highest_j = 0;
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
ptrdiff_t _Np = _VSTD::distance(__first, __last);
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__node* __st = __start_.get();
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
if (__st)
{
Fix for PR22061 by K-ballo llvm-svn: 227384
2015-01-28 22:22:35 +00:00
sub_match<const _CharT*> __unmatched;
__unmatched.first = __last;
__unmatched.second = __last;
__unmatched.matched = false;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__states.push_back(__state());
__states.back().__do_ = 0;
__states.back().__first_ = __first;
__states.back().__current_ = __first;
__states.back().__last_ = __last;
Fix for PR22061 by K-ballo llvm-svn: 227384
2015-01-28 22:22:35 +00:00
__states.back().__sub_matches_.resize(mark_count(), __unmatched);
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__states.back().__loop_data_.resize(__loop_count());
__states.back().__node_ = __st;
__states.back().__flags_ = __flags;
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
__states.back().__at_first_ = __at_first;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
bool __matched = false;
Apply D28224: 'Throw exception after too many steps' Fixes PR#20291. Thanks to Tim Shen for the patch llvm-svn: 313056
2017-09-12 17:56:59 +00:00
int __counter = 0;
int __length = __last - __first;
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
do
{
Apply D28224: 'Throw exception after too many steps' Fixes PR#20291. Thanks to Tim Shen for the patch llvm-svn: 313056
2017-09-12 17:56:59 +00:00
++__counter;
if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
__counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
__throw_regex_error<regex_constants::error_complexity>();
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__state& __s = __states.back();
if (__s.__node_)
__s.__node_->__exec(__s);
switch (__s.__do_)
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
case __state::__end_state:
[libcxx] Make regex_match backtrack when search fails Summary: Fixes PR19851. alg.re.match/ecma.pass.cpp still XFAILS on linux, but after commenting out locale-related tests, it passes. I don't have a freebsd machine to produce a full pass. Reviewers: mclow.lists Subscribers: cfe-commits, emaste Differential Revision: https://reviews.llvm.org/D26026 llvm-svn: 285352
2016-10-27 21:40:34 +00:00
if ((__flags & regex_constants::match_not_null) &&
[libcxx] Support std::regex_constants::match_not_null Summary: Fixes PR21597. Reviewers: mclow.lists, EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D25595 llvm-svn: 284881
2016-10-21 20:41:47 +00:00
__s.__current_ == __first)
{
__states.pop_back();
break;
}
[libcxx] Make regex_match backtrack when search fails Summary: Fixes PR19851. alg.re.match/ecma.pass.cpp still XFAILS on linux, but after commenting out locale-related tests, it passes. I don't have a freebsd machine to produce a full pass. Reviewers: mclow.lists Subscribers: cfe-commits, emaste Differential Revision: https://reviews.llvm.org/D26026 llvm-svn: 285352
2016-10-27 21:40:34 +00:00
if ((__flags & regex_constants::__full_match) &&
__s.__current_ != __last)
{
__states.pop_back();
break;
}
continued regex development... llvm-svn: 109512
2010-07-27 17:24:17 +00:00
if (!__matched || __highest_j < __s.__current_ - __s.__first_)
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
{
continued regex development... llvm-svn: 109512
2010-07-27 17:24:17 +00:00
__highest_j = __s.__current_ - __s.__first_;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__best_state = __s;
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
}
continued regex development... llvm-svn: 109512
2010-07-27 17:24:17 +00:00
__matched = true;
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
if (__highest_j == _Np)
continued regex development... llvm-svn: 109512
2010-07-27 17:24:17 +00:00
__states.clear();
else
__states.pop_back();
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
break;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
case __state::__accept_and_consume:
case __state::__repeat:
case __state::__accept_but_not_consume:
break;
case __state::__split:
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
__state __snext = __s;
__s.__node_->__exec_split(true, __s);
__snext.__node_->__exec_split(false, __snext);
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__states.push_back(_VSTD::move(__snext));
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
}
break;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
case __state::__reject:
__states.pop_back();
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
break;
default:
Consolidate a bunch of #ifdef _LIBCPP_NO_EXCEPTIONS .. #endif blocks into a single template function. NFC llvm-svn: 243415
2015-07-28 13:30:47 +00:00
__throw_regex_error<regex_constants::__re_err_unknown>();
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
break;
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
} while (!__states.empty());
if (__matched)
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
{
__m.__matches_[0].first = __first;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
__m.__matches_[0].second = _VSTD::next(__first, __highest_j);
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
__m.__matches_[0].matched = true;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 15:51:17 +00:00
for (unsigned __i = 0; __i < __best_state.__sub_matches_.size(); ++__i)
__m.__matches_[__i+1] = __best_state.__sub_matches_[__i];
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-08 17:43:58 +00:00
return true;
}
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
return false;
}
template <class _CharT, class _Traits>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
template <class _Allocator>
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
bool
basic_regex<_CharT, _Traits>::__match_at_start(
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
const _CharT* __first, const _CharT* __last,
match_results<const _CharT*, _Allocator>& __m,
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
regex_constants::match_flag_type __flags, bool __at_first) const
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{
Fix PR#35967: '<regex> syntax_option_type is not a proper bitmask' Sadly, this is an ABI break, so it's only available if you define either '_LIBCPP_ABI_VERSION > 2' or '_LIBCPP_ABI_UNSTABLE' or '_LIBCPP_ABI_REGEX_CONSTANTS_NONZERO' and rebuild your dylib. llvm-svn: 357190
2019-03-28 17:30:23 +00:00
if (__get_grammar(__flags_) == ECMAScript)
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
return __match_at_start_ecma(__first, __last, __m, __flags, __at_first);
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
if (mark_count() == 0)
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
return __match_at_start_posix_nosubs(__first, __last, __m, __flags, __at_first);
return __match_at_start_posix_subs(__first, __last, __m, __flags, __at_first);
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
}
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
template <class _CharT, class _Traits>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
template <class _Allocator>
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
bool
basic_regex<_CharT, _Traits>::__search(
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
const _CharT* __first, const _CharT* __last,
match_results<const _CharT*, _Allocator>& __m,
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
regex_constants::match_flag_type __flags) const
{
[FIX][libc++][Regex] Using regex_constants match_prev_avail | match_not_bol | match_not_bow Summary: pr42199 When using regex_constants::match_prev_avail, it is defined that --first is valid, and match_not_bol and match_not_bow should be ignored. At the moment these flags are not ignored. This fixis that. Reviewers: ldionne, miyuki, EricWF, mclow.lists, #libc Reviewed By: ldionne, miyuki, #libc Subscribers: broadwaylamb, dexonsmith, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D75622
2020-04-30 23:34:01 +01:00
if (__flags & regex_constants::match_prev_avail)
__flags &= ~(regex_constants::match_not_bol | regex_constants::match_not_bow);
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
__m.__init(1 + mark_count(), __first, __last,
__flags & regex_constants::__no_update_pos);
[NFC][libcxx] Remove trailing whitespace It's incredibly annoying when trying to create diffs llvm-svn: 361981
2019-05-29 16:01:36 +00:00
if (__match_at_start(__first, __last, __m, __flags,
Bill Fisher: This patch fixes a bug where regex_iterator doesn't indicate when it's restarting in the middle of a string. This bug causes /^a/ to match in the middle of the string "aaaaaaa", during iteration. My patch uses to communicate when is false. llvm-svn: 185950
2013-07-09 17:29:09 +00:00
!(__flags & regex_constants::__no_update_pos)))
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
{
__m.__prefix_.second = __m[0].first;
__m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
__m.__suffix_.first = __m[0].second;
__m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
return true;
}
fix bug incrementing past end in search llvm-svn: 109716
2010-07-29 01:15:27 +00:00
if (__first != __last && !(__flags & regex_constants::match_continuous))
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
{
bug fix concerning search not at beginning of string and word boundaries llvm-svn: 109750
2010-07-29 15:17:28 +00:00
__flags |= regex_constants::match_prev_avail;
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
for (++__first; __first != __last; ++__first)
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
{
bug fix concerning search not at beginning of string and word boundaries llvm-svn: 109750
2010-07-29 15:17:28 +00:00
__m.__matches_.assign(__m.size(), __m.__unmatched_);
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-26 20:02:27 +00:00
if (__match_at_start(__first, __last, __m, __flags, false))
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
{
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
__m.__prefix_.second = __m[0].first;
__m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
__m.__suffix_.first = __m[0].second;
__m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
return true;
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
__m.__matches_.assign(__m.size(), __m.__unmatched_);
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
}
}
First loop test passed. The data structure and search algorithm is still crude and in-flux. But this milestone needed to be locked in. Right now every loop is implemented in terms of a structure that will handle the most complicated {min, max} loop. Though only *-loops are tested at the moment. In a future iteration *-loops will likely be optimized a little more. The only tests are for basic posix so far, but I have prototype code running for extended posix and ecma. The prototype code lacks the complicating properties of the real <regex> requirements though. llvm-svn: 107803
2010-07-07 19:14:52 +00:00
__m.__matches_.clear();
return false;
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits>
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
inline _LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
bool
regex_search(_BidirectionalIterator __first, _BidirectionalIterator __last,
match_results<_BidirectionalIterator, _Allocator>& __m,
const basic_regex<_CharT, _Traits>& __e,
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
regex_constants::match_flag_type __flags = regex_constants::match_default)
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
{
Bill Fisher: This patch fixes a less likely case where '\b' can back up into invalid memory, when driven by a regex_iterator (for case 1, see r185273 or http://llvm.org/bugs/show_bug.cgi?id=16240) The attached test program also supplies a test for the case 1 fix in r185273. llvm-svn: 186089
2013-07-11 15:32:55 +00:00
int __offset = (__flags & regex_constants::match_prev_avail) ? 1 : 0;
basic_string<_CharT> __s(_VSTD::prev(__first, __offset), __last);
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
match_results<const _CharT*> __mc;
Bill Fisher: This patch fixes a less likely case where '\b' can back up into invalid memory, when driven by a regex_iterator (for case 1, see r185273 or http://llvm.org/bugs/show_bug.cgi?id=16240) The attached test program also supplies a test for the case 1 fix in r185273. llvm-svn: 186089
2013-07-11 15:32:55 +00:00
bool __r = __e.__search(__s.data() + __offset, __s.data() + __s.size(), __mc, __flags);
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
__m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
return __r;
}
Prevent '\b' from backing up into invalid memory. Fixes http://llvm.org/bugs/show_bug.cgi?id=16240. Sorry, I can not think of a good test case for this one, except by running valgrind as reported in the bug. llvm-svn: 185273
2013-06-29 23:45:43 +00:00
template <class _Iter, class _Allocator, class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
bool
regex_search(__wrap_iter<_Iter> __first,
__wrap_iter<_Iter> __last,
match_results<__wrap_iter<_Iter>, _Allocator>& __m,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
match_results<const _CharT*> __mc;
bool __r = __e.__search(__first.base(), __last.base(), __mc, __flags);
__m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
return __r;
}
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
template <class _Allocator, class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
bool
regex_search(const _CharT* __first, const _CharT* __last,
match_results<const _CharT*, _Allocator>& __m,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
First, very primitive, search results on one engine llvm-svn: 107294
2010-06-30 17:22:19 +00:00
{
return __e.__search(__first, __last, __m, __flags);
}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
template <class _BidirectionalIterator, class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
bool
regex_search(_BidirectionalIterator __first, _BidirectionalIterator __last,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
basic_string<_CharT> __s(__first, __last);
match_results<const _CharT*> __mc;
return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
}
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
bool
regex_search(const _CharT* __first, const _CharT* __last,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
match_results<const _CharT*> __mc;
return __e.__search(__first, __last, __mc, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
}
template <class _CharT, class _Allocator, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
bool
regex_search(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
return __e.__search(__str, __str + _Traits::length(__str), __m, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
}
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
bool
regex_search(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
match_results<const _CharT*> __m;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
return _VSTD::regex_search(__str, __m, __e, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
}
template <class _ST, class _SA, class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
bool
regex_search(const basic_string<_CharT, _ST, _SA>& __s,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
match_results<const _CharT*> __mc;
return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
}
template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
bool
regex_search(const basic_string<_CharT, _ST, _SA>& __s,
match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
match_results<const _CharT*> __mc;
bool __r = __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
__m.__assign(__s.begin(), __s.end(), __mc, __flags & regex_constants::__no_update_pos);
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-14 21:14:52 +00:00
return __r;
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
}
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
#if _LIBCPP_STD_VER > 11
template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
bool
regex_search(const basic_string<_Cp, _ST, _SA>&& __s,
match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
const basic_regex<_Cp, _Tp>& __e,
[NFC][libcxx] Remove trailing whitespace It's incredibly annoying when trying to create diffs llvm-svn: 361981
2019-05-29 16:01:36 +00:00
regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
#endif
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
// regex_match
template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits>
[libc++] Add a bunch of missing _LIBCPP_HIDE_FROM_ABI Reviewed By: ldionne, Mordante, var-const, huixie90, #libc Spies: jloser, libcxx-commits, arichardson, miyuki Differential Revision: https://reviews.llvm.org/D129968
2022-08-13 13:23:16 +02:00
_LIBCPP_HIDE_FROM_ABI bool
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
match_results<_BidirectionalIterator, _Allocator>& __m,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
[libcxx] Make regex_match backtrack when search fails Summary: Fixes PR19851. alg.re.match/ecma.pass.cpp still XFAILS on linux, but after commenting out locale-related tests, it passes. I don't have a freebsd machine to produce a full pass. Reviewers: mclow.lists Subscribers: cfe-commits, emaste Differential Revision: https://reviews.llvm.org/D26026 llvm-svn: 285352
2016-10-27 21:40:34 +00:00
bool __r = _VSTD::regex_search(
__first, __last, __m, __e,
__flags | regex_constants::match_continuous |
regex_constants::__full_match);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
if (__r)
{
__r = !__m.suffix().matched;
if (!__r)
__m.__matches_.clear();
}
return __r;
}
template <class _BidirectionalIterator, class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
bool
regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
match_results<_BidirectionalIterator> __m;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
return _VSTD::regex_match(__first, __last, __m, __e, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
}
template <class _CharT, class _Allocator, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
bool
regex_match(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
return _VSTD::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
}
template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
bool
regex_match(const basic_string<_CharT, _ST, _SA>& __s,
match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
return _VSTD::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
}
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
#if _LIBCPP_STD_VER > 11
template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
bool
regex_match(const basic_string<_CharT, _ST, _SA>&& __s,
match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
const basic_regex<_CharT, _Traits>& __e,
[NFC][libcxx] Remove trailing whitespace It's incredibly annoying when trying to create diffs llvm-svn: 361981
2019-05-29 16:01:36 +00:00
regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
#endif
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
bool
regex_match(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
return _VSTD::regex_match(__str, __str + _Traits::length(__str), __e, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
}
template <class _ST, class _SA, class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
bool
regex_match(const basic_string<_CharT, _ST, _SA>& __s,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
return _VSTD::regex_match(__s.begin(), __s.end(), __e, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 00:21:42 +00:00
}
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
// regex_iterator
template <class _BidirectionalIterator,
class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
class _Traits = regex_traits<_CharT> >
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
class _LIBCPP_TEMPLATE_VIS regex_iterator;
typedef regex_iterator<const char*> cregex_iterator;
typedef regex_iterator<string::const_iterator> sregex_iterator;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef regex_iterator<const wchar_t*> wcregex_iterator;
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#endif
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
template <class _BidirectionalIterator, class _CharT, class _Traits>
class
_LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(cregex_iterator)
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_iterator))
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
_LIBCPP_PREFERRED_NAME(sregex_iterator)
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_iterator))
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
regex_iterator
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
{
public:
typedef basic_regex<_CharT, _Traits> regex_type;
typedef match_results<_BidirectionalIterator> value_type;
typedef ptrdiff_t difference_type;
typedef const value_type* pointer;
typedef const value_type& reference;
typedef forward_iterator_tag iterator_category;
private:
_BidirectionalIterator __begin_;
_BidirectionalIterator __end_;
const regex_type* __pregex_;
regex_constants::match_flag_type __flags_;
value_type __match_;
public:
regex_iterator();
regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type& __re,
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
regex_constants::match_flag_type __m
= regex_constants::match_default);
#if _LIBCPP_STD_VER > 11
regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type&& __re,
[NFC][libcxx] Remove trailing whitespace It's incredibly annoying when trying to create diffs llvm-svn: 361981
2019-05-29 16:01:36 +00:00
regex_constants::match_flag_type __m
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
= regex_constants::match_default) = delete;
#endif
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
bool operator==(const regex_iterator& __x) const;
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
bool operator!=(const regex_iterator& __x) const {return !(*this == __x);}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
reference operator*() const {return __match_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
Change a couple of '&' to addressof(). NFC llvm-svn: 352007
2019-01-24 02:02:50 +00:00
pointer operator->() const {return _VSTD::addressof(__match_);}
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
regex_iterator& operator++();
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
regex_iterator operator++(int)
{
regex_iterator __t(*this);
++(*this);
return __t;
}
};
template <class _BidirectionalIterator, class _CharT, class _Traits>
regex_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_iterator()
: __begin_(), __end_(), __pregex_(nullptr), __flags_(), __match_()
{
}
template <class _BidirectionalIterator, class _CharT, class _Traits>
regex_iterator<_BidirectionalIterator, _CharT, _Traits>::
regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type& __re, regex_constants::match_flag_type __m)
: __begin_(__a),
__end_(__b),
Change a couple of '&' to addressof(). NFC llvm-svn: 352007
2019-01-24 02:02:50 +00:00
__pregex_(_VSTD::addressof(__re)),
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
__flags_(__m)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_VSTD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
}
template <class _BidirectionalIterator, class _CharT, class _Traits>
bool
regex_iterator<_BidirectionalIterator, _CharT, _Traits>::
operator==(const regex_iterator& __x) const
{
if (__match_.empty() && __x.__match_.empty())
return true;
if (__match_.empty() || __x.__match_.empty())
return false;
return __begin_ == __x.__begin_ &&
__end_ == __x.__end_ &&
__pregex_ == __x.__pregex_ &&
__flags_ == __x.__flags_ &&
__match_[0] == __x.__match_[0];
}
template <class _BidirectionalIterator, class _CharT, class _Traits>
regex_iterator<_BidirectionalIterator, _CharT, _Traits>&
regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
{
__flags_ |= regex_constants::__no_update_pos;
_BidirectionalIterator __start = __match_[0].second;
Fix a bug in regex_Iterator where it would report zero-length matches forever. Reported as http://llvm.org/PR33681. Thanks to Karen Arutyunov for the report. llvm-svn: 307171
2017-07-05 16:37:19 +00:00
if (__match_[0].first == __match_[0].second)
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
{
if (__start == __end_)
{
__match_ = value_type();
return *this;
}
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
else if (_VSTD::regex_search(__start, __end_, __match_, *__pregex_,
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
__flags_ | regex_constants::match_not_null |
regex_constants::match_continuous))
return *this;
else
++__start;
}
__flags_ |= regex_constants::match_prev_avail;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
if (!_VSTD::regex_search(__start, __end_, __match_, *__pregex_, __flags_))
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
__match_ = value_type();
return *this;
}
// regex_token_iterator
template <class _BidirectionalIterator,
class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
class _Traits = regex_traits<_CharT> >
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
class _LIBCPP_TEMPLATE_VIS regex_token_iterator;
typedef regex_token_iterator<const char*> cregex_token_iterator;
typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
#endif
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
template <class _BidirectionalIterator, class _CharT, class _Traits>
class
_LIBCPP_TEMPLATE_VIS
_LIBCPP_PREFERRED_NAME(cregex_token_iterator)
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_token_iterator))
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
_LIBCPP_PREFERRED_NAME(sregex_token_iterator)
[libc++] Add an option to disable wide character support in libc++ Some embedded platforms do not wish to support the C library functionality for handling wchar_t because they have no use for it. It makes sense for libc++ to work properly on those platforms, so this commit adds a carve-out of functionality for wchar_t. Unfortunately, unlike some other carve-outs (e.g. random device), this patch touches several parts of the library. However, despite the wide impact of this patch, I still think it is important to support this configuration since it makes it much simpler to port libc++ to some embedded platforms. Differential Revision: https://reviews.llvm.org/D111265
2021-08-23 15:32:36 -04:00
_LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_token_iterator))
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-11 17:12:18 -08:00
regex_token_iterator
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
{
public:
typedef basic_regex<_CharT, _Traits> regex_type;
typedef sub_match<_BidirectionalIterator> value_type;
typedef ptrdiff_t difference_type;
typedef const value_type* pointer;
typedef const value_type& reference;
typedef forward_iterator_tag iterator_category;
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
private:
typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Position;
_Position __position_;
const value_type* __result_;
value_type __suffix_;
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
ptrdiff_t __n_;
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
vector<int> __subs_;
public:
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
regex_token_iterator();
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type& __re, int __submatch = 0,
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
regex_constants::match_flag_type __m =
regex_constants::match_default);
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
#if _LIBCPP_STD_VER > 11
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;
#endif
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type& __re, const vector<int>& __submatches,
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
regex_constants::match_flag_type __m =
regex_constants::match_default);
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
#if _LIBCPP_STD_VER > 11
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type&& __re, const vector<int>& __submatches,
regex_constants::match_flag_type __m =
regex_constants::match_default) = delete;
#endif
Cleanup _LIBCPP_HAS_NO_<c++11-features> macro usage in regex llvm-svn: 300627
2017-04-18 23:42:15 +00:00
#ifndef _LIBCPP_CXX03_LANG
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
const regex_type& __re,
initializer_list<int> __submatches,
regex_constants::match_flag_type __m =
regex_constants::match_default);
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
#if _LIBCPP_STD_VER > 11
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type&& __re,
initializer_list<int> __submatches,
regex_constants::match_flag_type __m =
regex_constants::match_default) = delete;
#endif
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-20 12:03:32 -04:00
#endif // _LIBCPP_CXX03_LANG
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
template <size_t _Np>
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
regex_token_iterator(_BidirectionalIterator __a,
_BidirectionalIterator __b,
const regex_type& __re,
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
const int (&__submatches)[_Np],
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
regex_constants::match_flag_type __m =
regex_constants::match_default);
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
#if _LIBCPP_STD_VER > 11
[libc++] Consistently replace `std::` qualification with `_VSTD::` or nothing. NFCI. I used a lot of `git grep` to find places where `std::` was being used outside of comments and assert-messages. There were three outcomes: - Qualified function calls, e.g. `std::move` becomes `_VSTD::move`. This is the most common case. - Typenames that don't need qualification, e.g. `std::allocator` becomes `allocator`. Leaving these as `_VSTD::allocator` would also be fine, but I decided that removing the qualification is more consistent with existing practice. - Names that specifically need un-versioned `std::` qualification, or that I wasn't sure about. For example, I didn't touch any code in <atomic>, <math.h>, <new>, or any ext/ or experimental/ headers; and I didn't touch any instances of `std::type_info`. In some deduction guides, we were accidentally using `class Alloc = typename std::allocator<T>`, despite `std::allocator<T>`'s type-ness not being template-dependent. Because `std::allocator` is a qualified name, this did parse as we intended; but what we meant was simply `class Alloc = allocator<T>`. Differential Revision: https://reviews.llvm.org/D92250
2020-11-27 11:02:06 -05:00
template <size_t _Np>
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-19 21:21:11 +00:00
regex_token_iterator(_BidirectionalIterator __a,
_BidirectionalIterator __b,
const regex_type&& __re,
const int (&__submatches)[_Np],
regex_constants::match_flag_type __m =
regex_constants::match_default) = delete;
#endif
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
regex_token_iterator(const regex_token_iterator&);
regex_token_iterator& operator=(const regex_token_iterator&);
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
bool operator==(const regex_token_iterator& __x) const;
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
bool operator!=(const regex_token_iterator& __x) const {return !(*this == __x);}
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
const value_type& operator*() const {return *__result_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
const value_type* operator->() const {return __result_;}
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
regex_token_iterator& operator++();
visibility-decoration. llvm-svn: 114647
2010-09-23 15:13:20 +00:00
_LIBCPP_INLINE_VISIBILITY
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
regex_token_iterator operator++(int)
{
regex_token_iterator __t(*this);
++(*this);
return __t;
}
private:
void __init(_BidirectionalIterator __a, _BidirectionalIterator __b);
Fix PR18404 - 'Bug in regex_token_iterator::operator++(int) implementation'. Enhance the tests for regex_token_iterator and regex_iterator. llvm-svn: 198878
2014-01-09 18:25:57 +00:00
void __establish_result () {
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
if (__subs_[__n_] == -1)
Fix PR18404 - 'Bug in regex_token_iterator::operator++(int) implementation'. Enhance the tests for regex_token_iterator and regex_iterator. llvm-svn: 198878
2014-01-09 18:25:57 +00:00
__result_ = &__position_->prefix();
else
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
__result_ = &(*__position_)[__subs_[__n_]];
[NFC][libcxx] Remove trailing whitespace It's incredibly annoying when trying to create diffs llvm-svn: 361981
2019-05-29 16:01:36 +00:00
}
[re.regiter] llvm-svn: 111178
2010-08-16 20:21:16 +00:00
};
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
template <class _BidirectionalIterator, class _CharT, class _Traits>
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
regex_token_iterator()
: __result_(nullptr),
__suffix_(),
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
__n_(0)
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
{
}
template <class _BidirectionalIterator, class _CharT, class _Traits>
void
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
__init(_BidirectionalIterator __a, _BidirectionalIterator __b)
{
if (__position_ != _Position())
Fix PR18404 - 'Bug in regex_token_iterator::operator++(int) implementation'. Enhance the tests for regex_token_iterator and regex_iterator. llvm-svn: 198878
2014-01-09 18:25:57 +00:00
__establish_result ();
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
else if (__subs_[__n_] == -1)
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
{
__suffix_.matched = true;
__suffix_.first = __a;
__suffix_.second = __b;
__result_ = &__suffix_;
}
else
__result_ = nullptr;
}
template <class _BidirectionalIterator, class _CharT, class _Traits>
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type& __re, int __submatch,
regex_constants::match_flag_type __m)
: __position_(__a, __b, __re, __m),
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
__n_(0),
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
__subs_(1, __submatch)
{
__init(__a, __b);
}
template <class _BidirectionalIterator, class _CharT, class _Traits>
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type& __re, const vector<int>& __submatches,
regex_constants::match_flag_type __m)
: __position_(__a, __b, __re, __m),
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
__n_(0),
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
__subs_(__submatches)
{
__init(__a, __b);
}
Cleanup _LIBCPP_HAS_NO_<c++11-features> macro usage in regex llvm-svn: 300627
2017-04-18 23:42:15 +00:00
#ifndef _LIBCPP_CXX03_LANG
Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574 llvm-svn: 137522
2011-08-12 21:56:02 +00:00
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
template <class _BidirectionalIterator, class _CharT, class _Traits>
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type& __re,
initializer_list<int> __submatches,
regex_constants::match_flag_type __m)
: __position_(__a, __b, __re, __m),
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
__n_(0),
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
__subs_(__submatches)
{
__init(__a, __b);
}
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-20 12:03:32 -04:00
#endif // _LIBCPP_CXX03_LANG
Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574 llvm-svn: 137522
2011-08-12 21:56:02 +00:00
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
template <class _BidirectionalIterator, class _CharT, class _Traits>
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
template <size_t _Np>
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type& __re,
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-29 18:15:50 +00:00
const int (&__submatches)[_Np],
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
regex_constants::match_flag_type __m)
: __position_(__a, __b, __re, __m),
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
__n_(0),
Change a couple of '&' to addressof(). NFC llvm-svn: 352007
2019-01-24 02:02:50 +00:00
__subs_(begin(__submatches), end(__submatches))
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
{
__init(__a, __b);
}
template <class _BidirectionalIterator, class _CharT, class _Traits>
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
regex_token_iterator(const regex_token_iterator& __x)
: __position_(__x.__position_),
__result_(__x.__result_),
__suffix_(__x.__suffix_),
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
__n_(__x.__n_),
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
__subs_(__x.__subs_)
{
if (__x.__result_ == &__x.__suffix_)
Fix a bug in regex_token_iterator's copy constructor. Caught by Bob Wilson. llvm-svn: 199122
2014-01-13 17:47:08 +00:00
__result_ = &__suffix_;
Fix PR18404 - 'Bug in regex_token_iterator::operator++(int) implementation'. Enhance the tests for regex_token_iterator and regex_iterator. llvm-svn: 198878
2014-01-09 18:25:57 +00:00
else if ( __result_ != nullptr )
__establish_result ();
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
}
template <class _BidirectionalIterator, class _CharT, class _Traits>
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>&
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
operator=(const regex_token_iterator& __x)
{
if (this != &__x)
{
__position_ = __x.__position_;
if (__x.__result_ == &__x.__suffix_)
Fix PR18404 - 'Bug in regex_token_iterator::operator++(int) implementation'. Enhance the tests for regex_token_iterator and regex_iterator. llvm-svn: 198878
2014-01-09 18:25:57 +00:00
__result_ = &__suffix_;
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
else
__result_ = __x.__result_;
__suffix_ = __x.__suffix_;
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
__n_ = __x.__n_;
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
__subs_ = __x.__subs_;
Fix PR18404 - 'Bug in regex_token_iterator::operator++(int) implementation'. Enhance the tests for regex_token_iterator and regex_iterator. llvm-svn: 198878
2014-01-09 18:25:57 +00:00
if ( __result_ != nullptr && __result_ != &__suffix_ )
__establish_result();
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
}
return *this;
}
template <class _BidirectionalIterator, class _CharT, class _Traits>
bool
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
operator==(const regex_token_iterator& __x) const
{
if (__result_ == nullptr && __x.__result_ == nullptr)
return true;
if (__result_ == &__suffix_ && __x.__result_ == &__x.__suffix_ &&
__suffix_ == __x.__suffix_)
return true;
if (__result_ == nullptr || __x.__result_ == nullptr)
return false;
if (__result_ == &__suffix_ || __x.__result_ == &__x.__suffix_)
return false;
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
return __position_ == __x.__position_ && __n_ == __x.__n_ &&
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
__subs_ == __x.__subs_;
}
template <class _BidirectionalIterator, class _CharT, class _Traits>
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>&
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
{
_Position __prev = __position_;
if (__result_ == &__suffix_)
__result_ = nullptr;
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
else if (static_cast<size_t>(__n_ + 1) < __subs_.size())
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
{
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
++__n_;
Fix PR18404 - 'Bug in regex_token_iterator::operator++(int) implementation'. Enhance the tests for regex_token_iterator and regex_iterator. llvm-svn: 198878
2014-01-09 18:25:57 +00:00
__establish_result();
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
}
else
{
fix sign comparison warnings llvm-svn: 290469
2016-12-24 00:24:44 +00:00
__n_ = 0;
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
++__position_;
if (__position_ != _Position())
Fix PR18404 - 'Bug in regex_token_iterator::operator++(int) implementation'. Enhance the tests for regex_token_iterator and regex_iterator. llvm-svn: 198878
2014-01-09 18:25:57 +00:00
__establish_result();
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
else
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
if (_VSTD::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end()
[re.tokiter] llvm-svn: 111278
2010-08-17 20:42:03 +00:00
&& __prev->suffix().length() != 0)
{
__suffix_.matched = true;
__suffix_.first = __prev->suffix().first;
__suffix_.second = __prev->suffix().second;
__result_ = &__suffix_;
}
else
__result_ = nullptr;
}
}
return *this;
}
[re.alg.replace]. This finishes all of <regex>. That being said, <regex> is exceptionally difficult to thoroughly test. If anyone has the ability to test this, combined with the interest to do so, now would be a good time. :-) llvm-svn: 111333
2010-08-18 00:13:08 +00:00
// regex_replace
template <class _OutputIterator, class _BidirectionalIterator,
class _Traits, class _CharT>
[libc++] Add a bunch of missing _LIBCPP_HIDE_FROM_ABI Reviewed By: ldionne, Mordante, var-const, huixie90, #libc Spies: jloser, libcxx-commits, arichardson, miyuki Differential Revision: https://reviews.llvm.org/D129968
2022-08-13 13:23:16 +02:00
_LIBCPP_HIDE_FROM_ABI _OutputIterator
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
regex_replace(_OutputIterator __output_iter,
[re.alg.replace]. This finishes all of <regex>. That being said, <regex> is exceptionally difficult to thoroughly test. If anyone has the ability to test this, combined with the interest to do so, now would be a good time. :-) llvm-svn: 111333
2010-08-18 00:13:08 +00:00
_BidirectionalIterator __first, _BidirectionalIterator __last,
const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Iter;
_Iter __i(__first, __last, __e, __flags);
_Iter __eof;
if (__i == __eof)
{
if (!(__flags & regex_constants::format_no_copy))
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
__output_iter = _VSTD::copy(__first, __last, __output_iter);
[re.alg.replace]. This finishes all of <regex>. That being said, <regex> is exceptionally difficult to thoroughly test. If anyone has the ability to test this, combined with the interest to do so, now would be a good time. :-) llvm-svn: 111333
2010-08-18 00:13:08 +00:00
}
else
{
sub_match<_BidirectionalIterator> __lm;
for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i)
{
if (!(__flags & regex_constants::format_no_copy))
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
__output_iter = _VSTD::copy(__i->prefix().first, __i->prefix().second, __output_iter);
__output_iter = __i->format(__output_iter, __fmt, __fmt + __len, __flags);
[re.alg.replace]. This finishes all of <regex>. That being said, <regex> is exceptionally difficult to thoroughly test. If anyone has the ability to test this, combined with the interest to do so, now would be a good time. :-) llvm-svn: 111333
2010-08-18 00:13:08 +00:00
__lm = __i->suffix();
if (__flags & regex_constants::format_first_only)
break;
}
if (!(__flags & regex_constants::format_no_copy))
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
__output_iter = _VSTD::copy(__lm.first, __lm.second, __output_iter);
[re.alg.replace]. This finishes all of <regex>. That being said, <regex> is exceptionally difficult to thoroughly test. If anyone has the ability to test this, combined with the interest to do so, now would be a good time. :-) llvm-svn: 111333
2010-08-18 00:13:08 +00:00
}
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
return __output_iter;
[re.alg.replace]. This finishes all of <regex>. That being said, <regex> is exceptionally difficult to thoroughly test. If anyone has the ability to test this, combined with the interest to do so, now would be a good time. :-) llvm-svn: 111333
2010-08-18 00:13:08 +00:00
}
template <class _OutputIterator, class _BidirectionalIterator,
class _Traits, class _CharT, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
_OutputIterator
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
regex_replace(_OutputIterator __output_iter,
[re.alg.replace]. This finishes all of <regex>. That being said, <regex> is exceptionally difficult to thoroughly test. If anyone has the ability to test this, combined with the interest to do so, now would be a good time. :-) llvm-svn: 111333
2010-08-18 00:13:08 +00:00
_BidirectionalIterator __first, _BidirectionalIterator __last,
const basic_regex<_CharT, _Traits>& __e,
const basic_string<_CharT, _ST, _SA>& __fmt,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
Rename identifiers named `__output` Summary: In the CHERI clang compiler __output and __input are keywords and therefore we can't compile libc++ with our compiler. Reviewers: mclow.lists, EricWF, theraven Reviewed By: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D39537 llvm-svn: 318144
2017-11-14 11:14:25 +00:00
return _VSTD::regex_replace(__output_iter, __first, __last, __e, __fmt.c_str(), __flags);
[re.alg.replace]. This finishes all of <regex>. That being said, <regex> is exceptionally difficult to thoroughly test. If anyone has the ability to test this, combined with the interest to do so, now would be a good time. :-) llvm-svn: 111333
2010-08-18 00:13:08 +00:00
}
template <class _Traits, class _CharT, class _ST, class _SA, class _FST,
class _FSA>
inline _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT, _ST, _SA>
regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
const basic_regex<_CharT, _Traits>& __e,
const basic_string<_CharT, _FST, _FSA>& __fmt,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
basic_string<_CharT, _ST, _SA> __r;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
[re.alg.replace]. This finishes all of <regex>. That being said, <regex> is exceptionally difficult to thoroughly test. If anyone has the ability to test this, combined with the interest to do so, now would be a good time. :-) llvm-svn: 111333
2010-08-18 00:13:08 +00:00
__fmt.c_str(), __flags);
return __r;
}
template <class _Traits, class _CharT, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT, _ST, _SA>
regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
basic_string<_CharT, _ST, _SA> __r;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
[re.alg.replace]. This finishes all of <regex>. That being said, <regex> is exceptionally difficult to thoroughly test. If anyone has the ability to test this, combined with the interest to do so, now would be a good time. :-) llvm-svn: 111333
2010-08-18 00:13:08 +00:00
__fmt, __flags);
return __r;
}
template <class _Traits, class _CharT, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT>
regex_replace(const _CharT* __s,
const basic_regex<_CharT, _Traits>& __e,
const basic_string<_CharT, _ST, _SA>& __fmt,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
basic_string<_CharT> __r;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_VSTD::regex_replace(back_inserter(__r), __s,
[re.alg.replace]. This finishes all of <regex>. That being said, <regex> is exceptionally difficult to thoroughly test. If anyone has the ability to test this, combined with the interest to do so, now would be a good time. :-) llvm-svn: 111333
2010-08-18 00:13:08 +00:00
__s + char_traits<_CharT>::length(__s), __e,
__fmt.c_str(), __flags);
return __r;
}
template <class _Traits, class _CharT>
inline _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT>
regex_replace(const _CharT* __s,
const basic_regex<_CharT, _Traits>& __e,
const _CharT* __fmt,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
basic_string<_CharT> __r;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-06-30 21:18:19 +00:00
_VSTD::regex_replace(back_inserter(__r), __s,
[re.alg.replace]. This finishes all of <regex>. That being said, <regex> is exceptionally difficult to thoroughly test. If anyone has the ability to test this, combined with the interest to do so, now would be a good time. :-) llvm-svn: 111333
2010-08-18 00:13:08 +00:00
__s + char_traits<_CharT>::length(__s), __e,
__fmt, __flags);
return __r;
}
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 00:34:59 +00:00
_LIBCPP_END_NAMESPACE_STD
[Libc++] Use #pragma push_macro/pop_macro to better handle min/max on Windows Summary: This patch improves how libc++ handles min/max macros within the headers. Previously libc++ would undef them and emit a warning. This patch changes libc++ to use `#pragma push_macro` to save the macro before undefining it, and `#pragma pop_macro` to restore the macros and the end of the header. Reviewers: mclow.lists, bcraig, compnerd, EricWF Reviewed By: EricWF Subscribers: cfe-commits, krytarowski Differential Revision: https://reviews.llvm.org/D33080 llvm-svn: 304357
2017-05-31 22:07:49 +00:00
_LIBCPP_POP_MACROS
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-20 12:03:32 -04:00
#endif // _LIBCPP_REGEX
Reference in New Issue Copy Permalink