+2013-10-06 Tim Shen <timshen91@gmail.com>
+
+ * include/bits/regex.h: (regex_token_iterator<>::regex_token_iterator):
+ Fix compile error.
+ * include/bits/regex.tcc: (regex_replace<>): Remove default parameter.
+
+2013-10-06 Tim Shen <timshen91@gmail.com>
+
+ * include/bits/regex.h (__regex_algo_impl<>, regex_match<>,
+ regex_search<>): New abstract function for regex_match and regex_search.
+ * include/bits/regex.tcc (__regex_algo_impl<>): Implement.
+ * include/bits/regex_executor.h
+ (_Executor<>::_M_lookahead,
+ _DFSExecutor<>::_M_clone,
+ _BFSExecutor<>::_M_clone): Let _M_clone to choose which executor to
+ use.
+ * include/bits/regex_executor.tcc (__get_executor<>): Update the
+ definition to support __policy.
+ * testsuite/28_regex/algorithms/regex_match/awk/cstring_01.cc: Use
+ *_debug.
+ * testsuite/28_regex/algorithms/regex_match/basic/empty_range.cc: Same.
+ * testsuite/28_regex/algorithms/regex_match/basic/string_01.cc: Same.
+ * testsuite/28_regex/algorithms/regex_match/basic/string_range_00_03.cc:
+ Same.
+ * testsuite/28_regex/algorithms/regex_match/basic/string_range_01_03.cc:
+ Same.
+ * testsuite/28_regex/algorithms/regex_match/basic/string_range_02_03.cc:
+ Same.
+ * testsuite/28_regex/algorithms/regex_match/ecma/char/53622.cc: Same.
+ * testsuite/28_regex/algorithms/regex_match/ecma/char/57173.cc: Same.
+ * testsuite/28_regex/algorithms/regex_match/ecma/char/58576.cc: Same.
+ * testsuite/28_regex/algorithms/regex_match/ecma/char/anymatcher.cc:
+ Same.
+ * testsuite/28_regex/algorithms/regex_match/ecma/char/backref.cc: Same.
+ * testsuite/28_regex/algorithms/regex_match/ecma/char/empty_range.cc:
+ Same.
+ * testsuite/28_regex/algorithms/regex_match/ecma/char/emptygroup.cc:
+ Same.
+ * testsuite/28_regex/algorithms/regex_match/ecma/char/hex.cc: Same.
+ * testsuite/28_regex/algorithms/regex_match/ecma/char/quoted_char.cc:
+ Same.
+ * testsuite/28_regex/algorithms/regex_match/ecma/wchar_t/anymatcher.cc:
+ Same.
+ * testsuite/28_regex/algorithms/regex_match/ecma/wchar_t/hex.cc: Same.
+ * testsuite/28_regex/algorithms/regex_match/extended/
+ string_bracket_01.cc: Same.
+ * testsuite/28_regex/algorithms/regex_match/extended/cstring_plus.cc:
+ Same.
+ * testsuite/28_regex/algorithms/regex_match/extended/
+ string_questionmark.cc: Same.
+ * testsuite/28_regex/algorithms/regex_match/extended/cstring_range.cc:
+ Same.
+ * testsuite/28_regex/algorithms/regex_match/extended/string_any.cc:
+ Same.
+ * testsuite/28_regex/algorithms/regex_match/extended/
+ string_dispatch_01.cc: Same.
+ * testsuite/28_regex/algorithms/regex_match/extended/
+ string_range_00_03.cc: Same.
+ * testsuite/28_regex/algorithms/regex_match/extended/
+ string_range_01_03.cc: Same.
+ * testsuite/28_regex/algorithms/regex_match/extended/
+ string_range_02_03.cc: Same.
+ * testsuite/28_regex/algorithms/regex_match/extended/wstring_locale.cc:
+ Same.
+ * testsuite/28_regex/algorithms/regex_search/basic/string_01.cc: Same.
+ * testsuite/28_regex/algorithms/regex_search/ecma/assertion.cc: Same.
+ * testsuite/28_regex/algorithms/regex_search/ecma/flags.cc: Same.
+ * testsuite/28_regex/algorithms/regex_search/ecma/greedy.cc: Same.
+ * testsuite/28_regex/algorithms/regex_search/ecma/string_01.cc: Same.
+ * testsuite/28_regex/match_results/format.cc: Same.
+ * testsuite/util/testsuite_regex.h
+ (regex_match_debug<>, regex_search_debug<>): Implement.
+
2013-10-06 Oleg Endo <olegendo@gcc.gnu.org>
Paolo Carlini <paolo.carlini@oracle.com>
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace __detail
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ template<typename _BiIter, typename _Alloc,
+ typename _CharT, typename _TraitsT,
+ _RegexExecutorPolicy __policy,
+ bool __match_mode>
+ bool
+ __regex_algo_impl(_BiIter __s,
+ _BiIter __e,
+ match_results<_BiIter, _Alloc>& __m,
+ const basic_regex<_CharT, _TraitsT>& __re,
+ regex_constants::match_flag_type __flags);
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+
/**
* @addtogroup regex
* @{
_AutomatonPtr;
template<typename _BiIter, typename _Alloc,
- typename _CharT, typename _TraitsT>
+ typename _CharT, typename _TraitsT,
+ __detail::_RegexExecutorPolicy __policy>
friend std::unique_ptr<
__detail::_Executor<_BiIter, _Alloc, _CharT, _TraitsT>>
__detail::__get_executor(_BiIter,
const basic_regex<_CharT, _TraitsT>&,
regex_constants::match_flag_type);
- template<typename _Bp, typename _Ap, typename _Cp, typename _Rp>
- friend bool
- regex_match(_Bp, _Bp,
- match_results<_Bp, _Ap>&,
- const basic_regex<_Cp, _Rp>&,
- regex_constants::match_flag_type);
-
- template<typename _Bp, typename _Ap, typename _Cp, typename _Rp>
+ template<typename _Bp, typename _Ap, typename _Cp, typename _Rp,
+ __detail::_RegexExecutorPolicy, bool>
friend bool
- regex_search(_Bp, _Bp,
- match_results<_Bp, _Ap>&,
- const basic_regex<_Cp, _Rp>&,
- regex_constants::match_flag_type);
+ __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
+ const basic_regex<_Cp, _Rp>&,
+ regex_constants::match_flag_type);
template<typename, typename, typename, typename>
friend class __detail::_Executor;
template<typename, typename, typename>
friend class regex_iterator;
- template<typename _Bp, typename _Ap,
- typename _Ch_type, typename _Rx_traits>
- friend bool
- regex_match(_Bp, _Bp, match_results<_Bp, _Ap>&,
- const basic_regex<_Ch_type,
- _Rx_traits>&,
- regex_constants::match_flag_type);
-
- template<typename _Bp, typename _Ap,
- typename _Ch_type, typename _Rx_traits>
+ template<typename _Bp, typename _Ap, typename _Cp, typename _Rp,
+ __detail::_RegexExecutorPolicy, bool>
friend bool
- regex_search(_Bp, _Bp, match_results<_Bp, _Ap>&,
- const basic_regex<_Ch_type,
- _Rx_traits>&,
- regex_constants::match_flag_type);
+ __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
+ const basic_regex<_Cp, _Rp>&,
+ regex_constants::match_flag_type);
_Bi_iter _M_begin;
bool _M_in_iterator;
*/
template<typename _Bi_iter, typename _Alloc,
typename _Ch_type, typename _Rx_traits>
- bool
+ inline bool
regex_match(_Bi_iter __s,
_Bi_iter __e,
match_results<_Bi_iter, _Alloc>& __m,
const basic_regex<_Ch_type, _Rx_traits>& __re,
regex_constants::match_flag_type __flags
- = regex_constants::match_default);
+ = regex_constants::match_default)
+ {
+ return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
+ __detail::_RegexExecutorPolicy::_S_auto, true>
+ (__s, __e, __m, __re, __flags);
+ }
/**
* @brief Indicates if there is a match between the regular expression @p e
*/
template<typename _Bi_iter, typename _Alloc,
typename _Ch_type, typename _Rx_traits>
- bool
- regex_search(_Bi_iter __first, _Bi_iter __last,
+ inline bool
+ regex_search(_Bi_iter __s, _Bi_iter __e,
match_results<_Bi_iter, _Alloc>& __m,
const basic_regex<_Ch_type, _Rx_traits>& __re,
regex_constants::match_flag_type __flags
- = regex_constants::match_default);
+ = regex_constants::match_default)
+ {
+ return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
+ __detail::_RegexExecutorPolicy::_S_auto, false>
+ (__s, __e, __m, __re, __flags);
+ }
/**
* Searches for a regular expression within a range.
* @param __rhs [IN] A %regex_token_iterator to copy.
*/
regex_token_iterator(const regex_token_iterator& __rhs)
- : _M_position(__rhs.position), _M_subs(__rhs.subs), _M_n(__rhs.N),
- _M_result(__rhs.result), _M_suffix(__rhs.suffix),
+ : _M_position(__rhs._M_position), _M_subs(__rhs._M_subs),
+ _M_n(__rhs._M_n), _M_result(__rhs._M_result), _M_suffix(__rhs._M_suffix),
_M_has_m1(__rhs._M_has_m1)
{
if (__rhs._M_result == &__rhs._M_suffix)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace __detail
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ // Result of merging regex_match and regex_search.
+ //
+ // __policy now can be _S_auto(auto dispatch by checking back-references)
+ // and _S_force_dfs(just use _DFSExecutor).
+ //
+ // That __match_mode is true means regex_match, else regex_search.
+ template<typename _BiIter, typename _Alloc,
+ typename _CharT, typename _TraitsT,
+ _RegexExecutorPolicy __policy,
+ bool __match_mode>
+ bool
+ __regex_algo_impl(_BiIter __s,
+ _BiIter __e,
+ match_results<_BiIter, _Alloc>& __m,
+ const basic_regex<_CharT, _TraitsT>& __re,
+ regex_constants::match_flag_type __flags)
+ {
+ if (__re._M_automaton == nullptr)
+ return false;
+
+ typename match_results<_BiIter, _Alloc>::_Base_type& __res = __m;
+ __res.resize(__re._M_automaton->_M_sub_count() + 2);
+ for (auto& __it : __res)
+ __it.matched = false;
+
+ typedef std::unique_ptr<_Executor<_BiIter, _Alloc, _CharT, _TraitsT>>
+ _ExecutorPtr;
+ typedef _DFSExecutor<_BiIter, _Alloc, _CharT, _TraitsT> _DFSExecutorT;
+ typedef _BFSExecutor<_BiIter, _Alloc, _CharT, _TraitsT> _BFSExecutorT;
+
+ _ExecutorPtr __executor =
+ __get_executor<_BiIter, _Alloc, _CharT, _TraitsT,
+ __policy>(__s, __e, __res, __re, __flags);
+
+ bool __ret;
+ if (__match_mode)
+ __ret = __executor->_M_match();
+ else
+ __ret = __executor->_M_search();
+ if (__ret)
+ {
+ for (auto __it : __res)
+ if (!__it.matched)
+ __it.first = __it.second = __e;
+ auto& __pre = __res[__res.size()-2];
+ auto& __suf = __res[__res.size()-1];
+ if (__match_mode)
+ {
+ __pre.matched = false;
+ __pre.first = __s;
+ __pre.second = __s;
+ __suf.matched = false;
+ __suf.first = __e;
+ __suf.second = __e;
+ }
+ else
+ {
+ __pre.first = __s;
+ __pre.second = __res[0].first;
+ __pre.matched = (__pre.first != __pre.second);
+ __suf.first = __res[0].second;
+ __suf.second = __e;
+ __suf.matched = (__suf.first != __suf.second);
+ }
+ if (__re.flags() & regex_constants::nosubs)
+ __res.resize(3);
+ }
+ return __ret;
+ }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+}
+
template<typename _Ch_type>
template<typename _Fwd_iter>
typename regex_traits<_Ch_type>::string_type
value(_Ch_type __ch, int __radix) const
{
std::basic_istringstream<char_type> __is(string_type(1, __ch));
- int __v;
+ long __v;
if (__radix == 8)
__is >> std::oct;
else if (__radix == 16)
const __ctype_type&
__fctyp(use_facet<__ctype_type>(__traits.getloc()));
- auto __output = [&](int __idx)
+ auto __output = [&](size_t __idx)
{
auto& __sub = _Base_type::operator[](__idx);
if (__sub.matched)
__output(_Base_type::size()-1);
else if (__fctyp.is(__ctype_type::digit, *__next))
{
- int __num = __traits.value(*__next, 10);
+ long __num = __traits.value(*__next, 10);
if (++__next != __fmt_last
&& __fctyp.is(__ctype_type::digit, *__next))
{
return __out;
}
- template<typename _Bi_iter, typename _Alloc,
- typename _Ch_type, typename _Rx_traits>
- bool
- regex_match(_Bi_iter __s,
- _Bi_iter __e,
- match_results<_Bi_iter, _Alloc>& __m,
- const basic_regex<_Ch_type, _Rx_traits>& __re,
- regex_constants::match_flag_type __flags
- = regex_constants::match_default)
- {
- if (__re._M_automaton == nullptr)
- return false;
-
- typename match_results<_Bi_iter, _Alloc>::_Base_type& __res = __m;
- auto __size = __re._M_automaton->_M_sub_count();
- __size += 2;
- __res.resize(__size);
- for (decltype(__size) __i = 0; __i < __size; ++__i)
- __res[__i].matched = false;
-
- if (__detail::__get_executor(__s, __e, __res, __re, __flags)->_M_match())
- {
- for (auto __it : __res)
- if (!__it.matched)
- __it.first = __it.second = __e;
- auto& __pre = __res[__res.size()-2];
- auto& __suf = __res[__res.size()-1];
- __pre.matched = false;
- __pre.first = __s;
- __pre.second = __s;
- __suf.matched = false;
- __suf.first = __e;
- __suf.second = __e;
- return true;
- }
- return false;
- }
-
- template<typename _Bi_iter, typename _Alloc,
- typename _Ch_type, typename _Rx_traits>
- bool
- regex_search(_Bi_iter __first, _Bi_iter __last,
- match_results<_Bi_iter, _Alloc>& __m,
- const basic_regex<_Ch_type, _Rx_traits>& __re,
- regex_constants::match_flag_type __flags
- = regex_constants::match_default)
- {
- if (__re._M_automaton == nullptr)
- return false;
-
- typename match_results<_Bi_iter, _Alloc>::_Base_type& __res = __m;
- auto __size = __re._M_automaton->_M_sub_count();
- __size += 2;
- __res.resize(__size);
- for (decltype(__size) __i = 0; __i < __size; ++__i)
- __res[__i].matched = false;
-
- if (__detail::__get_executor(__first, __last, __res, __re, __flags)
- ->_M_search())
- {
- for (auto __it : __res)
- if (!__it.matched)
- __it.first = __it.second = __last;
- auto& __pre = __res[__res.size()-2];
- auto& __suf = __res[__res.size()-1];
- __pre.first = __first;
- __pre.second = __res[0].first;
- __pre.matched = (__pre.first != __pre.second);
- __suf.first = __res[0].second;
- __suf.second = __last;
- __suf.matched = (__suf.first != __suf.second);
- return true;
- }
- return false;
- }
-
template<typename _Out_iter, typename _Bi_iter,
typename _Rx_traits, typename _Ch_type>
_Out_iter
regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
const basic_regex<_Ch_type, _Rx_traits>& __e,
const _Ch_type* __fmt,
- regex_constants::match_flag_type __flags
- = regex_constants::match_default)
+ regex_constants::match_flag_type __flags)
{
typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> _IterT;
_IterT __i(__first, __last, __e, __flags);
* @{
*/
- typedef int _StateIdT;
+ typedef long _StateIdT;
typedef std::set<_StateIdT> _StateSet;
static const _StateIdT _S_invalid_state_id = -1;
/// Operation codes that define the type of transitions within the base NFA
/// that represents the regular expression.
- enum _Opcode
+ enum _Opcode : int
{
_S_opcode_unknown,
_S_opcode_alternative,
class _State
{
public:
- typedef int _OpcodeT;
typedef _Matcher<_CharT> _MatcherT;
- _OpcodeT _M_opcode; // type of outgoing transition
+ _Opcode _M_opcode; // type of outgoing transition
_StateIdT _M_next; // outgoing transition
union // Since they are mutually exclusive.
{
- unsigned int _M_subexpr; // for _S_opcode_subexpr_*
- unsigned int _M_backref_index; // for _S_opcode_backref
+ size_t _M_subexpr; // for _S_opcode_subexpr_*
+ size_t _M_backref_index; // for _S_opcode_backref
struct
{
// for _S_opcode_alternative.
};
_MatcherT _M_matches; // for _S_opcode_match
- explicit _State(_OpcodeT __opcode)
+ explicit _State(_Opcode __opcode)
: _M_opcode(__opcode), _M_next(_S_invalid_state_id)
{ }
class _Automaton
{
public:
- typedef unsigned int _SizeT;
+ typedef size_t _SizeT;
public:
virtual _SizeT
public:
typedef _State<_CharT, _TraitsT> _StateT;
typedef const _Matcher<_CharT>& _MatcherT;
- typedef unsigned int _SizeT;
+ typedef size_t _SizeT;
typedef regex_constants::syntax_option_type _FlagT;
_NFA(_FlagT __f)
}
_StateIdT
- _M_insert_backref(unsigned int __index);
+ _M_insert_backref(size_t __index);
_StateIdT
_M_insert_line_begin()
_M_dot(std::ostream& __ostr) const;
#endif
- std::vector<unsigned int> _M_paren_stack;
+ std::vector<size_t> _M_paren_stack;
_StateSet _M_accepting_states;
_FlagT _M_flags;
_StateIdT _M_start_state;
{
__ostr << "digraph _Nfa {\n"
<< " rankdir=LR;\n";
- for (unsigned int __i = 0; __i < this->size(); ++__i)
+ for (size_t __i = 0; __i < this->size(); ++__i)
{ this->at(__i)._M_dot(__ostr, __i); }
__ostr << "}\n";
return __ostr;
template<typename _CharT, typename _TraitsT>
_StateIdT _NFA<_CharT, _TraitsT>::
- _M_insert_backref(unsigned int __index)
+ _M_insert_backref(size_t __index)
{
// To figure out whether a backref is valid, a stack is used to store
// unfinished sub-expressions. For example, when parsing
__throw_regex_error(regex_constants::error_badbrace);
_StateSeqT __r(_M_pop());
_StateSeqT __e(_M_nfa, _M_nfa._M_insert_dummy());
- int __min_rep = _M_cur_int_value(10);
+ long __min_rep = _M_cur_int_value(10);
bool __infi = false;
- int __n;
+ long __n;
// {3
if (_M_match_token(_ScannerT::_S_token_comma))
__neg = __neg && _M_match_token(_ScannerT::_S_token_opt);
- for (int __i = 0; __i < __min_rep; ++__i)
+ for (long __i = 0; __i < __min_rep; ++__i)
__e._M_append(__r._M_clone());
if (__infi)
// "match less" one. Switch _M_alt and _M_next of all created
// nodes. This is a hacking but IMO works well.
std::stack<_StateIdT> __stack;
- for (int __i = 0; __i < __n; ++__i)
+ for (long __i = 0; __i < __n; ++__i)
{
auto __tmp = __r._M_clone();
auto __alt = _M_nfa._M_insert_alt(__tmp._M_start,
}
else if (_M_match_token(_ScannerT::_S_token_subexpr_begin))
{
- int __mark = _M_nfa._M_sub_count();
+ auto __mark = _M_nfa._M_sub_count();
_StateSeqT __r(_M_nfa, _M_nfa._M_insert_subexpr_begin());
this->_M_disjunction();
if (!_M_match_token(_ScannerT::_S_token_subexpr_end))
_Compiler<_FwdIter, _CharT, _TraitsT>::
_M_cur_int_value(int __radix)
{
- int __v = 0;
+ long __v = 0;
for (typename _StringT::size_type __i = 0;
__i < _M_value.length(); ++__i)
__v =__v * __radix + _M_traits.value(_M_value[__i], __radix);
bool
_M_word_boundry(_State<_CharT, _TraitsT> __state) const;
+ virtual std::unique_ptr<_Executor>
+ _M_clone() const = 0;
+
+ // Return whether now match the given sub-NFA.
bool
- _M_lookahead(_State<_CharT, _TraitsT> __state) const;
+ _M_lookahead(_State<_CharT, _TraitsT> __state) const
+ {
+ auto __sub = this->_M_clone();
+ __sub->_M_set_start(__state._M_alt);
+ return __sub->_M_search_from_first();
+ }
void
_M_set_results(_ResultsVec& __cur_results);
bool
_M_dfs(_StateIdT __start);
+ std::unique_ptr<_BaseT>
+ _M_clone() const
+ {
+ return std::unique_ptr<_BaseT>(new _DFSExecutor(this->_M_current,
+ this->_M_end,
+ this->_M_results,
+ this->_M_re,
+ this->_M_flags));
+ }
+
// To record current solution.
_ResultsVec _M_cur_results;
const _NFAT& _M_nfa;
// greedy policy.
//
// The definition of `greedy`:
- // For the sequence of quantifiers in NFA sorted by there start position,
- // now maintain a vector in every matching state, with equal length to
+ // For the sequence of quantifiers in NFA sorted by their start positions,
+ // now maintain a vector in every matching state, with length equal to
// quantifier seq, recording repeating times of every quantifier. Now to
// compare two matching states, we just lexically compare these two
// vectors. To win the compare(to survive), one matching state needs to
// operator<() for lexicographical_compare will emit the answer.
//
// When two vectors equal, it means the `where`, `when` and quantifier
- // counts are identical, and indicates the same solution; so just return
- // false.
+ // counts are identical, and indicates the same solution; so
+ // _ResultsEntry::operator<() just return false.
struct _ResultsEntry
: private _ResultsVec
{
public:
- _ResultsEntry(unsigned int __res_sz, unsigned int __sz)
+ _ResultsEntry(size_t __res_sz, size_t __sz)
: _ResultsVec(__res_sz), _M_quant_keys(__sz)
{ }
void
- resize(unsigned int __n)
+ resize(size_t __n)
{ _ResultsVec::resize(__n); }
- unsigned int
+ size_t
size()
{ return _ResultsVec::size(); }
sub_match<_BiIter>&
- operator[](unsigned int __idx)
+ operator[](size_t __idx)
{ return _ResultsVec::operator[](__idx); }
bool
}
void
- _M_inc(unsigned int __idx, bool __neg)
+ _M_inc(size_t __idx, bool __neg)
{ _M_quant_keys[__idx] += __neg ? 1 : -1; }
_ResultsVec&
bool
_M_includes_some();
+ std::unique_ptr<_BaseT>
+ _M_clone() const
+ {
+ return std::unique_ptr<_BaseT>(new _BFSExecutor(this->_M_current,
+ this->_M_end,
+ this->_M_results,
+ this->_M_re,
+ this->_M_flags));
+ }
+
std::map<_StateIdT, _ResultsPtr> _M_covered;
// To record global optimal solution.
_ResultsPtr _M_cur_results;
_StateIdT _M_start_state;
};
- template<typename _BiIter, typename _Alloc,
- typename _CharT, typename _TraitsT>
- std::unique_ptr<_Executor<_BiIter, _Alloc, _CharT, _TraitsT>>
- __get_executor(_BiIter __b,
- _BiIter __e,
- std::vector<sub_match<_BiIter>, _Alloc>& __m,
- const basic_regex<_CharT, _TraitsT>& __re,
- regex_constants::match_flag_type __flags);
-
//@} regex-detail
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
return __ans;
}
- // Return whether now match the given sub-NFA.
- template<typename _BiIter, typename _Alloc,
- typename _CharT, typename _TraitsT>
- bool _Executor<_BiIter, _Alloc, _CharT, _TraitsT>::
- _M_lookahead(_State<_CharT, _TraitsT> __state) const
- {
- auto __sub = __get_executor(this->_M_current,
- this->_M_end,
- this->_M_results,
- this->_M_re,
- this->_M_flags);
- __sub->_M_set_start(__state._M_alt);
- return __sub->_M_search_from_first();
- }
-
template<typename _BiIter, typename _Alloc,
typename _CharT, typename _TraitsT>
void _Executor<_BiIter, _Alloc, _CharT, _TraitsT>::
_M_set_results(_ResultsVec& __cur_results)
{
- if (_M_re.flags() & regex_constants::nosubs)
- {
- // truncate
- __cur_results.resize(3);
- _M_results.resize(3);
- }
- for (unsigned int __i = 0; __i < __cur_results.size(); ++__i)
+ for (size_t __i = 0; __i < __cur_results.size(); ++__i)
if (__cur_results[__i].matched)
_M_results[__i] = __cur_results[__i];
}
+ enum class _RegexExecutorPolicy : int
+ { _S_auto, _S_force_dfs };
+
template<typename _BiIter, typename _Alloc,
- typename _CharT, typename _TraitsT>
+ typename _CharT, typename _TraitsT,
+ _RegexExecutorPolicy __policy>
std::unique_ptr<_Executor<_BiIter, _Alloc, _CharT, _TraitsT>>
__get_executor(_BiIter __b,
_BiIter __e,
typedef _BFSExecutor<_BiIter, _Alloc, _CharT, _TraitsT> _BFSExecutorT;
auto __p = std::static_pointer_cast<_NFA<_CharT, _TraitsT>>
(__re._M_automaton);
- if (__p->_M_has_backref)
+ if (__policy == _RegexExecutorPolicy::_S_force_dfs
+ || (__policy == _RegexExecutorPolicy::_S_auto && __p->_M_has_backref))
return _ExecutorPtr(new _DFSExecutorT(__b, __e, __m, __re, __flags));
return _ExecutorPtr(new _BFSExecutorT(__b, __e, __m, __re, __flags));
}
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+using namespace __gnu_test;
using namespace std;
void
bool test __attribute__((unused)) = true;
regex("\\[", regex_constants::awk);
- VERIFY(regex_match("\"", regex("[\\\"]", regex_constants::awk)));
- VERIFY(regex_match("/", regex("/", regex_constants::awk)));
- VERIFY(regex_match("\a", regex("\\a", regex_constants::awk)));
- VERIFY(regex_match("\"", regex("\\\"", regex_constants::awk)));
- VERIFY(regex_match("5", regex("\\65", regex_constants::awk)));
- VERIFY(regex_match("53", regex("\\0653", regex_constants::awk)));
+ VERIFY(regex_match_debug("\"", regex("[\\\"]", regex_constants::awk)));
+ VERIFY(regex_match_debug("/", regex("/", regex_constants::awk)));
+ VERIFY(regex_match_debug("\a", regex("\\a", regex_constants::awk)));
+ VERIFY(regex_match_debug("\"", regex("\\\"", regex_constants::awk)));
+ VERIFY(regex_match_debug("5", regex("\\65", regex_constants::awk)));
+ VERIFY(regex_match_debug("53", regex("\\0653", regex_constants::awk)));
}
int
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+using namespace __gnu_test;
using namespace std;
void
}
FAIL("[]");
FAIL("[^]");
- VERIFY(regex_match("]", regex("[]]", regex_constants::basic)));
- VERIFY(!regex_match("]", regex("[^]]", regex_constants::basic)));
+ VERIFY(regex_match_debug ("]", regex("[]]", regex_constants::basic)));
+ VERIFY(!regex_match_debug ("]", regex("[^]]", regex_constants::basic)));
}
int
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
void
test01()
std::string target("aaba");
std::smatch m;
- VERIFY( std::regex_match(target, m, re) );
+ VERIFY( regex_match_debug(target, m, re) );
VERIFY( m.size() == re.mark_count()+1 );
VERIFY( m.empty() == false );
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
void
test01()
std::string target("aa");
std::smatch m;
- VERIFY( std::regex_match(target, m, re) );
+ VERIFY( regex_match_debug(target, m, re) );
VERIFY( m.size() == re.mark_count()+1 );
VERIFY( m.empty() == false );
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
void
test01()
std::string target("aa");
std::smatch m;
- VERIFY( std::regex_match(target, m, re) );
+ VERIFY( regex_match_debug(target, m, re) );
VERIFY( m.size() == re.mark_count()+1 );
VERIFY( m.empty() == false );
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
void
test01()
std::string target("aa");
std::smatch m;
- VERIFY( std::regex_match(target, m, re) );
+ VERIFY( regex_match_debug(target, m, re) );
VERIFY( m.size() == re.mark_count()+1 );
VERIFY( m.empty() == false );
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
// libstdc++/53622
void
std::string target("zxcv/onetwoabc");
std::smatch m;
- VERIFY( std::regex_match(target, m, re) );
+ VERIFY( regex_match_debug(target, m, re) );
VERIFY( m.size() == 2 );
VERIFY( m[0].matched == true );
VERIFY( std::string(m[0].first, m[0].second) == "zxcv/onetwoabc" );
std::string target("zxcv/onetwoabc");
std::smatch m;
- VERIFY( std::regex_match(target, m, re) );
+ VERIFY( regex_match_debug(target, m, re) );
VERIFY( m.size() == 3 );
VERIFY( m[0].matched == true );
VERIFY( std::string(m[0].first, m[0].second) == "zxcv/onetwoabc" );
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
#include <iostream>
// libstdc++/57173
std::string target("/asdf/qwerty");
std::smatch m;
- VERIFY( std::regex_match(target, m, re) );
+ VERIFY( regex_match_debug(target, m, re) );
VERIFY( m.size() == 2 );
VERIFY( std::string(m[1].first, m[1].second) == "/qwerty");
}
std::string target("/asdf/qwerty");
std::smatch m;
- VERIFY( std::regex_match(target, m, re) );
+ VERIFY( regex_match_debug(target, m, re) );
VERIFY( m.size() == 3 );
VERIFY( std::string(m[1].first, m[1].second) == "/qwerty");
}
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
// libstdc++/58576
void
test01()
{
- using namespace std;
-
bool test __attribute__((unused)) = true;
string domain_name = "valid.hostname.org";
};
try
{
- VERIFY(regex_match( domain_name, m, fqdn_regex ));
+ VERIFY(regex_match_debug( domain_name, m, fqdn_regex ));
VERIFY(m.size() == sizeof(sol) / sizeof(*sol));
- for (int i = 0; i < (int)m.size(); i++) {
+ for (size_t i = 0; i < m.size(); i++) {
string s(m[i].first, m[i].second);
VERIFY(s == sol[i]);
}
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+using namespace __gnu_test;
using namespace std;
void
{\
regex re(res);\
string st(s);\
- VERIFY(!regex_match(st, re));\
+ VERIFY(!regex_match_debug(st, re));\
}
TEST(".", "\0");
TEST(".", "\n");
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+using namespace __gnu_test;
using namespace std;
void
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+using namespace __gnu_test;
using namespace std;
void
{
bool test __attribute__((unused)) = true;
- VERIFY(!regex_match("x", regex("[]")));
- VERIFY(regex_match("x", regex("[^]")));
- VERIFY(!regex_match("]", regex("[]]")));
- VERIFY(!regex_match("]", regex("[^]]")));
+ VERIFY(!regex_match_debug("x", regex("[]")));
+ VERIFY(regex_match_debug("x", regex("[^]")));
+ VERIFY(!regex_match_debug("]", regex("[]]")));
+ VERIFY(!regex_match_debug("]", regex("[^]]")));
}
int
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+using namespace __gnu_test;
using namespace std;
void
regex re("()*\\1");
cmatch m;
const char s[] = "";
- VERIFY( regex_match(s, m, re) );
+ VERIFY( regex_match_debug(s, m, re) );
VERIFY( m.size() == 2 );
VERIFY( m[0].matched );
VERIFY( m[1].matched );
regex re("()*");
cmatch m;
const char s[] = "";
- VERIFY( regex_match(s, m, re) );
+ VERIFY( regex_match_debug(s, m, re) );
}
}
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+using namespace __gnu_test;
using namespace std;
void
{
bool test __attribute__((unused)) = true;
- VERIFY(regex_match(":", regex("\\x3a")));
+ VERIFY(regex_match_debug(":", regex("\\x3a")));
try
{
regex("\\u400x");
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+using namespace __gnu_test;
using namespace std;
void
{
bool test __attribute__((unused)) = true;
- VERIFY(regex_match("01", regex("\\d*")));
- VERIFY(regex_match("asdfjkl", regex("\\D*")));
- VERIFY(!regex_match("asdfjkl0", regex("\\D*")));
- VERIFY(regex_match("\r\t\v\f ", regex("\\s*")));
- VERIFY(regex_match("asdfjkl", regex("\\S*")));
- VERIFY(!regex_match("asdfjkl\r", regex("\\S*")));
- VERIFY(regex_match("_az", regex("\\w*")));
- VERIFY(regex_match("!@#$%", regex("\\W*")));
- VERIFY(!regex_match("_01234", regex("\\W*")));
+ VERIFY(regex_match_debug("01", regex("\\d*")));
+ VERIFY(regex_match_debug("asdfjkl", regex("\\D*")));
+ VERIFY(!regex_match_debug("asdfjkl0", regex("\\D*")));
+ VERIFY(regex_match_debug("\r\t\v\f ", regex("\\s*")));
+ VERIFY(regex_match_debug("asdfjkl", regex("\\S*")));
+ VERIFY(!regex_match_debug("asdfjkl\r", regex("\\S*")));
+ VERIFY(regex_match_debug("_az", regex("\\w*")));
+ VERIFY(regex_match_debug("!@#$%", regex("\\W*")));
+ VERIFY(!regex_match_debug("_01234", regex("\\W*")));
}
int
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+using namespace __gnu_test;
using namespace std;
void
{\
wregex re(res);\
wstring st(s);\
- VERIFY(!regex_match(st, re));\
+ VERIFY(!regex_match_debug(st, re));\
}
TESTL(L".", L"\u2028");
TESTL(L".", L"\u2029");
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+using namespace __gnu_test;
using namespace std;
void
{
bool test __attribute__((unused)) = true;
- VERIFY(regex_match(L"\u1234", wregex(L"\\u1234")));
+ VERIFY(regex_match_debug(L"\u1234", wregex(L"\\u1234")));
}
int
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
void
test01()
{
std::regex re("pre/[za-x]", std::regex::extended);
- VERIFY( std::regex_match("pre/z", re) );
- VERIFY( std::regex_match("pre/a", re) );
- VERIFY( !std::regex_match("pre/y", re) );
+ VERIFY( regex_match_debug("pre/z", re) );
+ VERIFY( regex_match_debug("pre/a", re) );
+ VERIFY( !regex_match_debug("pre/y", re) );
}
{
std::regex re("pre/[[:uPPer:]]", std::regex::extended);
- VERIFY( std::regex_match("pre/Z", re) );
- VERIFY( !std::regex_match("pre/_", re) );
- VERIFY( !std::regex_match("pre/a", re) );
- VERIFY( !std::regex_match("pre/0", re) );
+ VERIFY( regex_match_debug("pre/Z", re) );
+ VERIFY( !regex_match_debug("pre/_", re) );
+ VERIFY( !regex_match_debug("pre/a", re) );
+ VERIFY( !regex_match_debug("pre/0", re) );
}
{
std::regex re("pre/[[:lOWer:]]", std::regex::extended | std::regex::icase);
- VERIFY( std::regex_match("pre/Z", re) );
- VERIFY( std::regex_match("pre/a", re) );
+ VERIFY( regex_match_debug("pre/Z", re) );
+ VERIFY( regex_match_debug("pre/a", re) );
}
{
std::regex re("pre/[[:w:][.tilde.]]", std::regex::extended);
- VERIFY( std::regex_match("pre/~", re) );
- VERIFY( std::regex_match("pre/_", re) );
- VERIFY( std::regex_match("pre/a", re) );
- VERIFY( std::regex_match("pre/0", re) );
+ VERIFY( regex_match_debug("pre/~", re) );
+ VERIFY( regex_match_debug("pre/_", re) );
+ VERIFY( regex_match_debug("pre/a", re) );
+ VERIFY( regex_match_debug("pre/0", re) );
}
{
std::regex re("pre/[[=a=]]", std::regex::extended);
- VERIFY( std::regex_match("pre/a", re) );
- VERIFY( std::regex_match("pre/A", re) );
+ VERIFY( regex_match_debug("pre/a", re) );
+ VERIFY( regex_match_debug("pre/A", re) );
}
}
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
void
test01()
const char target[] = "aa";
std::cmatch m;
- VERIFY( std::regex_match(target, m, re) );
+ VERIFY( regex_match_debug(target, m, re) );
VERIFY( re.mark_count() == 1 );
VERIFY( m.size() == re.mark_count()+1 );
VERIFY( m[1].second == target+sizeof(target)-1 );
VERIFY( m[1].matched == true );
- VERIFY(!std::regex_match("", std::regex("a+", std::regex::extended)));
- VERIFY(std::regex_match("a", std::regex("a+", std::regex::extended)));
- VERIFY(std::regex_match("aa", std::regex("a+", std::regex::extended)));
+ VERIFY(!regex_match_debug("", std::regex("a+", std::regex::extended)));
+ VERIFY(regex_match_debug("a", std::regex("a+", std::regex::extended)));
+ VERIFY(regex_match_debug("aa", std::regex("a+", std::regex::extended)));
}
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
void
test01()
char target[] = "a";
std::cmatch m;
- VERIFY( std::regex_match(target, m, re) );
+ VERIFY( regex_match_debug(target, m, re) );
VERIFY( re.mark_count() == 1 );
VERIFY( m.size() == re.mark_count()+1 );
VERIFY( m[1].second == target+sizeof(target)-1 );
VERIFY( m[1].matched == true );
- VERIFY(std::regex_match("", std::regex("a?", std::regex::extended)));
- VERIFY(std::regex_match("a", std::regex("a?", std::regex::extended)));
- VERIFY(!std::regex_match("aa", std::regex("a?", std::regex::extended)));
+ VERIFY(regex_match_debug("", std::regex("a?", std::regex::extended)));
+ VERIFY(regex_match_debug("a", std::regex("a?", std::regex::extended)));
+ VERIFY(!regex_match_debug("aa", std::regex("a?", std::regex::extended)));
}
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+using namespace __gnu_test;
using namespace std;
void
regex re;
re.assign("(ab){3}", std::regex::extended);
- VERIFY(!regex_match("abab", re));
- VERIFY(regex_match("ababab", re));
- VERIFY(!regex_match("abababab", re));
+ VERIFY(!regex_match_debug("abab", re));
+ VERIFY(regex_match_debug("ababab", re));
+ VERIFY(!regex_match_debug("abababab", re));
re.assign("(ab){3,}", std::regex::extended);
- VERIFY(!regex_match("abab", re));
- VERIFY(regex_match("ababab", re));
- VERIFY(regex_match("abababab", re));
- VERIFY(regex_match("ababababab", re));
+ VERIFY(!regex_match_debug("abab", re));
+ VERIFY(regex_match_debug("ababab", re));
+ VERIFY(regex_match_debug("abababab", re));
+ VERIFY(regex_match_debug("ababababab", re));
re.assign("(ab){0,3}", std::regex::extended);
- VERIFY(regex_match("", re));
- VERIFY(regex_match("ab", re));
- VERIFY(regex_match("abab", re));
- VERIFY(regex_match("ababab", re));
- VERIFY(!regex_match("abababab", re));
+ VERIFY(regex_match_debug("", re));
+ VERIFY(regex_match_debug("ab", re));
+ VERIFY(regex_match_debug("abab", re));
+ VERIFY(regex_match_debug("ababab", re));
+ VERIFY(!regex_match_debug("abababab", re));
re.assign("(a|b){0,2}", std::regex::extended);
- VERIFY(regex_match("", re));
- VERIFY(regex_match("a", re));
- VERIFY(regex_match("b", re));
- VERIFY(regex_match("aa", re));
- VERIFY(regex_match("ab", re));
- VERIFY(regex_match("ba", re));
- VERIFY(regex_match("bb", re));
- VERIFY(!regex_match("aaa", re));
+ VERIFY(regex_match_debug("", re));
+ VERIFY(regex_match_debug("a", re));
+ VERIFY(regex_match_debug("b", re));
+ VERIFY(regex_match_debug("aa", re));
+ VERIFY(regex_match_debug("ab", re));
+ VERIFY(regex_match_debug("ba", re));
+ VERIFY(regex_match_debug("bb", re));
+ VERIFY(!regex_match_debug("aaa", re));
}
int
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
void
test01()
std::string target("aaba");
std::smatch m;
- VERIFY( std::regex_match(target, m, re) );
+ VERIFY( regex_match_debug(target, m, re) );
VERIFY( m.size() == re.mark_count()+1 );
VERIFY( m.empty() == false );
regex_constants::match_flag_type __flags
= regex_constants::match_default)
{
+ using namespace __detail;
auto& __res = (vector<sub_match<_Bi_iter>, _Alloc>&)(__m);
VERIFY( (dynamic_cast
- <__detail::_DFSExecutor<_Bi_iter, _Alloc, _Ch_type, _Rx_traits>*>
- (&*__detail::__get_executor(__s, __e, __res, __re, __flags))
+ <_DFSExecutor<_Bi_iter, _Alloc, _Ch_type, _Rx_traits>*>
+ (&*__get_executor<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
+ _RegexExecutorPolicy::_S_auto>(__s, __e, __res, __re, __flags))
!= nullptr) );
}
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
void
test01()
std::string target("aa");
std::smatch m;
- VERIFY( std::regex_match(target, m, re) );
+ VERIFY( regex_match_debug(target, m, re) );
VERIFY( m.size() == re.mark_count()+1 );
VERIFY( m.empty() == false );
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
void
test01()
std::string target("aa");
std::smatch m;
- VERIFY( std::regex_match(target, m, re) );
+ VERIFY( regex_match_debug(target, m, re) );
VERIFY( m.size() == re.mark_count()+1 );
VERIFY( m.empty() == false );
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
void
test01()
std::string target("aa");
std::smatch m;
- VERIFY( std::regex_match(target, m, re) );
+ VERIFY( regex_match_debug(target, m, re) );
VERIFY( m.size() == re.mark_count()+1 );
VERIFY( m.empty() == false );
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
void
test01()
re2.imbue(std::locale("de_DE.UTF-8"));
re2.assign(L"[[:upper:]]*", std::regex::extended);
std::wsmatch m2;
- VERIFY(std::regex_match(str2, m2, re2));
+ VERIFY(regex_match_debug(str2, m2, re2));
}
int
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
void
test01()
std::string target("xxasdfyy");
std::smatch m;
- VERIFY( std::regex_search(target, m, re) );
+ VERIFY( regex_search_debug(target, m, re) );
VERIFY( m.size() == re.mark_count()+1 );
VERIFY( m.empty() == false );
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+using namespace __gnu_test;
using namespace std;
void
{
bool test __attribute__((unused)) = true;
- VERIFY(!regex_search("2123456", regex("^1234")));
- VERIFY(regex_search("123456", regex("^1234")));
- VERIFY(regex_search("123456", regex("(5|^)1234")));
- VERIFY(regex_search("5123456", regex("(5|^)1234")));
- VERIFY(!regex_search("1234562", regex("3456$")));
- VERIFY(regex_search("123456", regex("3456$")));
- VERIFY(!regex_search("123456", regex("(?=1234)56")));
- VERIFY(regex_search("123456", regex("(?=1234)123456")));
- VERIFY(regex_search("123456", regex("(?!1234)56")));
- VERIFY(!regex_search("123456", regex("(?!1234)123456")));
+ VERIFY(!regex_search_debug("2123456", regex("^1234")));
+ VERIFY(regex_search_debug("123456", regex("^1234")));
+ VERIFY(regex_search_debug("123456", regex("(5|^)1234")));
+ VERIFY(regex_search_debug("5123456", regex("(5|^)1234")));
+ VERIFY(!regex_search_debug("1234562", regex("3456$")));
+ VERIFY(regex_search_debug("123456", regex("3456$")));
+ VERIFY(!regex_search_debug("123456", regex("(?=1234)56")));
+ VERIFY(regex_search_debug("123456", regex("(?=1234)123456")));
+ VERIFY(regex_search_debug("123456", regex("(?!1234)56")));
+ VERIFY(!regex_search_debug("123456", regex("(?!1234)123456")));
- VERIFY(regex_search("a-", regex("a\\b-")));
- VERIFY(!regex_search("ab", regex("a\\bb")));
- VERIFY(!regex_search("a-", regex("a\\B-")));
- VERIFY(regex_search("ab", regex("a\\Bb")));
+ VERIFY(regex_search_debug("a-", regex("a\\b-")));
+ VERIFY(!regex_search_debug("ab", regex("a\\bb")));
+ VERIFY(!regex_search_debug("a-", regex("a\\B-")));
+ VERIFY(regex_search_debug("ab", regex("a\\Bb")));
string s("This is a regular expression");
string sol[] =
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+using namespace __gnu_test;
using namespace std;
void
cmatch m;
regex re("((as)(df))", regex_constants::ECMAScript | regex_constants::nosubs);
- VERIFY(regex_search("asdf", m, re));
+ VERIFY(regex_search_debug("asdf", m, re));
VERIFY(m.size() == 1);
VERIFY(m[0].matched && string(m[0].first, m[0].second) == "asdf");
- VERIFY( regex_search("a", regex("^a")));
- VERIFY(!regex_search("a", regex("^a"), regex_constants::match_not_bol));
- VERIFY( regex_search("a", regex("a$")));
- VERIFY(!regex_search("a", regex("a$"), regex_constants::match_not_eol));
- VERIFY( regex_search("a", regex("\\ba")));
- VERIFY(!regex_search("a", regex("\\ba"), regex_constants::match_not_bow));
- VERIFY( regex_search("a", regex("a\\b")));
- VERIFY(!regex_search("a", regex("a\\b"), regex_constants::match_not_eow));
- VERIFY( regex_search("", regex("")));
- VERIFY(!regex_search("", regex(""), regex_constants::match_not_null));
- VERIFY( regex_search("", regex("^$")));
- VERIFY(!regex_search("", regex("^$"), regex_constants::match_not_null));
- VERIFY( regex_search("aaa", m, regex("a*?"),
- regex_constants::match_not_null));
+ VERIFY( regex_search_debug("a", regex("^a")));
+ VERIFY(!regex_search_debug("a", regex("^a"), regex_constants::match_not_bol));
+ VERIFY( regex_search_debug("a", regex("a$")));
+ VERIFY(!regex_search_debug("a", regex("a$"), regex_constants::match_not_eol));
+ VERIFY( regex_search_debug("a", regex("\\ba")));
+ VERIFY(!regex_search_debug("a", regex("\\ba"),
+ regex_constants::match_not_bow));
+ VERIFY( regex_search_debug("a", regex("a\\b")));
+ VERIFY(!regex_search_debug("a", regex("a\\b"),
+ regex_constants::match_not_eow));
+ VERIFY( regex_search_debug("", regex("")));
+ VERIFY(!regex_search_debug("", regex(""), regex_constants::match_not_null));
+ VERIFY( regex_search_debug("", regex("^$")));
+ VERIFY(!regex_search_debug("", regex("^$"), regex_constants::match_not_null));
+ VERIFY( regex_search_debug("aaa", m, regex("a*?"),
+ regex_constants::match_not_null));
VERIFY(m[0].matched && string(m[0].first, m[0].second) == "a");
- VERIFY( regex_search("asdf", regex("sdf")));
- VERIFY(!regex_search("asdf", regex("sdf"),
- regex_constants::match_continuous));
- VERIFY( regex_search(" a"+1, regex("\\ba"),
- regex_constants::match_prev_avail));
- VERIFY( regex_search("ba"+1, regex("\\Ba"),
- regex_constants::match_prev_avail));
+ VERIFY( regex_search_debug("asdf", regex("sdf")));
+ VERIFY(!regex_search_debug("asdf", regex("sdf"),
+ regex_constants::match_continuous));
+ VERIFY( regex_search_debug(" a"+1, regex("\\ba"),
+ regex_constants::match_prev_avail));
+ VERIFY( regex_search_debug("ba"+1, regex("\\Ba"),
+ regex_constants::match_prev_avail));
}
int
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+using namespace __gnu_test;
using namespace std;
void
cmatch m;
#define TEST(i, s) VERIFY(m[i].matched && string(m[i].first, m[i].second) == s)
- VERIFY(regex_search("aaaa", m, regex("a*")));
+ VERIFY(regex_search_debug("aaaa", m, regex("a*")));
TEST(0, "aaaa");
- VERIFY(regex_search("aaaa", m, regex("a*?")));
+ VERIFY(regex_search_debug("aaaa", m, regex("a*?")));
TEST(0, "");
- VERIFY(regex_search("aaaa", m, regex("a+")));
+ VERIFY(regex_search_debug("aaaa", m, regex("a+")));
TEST(0, "aaaa");
- VERIFY(regex_search("aaaa", m, regex("a+?")));
+ VERIFY(regex_search_debug("aaaa", m, regex("a+?")));
TEST(0, "a");
- VERIFY(regex_search("a", m, regex("a?")));
+ VERIFY(regex_search_debug("a", m, regex("a?")));
TEST(0, "a");
- VERIFY(regex_search("a", m, regex("a??")));
+ VERIFY(regex_search_debug("a", m, regex("a??")));
TEST(0, "");
- VERIFY(regex_search("", m, regex("a??")));
+ VERIFY(regex_search_debug("", m, regex("a??")));
TEST(0, "");
- VERIFY(regex_search("aaaa", m, regex("(a+)(a+)")));
+ VERIFY(regex_search_debug("aaaa", m, regex("(a+)(a+)")));
TEST(1, "aaa");
TEST(2, "a");
- VERIFY(regex_search("aaaa", m, regex("(a+?)(a+)")));
+ VERIFY(regex_search_debug("aaaa", m, regex("(a+?)(a+)")));
TEST(1, "a");
TEST(2, "aaa");
- VERIFY(regex_search("aaaa", m, regex("(a+?)(a+)")));
+ VERIFY(regex_search_debug("aaaa", m, regex("(a+?)(a+)")));
TEST(1, "a");
TEST(2, "aaa");
- VERIFY(regex_search("aaaa", m, regex("(a+?)(a+?)")));
+ VERIFY(regex_search_debug("aaaa", m, regex("(a+?)(a+?)")));
TEST(1, "a");
TEST(2, "a");
}
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
+
+using namespace __gnu_test;
+using namespace std;
void
test01()
{
bool test __attribute__((unused)) = true;
- VERIFY(std::regex_search("", std::regex("")));
+ VERIFY(regex_search_debug("", std::regex("")));
}
int
#include <regex>
#include <testsuite_hooks.h>
+#include <testsuite_regex.h>
using namespace std;
+using namespace __gnu_test;
void
test01()
bool test __attribute__((unused)) = true;
cmatch m;
- VERIFY(regex_search("*** this is a string !!!", m,
- regex("(\\w+) (\\w+) (\\w+) (\\w+)")));
+ VERIFY(regex_search_debug("*** this is a string !!!", m,
+ regex("(\\w+) (\\w+) (\\w+) (\\w+)")));
VERIFY(m.format("$&|$`|$3|$4|$2|$1|$'$$$")
== "this is a string|*** |a|string|is|this| !!!$$");
VERIFY(m.format("&|\\3|\\4|\\2|\\1|\\",
// Test on a compilation of simple expressions, throw regex_error on error.
typedef std::regex regex_type;
typedef regex_type::flag_type flag_type;
+ typedef std::regex_constants::match_flag_type match_flag_type;
typedef std::regex_constants::error_type error_type;
typedef std::size_t size_type;
typedef std::string string_type;
+ using std::basic_regex;
+ using std::match_results;
// Utilities
struct regex_expected_fail { };
}
}
+ // regex_match_debug behaves like regex_match, but will run *two* executors
+ // (if there's no back-reference) and check if their results agree. If not,
+ // an exception throws. One can use them just in the way of using regex_match.
+ template<typename _Bi_iter, typename _Alloc,
+ typename _Ch_type, typename _Rx_traits>
+ bool
+ regex_match_debug(_Bi_iter __s,
+ _Bi_iter __e,
+ match_results<_Bi_iter, _Alloc>& __m,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ match_flag_type __flags
+ = std::regex_constants::match_default)
+ {
+ using namespace std::__detail;
+ auto __res1 = __regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
+ _RegexExecutorPolicy::_S_auto, true>
+ (__s, __e, __m, __re, __flags);
+ match_results<_Bi_iter, _Alloc> __mm;
+ auto __res2 = __regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
+ _RegexExecutorPolicy::_S_force_dfs, true>
+ (__s, __e, __mm, __re, __flags);
+ if (__res1 == __res2 && __m == __mm)
+ return __res1;
+ throw(std::exception());
+ }
+
+ // No match_results version
+ template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
+ inline bool
+ regex_match_debug(_Bi_iter __first,
+ _Bi_iter __last,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ match_flag_type __flags
+ = std::regex_constants::match_default)
+ {
+ match_results<_Bi_iter> __what;
+ return regex_match_debug(__first, __last, __what, __re, __flags);
+ }
+
+ // C-string version
+ template<typename _Ch_type, typename _Alloc, typename _Rx_traits>
+ inline bool
+ regex_match_debug(const _Ch_type* __s,
+ match_results<const _Ch_type*, _Alloc>& __m,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ match_flag_type __f
+ = std::regex_constants::match_default)
+ { return regex_match_debug(__s, __s + _Rx_traits::length(__s),
+ __m, __re, __f); }
+
+ // C-string version without match_results
+ template<typename _Ch_type, class _Rx_traits>
+ inline bool
+ regex_match_debug(const _Ch_type* __s,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ match_flag_type __f
+ = std::regex_constants::match_default)
+ { return regex_match_debug(__s, __s + _Rx_traits::length(__s),
+ __re, __f); }
+
+ // std::basic_string version
+ template<typename _Ch_traits, typename _Ch_alloc,
+ typename _Alloc, typename _Ch_type, typename _Rx_traits>
+ inline bool
+ regex_match_debug(const std::basic_string<_Ch_type, _Ch_traits,
+ _Ch_alloc>& __s,
+ match_results<typename std::basic_string<_Ch_type,
+ _Ch_traits, _Ch_alloc>::const_iterator,
+ _Alloc>& __m,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ match_flag_type __flags
+ = std::regex_constants::match_default)
+ { return regex_match_debug(__s.begin(), __s.end(),
+ __m, __re, __flags); }
+
+ // std::basic_string version without match_results
+ template<typename _Ch_traits, typename _Str_allocator,
+ typename _Ch_type, typename _Rx_traits>
+ inline bool
+ regex_match_debug(const std::basic_string<_Ch_type, _Ch_traits,
+ _Str_allocator>& __s,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ match_flag_type __flags
+ = std::regex_constants::match_default)
+ { return regex_match_debug(__s.begin(), __s.end(), __re, __flags); }
+
+ // regex_match_debug behaves like regex_match, but will run *two* executors
+ // (if there's no back-reference) and check if their results agree. If not,
+ // an exception throws. One can use them just in the way of using regex_match.
+ template<typename _Bi_iter, typename _Alloc,
+ typename _Ch_type, typename _Rx_traits>
+ bool
+ regex_search_debug(_Bi_iter __s,
+ _Bi_iter __e,
+ match_results<_Bi_iter, _Alloc>& __m,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ match_flag_type __flags
+ = std::regex_constants::match_default)
+ {
+ using namespace std::__detail;
+ auto __res1 = __regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
+ _RegexExecutorPolicy::_S_auto, false>
+ (__s, __e, __m, __re, __flags);
+ match_results<_Bi_iter, _Alloc> __mm;
+ auto __res2 = __regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
+ _RegexExecutorPolicy::_S_force_dfs, false>
+ (__s, __e, __mm, __re, __flags);
+ if (__res1 == __res2 && __m == __mm)
+ return __res1;
+ throw(std::exception()); // Let test fail. Give it a name.
+ }
+
+ // No match_results version
+ template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
+ inline bool
+ regex_search_debug(_Bi_iter __first,
+ _Bi_iter __last,
+ const basic_regex<_Ch_type, _Rx_traits>& __re,
+ match_flag_type __flags
+ = std::regex_constants::match_default)
+ {
+ match_results<_Bi_iter> __what;
+ return regex_search_debug(__first, __last, __what, __re, __flags);
+ }
+
+ // C-string version
+ template<typename _Ch_type, class _Alloc, class _Rx_traits>
+ inline bool
+ regex_search_debug(const _Ch_type* __s,
+ match_results<const _Ch_type*, _Alloc>& __m,
+ const basic_regex<_Ch_type, _Rx_traits>& __e,
+ match_flag_type __f
+ = std::regex_constants::match_default)
+ { return regex_search_debug(__s, __s + _Rx_traits::length(__s),
+ __m, __e, __f); }
+
+ // C-string version without match_results
+ template<typename _Ch_type, typename _Rx_traits>
+ inline bool
+ regex_search_debug(const _Ch_type* __s,
+ const basic_regex<_Ch_type, _Rx_traits>& __e,
+ match_flag_type __f
+ = std::regex_constants::match_default)
+ { return regex_search_debug(__s, __s + _Rx_traits::length(__s),
+ __e, __f); }
+
+ // std::basic_string version
+ template<typename _Ch_traits, typename _Ch_alloc,
+ typename _Alloc, typename _Ch_type,
+ typename _Rx_traits>
+ inline bool
+ regex_search_debug(const std::basic_string<_Ch_type, _Ch_traits,
+ _Ch_alloc>& __s,
+ match_results<typename std::basic_string<_Ch_type,
+ _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&
+ __m,
+ const basic_regex<_Ch_type, _Rx_traits>& __e,
+ match_flag_type __f
+ = std::regex_constants::match_default)
+ { return regex_search_debug(__s.begin(), __s.end(), __m, __e, __f); }
+
+ // std::basic_string version without match_results
+ template<typename _Ch_traits, typename _String_allocator,
+ typename _Ch_type, typename _Rx_traits>
+ inline bool
+ regex_search_debug(const std::basic_string<_Ch_type, _Ch_traits,
+ _String_allocator>& __s,
+ const basic_regex<_Ch_type, _Rx_traits>& __e,
+ match_flag_type __f
+ = std::regex_constants::match_default)
+ { return regex_search_debug(__s.begin(), __s.end(), __e, __f); }
+
} // namespace __gnu_test
#endif
projects / thirdparty / gcc.git / commitdiff
