tests from mark

From-SVN: r17427

gcc/testsuite/g++.old-deja/g++.mike/p5840.C

@@ -17,17 +17,19 @@ public:
   int value (Foo* a) { return (a->*Id)(); }
 };
 
-template class Bar <Derived, &Signal::Name>;
+/* The following line is illegal under the new rules for non-type
+   template arguments in the standard, so it is commented out.  */
+/* template class Bar <Derived, &Signal::Name>; */
 template class Bar <Signal, &Signal::Name>;
 template class Bar <Derived, &Derived::Name>;
 
 Derived a;
 
-Bar<Derived, &Signal::Name> dispatcher1;
+/* Bar<Derived, &Signal::Name> dispatcher1; */
 Bar<Derived, &Derived::Name> dispatcher2;
 
 main() {
-  int i1 = dispatcher1.value(&a);
+  /* int i1 = dispatcher1.value(&a); */
   int i2 = dispatcher2.value(&a);
-  return i1 != 1 || i2 != 2;
+  return /* i1 != 1 || */ i2 != 2;
 }

gcc/testsuite/g++.old-deja/g++.mike/pt3.C

@@ -15,11 +15,14 @@ syHandle<Repr>::~syHandle()
 }
 
 typedef char * char_ptr_t;
+
+template <>
 syHandle<char_ptr_t>::syHandle() 
 {
     _repr = 0;
 }
 
+template <>
 syHandle<char_ptr_t>::~syHandle() 
 {
     _repr = 0;

gcc/testsuite/g++.old-deja/g++.mike/pt4.C

 // Build don't link:
 
 template <char* c> struct B { B() { } };
-B<0> bnull; 
+B<0> bnull; // ERROR - could not convert template argument

gcc/testsuite/g++.old-deja/g++.other/static1.C

+extern "C" void abort();
+
+struct S
+{
+  static const int i = 3;
+};
+
+const int S::i = 2; // ERROR - duplicate initialization

gcc/testsuite/g++.old-deja/g++.pt/bad-type.C

+template<class Type>
+class A
+{
+public:
+  Type m;
+};
+
+template<class Type>
+void f(A<Type>& a, Type d)
+{
+  A.m=d; // ERROR - invalid use of template
+}
+
+int main()
+{
+  A<int> a;
+  f(a,2);
+}
+ 

gcc/testsuite/g++.old-deja/g++.pt/explicit32.C

@@ -12,7 +12,7 @@ struct S<int>
   void foo();
 };
 
-template <>
+
 void S<int>::foo()
 {
 }

gcc/testsuite/g++.old-deja/g++.pt/explicit34.C

@@ -4,7 +4,7 @@ template <class T>
 void foo(T t);
 
 template <>
-void foo(int) {}; // ERROR - redefinition.
+void foo(int) {}; 
 
 template <>
-void foo<int>(int) {} // ERROR - redefinition.
+void foo<int>(int) {} // ERROR - duplicate specialization.

gcc/testsuite/g++.old-deja/g++.pt/explicit38.C

+template <int I>
+void f(int j);
+
+void g()
+{
+  f<7, 12>(3); // ERROR - no matching function.
+}

gcc/testsuite/g++.old-deja/g++.pt/explicit39.C

+template <class T>
+void f(int i);
+
+void g()
+{
+  f<7>(3); // ERROR - no matching function.
+}

gcc/testsuite/g++.old-deja/g++.pt/explicit40.C

+extern "C" void abort();
+
+template <void* P>
+void f(int j);
+
+template <unsigned int I>
+void f(int j);
+
+
+template <void* P>
+void f(int j)
+{
+  abort();
+}
+
+
+template <unsigned int I>
+void f(int j)
+{
+}
+
+
+int main()
+{
+  f<3>(7);
+}
+

gcc/testsuite/g++.old-deja/g++.pt/explicit41.C

+template <int I>
+void f(int i);
+
+void g()
+{
+  int i;
+  f<i>(7); // ERROR - template argument 1 is invalid.
+}

gcc/testsuite/g++.old-deja/g++.pt/explicit42.C

