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

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