maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/libcxx/include/regex

6602 lines
215 KiB
Plaintext
Raw Normal View History

Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
// -*- C++ -*-
//===--------------------------- regex ------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
license change llvm-svn: 119395
2010-11-17 06:09:02 +08:00
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_REGEX
#define _LIBCPP_REGEX
/*
regex synopsis
#include <initializer_list>
namespace std
{
namespace regex_constants
{
emum syntax_option_type
{
icase = unspecified,
nosubs = unspecified,
optimize = unspecified,
collate = unspecified,
ECMAScript = unspecified,
basic = unspecified,
extended = unspecified,
awk = unspecified,
grep = unspecified,
egrep = unspecified
};
constexpr syntax_option_type operator~(syntax_option_type f);
constexpr syntax_option_type operator&(syntax_option_type lhs, syntax_option_type rhs);
constexpr syntax_option_type operator|(syntax_option_type lhs, syntax_option_type rhs);
enum match_flag_type
{
match_default = 0,
match_not_bol = unspecified,
match_not_eol = unspecified,
match_not_bow = unspecified,
match_not_eow = unspecified,
match_any = unspecified,
match_not_null = unspecified,
match_continuous = unspecified,
match_prev_avail = unspecified,
format_default = 0,
format_sed = unspecified,
format_no_copy = unspecified,
format_first_only = unspecified
};
constexpr match_flag_type operator~(match_flag_type f);
constexpr match_flag_type operator&(match_flag_type lhs, match_flag_type rhs);
constexpr match_flag_type operator|(match_flag_type lhs, match_flag_type rhs);
enum error_type
{
error_collate = unspecified,
error_ctype = unspecified,
error_escape = unspecified,
error_backref = unspecified,
error_brack = unspecified,
error_paren = unspecified,
error_brace = unspecified,
error_badbrace = unspecified,
error_range = unspecified,
error_space = unspecified,
error_badrepeat = unspecified,
error_complexity = unspecified,
error_stack = unspecified
};
} // regex_constants
class regex_error
: public runtime_error
{
public:
explicit regex_error(regex_constants::error_type ecode);
regex_constants::error_type code() const;
};
template <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;
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;
// construct/copy/destroy:
basic_regex();
explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript);
basic_regex(const charT* p, size_t len, flag_type f);
basic_regex(const basic_regex&);
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 09:31:58 +08:00
basic_regex(basic_regex&&) noexcept;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 09:31:58 +08:00
basic_regex& operator=(basic_regex&&) noexcept;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 09:31:58 +08:00
basic_regex& assign(basic_regex&& that) noexcept;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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);
template <class string_traits, class A>
basic_regex& assign(const basic_string<charT, string_traits, A>& s,
flag_type f = regex_constants::ECMAScript);
template <class InputIterator>
basic_regex& assign(InputIterator first, InputIterator last,
flag_type f = regex_constants::ECMAScript);
basic_regex& assign(initializer_list<charT>, flag_type = regex_constants::ECMAScript);
// const operations:
unsigned mark_count() const;
flag_type flags() const;
// locale:
locale_type imbue(locale_type loc);
locale_type getloc() const;
// swap:
void swap(basic_regex&);
};
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-09 05:07:55 +08:00
constexpr sub_match();
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 09:56:31 +08:00
typedef value_type& reference;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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:
explicit match_results(const Allocator& a = Allocator());
match_results(const match_results& m);
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 09:31:58 +08:00
match_results(match_results&& m) noexcept;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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-09 05:07:55 +08:00
bool ready() const;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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-20 05:21:11 +08: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 08:34:59 +08: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-20 05:21:11 +08: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 08:34:59 +08: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);
template <class traits, class charT, class ST, class SA, class FST, class FSA>>
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);
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-20 05:21:11 +08:00
regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type&& __re,
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 08:34:59 +08: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,
class charT = typename iterator_traits< BidirectionalIterator>::value_type,
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-20 05:21:11 +08: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 08:34:59 +08: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-20 05:21:11 +08: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 08:34:59 +08: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-20 05:21:11 +08: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 08:34:59 +08: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-20 05:21:11 +08: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) = delete // C++14;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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
*/
#include <__config>
#include <stdexcept>
#include <__locale>
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
#include <initializer_list>
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
#include <utility>
#include <iterator>
#include <string>
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
#include <memory>
#include <vector>
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
#include <deque>
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
Add protection from min/max macros llvm-svn: 145407
2011-11-30 00:45:27 +08:00
#include <__undef_min_max>
Windows support by Ruben Van Boxem. llvm-svn: 142235
2011-10-18 04:05:10 +08:00
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
#pragma GCC system_header
Windows support by Ruben Van Boxem. llvm-svn: 142235
2011-10-18 04:05:10 +08:00
#endif
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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,
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
ECMAScript = 0,
basic = 1 << 4,
extended = 1 << 5,
awk = 1 << 6,
grep = 1 << 7,
egrep = 1 << 8
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
};
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 09:31:58 +08:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 10:13:55 +08:00
return syntax_option_type(~int(__x) & 0x1FF);
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 09:31:58 +08:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 09:31:58 +08:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 09:31:58 +08:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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-17 04:21:16 +08:00
format_first_only = 1 << 10,
__no_update_pos = 1 << 11
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
};
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 09:31:58 +08:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 10:13:55 +08:00
return match_flag_type(~int(__x) & 0x0FFF);
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 09:31:58 +08:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 09:31:58 +08:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 09:31:58 +08:00
_LIBCPP_CONSTEXPR
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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-25 05:28:00 +08:00
error_stack,
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
__re_err_grammar,
__re_err_empty,
__re_err_unknown
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
};
} // regex_constants
class _LIBCPP_EXCEPTION_ABI regex_error
: public runtime_error
{
regex_constants::error_type __code_;
public:
explicit regex_error(regex_constants::error_type __ecode);
virtual ~regex_error() throw();
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
regex_constants::error_type code() const {return __code_;}
};
template <class _CharT>
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-13 02:38:34 +08:00
struct _LIBCPP_TYPE_VIS_ONLY regex_traits
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
{
public:
typedef _CharT char_type;
typedef basic_string<char_type> string_type;
typedef locale locale_type;
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-22 05:01:43 +08:00
typedef ctype_base::mask char_class_type;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-22 05:01:43 +08:00
static const char_class_type __regex_word = 0x80;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
static size_t length(const char_type* __p)
{return char_traits<char_type>::length(__p);}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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-22 05:01:43 +08: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 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-22 05:01:43 +08: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 23:43:25 +08:00
{return __regex_traits_value(__ch, __radix);}
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
locale_type imbue(locale_type __l);
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
locale_type getloc()const {return __loc_;}
private:
void __init();
template <class _ForwardIterator>
string_type
__transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const;
template <class _ForwardIterator>
string_type
__transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
template <class _ForwardIterator>
string_type
__lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const;
template <class _ForwardIterator>
string_type
__lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-22 05:01:43 +08:00
template <class _ForwardIterator>
char_class_type
__lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
bool __icase, char) const;
template <class _ForwardIterator>
char_class_type
__lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
bool __icase, wchar_t) 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 23:43:25 +08:00
static int __regex_traits_value(unsigned char __ch, int __radix);
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:43:25 +08:00
int __regex_traits_value(char __ch, int __radix) const
{return __regex_traits_value(static_cast<unsigned char>(__ch), __radix);}
int __regex_traits_value(wchar_t __ch, int __radix) const;
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08:00
};
Albert Wong: definition for regex_traits<_CharT>::__regex_word. llvm-svn: 176640
2013-03-08 03:38:08 +08: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 08:34:59 +08: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;
}
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;
}
// 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-13 02:38:34 +08:00
_LIBCPP_FUNC_VIS string __get_collation_name(const char* __s);
Just getting our toes wet on <regex> llvm-svn: 106187
2010-06-17 08:34:59 +08: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;
}
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;
}
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-22 05:01:43 +08: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-30 03:23:39 +08: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-22 05:01:43 +08: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);
}
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);
}
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));
}
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 23:43:25 +08: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-22 05:01:43 +08:00
{
if ((__ch & 0xF8u) == 0x30) // '0' <= __ch && __ch <= '7'
return __ch - '0';
if (__radix != 8)
{
if ((__ch & 0xFEu) == 0x38) // '8' <= __ch && __ch <= '9'
return __ch - '0';
if (__radix == 16)
{
__ch |= 0x20; // tolower
if ('a' <= __ch && __ch <= 'f')
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08: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-22 05:01:43 +08:00
}
}
return -1;
}
template <class _CharT>
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
inline _LIBCPP_INLINE_VISIBILITY
Finished [re.traits]. I'd like to acknowledge the help of Bjorn Reese with <regex>. llvm-svn: 106478
2010-06-22 05:01:43 +08: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 23:43:25 +08: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-22 05:01:43 +08: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 23:43:25 +08: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-22 05:01:43 +08:00
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
template <class _CharT> class __node;
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-13 02:38:34 +08:00
template <class _BidirectionalIterator> class _LIBCPP_TYPE_VIS_ONLY sub_match;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +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 09:25:38 +08:00
template <class _BidirectionalIterator,
class _Allocator = allocator<sub_match<_BidirectionalIterator> > >
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-13 02:38:34 +08:00
class _LIBCPP_TYPE_VIS_ONLY 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 09:25:38 +08:00
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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 23:51:17 +08:00
struct __state
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-08 03:14:52 +08: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-09 01:43:58 +08: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-08 03:14:52 +08: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 23:51:17 +08:00
__split,
__repeat
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-27 04:02:27 +08: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 23:51:17 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
};
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
__node(const __node&);
__node& operator=(const __node&);
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08: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-08 03:14:52 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08:00
__node() {}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08:00
virtual void __exec(__state&) const {};
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
};
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
{
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
typedef _VSTD::__state<_CharT> __state;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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-08 03:14:52 +08:00
__end_state() {}
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
virtual void __exec(__state&) const;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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 23:51:17 +08:00
void
__end_state<_CharT>::__exec(__state& __s) const
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
__s.__do_ = __state::__end_state;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-08 03:14:52 +08:00
// __has_one_state
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-08 03:14:52 +08: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 23:51:17 +08:00
: public __node<_CharT>
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +08:00
public:
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
: __first_(__s) {}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08:00
__node<_CharT>* first() const {return __first_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08: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-08 03:14:52 +08: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 23:13:20 +08: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 23:51:17 +08: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-08 03:14:52 +08: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-30 02:37:43 +08: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-08 03:14:52 +08:00
// __empty_state
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08: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-08 03:14:52 +08:00
class __empty_state
: public __owns_one_state<_CharT>
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08: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-08 03:14:52 +08:00
typedef __owns_one_state<_CharT> base;
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08: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-08 03:14:52 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
__s.__do_ = __state::__accept_but_not_consume;
__s.__node_ = this->first();
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08: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-08 03:14:52 +08:00
// __empty_non_own_state
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-08 03:14:52 +08:00
class __empty_non_own_state
: public __has_one_state<_CharT>
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-08 03:14:52 +08:00
typedef __has_one_state<_CharT> base;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-08 03:14:52 +08:00
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08: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-08 03:14:52 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-07-01 05:18:19 +08: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 23:51:17 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +08:00
}
// __owns_two_states
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-08 03:14:52 +08: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-30 02:37:43 +08:00
public:
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
: base(__s1), __second_(__s2) {}
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-08 03:14:52 +08:00
virtual ~__owns_two_states();
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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-08 03:14:52 +08:00
base* second() const {return __second_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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-08 03:14:52 +08:00
base*& second() {return __second_;}
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
};
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08: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-08 03:14:52 +08:00
__owns_two_states<_CharT>::~__owns_two_states()
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08: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-08 03:14:52 +08:00
delete __second_;
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08: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-08 03:14:52 +08:00
// __loop
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08: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-08 03:14:52 +08:00
class __loop
: public __owns_two_states<_CharT>
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
bool __greedy_;
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08: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-08 03:14:52 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-09 01:43:58 +08:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
private:
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08: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-09 01:43:58 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-09 01:43:58 +08:00
}
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08: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 23:51:17 +08:00
void
__loop<_CharT>::__exec(__state& __s) const
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-28 01:24:17 +08: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 23:51:17 +08:00
__s.__do_ = __state::__split;
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08: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 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-09 01:43:58 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-09 01:43:58 +08:00
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +08:00
}
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-17 03:08:36 +08: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-07-01 05:18:19 +08: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-17 03:08:36 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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-17 03:08:36 +08: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 22:12:20 +08: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-17 03:08:36 +08:00
__s.__node_ = this->second();
A few more tests for posix extended alternation llvm-svn: 109107
2010-07-22 22:12:20 +08: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-17 03:08:36 +08:00
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08: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-08 03:14:52 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-07-01 04:30:19 +08: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-08 03:14:52 +08:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +08:00
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
: public __owns_one_state<_CharT>
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08: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-08 03:14:52 +08: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-09 01:43:58 +08:00
unsigned __mexp_;
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08:00
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
typedef _VSTD::__state<_CharT> __state;
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08: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-09 01:43:58 +08:00
: base(__s), __mexp_(__mexp) {}
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
virtual void __exec(__state&) const;
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08: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 23:51:17 +08:00
void
__end_marked_subexpression<_CharT>::__exec(__state& __s) const
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-07-01 04:30:19 +08: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-08 03:14:52 +08:00
back references for BRE llvm-svn: 108168
2010-07-13 02:16:05 +08: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-07-01 05:18:19 +08:00
typedef _VSTD::__state<_CharT> __state;
back references for BRE llvm-svn: 108168
2010-07-13 02:16:05 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
back references for BRE llvm-svn: 108168
2010-07-13 02:16:05 +08: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
{
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-07-01 05:18:19 +08:00
_VSTD::equal(__sm.first, __sm.second, __s.__current_))
back references for BRE llvm-svn: 108168
2010-07-13 02:16:05 +08: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-13 03:11:27 +08: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-07-01 05:18:19 +08: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-13 03:11:27 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-13 03:11:27 +08: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-07-01 05:18:19 +08: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-13 03:11:27 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-13 03:11:27 +08: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 09:25:38 +08: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-07-01 05:18:19 +08: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 09:25:38 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 09:25:38 +08: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 23:17:28 +08: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 09:25:38 +08: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-27 04:02:27 +08:00
// __l_anchor
template <class _CharT>
class __l_anchor
: public __owns_one_state<_CharT>
{
typedef __owns_one_state<_CharT> base;
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
typedef _VSTD::__state<_CharT> __state;
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08:00
_LIBCPP_INLINE_VISIBILITY
__l_anchor(__node<_CharT>* __s)
: base(__s) {}
virtual void __exec(__state&) const;
};
template <class _CharT>
void
__l_anchor<_CharT>::__exec(__state& __s) const
{
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-20 01:05:59 +08: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-27 04:02:27 +08:00
{
__s.__do_ = __state::__accept_but_not_consume;
__s.__node_ = this->first();
}
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 23:51:17 +08: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-08 03:14:52 +08:00
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08: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 23:51:17 +08:00
class __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-08 03:14:52 +08: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-07-01 05:18:19 +08: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-08 03:14:52 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08:00
__r_anchor(__node<_CharT>* __s)
: 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-08 03:14:52 +08:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08:00
void
__r_anchor<_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-08 03:14:52 +08: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-20 01:05:59 +08: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 23:51:17 +08:00
{
__s.__do_ = __state::__accept_but_not_consume;
__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-08 03:14:52 +08:00
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-08 03:14:52 +08: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-07-01 05:18:19 +08: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-08 03:14:52 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08: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 08:15:26 +08: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-08 03:14:52 +08:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08:00
void
__match_any<_CharT>::__exec(__state& __s) const
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +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 09:25:38 +08: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-07-01 05:18:19 +08: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 09:25:38 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 09:25:38 +08: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-13 02:38:34 +08:00
template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<char>::__exec(__state&) const;
template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<wchar_t>::__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-08 03:14:52 +08: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-07-01 04:30:19 +08:00
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
typedef _VSTD::__state<_CharT> __state;
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
: base(__s), __c_(__c) {}
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08:00
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
virtual void __exec(__state&) const;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
};
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08: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 23:51:17 +08:00
void
__match_char<_CharT>::__exec(__state& __s) const
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-07-01 04:30:19 +08: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-08 03:14:52 +08:00
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-13 03:11:27 +08: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-07-01 05:18:19 +08: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-13 03:11:27 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-13 03:11:27 +08: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-07-01 05:18:19 +08: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-13 03:11:27 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-13 03:11:27 +08: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-14 05:48:06 +08: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-29 01:35:27 +08:00
vector<_CharT> __neg_chars_;
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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-30 03:23:39 +08: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-14 05:48:06 +08:00
bool __negate_;
bool __icase_;
bool __collate_;
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 23:45:11 +08:00
bool __might_have_digraph_;
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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-07-01 05:18:19 +08:00
typedef _VSTD::__state<_CharT> __state;
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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-29 01:35:27 +08: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 23:45:11 +08:00
__might_have_digraph_(__traits_.getloc().name() != "C") {}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
virtual void __exec(__state&) const;
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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-29 01:35:27 +08:00
bool __negated() const {return __negate_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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 23:13:20 +08: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-29 01:35:27 +08: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 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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
{
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
if (__b.size() != 1 || __e.size() != 1)
throw regex_error(regex_constants::error_collate);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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-07-01 05:18:19 +08:00
__ranges_.push_back(make_pair(_VSTD::move(__b), _VSTD::move(__e)));
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
}
}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
void __add_equivalence(const string_type& __s)
{__equivalences_.push_back(__s);}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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-30 03:23:39 +08:00
void __add_class(typename regex_traits<_CharT>::char_class_type __mask)
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
{__mask_ |= __mask;}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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-30 03:23:39 +08: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-29 01:35:27 +08:00
{__neg_mask_ |= __mask;}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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 23:45:11 +08:00
if (__might_have_digraph_)
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
const _CharT* __next = _VSTD::next(__s.__current_);
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 23:45:11 +08:00
if (__next != __s.__last_)
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
{
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 23:45:11 +08:00
pair<_CharT, _CharT> __ch2(*__s.__current_, *__next);
if (__icase_)
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
{
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 23:45:11 +08: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-14 05:48:06 +08:00
}
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 23:45:11 +08:00
if (!__traits_.lookup_collatename(&__ch2.first, &__ch2.first+2).empty())
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
{
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 23:45:11 +08: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-14 05:48:06 +08:00
{
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 23:45:11 +08:00
if (__ch2 == __digraphs_[__i])
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
{
__found = true;
goto __exit;
}
}
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 23:45:11 +08:00
if (__collate_ && !__ranges_.empty())
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
{
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 23:45:11 +08: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-14 05:48:06 +08:00
{
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 23:45:11 +08: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-14 05:48:06 +08:00
}
}
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 23:45:11 +08: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-29 01:35:27 +08: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-14 05:48:06 +08: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;
}
}
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-29 01:35:27 +08:00
if (!__neg_chars_.empty())
{
for (size_t __i = 0; __i < __neg_chars_.size(); ++__i)
{
if (__ch == __neg_chars_[__i])
goto __is_neg_char;
}
__found = true;
goto __exit;
}
__is_neg_char:
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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-29 01:35:27 +08:00
{
__found = true;
goto __exit;
}
if (__neg_mask_ && !__traits_.isctype(__ch, __neg_mask_))
{
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
__found = true;
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-29 01:35:27 +08:00
goto __exit;
}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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-15 03:58:17 +08:00
template <class _CharT, class _Traits> class __lookahead;
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
template <class _CharT, class _Traits = regex_traits<_CharT> >
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-13 02:38:34 +08:00
class _LIBCPP_TYPE_VIS_ONLY basic_regex
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
{
public:
// types:
typedef _CharT value_type;
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-08 03:14:52 +08:00
unsigned __loop_count_;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-08 03:14:52 +08:00
shared_ptr<__empty_state<_CharT> > __start_;
__owns_one_state<_CharT>* __end_;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08: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-25 05:28:00 +08:00
public:
// constants:
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 09:31:58 +08: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;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
// construct/copy/destroy:
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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-08 03:14:52 +08:00
basic_regex()
weekly update to by-chapter-summary, plus left and right anchor support in basic posix. llvm-svn: 107938
2010-07-09 08:15:26 +08:00
: __flags_(), __marked_count_(0), __loop_count_(0), __open_count_(0),
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08:00
__end_(0)
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-08 03:14:52 +08:00
{}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08: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 08:15:26 +08:00
: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08:00
__end_(0)
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
{__parse(__p, __p + __traits_.length(__p));}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
basic_regex(const value_type* __p, size_t __len, flag_type __f)
weekly update to by-chapter-summary, plus left and right anchor support in basic posix. llvm-svn: 107938
2010-07-09 08:15:26 +08:00
: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08:00
__end_(0)
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
{__parse(__p, __p + __len);}
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08: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-25 05:28:00 +08:00
template <class _ST, class _SA>
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08: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 08:15:26 +08:00
: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08:00
__end_(0)
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
{__parse(__p.begin(), __p.end());}
template <class _ForwardIterator>
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08: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 08:15:26 +08:00
: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08:00
__end_(0)
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
{__parse(__first, __last);}
Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574 llvm-svn: 137522
2011-08-13 05:56:02 +08:00
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08: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 08:15:26 +08:00
: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08:00
__end_(0)
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
{__parse(__il.begin(), __il.end());}
Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574 llvm-svn: 137522
2011-08-13 05:56:02 +08:00
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08:00
// ~basic_regex() = default;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08:00
// basic_regex& operator=(const basic_regex&) = default;
// basic_regex& operator=(basic_regex&&) = default;
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08:00
basic_regex& operator=(const value_type* __p)
{return assign(__p);}
Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574 llvm-svn: 137522
2011-08-13 05:56:02 +08:00
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08:00
basic_regex& operator=(initializer_list<value_type> __il)
{return assign(__il);}
Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574 llvm-svn: 137522
2011-08-13 05:56:02 +08:00
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
template <class _ST, class _SA>
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08: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-25 05:28:00 +08:00
// assign:
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08:00
basic_regex& assign(const basic_regex& __that)
{return *this = __that;}
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 09:31:58 +08:00
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
basic_regex& assign(basic_regex&& __that) _NOEXCEPT
{return *this = _VSTD::move(__that);}
#endif
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08: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 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08:00
basic_regex& assign(const value_type* __p, size_t __len, flag_type __f)
{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-25 05:28:00 +08:00
template <class _ST, class _SA>
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
basic_regex& assign(const basic_string<value_type, _ST, _SA>& __s,
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08: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-25 05:28:00 +08:00
template <class _InputIterator>
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08:00
typename enable_if
<
__is_input_iterator <_InputIterator>::value &&
!__is_forward_iterator<_InputIterator>::value,
basic_regex&
>::type
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 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08: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 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08:00
typename enable_if
<
__is_forward_iterator<_ForwardIterator>::value,
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-14 00:49:52 +08:00
return assign(basic_regex(__first, __last, __f));
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08:00
}
Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574 llvm-svn: 137522
2011-08-13 05:56:02 +08:00
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
basic_regex& assign(initializer_list<value_type> __il,
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08: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-25 05:28:00 +08:00
Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574 llvm-svn: 137522
2011-08-13 05:56:02 +08:00
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
// const operations:
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
unsigned mark_count() const {return __marked_count_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
flag_type flags() const {return __flags_;}
// locale:
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08:00
locale_type imbue(locale_type __loc)
{
__member_init(ECMAScript);
__start_.reset();
return __traits_.imbue(__loc);
}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
locale_type getloc() const {return __traits_.getloc();}
// swap:
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08: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-25 05:28:00 +08:00
private:
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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-08 03:14:52 +08:00
unsigned __loop_count() const {return __loop_count_;}
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
template <class _ForwardIterator>
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08: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-25 05:28:00 +08: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-08 03:14:52 +08: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-09 01:43:58 +08:00
__owns_one_state<_CharT>* __s,
unsigned __mexp_begin, unsigned __mexp_end);
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-17 03:08:36 +08: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-26 04:56:08 +08: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-14 05:48:06 +08:00
__parse_follow_list(_ForwardIterator __first, _ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
template <class _ForwardIterator>
_ForwardIterator
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
__parse_expression_term(_ForwardIterator __first, _ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
template <class _ForwardIterator>
_ForwardIterator
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
__parse_equivalence_class(_ForwardIterator __first, _ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
template <class _ForwardIterator>
_ForwardIterator
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
__parse_character_class(_ForwardIterator __first, _ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
template <class _ForwardIterator>
_ForwardIterator
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
__parse_collating_symbol(_ForwardIterator __first, _ForwardIterator __last,
basic_string<_CharT>& __col_sym);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
template <class _ForwardIterator>
_ForwardIterator
__parse_DUP_COUNT(_ForwardIterator __first, _ForwardIterator __last, int& __c);
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-23 01:53:24 +08: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 09:25:38 +08: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-29 01:35:27 +08: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 09:25:38 +08:00
template <class _ForwardIterator>
_ForwardIterator
__parse_pattern_character(_ForwardIterator __first, _ForwardIterator __last);
grep and egrep grammars llvm-svn: 109534
2010-07-28 03:53:10 +08: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-29 01:35:27 +08: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-26 04:56:08 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08: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 08:15:26 +08: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 23:51:17 +08: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 09:25:38 +08:00
void __push_match_any_but_newline();
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-09 01:43:58 +08: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 23:13:20 +08: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 09:25:38 +08: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-08 03:14:52 +08: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-14 05:48:06 +08:00
__bracket_expression<_CharT, _Traits>* __start_matching_list(bool __negate);
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
void __push_char(value_type __c);
back references for BRE llvm-svn: 108168
2010-07-13 02:16:05 +08: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-17 03:08:36 +08:00
void __push_alternation(__owns_one_state<_CharT>* __sa,
__owns_one_state<_CharT>* __sb);
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08: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-23 01:53:24 +08: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 09:25:38 +08: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-24 00:18:04 +08:00
void __push_lookahead(const basic_regex&, bool, unsigned);
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
template <class _Allocator>
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
bool
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08: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-07-01 01:22:19 +08:00
regex_constants::match_flag_type __flags) const;
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08: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-08 03:14:52 +08:00
bool
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08: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-27 04:02:27 +08: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 09:25:38 +08: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-08 03:14:52 +08: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 09:25:38 +08: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-27 04:02:27 +08:00
regex_constants::match_flag_type __flags, bool) const;
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08: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-08 03:14:52 +08:00
bool
__match_at_start_posix_nosubs(const _CharT* __first, const _CharT* __last,
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
match_results<const _CharT*, _Allocator>& __m,
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08:00
regex_constants::match_flag_type __flags, bool) const;
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08: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-08 03:14:52 +08:00
bool
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08: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-27 04:02:27 +08: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-08 03:14:52 +08:00
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
template <class _Bp, class _Ap, class _Cp, class _Tp>
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08: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-07-01 01:22:19 +08: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-25 05:28:00 +08:00
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
template <class _Ap, class _Cp, class _Tp>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08: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-15 05:14:52 +08:00
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
template <class _Bp, class _Cp, class _Tp>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
regex_search(_Bp, _Bp, const basic_regex<_Cp, _Tp>&,
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
regex_constants::match_flag_type);
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
template <class _Cp, class _Tp>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08: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-15 05:14:52 +08:00
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
template <class _Cp, class _Ap, class _Tp>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08: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-15 05:14:52 +08:00
regex_constants::match_flag_type);
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
template <class _ST, class _SA, class _Cp, class _Tp>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08: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-15 05:14:52 +08:00
regex_constants::match_flag_type __flags);
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08: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-15 05:14:52 +08:00
regex_constants::match_flag_type __flags);
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08: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-30 07:45:43 +08: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-28 06:20:32 +08: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-08 03:14:52 +08:00
};
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
Zhang Xiongpang: Add definitions for const data members. Fixes http://llvm.org/bugs/show_bug.cgi?id=14585. llvm-svn: 170026
2012-12-13 05:14:28 +08: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-25 05:28:00 +08:00
template <class _CharT, class _Traits>
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08:00
void
basic_regex<_CharT, _Traits>::swap(basic_regex& __r)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
using _VSTD::swap;
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08: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-25 05:28:00 +08:00
{
Everything under [re.regex] llvm-svn: 111024
2010-08-14 02:11:23 +08: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-25 05:28:00 +08:00
}
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08: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-24 00:18:04 +08:00
unsigned __mexp_;
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08:00
bool __invert_;
__lookahead(const __lookahead&);
__lookahead& operator=(const __lookahead&);
public:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
typedef _VSTD::__state<_CharT> __state;
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08: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-24 00:18:04 +08:00
__lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s, unsigned __mexp)
: base(__s), __exp_(__exp), __invert_(__invert), __mexp_(__mexp) {}
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08: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-25 05:28:00 +08:00
template <class _CharT, class _Traits>
void
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08:00
__lookahead<_CharT, _Traits>::__exec(__state& __s) const
{
match_results<const _CharT*> __m;
__m.__init(1 + __exp_.mark_count(), __s.__current_, __s.__last_);
bool __matched = __exp_.__match_at_start_ecma(__s.__current_, __s.__last_,
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08:00
__m,
__s.__flags_ | regex_constants::match_continuous,
William Fisher: A bug in __lookahead::exec causes /(?=^)b/ to match ab. When makes a recursive call to , it passes true for the value of . This causes a beginning-of-line anchor (^) inside a lookahead assertion to match anywhere in the text. This fixes http://llvm.org/bugs/show_bug.cgi?id=11118 llvm-svn: 185196
2013-06-29 03:11:23 +08:00
__s.__at_first_ && __s.__current_ == __s.__first_);
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08: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-24 00:18:04 +08: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-28 06:20:32 +08:00
}
else
{
__s.__do_ = __state::__reject;
__s.__node_ = nullptr;
}
}
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-25 05:28:00 +08: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-08 03:14:52 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +08:00
__start_.reset(new __empty_state<_CharT>(__h.get()));
__h.release();
__end_ = __start_.get();
}
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
switch (__flags_ & 0x1F0)
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
{
case ECMAScript:
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08: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-25 05:28:00 +08:00
break;
case basic:
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08: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-25 05:28:00 +08: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-29 01:35:27 +08: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-25 05:28:00 +08:00
break;
case grep:
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08: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-25 05:28:00 +08:00
break;
case egrep:
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08: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-25 05:28:00 +08:00
break;
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
default:
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
throw regex_error(regex_constants::__re_err_grammar);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
}
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08:00
return __first;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08: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-07-01 05:18:19 +08: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-25 05:28:00 +08:00
if (__temp == __last && *__first == '$')
{
__push_r_anchor();
++__first;
}
}
}
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
if (__first != __last)
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
throw regex_error(regex_constants::__re_err_empty);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
}
return __first;
}
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-17 03:08:36 +08:00
__owns_one_state<_CharT>* __sa = __end_;
_ForwardIterator __temp = __parse_ERE_branch(__first, __last);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-17 03:08:36 +08:00
if (__temp == __first)
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
throw regex_error(regex_constants::__re_err_empty);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-17 03:08:36 +08:00
__first = __temp;
while (__first != __last && *__first == '|')
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
{
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-17 03:08:36 +08:00
__owns_one_state<_CharT>* __sb = __end_;
__temp = __parse_ERE_branch(++__first, __last);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
if (__temp == __first)
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
throw regex_error(regex_constants::__re_err_empty);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-17 03:08:36 +08:00
__push_alternation(__sa, __sb);
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
if (__temp == __first)
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
throw regex_error(regex_constants::__re_err_empty);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-17 03:08:36 +08:00
__owns_one_state<_CharT>* __e = __end_;
unsigned __mexp_begin = __marked_count_;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-07-01 04:30:19 +08:00
__push_begin_marked_subexpression();
unsigned __temp_count = __marked_count_;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
++__open_count_;
__temp = __parse_extended_reg_exp(++__temp, __last);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
if (__temp == __last || *__temp != ')')
throw regex_error(regex_constants::error_paren);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08:00
__push_end_marked_subexpression(__temp_count);
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-17 03:08:36 +08:00
__temp = __parse_ERE_dupl_symbol(__temp, __last, __e, __mexp_begin+1,
__marked_count_+1);
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-25 05:28:00 +08: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-08 03:14:52 +08: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-09 01:43:58 +08: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-25 05:28:00 +08: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-09 01:43:58 +08: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-25 05:28:00 +08: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-07-01 04:30:19 +08: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-25 05:28:00 +08:00
__first = __parse_RE_expression(__temp, __last);
__temp = __parse_Back_close_paren(__first, __last);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
if (__temp == __first)
throw regex_error(regex_constants::error_paren);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08: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-25 05:28:00 +08: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-30 02:37:43 +08: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-25 05:28:00 +08:00
if (__temp == __first)
{
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-25 05:28:00 +08:00
if (__temp == __first)
{
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-25 05:28:00 +08:00
{
__push_match_any();
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-25 05:28:00 +08:00
}
else
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-25 05:28:00 +08:00
}
}
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
__first = __temp;
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08: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-07-01 05:18:19 +08: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-25 05:28:00 +08: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-07-01 05:18:19 +08: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-25 05:28:00 +08: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-07-01 05:18:19 +08: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-25 05:28:00 +08: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-07-01 05:18:19 +08: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-25 05:28:00 +08: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-07-01 05:18:19 +08: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-25 05:28:00 +08:00
if (__temp != __last)
{
Update __parse_DUP_COUNT and __parse_BACKREF to use the traits class to recognize digits. Fixes PR18514 llvm-svn: 199541
2014-01-18 11:40:03 +08:00
if (*__first == '\\')
{
int __val = __traits_.value(*__temp, 10);
if (__val >= 1 && __val <= 9)
{
__push_back_ref(__val);
__first = ++__temp;
}
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08: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-07-01 05:18:19 +08: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-25 05:28:00 +08: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-26 04:56:08 +08:00
__push_char(*__first);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
++__first;
}
return __first;
}
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-25 05:28:00 +08: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-07-01 05:18:19 +08: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-25 05:28:00 +08:00
if (__temp != __last)
{
if (*__first == '\\')
{
switch (*__temp)
{
case '^':
case '.':
case '*':
case '[':
case '$':
case '\\':
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
__push_char(*__temp);
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
__first = ++__temp;
break;
}
}
}
}
return __first;
}
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-07-01 05:18:19 +08:00
_ForwardIterator __temp = _VSTD::next(__first);
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-29 04:31:05 +08:00
case '}':
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-29 01:35:27 +08:00
default:
if ((__flags_ & 0x1F0) == awk)
__first = __parse_awk_escape(++__first, __last);
break;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
}
}
}
}
return __first;
}
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08: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-08 03:14:52 +08:00
_ForwardIterator __last,
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-09 01:43:58 +08: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-25 05:28:00 +08:00
{
if (__first != __last)
{
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
if (*__first == '*')
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
{
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-09 01:43:58 +08: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-25 05:28:00 +08: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);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
if (__temp == __first)
throw regex_error(regex_constants::error_badbrace);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
__first = __temp;
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
if (__first == __last)
throw regex_error(regex_constants::error_brace);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
if (*__first != ',')
{
__temp = __parse_Back_close_brace(__first, __last);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
if (__temp == __first)
throw regex_error(regex_constants::error_brace);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
back references for BRE llvm-svn: 108168
2010-07-13 02:16:05 +08: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-25 05:28:00 +08:00
__first = __temp;
}
else
{
++__first; // consume ','
int __max = -1;
__first = __parse_DUP_COUNT(__first, __last, __max);
__temp = __parse_Back_close_brace(__first, __last);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
if (__temp == __first)
throw regex_error(regex_constants::error_brace);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08: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-17 03:08:36 +08: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-25 05:28:00 +08:00
else
{
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
if (__max < __min)
throw regex_error(regex_constants::error_badbrace);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
back references for BRE llvm-svn: 108168
2010-07-13 02:16:05 +08: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-25 05:28:00 +08:00
}
__first = __temp;
}
}
}
}
return __first;
}
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-17 03:08:36 +08:00
_ForwardIterator __last,
__owns_one_state<_CharT>* __s,
unsigned __mexp_begin,
unsigned __mexp_end)
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
{
if (__first != __last)
{
fix parse bug in ecma non-greedy loop llvm-svn: 109711
2010-07-29 08:36:00 +08:00
unsigned __grammar = __flags_ & 0x1F0;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
switch (*__first)
{
case '*':
++__first;
fix parse bug in ecma non-greedy loop llvm-svn: 109711
2010-07-29 08:36:00 +08: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 09:25:38 +08: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-30 02:37:43 +08:00
break;
case '+':
++__first;
fix parse bug in ecma non-greedy loop llvm-svn: 109711
2010-07-29 08:36:00 +08: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 09:25:38 +08: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-30 02:37:43 +08:00
break;
case '?':
++__first;
fix parse bug in ecma non-greedy loop llvm-svn: 109711
2010-07-29 08:36:00 +08: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 09:25:38 +08: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-30 02:37:43 +08: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-17 03:08:36 +08:00
_ForwardIterator __temp = __parse_DUP_COUNT(++__first, __last, __min);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
if (__temp == __first)
throw regex_error(regex_constants::error_badbrace);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
__first = __temp;
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
if (__first == __last)
throw regex_error(regex_constants::error_brace);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
switch (*__first)
{
case '}':
++__first;
fix parse bug in ecma non-greedy loop llvm-svn: 109711
2010-07-29 08:36:00 +08: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 09:25:38 +08: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-30 02:37:43 +08:00
break;
case ',':
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
++__first;
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__first == __last)
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
throw regex_error(regex_constants::error_badbrace);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
if (*__first == '}')
{
++__first;
fix parse bug in ecma non-greedy loop llvm-svn: 109711
2010-07-29 08:36:00 +08: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 09:25:38 +08: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-30 02:37:43 +08:00
}
else
{
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-17 03:08:36 +08:00
int __max = -1;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
__temp = __parse_DUP_COUNT(__first, __last, __max);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
if (__temp == __first)
throw regex_error(regex_constants::error_brace);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
__first = __temp;
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
if (__first == __last || *__first != '}')
throw regex_error(regex_constants::error_brace);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
++__first;
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
if (__max < __min)
throw regex_error(regex_constants::error_badbrace);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
fix parse bug in ecma non-greedy loop llvm-svn: 109711
2010-07-29 08:36:00 +08: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 09:25:38 +08: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-30 02:37:43 +08:00
}
A good start on extended posix regex. Loops working. Alternation working. Also update by-chapter completeness summary. llvm-svn: 108548
2010-07-17 03:08:36 +08:00
break;
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
default:
throw regex_error(regex_constants::error_badbrace);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
}
}
break;
}
}
return __first;
}
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08: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-12 01:04:31 +08:00
++__first;
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__first == __last)
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
throw regex_error(regex_constants::error_brack);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
bool __negate = false;
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
if (*__first == '^')
{
++__first;
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
__negate = true;
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
__bracket_expression<_CharT, _Traits>* __ml = __start_matching_list(__negate);
// __ml owned by *this
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
if (__first == __last)
throw regex_error(regex_constants::error_brack);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-29 01:35:27 +08:00
if ((__flags_ & 0x1F0) != ECMAScript && *__first == ']')
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
{
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
__ml->__add_char(']');
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
++__first;
}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
__first = __parse_follow_list(__first, __last, __ml);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
if (__first == __last)
throw regex_error(regex_constants::error_brack);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
if (*__first == '-')
{
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
__ml->__add_char('-');
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
++__first;
}
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
if (__first == __last || *__first != ']')
throw regex_error(regex_constants::error_brack);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08: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-14 05:48:06 +08:00
_ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml)
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
{
if (__first != __last)
{
while (true)
{
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
_ForwardIterator __temp = __parse_expression_term(__first, __last,
__ml);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08: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-14 05:48:06 +08:00
_ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml)
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
{
if (__first != __last && *__first != ']')
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
_ForwardIterator __temp = _VSTD::next(__first);
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
basic_string<_CharT> __start_range;
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
if (__temp != __last && *__first == '[')
{
if (*__temp == '=')
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
return __parse_equivalence_class(++__temp, __last, __ml);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
else if (*__temp == ':')
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
return __parse_character_class(++__temp, __last, __ml);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
else if (*__temp == '.')
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
__first = __parse_collating_symbol(++__temp, __last, __start_range);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
}
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-29 01:35:27 +08:00
unsigned __grammar = __flags_ & 0x1F0;
if (__start_range.empty())
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
{
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-29 01:35:27 +08: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-26 04:56:08 +08:00
}
if (__first != __last && *__first != ']')
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
__temp = _VSTD::next(__first);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
if (__temp != __last && *__first == '-' && *__temp != ']')
{
// parse a range
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
basic_string<_CharT> __end_range;
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
__first = __temp;
++__temp;
if (__temp != __last && *__first == '[' && *__temp == '.')
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
__first = __parse_collating_symbol(++__temp, __last, __end_range);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
else
{
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-29 01:35:27 +08: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-26 04:56:08 +08:00
}
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
__ml->__add_range(_VSTD::move(__start_range), _VSTD::move(__end_range));
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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-24 01:37:05 +08:00
else if (!__start_range.empty())
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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-26 04:56:08 +08: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-24 01:37:05 +08:00
else if (!__start_range.empty())
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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-26 04:56:08 +08: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-29 01:35:27 +08: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)
{
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-29 01:35:27 +08:00
if (__first == __last)
throw regex_error(regex_constants::error_escape);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-29 01:35:27 +08: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)
{
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-29 01:35:27 +08:00
if (__first == __last)
throw regex_error(regex_constants::error_escape);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-29 01:35:27 +08: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-03 01:43:31 +08: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-29 01:35:27 +08:00
}
if (__str)
*__str = _CharT(__val);
else
__push_char(_CharT(__val));
}
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-29 01:35:27 +08:00
else
throw regex_error(regex_constants::error_escape);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-29 01:35:27 +08:00
return __first;
}
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08: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-14 05:48:06 +08:00
_ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml)
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
{
// Found [=
// This means =] must exist
value_type _Equal_close[2] = {'=', ']'};
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
_ForwardIterator __temp = _VSTD::search(__first, __last, _Equal_close,
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
_Equal_close+2);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
if (__temp == __last)
throw regex_error(regex_constants::error_brack);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
// [__first, __temp) contains all text in [= ... =]
typedef typename _Traits::string_type string_type;
string_type __collate_name =
__traits_.lookup_collatename(__first, __temp);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
if (__collate_name.empty())
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
throw regex_error(regex_constants::error_collate);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08: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-14 05:48:06 +08:00
__ml->__add_equivalence(__equiv_name);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
else
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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;
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
default:
throw regex_error(regex_constants::error_collate);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
}
}
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
__first = _VSTD::next(__temp, 2);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08: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-14 05:48:06 +08:00
_ForwardIterator __last,
__bracket_expression<_CharT, _Traits>* __ml)
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
{
// Found [:
// This means :] must exist
value_type _Colon_close[2] = {':', ']'};
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
_ForwardIterator __temp = _VSTD::search(__first, __last, _Colon_close,
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
_Colon_close+2);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
if (__temp == __last)
throw regex_error(regex_constants::error_brack);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08: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);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
if (__class_type == 0)
throw regex_error(regex_constants::error_brack);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
__ml->__add_class(__class_type);
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
__first = _VSTD::next(__temp, 2);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08: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-14 05:48:06 +08:00
_ForwardIterator __last,
basic_string<_CharT>& __col_sym)
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
{
// Found [.
// This means .] must exist
value_type _Dot_close[2] = {'.', ']'};
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
_ForwardIterator __temp = _VSTD::search(__first, __last, _Dot_close,
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
_Dot_close+2);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
if (__temp == __last)
throw regex_error(regex_constants::error_brack);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
// [__first, __temp) contains all text in [. ... .]
typedef typename _Traits::string_type string_type;
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
__col_sym = __traits_.lookup_collatename(__first, __temp);
switch (__col_sym.size())
{
case 1:
case 2:
break;
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
default:
throw regex_error(regex_constants::error_collate);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08:00
}
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
__first = _VSTD::next(__temp, 2);
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08: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 11:40:03 +08:00
if (__first != __last )
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
{
Update __parse_DUP_COUNT and __parse_BACKREF to use the traits class to recognize digits. Fixes PR18514 llvm-svn: 199541
2014-01-18 11:40:03 +08:00
int __val = __traits_.value(*__first, 10);
if ( __val != -1 )
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
{
Update __parse_DUP_COUNT and __parse_BACKREF to use the traits class to recognize digits. Fixes PR18514 llvm-svn: 199541
2014-01-18 11:40:03 +08:00
__c = __val;
for (++__first;
__first != __last && ( __val = __traits_.value(*__first, 10)) != -1;
++__first)
{
__c *= 10;
__c += __val;
}
regex: learning to crawl llvm-svn: 106882
2010-06-26 04:56:08 +08:00
}
}
return __first;
}
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-23 01:53:24 +08: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 09:25:38 +08: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-23 01:53:24 +08: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 09:25:38 +08: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-23 01:53:24 +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 09:25:38 +08:00
else
__first = __temp;
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-23 01:53:24 +08: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-07-01 05:18:19 +08:00
_ForwardIterator __temp = _VSTD::next(__first);
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-23 01:53:24 +08: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 09:25:38 +08:00
__push_word_boundary(false);
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-23 01:53:24 +08: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 09:25:38 +08:00
__push_word_boundary(true);
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-23 01:53:24 +08:00
__first = ++__temp;
}
}
}
break;
case '(':
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
_ForwardIterator __temp = _VSTD::next(__first);
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-23 01:53:24 +08:00
if (__temp != __last && *__temp == '?')
{
if (++__temp != __last)
{
switch (*__temp)
{
case '=':
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08: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-24 00:18:04 +08:00
unsigned __mexp = __exp.__marked_count_;
__push_lookahead(_VSTD::move(__exp), false, __marked_count_);
__marked_count_ += __mexp;
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08:00
if (__temp == __last || *__temp != ')')
throw regex_error(regex_constants::error_paren);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08:00
__first = ++__temp;
}
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-23 01:53:24 +08:00
break;
case '!':
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08: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-24 00:18:04 +08:00
unsigned __mexp = __exp.__marked_count_;
__push_lookahead(_VSTD::move(__exp), true, __marked_count_);
__marked_count_ += __mexp;
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08:00
if (__temp == __last || *__temp != ')')
throw regex_error(regex_constants::error_paren);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08:00
__first = ++__temp;
}
I believe posix extended expr is feature complete. Getting started on ecma exprs. llvm-svn: 109126
2010-07-23 01:53:24 +08: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 09:25:38 +08: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-12 01:04:31 +08:00
++__first;
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__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 09:25:38 +08:00
throw regex_error(regex_constants::error_paren);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08: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 09:25:38 +08:00
if (__temp != __last && *__first == '?' && *__temp == ':')
{
++__open_count_;
__first = __parse_ecma_exp(++__temp, __last);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08:00
if (__first == __last || *__first != ')')
throw regex_error(regex_constants::error_paren);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08:00
--__open_count_;
++__first;
}
else
{
__push_begin_marked_subexpression();
unsigned __temp_count = __marked_count_;
++__open_count_;
__first = __parse_ecma_exp(__first, __last);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08:00
if (__first == __last || *__first != ')')
throw regex_error(regex_constants::error_paren);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08:00
__push_end_marked_subexpression(__temp_count);
--__open_count_;
++__first;
}
}
break;
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-07-01 05:18:19 +08:00
_ForwardIterator __t1 = _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 09:25:38 +08: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';
for (++__first; '0' <= *__first && *__first <= '9'; ++__first)
__v = 10 * __v + *__first - '0';
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08:00
if (__v > mark_count())
throw regex_error(regex_constants::error_backref);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08: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-29 01:35:27 +08: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 09:25:38 +08: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-29 01:35:27 +08: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 09:25:38 +08: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-29 01:35:27 +08: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 09:25:38 +08: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-29 01:35:27 +08: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 09:25:38 +08: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-29 01:35:27 +08: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 09:25:38 +08: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-29 01:35:27 +08: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 09:25:38 +08:00
++__first;
break;
case 'c':
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08: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 09:25:38 +08: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-16 02:21:11 +08:00
if (('A' <= *__t && *__t <= 'Z') ||
('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 09:25:38 +08:00
{
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-29 01:35:27 +08: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 09:25:38 +08:00
__first = ++__t;
}
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-16 02:21:11 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
else
throw regex_error(regex_constants::error_escape);
#endif // _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08: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-16 02:21:11 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
else
throw regex_error(regex_constants::error_escape);
#endif // _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08:00
break;
case 'u':
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
++__first;
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__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 09:25:38 +08:00
throw regex_error(regex_constants::error_escape);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08:00
__hd = __traits_.value(*__first, 16);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08:00
if (__hd == -1)
throw regex_error(regex_constants::error_escape);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Quash a whole bunch of warnings llvm-svn: 145624
2011-12-02 04:21:04 +08:00
__sum = 16 * __sum + static_cast<unsigned>(__hd);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
++__first;
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__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 09:25:38 +08:00
throw regex_error(regex_constants::error_escape);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08:00
__hd = __traits_.value(*__first, 16);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08:00
if (__hd == -1)
throw regex_error(regex_constants::error_escape);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Quash a whole bunch of warnings llvm-svn: 145624
2011-12-02 04:21:04 +08:00
__sum = 16 * __sum + static_cast<unsigned>(__hd);
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 09:25:38 +08:00
// drop through
case 'x':
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
++__first;
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__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 09:25:38 +08:00
throw regex_error(regex_constants::error_escape);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08:00
__hd = __traits_.value(*__first, 16);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08:00
if (__hd == -1)
throw regex_error(regex_constants::error_escape);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Quash a whole bunch of warnings llvm-svn: 145624
2011-12-02 04:21:04 +08:00
__sum = 16 * __sum + static_cast<unsigned>(__hd);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
++__first;
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__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 09:25:38 +08:00
throw regex_error(regex_constants::error_escape);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08:00
__hd = __traits_.value(*__first, 16);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08:00
if (__hd == -1)
throw regex_error(regex_constants::error_escape);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
Quash a whole bunch of warnings llvm-svn: 145624
2011-12-02 04:21:04 +08: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-29 01:35:27 +08: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 09:25:38 +08:00
++__first;
break;
Fix Bug 19678 - libc++ does not correctly handle the regex: '[^\0]*' llvm-svn: 209307
2014-05-22 00:29:50 +08: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 09:25:38 +08: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-29 01:35:27 +08: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 09:25:38 +08:00
++__first;
}
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
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-29 02:57:30 +08:00
else
Fixed some bugs in the ecma bracket epression regarding escaped characters, and got the awk grammar going. llvm-svn: 109599
2010-07-29 01:35:27 +08:00
throw regex_error(regex_constants::error_escape);
Fixing whitespace problems llvm-svn: 111750
2010-08-22 08:02:43 +08:00
#endif // _LIBCPP_NO_EXCEPTIONS
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 09:25:38 +08: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-23 01:53:24 +08:00
}
grep and egrep grammars llvm-svn: 109534
2010-07-28 03:53:10 +08: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-07-01 05:18:19 +08:00
_ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
grep and egrep grammars llvm-svn: 109534
2010-07-28 03:53:10 +08: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-07-01 05:18:19 +08:00
__t1 = _VSTD::find(__first, __last, _CharT('\n'));
grep and egrep grammars llvm-svn: 109534
2010-07-28 03:53:10 +08: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-07-01 05:18:19 +08:00
_ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
grep and egrep grammars llvm-svn: 109534
2010-07-28 03:53:10 +08: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-07-01 05:18:19 +08:00
__t1 = _VSTD::find(__first, __last, _CharT('\n'));
grep and egrep grammars llvm-svn: 109534
2010-07-28 03:53:10 +08: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;
}
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-08 03:14:52 +08: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-14 05:48:06 +08:00
if (flags() & icase)
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-13 03:11:27 +08:00
__end_->first() = new __match_char_icase<_CharT, _Traits>
(__traits_, __c, __end_->first());
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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-13 03:11:27 +08: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-09 01:43:58 +08:00
__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
}
First test for marked subexpressions llvm-svn: 107317
2010-07-01 04:30:19 +08: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 23:45:11 +08: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-07-01 04:30:19 +08: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 23:45:11 +08: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-07-01 04:30:19 +08:00
}
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08:00
template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::__push_l_anchor()
{
__end_->first() = new __l_anchor<_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 08:15:26 +08:00
template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::__push_r_anchor()
{
__end_->first() = new __r_anchor<_CharT>(__end_->first());
__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 23:51:17 +08: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 08:15:26 +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 09:25:38 +08: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-23 01:53:24 +08: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 09:25:38 +08: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-13 02:16:05 +08: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-14 05:48:06 +08:00
if (flags() & icase)
regex_constants icase and collate for matching a single char and for matching back references llvm-svn: 108178
2010-07-13 03:11:27 +08:00
__end_->first() = new __back_ref_icase<_CharT, _Traits>
(__traits_, __i, __end_->first());
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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-13 03:11:27 +08: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-13 02:16:05 +08: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-17 03:08:36 +08: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-13 02:16:05 +08:00
}
Bracket expressions are working (lightly tested). llvm-svn: 108280
2010-07-14 05:48:06 +08: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-28 06:20:32 +08: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-24 00:18:04 +08:00
bool __invert,
unsigned __mexp)
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08: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-24 00:18:04 +08:00
__end_->first(), __mexp);
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08:00
__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
}
Continuing to work through regex, and updated libcxx_by_chapter.pdf with weekly test results llvm-svn: 106790
2010-06-25 05:28:00 +08:00
typedef basic_regex<char> regex;
typedef basic_regex<wchar_t> wregex;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
// sub_match
template <class _BidirectionalIterator>
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-13 02:38:34 +08:00
class _LIBCPP_TYPE_VIS_ONLY sub_match
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-09 05:07:55 +08:00
_LIBCPP_INLINE_VISIBILITY
noexcept and constexpr applied to <regex>. llvm-svn: 160594
2012-07-21 09:31:58 +08:00
_LIBCPP_CONSTEXPR sub_match() : matched() {}
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-09 05:07:55 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
difference_type length() const
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
{return matched ? _VSTD::distance(this->first, this->second) : 0;}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
string_type str() const
{return matched ? string_type(this->first, this->second) : string_type();}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
operator string_type() const
{return str();}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
int compare(const sub_match& __s) const
{return str().compare(__s.str());}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
int compare(const string_type& __s) const
{return str().compare(__s);}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08:00
int compare(const value_type* __s) const
{return str().compare(__s);}
};
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>
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-16 07:57:56 +08:00
return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) == 0;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-16 07:57:56 +08:00
return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) > 0;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-16 07:57:56 +08:00
return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) == 0;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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-16 07:57:56 +08:00
return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) < 0;
[re.submatch] llvm-svn: 107187
2010-06-30 02:37:43 +08: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();
}
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 09:25:38 +08:00
template <class _BidirectionalIterator, class _Allocator>
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-13 02:38:34 +08:00
class _LIBCPP_TYPE_VIS_ONLY match_results
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08: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-09 05:07:55 +08:00
bool __ready_;
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
public:
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
_BidirectionalIterator __position_start_;
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08: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 09:56:31 +08:00
typedef value_type& reference;
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08: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:
explicit match_results(const allocator_type& __a = allocator_type());
// 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-09 05:07:55 +08:00
_LIBCPP_INLINE_VISIBILITY
bool ready() const {return __ready_;}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
// size:
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
size_type size() const {return __matches_.size();}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
size_type max_size() const {return __matches_.max_size();}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
bool empty() const {return size() == 0;}
// element access:
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
difference_type length(size_type __sub = 0) const
{return (*this)[__sub].length();}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
difference_type position(size_type __sub = 0) const
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
{return _VSTD::distance(__position_start_, (*this)[__sub].first);}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
string_type str(size_type __sub = 0) const
{return (*this)[__sub].str();}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
const_reference operator[](size_type __n) const
{return __n < __matches_.size() ? __matches_[__n] : __unmatched_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
const_reference prefix() const {return __prefix_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
const_reference suffix() const {return __suffix_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Fix <rdar://problem/10255403> match_results::begin() is off by one llvm-svn: 141494
2011-10-08 22:36:16 +08:00
const_iterator begin() const {return empty() ? __matches_.end() : __matches_.begin();}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
const_iterator end() const {return __matches_.end();}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Fix <rdar://problem/10255403> match_results::begin() is off by one llvm-svn: 141494
2011-10-08 22:36:16 +08:00
const_iterator cbegin() const {return empty() ? __matches_.end() : __matches_.begin();}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
const_iterator cend() const {return __matches_.end();}
// 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>
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
_OutputIter
format(_OutputIter __out, const basic_string<char_type, _ST, _SA>& __fmt,
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
regex_constants::match_flag_type __flags = regex_constants::format_default) const
{return format(__out, __fmt.data(), __fmt.data() + __fmt.size(), __flags);}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
template <class _ST, class _SA>
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08: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-15 02:14:02 +08: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 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
string_type
format(const char_type* __fmt,
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08: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 08:21:42 +08:00
// allocator:
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08: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-30 02:15:50 +08:00
template <class _Bp, class _Ap>
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
void __assign(_BidirectionalIterator __f, _BidirectionalIterator __l,
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
const match_results<_Bp, _Ap>& __m, bool __no_update_pos)
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
{
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
_Bp __mf = __m.prefix().first;
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08: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-07-01 05:18:19 +08: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-15 05:14:52 +08: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-07-01 05:18:19 +08: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-15 05:14:52 +08:00
__prefix_.matched = __m.prefix().matched;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08: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-15 05:14:52 +08:00
__suffix_.matched = __m.suffix().matched;
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
if (!__no_update_pos)
__position_start_ = __prefix_.first;
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-09 05:07:55 +08:00
__ready_ = __m.ready();
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
}
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
private:
void __init(unsigned __s,
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
_BidirectionalIterator __f, _BidirectionalIterator __l,
bool __no_update_pos = false);
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
template <class, class> friend class basic_regex;
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
template <class _Bp, class _Ap, class _Cp, class _Tp>
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08: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 08:21:42 +08:00
regex_constants::match_flag_type);
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08:00
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
template <class _Bp, class _Ap>
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
friend
bool
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
operator==(const match_results<_Bp, _Ap>&, const match_results<_Bp, _Ap>&);
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
lookahead for ecma llvm-svn: 109548
2010-07-28 06:20:32 +08:00
template <class, class> friend class __lookahead;
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08: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-17 04:21:16 +08:00
__suffix_(),
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-09 05:07:55 +08:00
__position_start_(),
__ready_(false)
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
{
}
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
template <class _BidirectionalIterator, class _Allocator>
void
match_results<_BidirectionalIterator, _Allocator>::__init(unsigned __s,
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
_BidirectionalIterator __f, _BidirectionalIterator __l,
bool __no_update_pos)
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08: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-08 03:14:52 +08:00
__matches_.assign(__s, __unmatched_);
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08: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-09 01:43:58 +08:00
__suffix_ = __unmatched_;
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
if (!__no_update_pos)
__position_start_ = __prefix_.first;
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-09 05:07:55 +08:00
__ready_ = true;
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
}
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
template <class _BidirectionalIterator, class _Allocator>
template <class _OutputIter>
_OutputIter
match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out,
const char_type* __fmt_first, const char_type* __fmt_last,
regex_constants::match_flag_type __flags) const
{
if (__flags & regex_constants::format_sed)
{
for (; __fmt_first != __fmt_last; ++__fmt_first)
{
if (*__fmt_first == '&')
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
__out = _VSTD::copy(__matches_[0].first, __matches_[0].second,
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
__out);
else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last)
{
++__fmt_first;
if ('0' <= *__fmt_first && *__fmt_first <= '9')
{
size_t __i = *__fmt_first - '0';
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
__out = _VSTD::copy(__matches_[__i].first,
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
__matches_[__i].second, __out);
}
else
{
*__out = *__fmt_first;
++__out;
}
}
else
{
*__out = *__fmt_first;
++__out;
}
}
}
else
{
for (; __fmt_first != __fmt_last; ++__fmt_first)
{
if (*__fmt_first == '$' && __fmt_first + 1 != __fmt_last)
{
switch (__fmt_first[1])
{
case '$':
*__out = *++__fmt_first;
++__out;
break;
case '&':
++__fmt_first;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
__out = _VSTD::copy(__matches_[0].first, __matches_[0].second,
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
__out);
break;
case '`':
++__fmt_first;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
__out = _VSTD::copy(__prefix_.first, __prefix_.second, __out);
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
break;
case '\'':
++__fmt_first;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
__out = _VSTD::copy(__suffix_.first, __suffix_.second, __out);
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
break;
default:
if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9')
{
++__fmt_first;
size_t __i = *__fmt_first - '0';
if (__fmt_first + 1 != __fmt_last &&
'0' <= __fmt_first[1] && __fmt_first[1] <= '9')
{
++__fmt_first;
__i = 10 * __i + *__fmt_first - '0';
}
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
__out = _VSTD::copy(__matches_[__i].first,
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
__matches_[__i].second, __out);
}
else
{
*__out = *__fmt_first;
++__out;
}
break;
}
}
else
{
*__out = *__fmt_first;
++__out;
}
}
}
return __out;
}
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-07-01 05:18:19 +08:00
using _VSTD::swap;
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
swap(__matches_, __m.__matches_);
swap(__unmatched_, __m.__unmatched_);
swap(__prefix_, __m.__prefix_);
swap(__suffix_, __m.__suffix_);
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
swap(__position_start_, __m.__position_start_);
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-09 05:07:55 +08:00
swap(__ready_, __m.__ready_);
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
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>
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
bool
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-09 05:07:55 +08:00
if (__x.__ready_ != __y.__ready_)
return false;
if (!__x.__ready_)
return true;
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
return __x.__matches_ == __y.__matches_ &&
__x.__prefix_ == __y.__prefix_ &&
N3158 Missing preconditions for default-constructed match_result objects llvm-svn: 121282
2010-12-09 05:07:55 +08:00
__x.__suffix_ == __y.__suffix_;
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08:00
}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
template <class _BidirectionalIterator, class _Allocator>
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08: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 08:21:42 +08:00
template <class _BidirectionalIterator, class _Allocator>
Everything under [re.results] llvm-svn: 111074
2010-08-15 02:14:02 +08: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 08:21:42 +08: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-08 03:14:52 +08: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 09:25:38 +08: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-08 03:14:52 +08: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 09:25:38 +08: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-27 04:02:27 +08: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-08 03:14:52 +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 09:25:38 +08:00
vector<__state> __states;
__node* __st = __start_.get();
if (__st)
{
Fix for PR22061 by K-ballo llvm-svn: 227384
2015-01-29 06:22:35 +08: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 09:25:38 +08: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-29 06:22:35 +08: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 09:25:38 +08: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-27 04:02:27 +08:00
__states.back().__at_first_ = __at_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 09:25:38 +08:00
do
{
__state& __s = __states.back();
if (__s.__node_)
__s.__node_->__exec(__s);
switch (__s.__do_)
{
case __state::__end_state:
__m.__matches_[0].first = __first;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08: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 09:25:38 +08: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-07-01 05:18:19 +08: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 09:25:38 +08:00
}
break;
case __state::__reject:
__states.pop_back();
break;
default:
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
throw regex_error(regex_constants::__re_err_unknown);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#endif
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 09:25:38 +08:00
break;
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +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 09:25:38 +08: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-08 03:14:52 +08:00
return false;
}
template <class _CharT, class _Traits>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08: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-08 03:14:52 +08: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-15 05:14:52 +08:00
match_results<const _CharT*, _Allocator>& __m,
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08: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-08 03:14:52 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
deque<__state> __states;
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
ptrdiff_t __highest_j = 0;
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08: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 23:51:17 +08: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-08 03:14:52 +08: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 23:51:17 +08: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-27 04:02:27 +08:00
__states.back().__at_first_ = __at_first;
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 23:45:11 +08:00
bool __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-08 03:14:52 +08:00
do
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
case __state::__end_state:
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
if (!__matched || __highest_j < __s.__current_ - __s.__first_)
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 23:45:11 +08:00
__highest_j = __s.__current_ - __s.__first_;
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
__matched = true;
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
break;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
case __state::__consume_input:
break;
case __state::__accept_and_consume:
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
break;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +08:00
break;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-07-01 05:18:19 +08: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 23:51:17 +08: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-08 03:14:52 +08:00
break;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-08 03:14:52 +08:00
break;
default:
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
throw regex_error(regex_constants::__re_err_unknown);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#endif
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-08 03:14:52 +08:00
break;
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
} while (!__states.empty());
Minor optimizations. Minor bug fixes. More tests. llvm-svn: 108331
2010-07-14 23:45:11 +08: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-08 03:14:52 +08:00
{
__m.__matches_[0].first = __first;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08: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-08 03:14:52 +08: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-15 05:14:52 +08: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-08 03:14:52 +08:00
bool
basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08: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-27 04:02:27 +08: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-08 03:14:52 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
vector<__state> __states;
__state __best_state;
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
ptrdiff_t __j = 0;
ptrdiff_t __highest_j = 0;
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08: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 23:51:17 +08:00
__node* __st = __start_.get();
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-09 01:43:58 +08:00
if (__st)
{
Fix for PR22061 by K-ballo llvm-svn: 227384
2015-01-29 06:22:35 +08: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 23:51:17 +08: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-29 06:22:35 +08: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 23:51:17 +08: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-27 04:02:27 +08:00
__states.back().__at_first_ = __at_first;
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
const _CharT* __current = __first;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
bool __matched = false;
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-09 01:43:58 +08:00
do
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-09 01:43:58 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
case __state::__end_state:
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08: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-09 01:43:58 +08:00
{
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08: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 23:51:17 +08:00
__best_state = __s;
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-09 01:43:58 +08:00
}
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
__matched = true;
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
if (__highest_j == _Np)
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08: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-09 01:43:58 +08:00
break;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
case __state::__accept_and_consume:
back references for BRE llvm-svn: 108168
2010-07-13 02:16:05 +08:00
__j += __s.__current_ - __current;
__current = __s.__current_;
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-09 01:43:58 +08:00
break;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08:00
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-09 01:43:58 +08:00
{
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-07-01 05:18:19 +08: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-09 01:43:58 +08:00
}
break;
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-09 01:43:58 +08:00
break;
default:
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#ifndef _LIBCPP_NO_EXCEPTIONS
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
throw regex_error(regex_constants::__re_err_unknown);
now works with -fno-exceptions and -fno-rtti llvm-svn: 110828
2010-08-12 01:04:31 +08:00
#endif
Marked subexpressions in a loop in basic posix working (only lightly tested so far) llvm-svn: 107889
2010-07-09 01:43:58 +08:00
break;
}
Redesign number 3. The previous design was not handling matching of empty strings inside of loops. llvm-svn: 108151
2010-07-12 23:51:17 +08: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-09 01:43:58 +08:00
{
__m.__matches_[0].first = __first;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08: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-09 01:43:58 +08: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 23:51:17 +08: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-09 01:43:58 +08: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-08 03:14:52 +08:00
return false;
}
template <class _CharT, class _Traits>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08: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-08 03:14:52 +08:00
bool
basic_regex<_CharT, _Traits>::__match_at_start(
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08: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-27 04:02:27 +08: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-08 03:14:52 +08:00
{
continued regex development... llvm-svn: 109512
2010-07-28 01:24:17 +08:00
if ((__flags_ & 0x1F0) == ECMAScript)
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08: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-08 03:14:52 +08:00
if (mark_count() == 0)
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08: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-08 03:14:52 +08:00
}
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
template <class _CharT, class _Traits>
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08:00
template <class _Allocator>
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
bool
basic_regex<_CharT, _Traits>::__search(
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08: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-07-01 01:22:19 +08:00
regex_constants::match_flag_type __flags) const
{
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
__m.__init(1 + mark_count(), __first, __last,
__flags & regex_constants::__no_update_pos);
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-10 01:29:09 +08:00
if (__match_at_start(__first, __last, __m, __flags,
!(__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-08 03:14:52 +08: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 09:15:27 +08:00
if (__first != __last && !(__flags & regex_constants::match_continuous))
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
{
bug fix concerning search not at beginning of string and word boundaries llvm-svn: 109750
2010-07-29 23:17:28 +08: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-08 03:14:52 +08:00
for (++__first; __first != __last; ++__first)
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
{
bug fix concerning search not at beginning of string and word boundaries llvm-svn: 109750
2010-07-29 23:17:28 +08:00
__m.__matches_.assign(__m.size(), __m.__unmatched_);
Jonathan Sauer found a bug in the way ^ was handled llvm-svn: 128350
2011-03-27 04:02:27 +08:00
if (__match_at_start(__first, __last, __m, __flags, false))
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08: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-08 03:14:52 +08: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-07-01 01:22:19 +08: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-08 03:14:52 +08:00
__m.__matches_.assign(__m.size(), __m.__unmatched_);
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08: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-08 03:14:52 +08:00
__m.__matches_.clear();
return false;
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits>
First, very primitive, search results on one engine llvm-svn: 107294
2010-07-01 01:22:19 +08:00
inline _LIBCPP_INLINE_VISIBILITY
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08: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-07-01 01:22:19 +08:00
regex_constants::match_flag_type __flags = regex_constants::match_default)
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08: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 23:32:55 +08: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-15 05:14:52 +08: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 23:32:55 +08:00
bool __r = __e.__search(__s.data() + __offset, __s.data() + __s.size(), __mc, __flags);
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
__m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
Fixed to work with generalized iterators. llvm-svn: 108359
2010-07-15 05:14:52 +08: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-30 07:45:43 +08: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-15 05:14:52 +08: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-07-01 01:22:19 +08:00
{
return __e.__search(__first, __last, __m, __flags);
}
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08: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-15 05:14:52 +08: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 08:21:42 +08: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-15 05:14:52 +08:00
return __e.__search(__str, __str + _Traits::length(__str), __m, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08: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-15 05:14:52 +08:00
match_results<const _CharT*> __m;
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
return _VSTD::regex_search(__str, __m, __e, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08: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-15 05:14:52 +08: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 08:21:42 +08: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-15 05:14:52 +08: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-17 04:21:16 +08: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-15 05:14:52 +08:00
return __r;
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
}
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-20 05:21:11 +08: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,
regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
#endif
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
// regex_match
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)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
bool __r = _VSTD::regex_search(__first, __last, __m, __e,
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
__flags | regex_constants::match_continuous);
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-07-01 05:18:19 +08:00
return _VSTD::regex_match(__first, __last, __m, __e, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08: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-07-01 05:18:19 +08: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 08:21:42 +08: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-07-01 05:18:19 +08:00
return _VSTD::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
}
Implement LWG Issues #2329 and #2332 - disallow iterators into temporary regexes and regexes into temporary strings llvm-svn: 201717
2014-02-20 05:21:11 +08: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,
regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
#endif
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08: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-07-01 05:18:19 +08:00
return _VSTD::regex_match(__str, __str + _Traits::length(__str), __e, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08: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-07-01 05:18:19 +08:00
return _VSTD::regex_match(__s.begin(), __s.end(), __e, __flags);
two steps forward, one step back... llvm-svn: 107230
2010-06-30 08:21:42 +08:00
}
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
// regex_iterator
template <class _BidirectionalIterator,
class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
class _Traits = regex_traits<_CharT> >
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-13 02:38:34 +08:00
class _LIBCPP_TYPE_VIS_ONLY regex_iterator
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08: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-20 05:21:11 +08: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,
regex_constants::match_flag_type __m
= regex_constants::match_default) = delete;
#endif
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
bool operator==(const regex_iterator& __x) const;
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
bool operator!=(const regex_iterator& __x) const {return !(*this == __x);}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
reference operator*() const {return __match_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
pointer operator->() const {return &__match_;}
regex_iterator& operator++();
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08: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),
__pregex_(&__re),
__flags_(__m)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
_VSTD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08: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;
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-30 07:45:43 +08:00
if (__match_.empty())
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
{
if (__start == __end_)
{
__match_ = value_type();
return *this;
}
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
else if (_VSTD::regex_search(__start, __end_, __match_, *__pregex_,
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08: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-07-01 05:18:19 +08:00
if (!_VSTD::regex_search(__start, __end_, __match_, *__pregex_, __flags_))
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
__match_ = value_type();
return *this;
}
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;
// regex_token_iterator
template <class _BidirectionalIterator,
class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
class _Traits = regex_traits<_CharT> >
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-13 02:38:34 +08:00
class _LIBCPP_TYPE_VIS_ONLY regex_token_iterator
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08: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-18 04:42:03 +08:00
private:
typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Position;
_Position __position_;
const value_type* __result_;
value_type __suffix_;
ptrdiff_t _N_;
vector<int> __subs_;
public:
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08: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-18 04:42:03 +08: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-20 05:21:11 +08: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-17 04:21:16 +08:00
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type& __re, const vector<int>& __submatches,
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08: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-20 05:21:11 +08: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
Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574 llvm-svn: 137522
2011-08-13 05:56:02 +08:00
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08: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-20 05:21:11 +08: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
Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574 llvm-svn: 137522
2011-08-13 05:56:02 +08:00
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
template <size_t _Np>
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08: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-30 02:15:50 +08:00
const int (&__submatches)[_Np],
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08: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-20 05:21:11 +08:00
#if _LIBCPP_STD_VER > 11
template <std::size_t _Np>
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-17 04:21:16 +08:00
regex_token_iterator(const regex_token_iterator&);
regex_token_iterator& operator=(const regex_token_iterator&);
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08:00
bool operator==(const regex_token_iterator& __x) const;
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08:00
bool operator!=(const regex_token_iterator& __x) const {return !(*this == __x);}
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08:00
const value_type& operator*() const {return *__result_;}
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08:00
const value_type* operator->() const {return __result_;}
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
regex_token_iterator& operator++();
visibility-decoration. llvm-svn: 114647
2010-09-23 23:13:20 +08:00
_LIBCPP_INLINE_VISIBILITY
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08: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-10 02:25:57 +08:00
void __establish_result () {
if (__subs_[_N_] == -1)
__result_ = &__position_->prefix();
else
__result_ = &(*__position_)[__subs_[_N_]];
}
[re.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
};
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08:00
template <class _BidirectionalIterator, class _CharT, class _Traits>
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
regex_token_iterator()
: __result_(nullptr),
__suffix_(),
_N_(0)
{
}
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-10 02:25:57 +08:00
__establish_result ();
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08:00
else if (__subs_[_N_] == -1)
{
__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),
_N_(0),
__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),
_N_(0),
__subs_(__submatches)
{
__init(__a, __b);
}
Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574 llvm-svn: 137522
2011-08-13 05:56:02 +08:00
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08: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),
_N_(0),
__subs_(__submatches)
{
__init(__a, __b);
}
Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574 llvm-svn: 137522
2011-08-13 05:56:02 +08:00
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08:00
template <class _BidirectionalIterator, class _CharT, class _Traits>
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
template <size_t _Np>
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08: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-30 02:15:50 +08:00
const int (&__submatches)[_Np],
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08:00
regex_constants::match_flag_type __m)
: __position_(__a, __b, __re, __m),
_N_(0),
Further macro protection by replacing _[A-Z] with _[A-Z]p llvm-svn: 145410
2011-11-30 02:15:50 +08:00
__subs_(__submatches, __submatches + _Np)
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08: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_),
_N_(__x._N_),
__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-14 01:47:08 +08: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-10 02:25:57 +08:00
else if ( __result_ != nullptr )
__establish_result ();
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08: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-10 02:25:57 +08:00
__result_ = &__suffix_;
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08:00
else
__result_ = __x.__result_;
__suffix_ = __x.__suffix_;
_N_ = __x._N_;
__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-10 02:25:57 +08:00
if ( __result_ != nullptr && __result_ != &__suffix_ )
__establish_result();
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08: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;
return __position_ == __x.__position_ && _N_ == __x._N_ &&
__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;
else if (_N_ + 1 < __subs_.size())
{
++_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-10 02:25:57 +08:00
__establish_result();
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08:00
}
else
{
_N_ = 0;
++__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-10 02:25:57 +08:00
__establish_result();
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08:00
else
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
if (_VSTD::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end()
[re.tokiter] llvm-svn: 111278
2010-08-18 04:42:03 +08: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.regiter] llvm-svn: 111178
2010-08-17 04:21:16 +08:00
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;
[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 08:13:08 +08:00
// regex_replace
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)
{
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))
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
__out = _VSTD::copy(__first, __last, __out);
[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 08:13:08 +08: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))
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
__out = _VSTD::copy(__i->prefix().first, __i->prefix().second, __out);
[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 08:13:08 +08:00
__out = __i->format(__out, __fmt, __fmt + __len, __flags);
__lm = __i->suffix();
if (__flags & regex_constants::format_first_only)
break;
}
if (!(__flags & regex_constants::format_no_copy))
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
__out = _VSTD::copy(__lm.first, __lm.second, __out);
[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 08:13:08 +08:00
}
return __out;
}
template <class _OutputIterator, class _BidirectionalIterator,
class _Traits, class _CharT, class _ST, class _SA>
inline _LIBCPP_INLINE_VISIBILITY
_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)
{
_STD -> _VSTD to avoid macro clash on windows llvm-svn: 134190
2011-07-01 05:18:19 +08:00
return _VSTD::regex_replace(__out, __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 08:13:08 +08: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-07-01 05:18:19 +08: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 08:13:08 +08: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-07-01 05:18:19 +08: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 08:13:08 +08: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-07-01 05:18:19 +08: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 08:13:08 +08: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-07-01 05:18:19 +08: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 08:13:08 +08: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 08:34:59 +08:00
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_REGEX