+extern "C" void abort(void);
+
+template <int I>
+void f(int i)
+{
+}
+
+template <void*>
+void f(int i) 
+{ 
+  abort();
+}
+
+int main()
+{
+  f<0>(3);
+}

gcc/testsuite/g++.old-deja/g++.pt/explicit43.C

+extern "C" void abort(void);
+
+void F(int)
+{
+}
+
+
+void F(double)
+{
+  abort();
+}
+
+template <void (*F)(int)> 
+void g()
+{
+  (*F)(3);
+}
+
+
+int main()
+{
+  g<&F>();
+}

gcc/testsuite/g++.old-deja/g++.pt/instantiate1.C

+// Build don't link:
+
+template <class T>
+void f(T t);
+
+template void f<int>(int);
+template void f<>(long);
+
+template <class T>
+struct S
+{
+  void bar(int) {}
+  
+  template <class U>
+  void baz(U u) {}
+};
+
+
+template S<char>;
+template void S<int>::bar(int);
+template void S<double>::baz<short>(short);
+template void S<long>::baz<>(char);

gcc/testsuite/g++.old-deja/g++.pt/local1.C

+template <class STRUCT, class MEMBER> inline STRUCT *
+setback(MEMBER *bp, MEMBER STRUCT::*offset)
+{
+        if(!bp) return 0;
+        union { int i; MEMBER STRUCT::*of; } u;
+        u.of = offset;
+        return (STRUCT *) ((int) bp - u.i);
+}
+ 
+
+struct S
+{
+  int i;
+};
+
+int main()
+{
+  S s;
+
+  S* sp = setback (&s.i, &S::i);
+}

gcc/testsuite/g++.old-deja/g++.pt/local2.C

+extern "C" void abort();
+
+template <class T>
+void f(T)
+{
+  struct S {
+    int i;
+  } s;
+
+  s.i = 3;
+
+  if (s.i != 3)
+    abort();
+}
+
+
+int main()
+{
+  f(7);
+}

gcc/testsuite/g++.old-deja/g++.pt/local3.C

+extern "C" void abort();
+
+template <class T>
+void f(T)
+{
+  struct S {
+    int i;
+  };
+
+  S s;
+
+  s.i = 3;
+
+  if (s.i != 3)
+    abort();
+}
+
+
+int main()
+{
+  f(7);
+}

gcc/testsuite/g++.old-deja/g++.pt/local4.C

+extern "C" void abort();
+
+template <class T>
+struct S {};
+
+S<int> si;
+
+template <class T>
+int f(T t)
+{
+  struct S { 
+    int g(int i) { return i + 2; }
+  };
+
+  S s;
+
+  return s.g(t) + s.g(t);
+}
+
+
+int main()
+{
+  if (f(3) != 10)
+    abort();
+}

gcc/testsuite/g++.old-deja/g++.pt/local5.C

+template <class INT>
+class b
+{
+private:
+  char a(int x)
+  {
+    union {
+      int i;
+      char c;
+    } val;
+    val.i = x;
+    return val.c;
+  };
+
+public:
+  b()  {
+  }
+};
+
+int main() {
+  b<int> n;
+  return 0;
+}
+   

gcc/testsuite/g++.old-deja/g++.pt/memtemp28.C

-// Build don't run:
-// GROUPS passed templates membertemplates
-extern "C" int printf(const char*, ...);
+extern "C" void abort();
+
+int k;
 
 template <class X>
 struct S
 {
   template <class U>
   void f(U u)
-  { printf ("In S::f(U)\n"); g(u); }
+  { ++k; g(u); }
 
   template <class U>
   void g(U u)
-  { printf ("In S::g(U)\n"); }
+  { ++k; }
 
   int c[16];
 };
@@ -21,4 +21,7 @@ int main()
   S<char*> s;
   s.f(3);
   s.f("adf");
+
+  if (k != 4)
+    abort();
 }

gcc/testsuite/g++.old-deja/g++.pt/memtemp65.C

