1 // PR c++/69355 2 // { dg-do run } 3 4 template <int> struct A; 5 template <> struct A<1> {}; 6 template <class Obj, int> struct B 7 { 8 template <class T> struct C 9 { 10 typedef T *iterator; 11 C (iterator p1) : m_iter (p1) {} 12 void operator, (T p1) { *m_iter = p1; } 13 iterator m_iter; 14 }; 15 typedef double *iterator; 16 B (Obj &p1, double) : m_object (p1) {} 17 C<double> operator, (double); 18 Obj &m_object; 19 }; 20 template <class Obj, int LEN> 21 typename B<Obj, LEN>::template C<double> 22 B<Obj, LEN>::operator, (double p1) 23 { 24 iterator a = m_object.data (), b = a + 1; 25 *a = 1; 26 *b = p1; 27 return C<double>(b + 1); 28 } 29 class D {}; 30 inline double operator+(const double &p1, D) { return p1; } 31 template <int> class U; 32 template <int Sz, int K = 0> struct F 33 { 34 enum { doIt = K < Sz - 1 ? 1 : 0 }; 35 template <class Dest, class Src, class Assign> 36 static void assign (Dest &p1, Src &p2, Assign &p3) 37 { 38 p3.apply_on (p1 (K), p2 (K)); 39 F<Sz * doIt, (K + 1) * doIt>::assign (p1, p2, p3); 40 } 41 template <class Dest, class Src> static double dot (Dest &p1, Src &p2) 42 { 43 return p1 (K) * p2 (K) + F<Sz * doIt, (K + 1) * doIt>::dot (p1, p2); 44 } 45 }; 46 template <> struct F<0> 47 { 48 template <class Dest, class Src, class Assign> 49 static void assign (Dest &, Src &, Assign &) {} 50 template <class Dest, class Src> static D dot (Dest &, Src &) { return D (); } 51 }; 52 template <class E, int Sz> struct G 53 { 54 enum { ops_assign, use_meta }; 55 G (const E &p1) : m_expr (p1) {} 56 double operator()(int p1) const { return m_expr (p1); } 57 template <class Dest, class Src, class Assign> 58 static void do_assign (A<1>, Dest &p2, Src &p3, Assign &p4) 59 { 60 F<Sz>::assign (p2, p3, p4); 61 } 62 template <class Dest, class Assign> 63 void assign_to (Dest &p1, const Assign &p2) const 64 { 65 do_assign (A<1>(), p1, *this, p2); 66 } 67 E m_expr; 68 }; 69 struct H 70 { 71 static double apply_on (double p1, long double p2) { return p1 / p2; } 72 static void apply_on (double &p1, double p2) { p1 = p2; } 73 }; 74 template <class E1, class E2> struct I 75 { 76 I (const E1 &p1, const E2 &p2) : m_lhs (p1), m_rhs (p2) {} 77 double operator()(int p1) const 78 { 79 double c = m_lhs (p1); 80 return H::apply_on (c, m_rhs (0)); 81 } 82 E1 m_lhs; 83 const E2 m_rhs; 84 }; 85 struct J 86 { 87 J (double p1) : m_data (p1) {} 88 long double operator()(int) const { return m_data; } 89 long double m_data; 90 }; 91 template <int Sz> struct K 92 { 93 K (const U<Sz> &p1) : m_data (p1.data ()) {} 94 double operator()(int p1) const { return m_data[p1]; } 95 const double *m_data; 96 }; 97 template <int Sz> struct U 98 { 99 U () {} 100 U (const U &p1) 101 { 102 *this = G<ConstReference, Sz>(p1.const_ref ()); 103 } 104 B<U, Sz> operator=(double) { return B<U, Sz>(*this, 0); } 105 double *data () { return m_data; } 106 const double *data () const { return m_data; } 107 double &operator()(int p1) { return m_data[p1]; } 108 double operator()(int p1) const { return m_data[p1]; } 109 typedef K<Sz> ConstReference; 110 ConstReference const_ref () const { return *this; } 111 template <class E> void operator=(const G<E, Sz> &p1) 112 { 113 p1.assign_to (*this, H ()); 114 } 115 double m_data[Sz]; 116 }; 117 template <int Sz> 118 G<I<K<Sz>, J>, Sz> div (U<Sz> &p1, double p2) 119 { 120 typedef I<K<Sz>, J> expr_type; 121 return G<expr_type, Sz>(expr_type (p1.const_ref (), p2)); 122 } 123 template <int Sz> double norm2 (U<Sz> &p1) 124 { 125 return __builtin_sqrt (F<Sz>::dot (p1, p1)); 126 } 127 template <int Sz> 128 G<I<K<Sz>, J>, Sz> operator/(U<Sz> &p1, double p2) 129 { 130 return div (p1, p2); 131 } 132 typedef U<3> V; 133 V foo (V p1) 134 { 135 double e = norm2 (p1); 136 V r; 137 r = p1 / e; 138 return r; 139 } 140 int 141 main () 142 { 143 V f; 144 f = 1, 2, 3; 145 V r = foo (f); 146 if (__builtin_fabs (r (0) - 0.267261) > 0.01 147 || __builtin_fabs (r (1) - 0.534522) > 0.01 148 || __builtin_fabs (r (2) - 0.801784) > 0.01) 149 __builtin_abort (); 150 } 151