gcc/testsuite/g++.dg/torture/pr64568-2.C

   1 // { dg-do compile }
   2 // { dg-additional-options "-Wno-return-type" }
   3
   4 namespace std
   5 {
   6   typedef __SIZE_TYPE__ size_t;
   7 }
   8 class H;
   9 namespace std
  10 {
  11   template <typename> struct complex;
  12   template <typename _Tp>
  13       complex<_Tp> operator+(complex<_Tp> &__x, complex<_Tp> __y)
  14         {
  15           complex<_Tp> a = __x;
  16           a += __y;
  17           return a;
  18         }
  19   template <> struct complex<double>
  20     {
  21       int
  22           imag ()
  23             {
  24               return __imag__ _M_value;
  25             }
  26       void operator+=(complex __z) { _M_value += _M_value; _M_value  += __z.imag (); }
  27       _Complex double _M_value;
  28     };
  29 }
  30 struct A
  31 {
  32   typedef std::complex<double> &const_reference;
  33 };
  34 class B
  35 {
  36 public:
  37     B (int);
  38     std::complex<double> &operator[](int i) { return data_[i]; }
  39     std::complex<double> *data_;
  40 };
  41 struct C
  42 {
  43   static std::complex<double>
  44       apply (A::const_reference t1, std::complex<double> t2)
  45         {
  46           return t1 + t2;
  47         }
  48   typedef std::complex<double> result_type;
  49 };
  50 template <class T1, class> struct D
  51 {
  52   static void
  53       apply (T1 t1, std::complex<double> t2)
  54         {
  55           t1 = t2;
  56         }
  57 };
  58 class ublas_expression
  59 {
  60 public:
  61     ~ublas_expression ();
  62 };
  63 template <class> class F
  64 {
  65 };
  66 template <class E> class matrix_expression : ublas_expression
  67 {
  68 public:
  69     E &operator()() {}
  70 };
  71 class I : public F<int>
  72 {
  73 public:
  74     typedef int value_type;
  75     I (int);
  76 };
  77 template <class E1, class E2> matrix_expression<int> outer_prod (F<E1>, F<E2>);
  78 template <class E1, class F> class J : public matrix_expression<J<E1, F> >
  79 {
  80 public:
  81     typedef typename F::result_type value_type;
  82     value_type operator()(int i, int)
  83       {
  84         return F::apply (e1_ (i, 0), e2_ (0, 0));
  85       }
  86     E1 e1_;
  87     E1 e2_;
  88 };
  89 template <class E1, class E2>
  90 J<H, C> operator+(matrix_expression<E1>, matrix_expression<E2>);
  91 template <template <class, class> class F, class M, class E>
  92 void
  93 indexing_matrix_assign (M m, matrix_expression<E> e, int)
  94 {
  95   for (int i; i; ++i)
  96     F<typename M::reference, typename E::value_type>::apply (m (0, 0),
  97                                                              e ()(i, 0));
  98 }
  99 template <template <class, class> class F, class, class M, class E, class C>
 100 void
 101 matrix_assign (M m, matrix_expression<E> e, int, C)
 102 {
 103   indexing_matrix_assign<F> (m, e, 0);
 104 }
 105 template <template <class, class> class F, class M, class E>
 106 void
 107 matrix_assign (M m, matrix_expression<E> e)
 108 {
 109   matrix_assign<F, int> (m, e, 0, typename M::orientation_category ());
 110 }
 111 class H : matrix_expression<int>
 112 {
 113 public:
 114     typedef std::complex<double> &reference;
 115     typedef int orientation_category;
 116     H (int, int) : data_ (0) {}
 117     template <class AE> H (matrix_expression<AE> ae) : data_ (0)
 118   {
 119     matrix_assign<D> (*this, ae);
 120   }
 121     B &
 122         data ()
 123           {
 124           }
 125     std::complex<double> &operator()(int i, int) { return data ()[i]; }
 126     void operator+=(matrix_expression ae) { H (*this + ae); }
 127     B data_;
 128 };
 129 template <class M, class T, class V1, class V2>
 130 void
 131 sr2 (M m, T, V1 v1, V2 v2)
 132 {
 133   m += outer_prod (v2, v1);
 134 }
 135 template <class, class, std::size_t> struct G
 136 {
 137   void test ();
 138 };
 139 template struct G<I, H, 3>;
 140 template <class V, class M, std::size_t N>
 141 void
 142 G<V, M, N>::test ()
 143 {
 144   V b (0), c (0);
 145   M m (0, 0);
 146   sr2 (m, typename V::value_type (), b, c);
 147 }