Here are 2 versions of the same test case:
cregex_2.cpp.big - output of creduce (aeb8b294)
cregex_2.cpp - manually reduced
Unfortuantely its reproduction will require special build of compiler; however
I assume it could be useful on its own.
When doing manual reduction, I've removed all members of a[] except of first,
removed classes, A, B, and C, removed unused template parameters of other
classes including H, and then re-run creduce again.
--
Regards,
Konstantin
class A ;
template < class = A > class B;
template < class _Allocator> class B {
public:
typedef _Allocator allocator_type;
};
template <class charT> class C;
template <class charT, class = C<charT> > struct K;
template <class charT, class = K<charT> > class D;
typedef D<char, K<char> > regex;
template <class charT> class C {
public:
typedef charT char_type;
};
template <class , class implementationT > struct K : implementationT { };
typedef enum { match_default }
match_flags;
template <class , class > class D {
public:
int& get_traits() ;
};
template < class = B<>::allocator_type > class F;
template < class Allocator> class F {
public:
typedef Allocator allocator_type;
};
class G {
public:
G(G** ) ;
};
template <class BidiIterator, class Allocator, class traits> class H {
public:
typedef typename traits::char_type char_type;
typedef H self_type;
typedef bool (self_type::*matcher_proc_type)();
H(BidiIterator , BidiIterator , F< Allocator>& p3, D<char_type, traits>& p4, match_flags , BidiIterator ) : m_result(p3), re(p4), traits_inst(p4.get_traits()), rep_obj(0) { } bool find();
bool match_startmark();
bool match_endmark();
bool match_literal();
bool match_start_line();
bool match_end_line();
bool match_wild();
bool match_match();
bool match_word_boundary();
bool match_within_word();
bool match_word_start();
bool match_word_end();
bool match_buffer_start();
bool match_buffer_end();
bool match_backref();
bool match_long_set();
bool match_set();
bool match_jump();
bool match_alt();
bool match_rep();
bool match_combining();
bool match_soft_buffer_end();
bool match_restart_continue();
bool match_long_set_repeat();
bool match_set_repeat();
bool match_char_repeat();
bool match_dot_repeat_dispatch() ;
bool match_backstep();
bool match_assert_backref();
bool match_toggle_case();
bool match_recursion();
F< Allocator>& m_result;
D<char_type, traits>& re;
int& traits_inst;
G rep_obj;
};
class I;
class J {
I* pdata;
unsigned GrepFiles( );
};
class I {
public:
regex e;
};
match_flags c;
template <class BidiIterator, class Allocator, class traits> bool H<BidiIterator, Allocator, traits>::find() {
matcher_proc_type a[] = { (&H::match_startmark), &H::match_endmark, &H::match_literal, &H::match_start_line, &H::match_end_line, &H::match_wild, &H::match_match, &H::match_word_boundary, &H::match_within_word, &H::match_word_start, &H::match_word_end, &H::match_buffer_start, &H::match_buffer_end, &H::match_backref, &H::match_long_set, &H::match_set, &H::match_jump, &H::match_alt, &H::match_rep, &H::match_combining, &H::match_soft_buffer_end, &H::match_restart_continue, &H::match_dot_repeat_dispatch, &H::match_char_repeat, &H::match_set_repeat, &H::match_long_set_repeat, &H::match_backstep, &H::match_assert_backref, &H::match_toggle_case, &H::match_recursion };
}
template <class Predicate, class BidiIterator, class charT, class traits> int regex_grep(Predicate , BidiIterator , BidiIterator , D<charT, traits>& p4, match_flags ) {
F<> m;
H<BidiIterator, F<>::allocator_type, traits> b(0,0, m, p4, match_default,0);
b.find() ;
}
unsigned J::GrepFiles( ) {
int r = regex_grep(0,0,0, pdata->e, c);
}
class H
{
typedef bool (H::*matcher_proc_type) ();
bool find ();
bool match_startmark ();
};
bool
H::find ()
{
matcher_proc_type a[] = { (&H::match_startmark) };
}