+// Build don't link:
+
+template<unsigned int n> struct PartialDotProduct {
+    template<class T>
+    static T Expand(T* a, T* b) { return T(); }
+};
+
+const int N = 10;
+
+template<class In1, class In2>
+void
+dot(In1 f1, In2 f2)
+{
+  PartialDotProduct<N>::Expand(f1, f2);
+
+}
+
+int main()
+{
+  double a[N], b[N];
+  
+  dot(&a[0], &b[0]);
+}

gcc/testsuite/g++.old-deja/g++.pt/memtemp66.C

+// Build don't link:
+
+template <class T>
+struct S
+{
+  template <class U>
+  void f(U u) { this->template f<>(3); }
+};
+
+
+void g()
+{
+  S<char> s;
+  s.f(1.0);
+}

gcc/testsuite/g++.old-deja/g++.pt/memtemp67.C

+template <class T>
+struct A
+{
+  template <class T2>
+  operator A<T2>() const { return A<T2>(); }
+};
+
+main()
+{
+  A<int> a1;
+  A<long> a2;    
+  A<double> a3;
+  A<char> a4;
+
+  a2 = a1.operator A<long>();
+  a3 = (A<double>) a1;                   
+  a4 = a1;
+}
+ 

gcc/testsuite/g++.old-deja/g++.pt/recursion.C

+// Build don't link:
+
+const double M_PI=3.14159265358979323846;
+
+template<int N,int I,int J,int K>
+inline double SineSeries()
+{
+  const double x=I*2*M_PI/N;
+  const bool go=K+1!=J;
+  return 1.0-x*x/(2*K+2)/(2*K+3)*SineSeries<N*go,I*go,J*go,(K+1)*go>();
+}
+
+template<>
+inline double SineSeries<0,0,0,0>()
+{
+  return 1.0;
+}
+
+template<int N,int I>
+inline double Sine()
+{
+  const double x=(I*2*M_PI/N);
+  return x * SineSeries<N,I,10,0>();
+}
+
+int main()
+{
+  double f=Sine<32,5>();
+  return 0;
+}
+ 

gcc/testsuite/g++.old-deja/g++.pt/recursion2.C

+template< int i > struct T :
+public T< i-1 >
+{
+};
+
+template<> struct T< 0 >
+{
+};
+
+template< class F > struct T1 :
+public T< F::dim >
+{
+};
+
+template< int i > struct S
+{
+  enum { dim = i } ;
+};
+
+int main()
+{
+  T1< S< 4 > > t ;
+  return( 0 ) ;
+}
+

gcc/testsuite/g++.old-deja/g++.pt/spec10.C

+extern "C" void abort();
+
+template <class T>
+struct S
+{
+  template <int i>
+  int f(int j) { abort(); return 0; }
+
+  template <>
+  int f<7>(int j) { return j + 7; }
+
+  template <>
+  int f<8>(int j) { return j + 8; }
+};
+
+
+int main()
+{
+  S<double> s;
+
+  if (s.template f<7>(3) != 10)
+    abort();
+
+  if (s.template f<8>(3) != 11)
+    abort();
+}

gcc/testsuite/g++.old-deja/g++.pt/spec11.C

+extern "C" void abort();
+
+template <class T>
+struct S
+{
+  template <class U>
+  int f(U u);
+};
+
+template <class T>
+template <>
+int S<T>::f(int i) { return 1; }
+
+int main()
+{
+  S<char> sc;
+
+  if (sc.f(3) != 1)
+    abort();
+}

gcc/testsuite/g++.old-deja/g++.pt/spec2.C

+// Build don't link:
+
+class X
+{
+  public:
+    virtual void f() const = 0;
+};
+
+template <class T>
+class Y: public X
+{
+  public:
+    virtual void f() const;
+};
+
+template <class T>
+void Y<T>::f() const
+{
+}
+
+template <>
+void Y<bool>::f() const;
+
+template <>
+void Y<bool>::f() const
+{
+}

gcc/testsuite/g++.old-deja/g++.pt/spec3.C

