gcc/testsuite/g++.dg/pr59445.C

   1 /* { dg-do compile } */
   2 /* { dg-options "-O2 -Wno-return-type" } */
   3
   4 template <typename _Iterator> struct A;
   5 template <typename _Tp> struct A<_Tp *> {
   6   typedef _Tp value_type;
   7   typedef int difference_type;
   8 };
   9 template <typename _Compare> struct B {};
  10 template <typename _Compare> struct C {
  11   _Compare _M_comp;
  12   template <typename _Value, typename _Iterator>
  13   int operator()(_Value &p1, _Iterator p2) {
  14     return _M_comp(p1, *p2);
  15   }
  16 };
  17 template <typename _Compare> C<_Compare> __val_comp_iter(B<_Compare>);
  18 template <typename _RandomAccessIterator, typename _Compare>
  19 void __unguarded_linear_insert(_RandomAccessIterator p1, _Compare p2) {
  20   typename A<_RandomAccessIterator>::value_type a;
  21   _RandomAccessIterator b = p1;
  22   --b;
  23   while (p2(a, b)) {
  24     *p1 = 0;
  25     p1 = b;
  26     --b;
  27   }
  28 }
  29 template <typename _RandomAccessIterator, typename _Compare>
  30 void __insertion_sort(_RandomAccessIterator, _Compare p2) {
  31   for (_RandomAccessIterator c;; ++c)
  32     __unguarded_linear_insert(c, __val_comp_iter(p2));
  33 }
  34 template <typename _RandomAccessIterator, typename _Distance, typename _Compare>
  35 void __chunk_insertion_sort(_RandomAccessIterator, _Distance, _Compare p3) {
  36   _RandomAccessIterator d;
  37   __insertion_sort(d, p3);
  38 }
  39 template <typename _RandomAccessIterator, typename _Pointer, typename _Compare>
  40 void __merge_sort_with_buffer(_RandomAccessIterator p1, _Pointer, _Compare p3) {
  41   __chunk_insertion_sort(p1, 0, p3);
  42 }
  43 template <typename _RandomAccessIterator, typename _Pointer, typename _Distance,
  44           typename _Compare>
  45 void __stable_sort_adaptive(_RandomAccessIterator, _Pointer, _Distance,
  46                             _Compare p4) {
  47   _RandomAccessIterator e;
  48   __merge_sort_with_buffer(e, 0, p4);
  49 }
  50 template <typename _RandomAccessIterator, typename _Compare>
  51 void __stable_sort(_RandomAccessIterator p1, _Compare p2) {
  52   __stable_sort_adaptive(
  53       p1, 0, typename A<_RandomAccessIterator>::difference_type(), p2);
  54 }
  55 template <typename _RandomAccessIterator, typename _Compare>
  56 void stable_sort(_RandomAccessIterator, _RandomAccessIterator p2, _Compare) {
  57   B<_Compare> f;
  58   __stable_sort(p2, f);
  59 }
  60 class D {
  61 public:
  62   void m_fn1();
  63 };
  64 class F {
  65   struct G {
  66     D MFI;
  67     int operator()(int p1, int p2) {
  68       if (p1)
  69         return 0;
  70       if (p2)
  71         return 1;
  72       MFI.m_fn1();
  73     }
  74   };
  75   void m_fn1(int &p1) const;
  76 };
  77 void F::m_fn1(int &p1) const {
  78   int *g, *h;
  79   stable_sort(h, g, G());
  80 }
  81