gcc/libstdc++-v3/testsuite/util/testsuite_regex.h
Jonathan Wakely e09366718a libstdc++: Reduce template instantiations in <regex>
This moves the last two template parameters of __regex_algo_impl to be
runtime function parameters instead, so that we don't need four
different instantiations for the possible ways to call it. Most of the
function (and what it instantiates) is the same in all cases, so making
them compile-time choices doesn't really have much benefit.

Use  'if constexpr' for conditions that check template parameters, so
that when we do depend on a compile-time condition we only instantiate
what we need to.

libstdc++-v3/ChangeLog:

	* include/bits/regex.h (__regex_algo_impl): Change __policy and
	__match_mode template parameters to be function parameters.
	(regex_match, regex_search): Pass policy and match mode as
	function arguments.
	* include/bits/regex.tcc (__regex_algo_impl): Change template
	parameters to function parameters.
	* include/bits/regex_compiler.h (_RegexTranslatorBase): Use
	'if constexpr' for conditions using template parameters.
	(_RegexTranslator): Likewise.
	* include/bits/regex_executor.tcc (_Executor::_M_handle_accept):
	Likewise.
	* testsuite/util/testsuite_regex.h (regex_match_debug)
	(regex_search_debug): Move template arguments to function
	arguments.
2022-01-05 13:47:01 +00:00

306 lines
11 KiB
C++

// -*- C++ -*-
// regex utils for the C++ library testsuite.
//
// Copyright (C) 2012-2022 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
//
#ifndef _TESTSUITE_REGEX_H
#define _TESTSUITE_REGEX_H 1
#include <regex>
#include <stdexcept>
#include <iostream>
namespace __gnu_test
{
// 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 { };
const error_type regex_error_internal(static_cast<error_type>(-1));
// Stringify error codes for text logging.
const char* regex_error_codes[] =
{
"error_collate",
"error_ctype",
"error_escape",
"error_backref",
"error_brack",
"error_paren",
"error_brace",
"error_badbrace",
"error_range",
"error_space",
"error_badrepeat",
"error_complexity",
"error_stack"
};
void
show_regex_error_codes()
{
using namespace std;
using namespace std::regex_constants;
const char tab('\t');
cout << "error_collate = " << tab << error_collate << endl;
cout << "error_ctype = " << tab << error_ctype << endl;
cout << "error_escape = " << tab << error_escape << endl;
cout << "error_backref = " << tab << error_backref << endl;
cout << "error_brack = " << tab << error_brack << endl;
cout << "error_paren = " << tab << error_paren << endl;
cout << "error_brace = " << tab << error_brace << endl;
cout << "error_badbrace = " << tab << error_badbrace << endl;
cout << "error_range = " << tab << error_range << endl;
cout << "error_space = " << tab << error_space << endl;
cout << "error_badrepeat = " << tab << error_badrepeat << endl;
cout << "error_complexity =" << tab << error_complexity << endl;
cout << "error_stack = " << tab << error_stack << endl;
}
// Arguments
// string __res: the regular expression string
// flag_type __f: flag
// __error: expected error, if any
void
regex_sanity_check(const string_type& __res,
flag_type __f = regex_type::basic,
error_type __error = regex_error_internal)
{
using namespace std;
try
{
regex_type reo(__res, __f);
auto n = reo.mark_count();
cout << "regex_type::mark_count " << n << endl;
}
catch (const regex_error& e)
{
cout << "regex_sanity_check: " << __res << endl;
cout << "regex_error::what " << e.what() << endl;
show_regex_error_codes();
cout << "regex_error::code " << regex_error_codes[e.code()] << endl;
if (__error != regex_error_internal)
{
// Then expected error_type is __error. Check.
if (__error != e.code())
{
throw regex_expected_fail();
}
}
throw;
}
catch (const logic_error& e)
{
cout << "logic_error::what " << e.what() << endl;
throw;
}
catch (const std::exception& e)
{
cout << "exception: " << endl;
throw;
}
}
// 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 is thrown. The arguments are the same as for 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(__s, __e, __m, __re, __flags,
_RegexExecutorPolicy::_S_auto,
true);
match_results<_Bi_iter, _Alloc> __mm;
auto __res2 = __regex_algo_impl(__s, __e, __mm, __re, __flags,
_RegexExecutorPolicy::_S_alternate,
true);
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(__s, __e, __m, __re, __flags,
_RegexExecutorPolicy::_S_auto,
false);
match_results<_Bi_iter, _Alloc> __mm;
auto __res2 = __regex_algo_impl(__s, __e, __mm, __re, __flags,
_RegexExecutorPolicy::_S_alternate,
false);
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