http://gcc.gnu.org/bugzilla/show_bug.cgi?id=60787
Markus Trippelsdorf <trippels at gcc dot gnu.org> changed:
What |Removed |Added
----------------------------------------------------------------------------
Status|UNCONFIRMED |NEW
Last reconfirmed| |2014-04-08
CC| |trippels at gcc dot gnu.org
Ever confirmed|0 |1
--- Comment #2 from Markus Trippelsdorf <trippels at gcc dot gnu.org> ---
This is what creduce came up with:
template <class T> void destroy (T *);
template <class FI> struct ArrayFill
{
ArrayFill (FI, FI &p2) : tgt_start_ (), tgt_end_ (p2) {}
template <class Val> void m_fn1 (Val &, int &)
{
while (tgt_cur_ != tgt_end_)
++tgt_cur_;
}
~ArrayFill () throw()
{
if (tgt_cur_ != tgt_end_)
while (tgt_cur_ != tgt_start_)
{
--tgt_cur_;
destroy (&*tgt_cur_);
}
}
const FI tgt_start_, tgt_end_;
FI tgt_cur_;
};
template <class FI, class Val>
inline FI uninitialized_fill (FI &p1, FI &p2, Val &p3, int &p4)
{
ArrayFill<FI> a (p1, p2);
a.m_fn1 (p3, p4);
}
template <class, typename> struct A
{
typedef int *pointer;
typedef int &const_reference;
template <class Val2> int m_fn1 (const A<Val2, int> &p1)
{
return cur_ == p1.cur_;
}
const_reference operator*() {}
void operator++()
{
if (last_)
cur_ = first_;
}
void operator--() { --cur_; }
pointer cur_;
pointer first_;
pointer last_;
};
template <class Val, class Val2, typename BufSize>
inline int operator==(A<Val, BufSize> &p1, const A<Val2, BufSize> &p2)
{
return p1.m_fn1 (p2);
}
template <class Val, class Val2, typename BufSize>
inline int operator!=(A<Val, BufSize> &p1, const A<Val2, BufSize> &p2)
{
return !(p1 == p2);
}
struct B
{
typedef A<int, int>::const_reference const_reference;
};
class C
{
public:
typedef B::const_reference const_reference;
int *p_ma_;
struct MapCreator
{
~MapCreator ();
};
struct MultiNodeCreator
{
MultiNodeCreator (A<int, int>::pointer *, A<int, int>::pointer *, int &p3)
: ma_ (p3)
{
}
~MultiNodeCreator () throw();
void m_fn1 ();
int &ma_;
};
void m_fn1 (A<int, int>::pointer *, A<int, int>::pointer *, int &)
{
MultiNodeCreator b (0, 0, *p_ma_);
b.m_fn1 ();
}
C::MapCreator initialize_map__new_map;
int &m_fn2_p3;
void m_fn2 (int, int)
{
m_fn1 (0, 0, m_fn2_p3);
this->finish_.cur_ = this->finish_.first_;
}
C (int &);
A<int, int> start_;
A<int, int> finish_;
};
class G : C
{
void m_fn3 (const_reference p1, const int &)
{
this->m_fn2 (0, 0);
uninitialized_fill (this->start_, this->finish_, p1, *this->p_ma_);
}
public:
G (int, const_reference p2, int &p3) : C (p3) { m_fn3 (p2, 0); }
void m_fn4 (const_reference p1) { G (0, p1, *this->p_ma_); }
};
class F
{
void m_fn1 (int &);
G m_jobs;
};
void F::m_fn1 (int &p1) { m_jobs.m_fn4 (p1); }