+extern "C" void abort();
+
+class X
+{
+  public:
+    virtual int f() const = 0;
+};
+
+template <class T>
+class Y: public X
+{
+  public:
+    virtual int f() const;
+};
+
+template <class T>
+int Y<T>::f() const
+{
+  abort();
+  return 0;
+}
+
+template <>
+int Y<bool>::f() const;
+
+template <>
+int Y<bool>::f() const
+{
+  return 0;
+}
+
+int main()
+{
+  Y<bool> yb;
+
+  yb.f();
+}

gcc/testsuite/g++.old-deja/g++.pt/spec4.C

+// Build don't link:
+
+template <class T>
+struct S {};
+
+template <>
+struct S<int>
+{
+  void f();
+  void g();
+};
+
+void S<int>::f() {}
+
+template <>
+void S<int>::g() {} // ERROR - does not match any template declaration

gcc/testsuite/g++.old-deja/g++.pt/spec5.C

+// Build don't link:
+
+template <class T>
+void f(T t1, T t2);
+
+template <>
+void f(int i, int j);
+
+template <class T>
+void g(T t1, T t2) {}
+
+template void g(int i, int j);
+
+void h()
+{
+  f(3, 'c'); // ERROR - no matching function
+  g(3, 'c'); // ERROR - no matching function
+}
+
+

gcc/testsuite/g++.old-deja/g++.pt/spec6.C

+// Build don't link:
+
+struct S1
+{
+  template <class T>
+  void f(T t1, T t2);
+
+  template <>
+  void f(int i1, int i2);
+};
+
+template <class U>
+struct S2
+{
+  template <class T>
+  void f(T t1, T t2);
+
+  template <>
+  void f(int i1, int i2);
+};
+
+void h()
+{
+  S1 s1;
+  s1.f(3, 'c'); // ERROR - no matching function
+
+  S2<char> s2;
+  s2.f(3, 'c'); // ERROR - no matching function
+}

gcc/testsuite/g++.old-deja/g++.pt/spec7.C

+extern "C" void abort();
+
+template <class T>
+void f(T t1, T t2);
+
+template <>
+void f(int i, int j) 
+{
+  abort();
+}
+
+void f(short s, char c)
+{
+}
+
+int main()
+{
+  f(3, 'c');
+}

gcc/testsuite/g++.old-deja/g++.pt/spec8.C

+extern "C" void abort();
+
+template <void* P>
+void f(int j);
+
+template <int I>
+void f(int j);
+
+
+template <void* P>
+void f(int j)
+{
+  abort();
+}
+
+
+template <int I>
+void f(int j)
+{
+}
+
+
+int main()
+{
+  f<3>(7);
+}
+

gcc/testsuite/g++.old-deja/g++.pt/spec9.C

+extern "C" void abort();
+
+template <class T>
+inline int f(T t) 
+{
+  return 0;
+}
+
+int main()
+{
+  if (!f(3))
+    abort();
+}
+
+template <>
+int f(int i) 
+{             // ERROR - specialization of f<int>(int) after instantiation
+  return 1;
+}
+
+

gcc/testsuite/g++.old-deja/g++.pt/static_cast.C

+// Build don't link:
+
+template <class InputIterator, class BinaryOperation>
+void accumulate(InputIterator first, 
+    	         BinaryOperation binary_op) {
+}
+
+
+template<class R> int p( int val, R& r )
+{
+   return val + r;
+}
+
+template<class R> void f(R)
+{
+   accumulate(0, static_cast<int (*)(int, R&)>(p) );
+}
+
+main()
+{
+   f(0);
+}

gcc/testsuite/g++.old-deja/g++.pt/typename3.C

 // Build don't link:
-// GROUPS passed templates
+
 template <class T>
-struct bar { 
-  typedef typename T::baz baz;
+struct A
+{
+  typedef T A_Type;
 };
 
-template <class T>
-void foo(T)
+
+template <class U>
+struct B : public A<U>
 {
-  bar<T>::baz(); // ERROR - T is int.
-}
+  A_Type Func();
+};
+
 
-void foobar()
+template <class U>
+A<U>::A_Type B<U>::Func()
 {
-  foo(3);
 }