initial commit

316 files changed, 10301 insertions, 0 deletions

diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/README b/gcc/testsuite/g++.old-deja/g++.brendan/README
new file mode 100755
index 0000000..ce760b1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/README
@@ -0,0 +1,40 @@
+
+abstract	- abstract functions
+alignof		- gcc alignof builtin
+ambiguity	- diagnosing ambiguities
+arm		- ARM cases
+array-refs	- arrays of references
+bit-fields	- bit fields
+chainon		- deaths cuz we call chainon() incorrectly
+copy		- copy constructors
+crash		- old compiler crashes/aborts
+cvt		- user-defined conversions
+def-fns		- default function generation (in add'n to copy)
+enum-clash	- int vs enum
+enum		- enumerated types
+err-msg		- error messages
+friend		- dealing with friend functions and classes
+groff		- crashes derived from groff code
+init		- initialization bugs
+label		- handling labels
+line		- line numbers in error messages
+misc		- miscellaneous tests that didn't fit another category
+nest		- nested types
+new-array	- doing new of an array
+new		- generic operator new bugs
+operators	- tests for various overloaded operators
+parse		- parser bugs
+prepost		- prefix/postfix operator ++/--
+ptolemy		- bugs derived from ptolemy
+recurse		- infinite recursion in the compiler
+redecl		- handling redeclarations
+scope		- managing scopes
+shadow		- shadowing of params, etc
+sizeof		- ARM compliance w/ sizeof operator
+sorry		- old "sorry, not implemented" messages
+static		- handling static data
+template	- template bugs
+union		- handling unions
+visibility	- access control and visibility checking
+warnings	- warning messages
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/abstract1.C b/gcc/testsuite/g++.old-deja/g++.brendan/abstract1.C
new file mode 100755
index 0000000..b9cd9c5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/abstract1.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// GROUPS passed abstract-functions
+class O
+{
+public:
+   virtual int c()=0;
+};
+
+class I: public O
+{
+};
+
+class S: public virtual I
+{
+public: 
+  int c();
+  virtual int v()=0;
+};
+
+class D: public S
+{
+   int v();
+};
+
+D *p=new D();
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/access1.C b/gcc/testsuite/g++.old-deja/g++.brendan/access1.C
new file mode 100755
index 0000000..0272c7a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/access1.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed access-control
+class Base
+{
+protected:
+  virtual void DoSomething() = 0;
+};
+
+class Fibber : public Base
+{
+public:
+  void DoBP() {
+    DoSomething();
+  }
+};
+
+class Flat : public virtual Fibber
+{
+public:
+  void DoIt() {
+    DoSomething();
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/alignof.C b/gcc/testsuite/g++.old-deja/g++.brendan/alignof.C
new file mode 100755
index 0000000..1449ade
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/alignof.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed extensions
+struct bar { int bit : 1; };
+
+void foo (int *r, bar t)
+{
+  // doing alignof on a bit-field should be illegal
+  __alignof__ (t.bit);// ERROR - .*
+
+  // both of these (a regular ref and an INDIRECT_REF) should work
+  __alignof__ (r);
+  __alignof__ (*r);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ambiguity1.C b/gcc/testsuite/g++.old-deja/g++.brendan/ambiguity1.C
new file mode 100755
index 0000000..c6d6fcb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ambiguity1.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed ambiguity
+struct A {
+  A (int);
+};
+
+struct B {
+  B (int);
+};
+
+void myfunc (const A& t0); // ERROR - 
+void myfunc (const B& t0); // ERROR - 
+
+int main ()
+{
+   myfunc(1);   // ERROR - ambiguous call
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/anon-union1.C b/gcc/testsuite/g++.old-deja/g++.brendan/anon-union1.C
new file mode 100755
index 0000000..86b7ce3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/anon-union1.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed anonymous-unions
+static union {
+        char*   uC;
+private:
+        int     uI;// ERROR - .*private member.*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/arm1.C b/gcc/testsuite/g++.old-deja/g++.brendan/arm1.C
new file mode 100755
index 0000000..e415632
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/arm1.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed ARM-compliance
+// ARM $5.7, it's illegal to do math on a `void*'.
+
+int
+main()
+{
+  void *p;
+  ++p;// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/arm2.C b/gcc/testsuite/g++.old-deja/g++.brendan/arm2.C
new file mode 100755
index 0000000..62bdc3d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/arm2.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed ARM-compliance
+// ARM 9.4 ``There cannot be a static and a nonstatic member function
+//	     with the same name and the same argument types.''
+//
+// The trick is to make sure it's caught with both orders (static,
+// then normal, and vice-versa.
+
+class X {
+public:
+   int foo();
+  static int foo();	// error: redeclaration// ERROR - .*
+};
+
+class Y {
+public:
+   static int foo();
+  int foo();		// error: redeclaration// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/arm3.C b/gcc/testsuite/g++.old-deja/g++.brendan/arm3.C
new file mode 100755
index 0000000..c352bfa
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/arm3.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed initialization
+// ARM $11.4: A function first declared in a friend decl is equivalent
+// to an extern decl, so the below is illegal.
+
+class X {
+      friend g(); // ERROR - previous declaration
+};
+static g() { return 1; }// ERROR - previously declared
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/array-refs.C b/gcc/testsuite/g++.old-deja/g++.brendan/array-refs.C
new file mode 100755
index 0000000..0eaa45c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/array-refs.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed arm
+int a, b;
+
+// declaring an array of references should be illegal
+int & v[ 2] = { a, b};// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/array1.C b/gcc/testsuite/g++.old-deja/g++.brendan/array1.C
new file mode 100755
index 0000000..1812958
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/array1.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// Special g++ Options: -fconserve-space -fcommon
+// GROUPS passed array-bindings
+
+extern "C" void printf (char *, ...);
+char array[~(~0ul>>1)|~(0ul>>3)];  // ERROR - overflow in array dimension.*
+int main () { printf ("PASS\n"); return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/asm-extn1.C b/gcc/testsuite/g++.old-deja/g++.brendan/asm-extn1.C
new file mode 100755
index 0000000..fecd092
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/asm-extn1.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// Special g++ Options: -S
+// GROUPS passed asm-extension
+// Skip if not target: sparc-sun-*
+// This used to crash because c_expand_asm_keyword didn't know what to
+// do with this.  The parser rules were changed to accept an expr, instead
+// of a stmt.
+
+extern void traptable(void);
+
+main()
+{
+  asm("wr    %0,%%tbr" : : "r" (traptable));
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/bit-fields1.C b/gcc/testsuite/g++.old-deja/g++.brendan/bit-fields1.C
new file mode 100755
index 0000000..76f4ac3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/bit-fields1.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed bit-fields
+struct bar {
+  int : 2 = 1;// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/bit-fields2.C b/gcc/testsuite/g++.old-deja/g++.brendan/bit-fields2.C
new file mode 100755
index 0000000..c77ce86
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/bit-fields2.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed bit-fields
+	struct {
+	    char c;
+	    int i:8;
+	} s;
+	
+	int main()
+	{
+	    int &ir = s.i;	// ERROR - address of bitfield
+	    int *ip = &s.i;	// ERROR - address of bitfield
+	    ir = 10;
+	}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/bool1.C b/gcc/testsuite/g++.old-deja/g++.brendan/bool1.C
new file mode 100755
index 0000000..1e7b343
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/bool1.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed boolean
+int
+main()
+{
+    typedef char Boolean; // Instrinsic.h
+    Boolean c = false;
+    bool b = true;
+
+    if (!c != !b)
+	;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/code-gen1.C b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen1.C
new file mode 100755
index 0000000..84dd634
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen1.C
@@ -0,0 +1,40 @@
+// GROUPS passed code-generation
+// Check that sub-word sized structs/classes are passed correctly
+// if the struct/class has a constructor (i.e. ANY constructor).
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	unsigned int f1 : 8;
+	unsigned int f2 : 8;
+
+	base (int ii)
+	{
+	}
+};
+
+base global_base (7);
+
+int test2 (base formal_base);
+
+int main ()
+{
+	global_base.f1 = 0x55;
+	global_base.f2 = 0xee;
+
+	if (test2 (global_base) == 0)
+	  printf ("PASS\n");
+	else
+	  printf ("FAIL\n");
+
+	return 0;
+}
+
+int test2 (base formal_base)
+{
+	if (formal_base.f1 != global_base.f1)
+		return -1;
+	if (formal_base.f2 != global_base.f2)
+		return -1;
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/code-gen2.C b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen2.C
new file mode 100755
index 0000000..133755e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen2.C
@@ -0,0 +1,18 @@
+// GROUPS passed code-generation
+// Check that declarations with initializations are executed
+// correctly.
+
+extern "C" void printf (char *, ...); 
+
+int main ()
+{
+	char buff[40] ;
+	char *tmp = &buff[0];	// also fails for char *tmp = buff;
+
+	if ((unsigned int) tmp != (unsigned int) &buff[0])
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/code-gen3.C b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen3.C
new file mode 100755
index 0000000..6d73bd2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen3.C
@@ -0,0 +1,34 @@
+// GROUPS passed code-generation
+// Check that passing things which are not a multiple of
+// 4 bytes in size doesn't mess up other subsequent parameters.
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	int f1 : 8;
+	int f2 : 8;
+};
+
+base global_base;
+
+int val1;
+
+int test2 (struct base formal_base, int v1);
+
+int main ()
+{
+	val1 = 0x5e5e;
+	return test2 (global_base, val1);
+}
+
+int test2 (struct base formal_base, int v1)
+{
+	formal_base.f1 = formal_base.f2;	// prevent warnings
+
+	if (v1 != 0x5e5e)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/code-gen4.C b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen4.C
new file mode 100755
index 0000000..e29b16a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen4.C
@@ -0,0 +1,31 @@
+// Special g++ Options: -O
+// GROUPS passed code-generation
+// Options: -O
+//
+// Check that when an int value is assigned to a short int, the proper
+// half of the int (i.e. the low order half) ends up in the short.
+//
+// This fails with 1.32.0 with -O and f1() is inline.
+//
+// Workaround - declare "f1_arg" as type "short int".
+
+extern "C" void printf (char *, ...); 
+
+short int v2;
+
+long v1 = 0x11117777;
+
+inline void f1 (long f1_arg)
+{
+	v2 = f1_arg;
+}
+
+int main ()
+{
+	f1 (v1);
+
+	if (v2 != 0x00007777)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/code-gen5.C b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen5.C
new file mode 100755
index 0000000..0d59b56
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen5.C
@@ -0,0 +1,57 @@
+// Special g++ Options: -fthis-is-variable
+// GROUPS passed code-generation
+// Check that the "this" pointer is zero when a method is
+// called for an object pointed to by a null pointer.
+
+// Normally, the "__builtin_new" operation which actually
+// allocates objects in heap space is *not* called at the
+// actual point of the "new" keyword.  Rather, a check is
+// made within each constructor and if the "this" pointer
+// value passed in is zero, then the actual allocation of
+// memory (via __builtin_new) is done at that point (i.e.
+// at the very beginning of the constructor).
+
+// A special trick allows one to subvert this mechanism.
+// Specifically, if a given constructor contains a statement
+// like: "this = this", then no attempt will be made to
+// implicitly call __builtin_new within that constructor.
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	int member;
+
+	base ();
+	void member_function ();
+};
+
+base *base_pointer_1 = 0;
+base *base_pointer_2 = 0;
+
+int errors = 0;
+
+int main ()
+{
+	//base_pointer_2 = new base();
+	base_pointer_1->member_function ();
+
+	if (errors)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
+
+base::base ()
+{
+	this = this;
+	if ((int) this != 0)
+		errors++;
+}
+
+void base::member_function ()
+{
+	if ((int) this != 0)
+		errors++;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/code-gen6.C b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen6.C
new file mode 100755
index 0000000..ea5d730
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen6.C
@@ -0,0 +1,54 @@
+// GROUPS passed code-generation
+// Check that type float parameters can be correctly passed to
+// methods.
+
+extern "C" void printf (char *, ...); 
+
+class tres_floats {
+	float ff1;
+	float ff2;
+	float ff3;
+public:
+	tres_floats (float f1, float f2, float f3);
+	float get_f1 ();
+	float get_f2 ();
+	float get_f3 ();
+};
+
+float v1 = 1.2345;
+float v2 = 3.14159;
+float v3 = 0.707;
+
+int main ()
+{
+	tres_floats tf (v1, v2, v3);
+
+	if ((tf.get_f1() != v1) || (tf.get_f2() != v2) || (tf.get_f3() != v3))
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
+
+tres_floats::tres_floats (float f1, float f2, float f3)
+{
+	ff1 = f1;
+	ff2 = f2;
+	ff3 = f3;
+}
+
+float tres_floats::get_f1 ()
+{
+	return ff1;
+}
+
+float tres_floats::get_f2 ()
+{
+	return ff2;
+}
+
+float tres_floats::get_f3 ()
+{
+	return ff3;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/complex1.C b/gcc/testsuite/g++.old-deja/g++.brendan/complex1.C
new file mode 100755
index 0000000..908b4ca
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/complex1.C
@@ -0,0 +1,22 @@
+// Special g++ Options:
+
+// This test makes sure that the stuff in lex.c (real_yylex) is
+// set up to handle real and imag numbers correctly.  This test is against
+// a bug where the compiler was not converting the integer `90' to a
+// complex number, unless you did `90.0'.  Fixed 10/1/1997.
+
+extern "C" void printf (char *, ...);
+
+__complex__ double cd;
+
+int
+main(int argc, char *argv[])
+{
+  cd = 1.0+90i;
+  cd *= argc;
+
+  if (__real__ cd != 1 || __imag__ cd != 90)
+    exit (1);
+
+  exit (0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy1.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy1.C
new file mode 100755
index 0000000..27d959f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy1.C
@@ -0,0 +1,21 @@
+// GROUPS passed copy-ctors
+extern "C" void printf (char *, ...);
+int count = 0;
+
+class C {
+public:
+  C (int) { count++; }
+  operator int () { return 0; }
+};
+
+int
+main ()
+{
+  C c1 (1);
+  C c2 (c1);
+
+  if (count != 1)
+    printf ("FAIL\n");
+  else
+    printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy2.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy2.C
new file mode 100755
index 0000000..0ecc1e9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy2.C
@@ -0,0 +1,79 @@
+// GROUPS passed copy-ctors
+/*
+The old g++ output is
+
+Item()
+Compound()
+Pre foo
+foo
+~Compound()
+~Item()
+Post foo
+~Compound()
+~Item()
+
+The output should be something like (produced from ATT 2.1)
+
+Item()
+Compound()
+Pre foo
+Item(const Item& i)    <------ missing above
+foo
+~Compound()
+~Item()
+Post foo
+~Compound()
+~Item()
+
+*/
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int count = 0;
+
+void
+die (int x)
+{
+  if (x != ++count)
+    {
+      printf ("FAIL\n");
+      exit (1);
+    }
+}
+  
+
+class Item {
+ public:
+  Item() { die (1); }
+  Item(const Item& i) { die (4); }
+  ~Item() { count++; if (count != 7 && count != 10) die (-1); }
+};
+
+
+class Compound {
+  Item i;
+ public:
+  Compound() { die (2); }
+  ~Compound() { count++; if (count != 6 && count != 9) die (-1); }
+};
+
+
+void foo(Compound a)
+{
+  die (5);
+}
+
+int
+main()
+{
+  Compound a;
+
+  die (3);
+  foo(a);
+
+  die (8);
+
+  printf ("PASS\n");
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy3.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy3.C
new file mode 100755
index 0000000..3b1edd5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy3.C
@@ -0,0 +1,58 @@
+// GROUPS passed copy-ctors
+/*
+
+If I compile it with cfront (AT&T C++ Translator 2.00.02 08/25/89) and run it
+I get:
+
+	A::A()
+	A::A(const A&)
+	B::Bar()
+	A::~A()
+	A::~A()
+
+If I compile it with g++ (gcc version 2.2.2) and run it I get:
+
+	A::A()
+	B::Bar()
+	A::~A()
+	A::~A()
+
+*/
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int count = 0;
+
+void
+die (int x)
+{
+  if (x != ++count)
+    {
+      printf ("FAIL\n");
+      exit (1);
+    }
+}
+  
+
+class A {
+public:
+  A() { die (1); }
+  A(const A&) { die (2); }
+  ~A() { count++; if (count != 4 && count != 5) die (-1); }
+};
+
+class B : public A {
+public:
+  void Bar() { die (3); }
+};
+
+void Foo(B b) { b.Bar(); }
+
+int
+main()
+{
+  B b;
+  Foo(b);
+
+  printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy4.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy4.C
new file mode 100755
index 0000000..35b5393
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy4.C
@@ -0,0 +1,58 @@
+// GROUPS passed copy-ctors
+// Using Cfront 3.0.1 the programm below prints
+// 
+// 	  A()
+// 	  A(const A& a)
+// 	  ~A()
+// 	  A(A& a)        <---- !!!
+// 	  ~A()
+// 	  ~A()
+// 
+// the g++ 2.2.2 (sparc-sun-sunos4.1) generated code prints
+// 
+// 	  A()
+// 	  A(const A& a)
+// 	  ~A()
+// 	  A(const A& a)  <---- !!!
+// 	  ~A()
+// 	  ~A()
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int count = 0;
+
+void
+die (int x)
+{
+  if (x != ++count)
+    {
+      printf ("FAIL\n");
+      exit (1);
+    }
+}
+
+class A {
+public:
+  A() { die (1); }
+  A(const A& a) { die (2); }
+  A(A& a) { die (4); }
+  ~A() { count++; if (count != 3 && count != 5 && count != 6) die (-1); }
+};
+
+void foo1(const A& a) {
+  A b = a;
+}
+
+void foo2( A& a) {
+  A b = a;
+}
+
+int main() {
+  A a;
+
+  foo1(a);
+  foo2(a);
+
+  printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy5.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy5.C
new file mode 100755
index 0000000..277940b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy5.C
@@ -0,0 +1,85 @@
+// GROUPS passed copy-ctors
+/*
+bad:
+sibelius402> a.out
+a=5  a.virtMember()=30
+BaseClass::Increm --> {i=5, virtMember()=30}
+a=7  a.virtMember()=30
+b=7  b.virtMember()=30
+BaseClass::Increm --> {i=7, virtMember()=999}
+b=9  b.virtMember()=30
+sibelius403> 
+
+ good:
+
+sibelius406> a.out
+a=5  a.virtMember()=30
+BaseClass::Increm --> {i=5, virtMember()=30}
+a=7  a.virtMember()=30
+b=7  b.virtMember()=30
+BaseClass::Increm --> {i=7, virtMember()=30}
+b=9  b.virtMember()=30
+*/
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+void die () { printf ("FAIL\n"); exit (1); }
+
+class BaseClass {
+
+  friend int operator != (const BaseClass irv, int x);
+
+  int i;
+
+public:
+
+  BaseClass( const BaseClass& ir ) : i(ir.i) {};
+  BaseClass() : i(5) {};
+
+  virtual int virtMember() { return( 999 ); };
+
+  void Increm( int r );
+};
+
+void BaseClass::Increm( int r )
+{
+  if ((i == 5 && virtMember () == 30)
+      || (i == 7 && virtMember () == 30))
+    i += r;
+  else
+    die ();
+};
+
+class DerivedClass : public BaseClass {
+public:
+  int virtMember() { return( 30 ); };
+};
+
+int operator != (const BaseClass irv, int x) { return irv.i != x; }
+
+int
+main ()
+{
+    DerivedClass a;
+
+    if (a != 5 || a.virtMember () != 30)
+      die ();
+
+    a.Increm(2);
+
+    if (a != 7 || a.virtMember () != 30)
+      die ();
+
+    DerivedClass b = a;
+
+    if (b != 7 || a.virtMember () != 30)
+      die ();
+
+    b.Increm(2);
+
+    if (b != 9 || a.virtMember () != 30)
+      die ();
+
+    printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy6.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy6.C
new file mode 100755
index 0000000..d15a4be
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy6.C
@@ -0,0 +1,55 @@
+// GROUPS passed copy-ctors
+/*
+g++ 2.3.3 will prefer using type conversions over the
+implicitly generated copy constructor. This is wrong.
+If you explicitly define a copy constructor, it will
+use it. However, the implicit copy constructor MUST be
+called whenever an explicit one would have been called
+also. See below: g++ converts from and back into
+unsigned, instead of using the implicit copy constructor:
+here is the version:
+Reading specs from /usr/lib/gcc-lib/i386-linux/2.3.3/specs
+gcc version 2.3.3
+ /usr/lib/gcc-lib/i386-linux/2.3.3/cpp -lang-c++ -v -undef -D__GNUC__=2 -D__GNUG__=2 -D__cplusplus -Dunix -Di386 -Dlinux -D__unix__ -D__i386__ -D__linux__ -D__unix -D__i386 -D__linux bug2.cc /usr/tmp/cca02008.i
+GNU CPP version 2.3.3 (80386, BSD syntax)
+ /usr/lib/gcc-lib/i386-linux/2.3.3/cc1plus /usr/tmp/cca02008.i -quiet -dumpbase bug2.cc -version -o /usr/tmp/cca02008.s
+GNU C++ version 2.3.3 (80386, BSD syntax) compiled by GNU C version 2.3.3.
+ as -o /usr/tmp/cca020081.o /usr/tmp/cca02008.s
+ ld /usr/lib/crt0.o -nojump -L/usr/lib/gcc-lib/i386-linux/2.3.3 /usr/tmp/cca020081.o -lg++ -lgcc -lc -lgcc
+
+Ok, and here is the output:
+test k: constructing from scratch
+test l=k: type conversion into unsigned
+constructing from unsigned
+
+*/
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int count = 0;
+
+void die () { printf ("FAIL\n"); exit (1); }
+
+struct test {
+	test() { if (count != 0) die (); }
+
+	test(unsigned) {
+	  die ();
+	}
+	operator unsigned() {
+	  die ();
+	  return 0;
+	}
+};
+
+int
+main() {
+  test k;
+  test l=k;
+
+  printf ("PASS\n");
+
+  return 0;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy7.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy7.C
new file mode 100755
index 0000000..e2f4e7a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy7.C
@@ -0,0 +1,30 @@
+// GROUPS passed copy-ctors
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+void die () { printf ("FAIL\n"); exit (1); }
+
+class B {
+public:
+  B() {}
+  B(const B &) { printf ("PASS\n"); exit (0); };
+private:
+    int x;
+};
+
+class A : public B {
+public:
+    A() {}
+
+  A(const B &) { printf ("FAIL\n"); exit (1); }
+};
+
+int
+main()
+{
+    A a;
+    A b(a);
+
+    printf ("FAIL\n");
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy8.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy8.C
new file mode 100755
index 0000000..fe248ba
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy8.C
@@ -0,0 +1,67 @@
+// GROUPS passed copy-ctors
+/*
+This report is for GCC 2.3.3 running on a Sun/4.  The bug is that when
+a class instance is passed-by-value, GCC does not correctly copy the value.
+At the end of this report is an example program that demonstrates the bug.  
+It should print:
+
+	construct A('x')
+	copy A('x')
+	destruct A('x')
+	destruct A('x')
+
+and in fact does for IBM's xlC C++.  However, for GCC 2.3.3, it fails
+to print the second line ["copy A('x')"], which indicates that it failed
+to call the copy-constructor for class A when it should have.  Below is a 
+typescript that lists the program, shows how I compiled it, and shows the 
+incorrect output.
+*/
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int count = 0;
+
+void
+die (int x)
+{
+  if (x != ++count)
+    {
+      printf ("FAIL\n");
+      exit (1);
+    }
+}
+
+class A { // Class with explicit & instrumented copy-constructor and destructor.
+public:
+    const char * id;
+    A( const char * id1 ) : id(id1) { die (1); }
+
+    // Copy constructor
+    A( const A& a ) : id(a.id) { die (2); }
+
+    // Destructor
+    ~A() { count++; if (count != 3 && count != 4) die (-1); }
+};
+
+class X { // Class without explicit copy-constructor
+private:
+    A a;
+public:
+    X( const char * id ) : a(id) {}
+};
+
+void Func( X x ) {      // Function with call-by-value argument
+}
+
+int
+main() {
+    X x("x");           // Construct instance of x.
+
+    // The next line should call the copy-constructor for X since x is
+    // being passed by value.  For GCC 2.3.3 on a Sun/4, it does not.
+    Func(x);
+
+    printf ("PASS\n");
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy9.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy9.C
new file mode 100755
index 0000000..59fd228
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy9.C
@@ -0,0 +1,41 @@
+// GROUPS passed copy-ctors
+#include <iostream.h>
+
+// token types: from state parser
+const int T_EOF = 257;
+const int T_ERROR = 258;
+const int T_Float = 259;
+const int T_Int = 260;
+const int T_ID = 261;
+const int T_STRING = 262;
+
+class Complex;
+class State;
+
+// token, from state parser.
+class ParseToken {
+public:
+	int tok;
+	union {
+		char cval;
+		const char *sval;
+		int intval;
+		double  doubleval;
+		Complex* Complexval;
+		const State*  s;
+	}; 
+	ParseToken () { tok = 0; intval = 0;}
+};
+
+int
+main () {
+	ParseToken a;
+	a.tok = T_Float;
+	a.doubleval = 23.2;
+	ParseToken b(a);
+
+	if (b.doubleval == 23.2)
+	  cout << "PASS\n";
+	else
+	  cout << "FAIL\n";
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash1.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash1.C
new file mode 100755
index 0000000..66de235
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash1.C
@@ -0,0 +1,44 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class D_Interval;
+
+class Date
+{
+ public:
+  Date(const D_Interval*,const Date&);
+private:
+  const D_Interval* interval;
+};
+
+class Time_Interval
+{
+ public:
+   Time_Interval(const Date& start,const Date& stop);
+   const Date& Start() const { return start; }
+   const Date& Stop() const { return stop; }
+ private:
+   Date start;
+   Date stop;
+};
+
+class Dated_Data
+{
+ public:
+   Dated_Data(const Time_Interval& dates);
+   virtual ~Dated_Data();
+   Time_Interval Dates() const { return dates; }
+ private:
+   Time_Interval dates;
+};
+
+class Raw_Data : public Dated_Data
+{
+ public:
+   Raw_Data(const Dated_Data *source,const D_Interval& period);
+};
+
+Raw_Data::Raw_Data(const Dated_Data *source,const D_Interval& period)
+     : Dated_Data(Time_Interval(Date(&period,source->Dates().Start()),
+				Date(&period,source->Dates().Stop())))
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash10.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash10.C
new file mode 100755
index 0000000..6680718
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash10.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class word
+{
+  unsigned char b1, b2;
+public:
+  word (unsigned int i = 0) { b1 = i & 0xff; b2 = (i & 0xff00) >> 8; }
+  operator unsigned int () { return (b2 <<  8) + b1; }
+};
+
+class just_another
+{
+  int foo;
+  char bar[23];
+};
+
+int mumble(word w)
+{
+  just_another *jap;
+  unsigned bar;
+
+  bar = w;
+  
+  jap = new just_another [w];
+  
+  return 0;
+}  
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash11.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash11.C
new file mode 100755
index 0000000..a6c9226
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash11.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed old-abort
+extern "C" void printf (char *, ...);
+
+class A {
+	int	i;
+	int	j;
+    public:
+	int	h;
+	A() { i=10; j=20; }
+	virtual void f1() { printf("i=%d j=%d\n",i,j); }
+	friend virtual void f2() { printf("i=%d j=%d\n",i,j); }// ERROR -  virtual.*
+};
+
+class B : public A {
+    public:
+	virtual void f1() { printf("i=%d j=%d\n",i,j); }// ERROR -  member.*// ERROR -  member.*
+	friend virtual void f2() { printf("i=%d j=%d\n",i,j); }// ERROR -  virtual.*// ERROR -  member.*// ERROR -  member.*
+};
+
+int
+main() {
+	A * a = new A;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash12.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash12.C
new file mode 100755
index 0000000..0671c7b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash12.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class X
+{
+        int i;
+public:
+        X(int j);
+}
+
+X *x = new X[10]();// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash13.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash13.C
new file mode 100755
index 0000000..c375e9b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash13.C
@@ -0,0 +1,36 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class gen_op
+{
+public:
+  gen_op ( );
+  gen_op (const gen_op &Op1);
+  ~gen_op ( );
+  void operator = (const gen_op &Op1);
+};
+
+
+
+
+class spin_op 
+{
+public:
+  spin_op();
+  spin_op(const spin_op& SOp);
+  ~spin_op();
+  void operator= (const spin_op& SOp);
+  operator gen_op();
+};
+
+
+spin_op Fe();
+
+
+gen_op Spul_U_axis()
+{
+  gen_op U1;
+  U1 = Fe();
+}; // ERROR - reaches end of non-void function
+
+int
+main () {};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash14.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash14.C
new file mode 100755
index 0000000..dc28121
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash14.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed old-abort
+extern "C" void printf (char *, ...);
+
+
+class cl
+{
+  int i;
+public:
+  cl(int j = 0) {i = j;}
+  int get_i() {return i;}
+  };
+
+int
+main()
+{
+  cl ob[3] = {1, 2, 3};
+  int i;
+
+  for(i=0; i<3; i++)
+    printf("%d\n", ob[i].get_i());
+
+  return 0;
+  }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash15.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash15.C
new file mode 100755
index 0000000..56a7e75
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash15.C
@@ -0,0 +1,22 @@
+// Build don't link: 
+// GROUPS passed old-abort
+#include <iostream.h>
+
+class A {
+ public:
+  virtual ~A() {cout << "executed ~A()\n";};
+};
+
+class B : public A {
+ public:
+  virtual ~B() {cout << "executed ~B()\n";};
+};
+
+int
+main() {
+  cout << "starting\n";
+  B b;
+  b.~A();// ERROR -  destructor
+  cout << "done\n";
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash16.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash16.C
new file mode 100755
index 0000000..5030b29
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash16.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class Graph {
+public:
+      unsigned         char N;
+      Graph(void) {}; // ERROR - previously defined here
+}
+
+Graph::Graph(void)
+{    N = 10;// ERROR -  return type.*
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash17.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash17.C
new file mode 100755
index 0000000..7072eab
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash17.C
@@ -0,0 +1,35 @@
+// Build don't link: 
+// GROUPS passed old-abort
+//
+// This one creates
+//
+// gcc2: Internal compiler error: program cc1plus got fatal signal 11
+//
+// when compiled with g++.
+// The error goes away, if
+// 1) int ClassInvariant() is not virtual or
+// 2) GnObject has a virtual destructor or
+// 3) GnWidget has no virtual destructor or
+// 4) GnContracts has a virtual destructor
+//
+
+
+class GnContracts {
+  public:
+    virtual int ClassInvariant();
+//    virtual ~GnContracts();
+};
+
+class GnObject : public GnContracts {
+  public:
+//    virtual ~GnObject();
+};
+
+class GnWidget : public GnObject {
+  public:
+    virtual ~GnWidget();
+};
+
+class GnOptionGroup : public GnObject, public GnWidget {
+};// ERROR -  warning
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash18.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash18.C
new file mode 100755
index 0000000..d4a4c60
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash18.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed old-abort
+typedef int element;
+class Pix {
+public:
+    Pix();
+    Pix(const Pix&);
+
+    // Friend functions so that v == x works as does x == v works
+    friend int operator==(void *v, const Pix& x)
+        { return v == index; }// ERROR - .*
+    friend int operator==(void *v, const Pix& x)
+        { return v != index; }// ERROR - .*
+private:
+//    friend class List<T>;
+    element *index;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash19.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash19.C
new file mode 100755
index 0000000..1b8527d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash19.C
@@ -0,0 +1,1704 @@
+// Special g++ Options:
+// Build don't link: 
+// GROUPS passed old-abort
+typedef unsigned long _G_clock_t;
+typedef long _G_dev_t;
+typedef long int _G_fpos_t;
+typedef long _G_gid_t;
+typedef unsigned long _G_ino_t;
+typedef unsigned short _G_mode_t;
+typedef short _G_nlink_t;
+typedef long _G_off_t;
+typedef long _G_pid_t;
+typedef int _G_ptrdiff_t;
+typedef int   _G_sigset_t;
+typedef unsigned int _G_size_t;
+typedef long _G_time_t;
+typedef long _G_uid_t;
+typedef unsigned int _G_wchar_t;
+typedef int _G_ssize_t;
+typedef double * _G_va_list;
+class ostream; class streambuf; class backupbuf;
+extern "C" int __underflow(streambuf*);
+extern "C" int __overflow(streambuf*, int);
+typedef _G_off_t streamoff;
+typedef _G_off_t streampos;  
+typedef unsigned long __fmtflags;
+typedef unsigned char __iostate;
+struct _ios_fields {  
+    streambuf *_strbuf;
+    ostream* _tie;
+    int _width;
+    __fmtflags _flags;
+    _G_wchar_t _fill;
+    __iostate _state;
+    __iostate _exceptions;
+    int _precision;
+};
+enum state_value {
+    _good = 0 ,
+    _eof = 1 ,
+    _fail = 2 ,
+    _bad = 4  };
+enum open_mode {
+    input = 1 ,
+    output = 2 ,
+    atend = 4 ,
+    append = 8  };
+class ios : public _ios_fields {
+  public:
+    typedef __fmtflags fmtflags;
+    typedef int iostate;
+    typedef int openmode;
+    enum io_state {
+	goodbit = 0 ,
+	eofbit = 1 ,
+	failbit = 2 ,
+	badbit = 4  };
+    enum open_mode {
+	in = 1 ,
+	out = 2 ,
+	ate = 4 ,
+	app = 8 ,
+	trunc = 16 ,
+	nocreate = 32 ,
+	noreplace = 64 ,
+	bin = 128  };
+    enum seek_dir { beg, cur, end};
+    enum { skipws=01, left=02, right=04, internal=010,
+	   dec=020, oct=040, hex=0100,
+	   showbase=0200, showpoint=0400, uppercase=01000, showpos=02000,
+	   scientific=04000, fixed=010000, unitbuf=020000, stdio=040000,
+	   dont_close=0x80000000  
+	   };
+    enum {  
+	basefield=dec+oct+hex,
+	floatfield = scientific+fixed,
+	adjustfield = left+right+internal
+    };
+    ostream* tie() const { return _tie; }
+    ostream* tie(ostream* val) { ostream* save=_tie; _tie=val; return save; }
+    _G_wchar_t fill() const { return (_G_wchar_t)_fill; }
+    _G_wchar_t fill(_G_wchar_t newf)
+	{_G_wchar_t oldf = (_G_wchar_t)_fill; _fill = (char)newf; return oldf;}
+    fmtflags flags() const { return _flags; }
+    fmtflags flags(fmtflags new_val) {
+	fmtflags old_val = _flags; _flags = new_val; return old_val; }
+    int precision() const { return _precision; }
+    int precision(int newp) {
+	unsigned short oldp = _precision; _precision = (unsigned short)newp;
+	return oldp; }
+    fmtflags setf(fmtflags val) {
+	fmtflags oldbits = _flags;
+	_flags |= val; return oldbits; }
+    fmtflags setf(fmtflags val, fmtflags mask) {
+	fmtflags oldbits = _flags;
+	_flags = (_flags & ~mask) | (val & mask); return oldbits; }
+    fmtflags unsetf(fmtflags mask) {
+	fmtflags oldbits = _flags & mask;
+	_flags &= ~mask; return oldbits; }
+    int width() const { return _width; }
+    int width(int val) { int save = _width; _width = val; return save; }
+    void _throw_failure() { }
+    streambuf* rdbuf() const { return _strbuf; }
+    void clear(iostate state = 0) {
+	_state = _strbuf ? state : state|badbit;
+	if (_state & _exceptions) _throw_failure(); }
+    void set(iostate flag) { _state |= flag;
+	if (_state & _exceptions) _throw_failure(); }
+    int good() const { return _state == 0; }
+    int eof() const { return _state & ios::eofbit; }
+    int fail() const { return _state & (ios::badbit|ios::failbit); }
+    int bad() const { return _state & ios::badbit; }
+    iostate rdstate() const { return _state; }
+    operator void*() const { return fail() ? (void*)0 : (void*)(-1); }
+    int operator!() const { return fail(); }
+    iostate exception(iostate enable) {
+	iostate old = _exceptions; _exceptions = enable;
+	if (_state & _exceptions) _throw_failure();
+	return old; }
+    static int sync_with_stdio(int on);
+    static void sync_with_stdio() { sync_with_stdio(1); }
+    void unset(state_value flag) { _state &= ~flag; }
+    void close();
+    int is_open();
+    int readable();
+    int writable();
+  protected:
+    ios(streambuf* sb = 0, ostream* tie = 0);
+    virtual ~ios();
+    void init(streambuf* sb) { _state=0; _strbuf=sb; }
+};
+typedef ios::seek_dir _seek_dir;
+class streammarker {
+    friend class streambuf;
+    friend int __underflow(streambuf*);
+    struct streammarker *_next;   
+    streambuf *_sbuf;  
+    streampos _spos;  
+    void set_streampos(streampos sp) { _spos = sp; }
+    void set_offset(int offset) { _pos = offset; _spos = (streampos)(-2); }
+    int _pos;
+  public:
+    streammarker(streambuf *sb);
+    ~streammarker();
+    int saving() { return  _spos == -2; }
+    int delta(streammarker&);
+    int delta();
+};
+struct __streambuf {
+    int _flags;		 
+    char* _gptr;	 
+    char* _egptr;	 
+    char* _eback;	 
+    char* _pbase;	 
+    char* _pptr;	 
+    char* _epptr;	 
+    char* _base;	 
+    char* _ebuf;	 
+    struct streambuf *_chain;
+    friend class streammarker;
+    char *_other_gbase;  
+    char *_aux_limit;   
+    char *_other_egptr;  
+    streammarker *_markers;
+    unsigned short _cur_column;
+    char _unused;
+    char _shortbuf[1];
+};
+extern unsigned __adjust_column(unsigned start, const char *line, int count);
+struct streambuf : private __streambuf {
+    friend class ios;
+    friend class istream;
+    friend class ostream;
+    friend class streammarker;
+    friend int __underflow(streambuf*);
+  protected:
+    static streambuf* _list_all;  
+    streambuf*& xchain() { return _chain; }
+    void _un_link();
+    void _link_in();
+    char* gptr() const { return _gptr; }
+    char* pptr() const { return _pptr; }
+    char* egptr() const { return _egptr; }
+    char* epptr() const { return _epptr; }
+    char* pbase() const { return _pbase; }
+    char* eback() const { return _eback; }
+    char* base() const { return _base; }
+    char* ebuf() const { return _ebuf; }
+    int blen() const { return _ebuf - _base; }
+    void xput_char(char c) { *_pptr++ = c; }
+    int xflags() { return _flags; }
+    int xflags(int f) { int fl = _flags; _flags = f; return fl; }
+    void xsetflags(int f) { _flags |= f; }
+    void xsetflags(int f, int mask) { _flags = (_flags & ~mask) | (f & mask); }
+    void gbump(int n) { _gptr += n; }
+    void pbump(int n) { _pptr += n; }
+    void setb(char* b, char* eb, int a=0);
+    void setp(char* p, char* ep) { _pbase=_pptr=p; _epptr=ep; }
+    void setg(char* eb, char* g, char *eg) { _eback=eb; _gptr=g; _egptr=eg; }
+    char *shortbuf() { return _shortbuf; }
+    int in_backup() { return _flags & 0x100 ; }
+    char *Gbase() { return in_backup() ? _other_gbase : _eback; }
+    char *eGptr() { return in_backup() ? _other_egptr : _egptr; }
+    char *Bbase() { return in_backup() ? _eback : _other_gbase; }
+    char *Bptr() { return _aux_limit; }
+    char *eBptr() { return in_backup() ? _egptr : _other_egptr; }
+    char *Nbase() { return _other_gbase; }
+    char *eNptr() { return _other_egptr; }
+    int have_backup() { return _other_gbase != __null ; }
+    int have_markers() { return _markers != __null ; }
+    int _least_marker();
+    void switch_to_main_get_area();
+    void switch_to_backup_area();
+    void free_backup_area();
+    void unsave_markers();  
+    int put_mode() { return _flags & 0x800 ; }
+    int switch_to_get_mode();
+    streambuf(int flags=0);
+  public:
+    static int flush_all();
+    static void flush_all_linebuffered();  
+    virtual int underflow() = 0;  
+    virtual int overflow(int c = (-1) ) = 0;  
+    virtual int doallocate();
+    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
+    virtual streampos seekpos(streampos pos, int mode = ios::in|ios::out);
+    int seekmark(streammarker& mark, int delta = 0);
+    int sputbackc(char c);
+    int sungetc();
+    virtual ~streambuf();
+    int unbuffered() { return _flags & 2  ? 1 : 0; }
+    int linebuffered() { return _flags & 0x200  ? 1 : 0; }
+    void unbuffered(int i)
+	{ if (i) _flags |= 2 ; else _flags &= ~2 ; }
+    void linebuffered(int i)
+	{ if (i) _flags |= 0x200 ; else _flags &= ~0x200 ; }
+    int allocate() {  
+	if (base() || unbuffered()) return 0;
+	else return doallocate(); }
+    void allocbuf() { if (base() == __null ) doallocbuf(); }
+    void doallocbuf();
+    virtual int sync();
+    virtual int pbackfail(int c);
+    virtual streambuf* setbuf(char* p, int len);
+    int in_avail() { return _egptr - _gptr; }
+    int out_waiting() { return _pptr - _pbase; }
+    virtual int xsputn(const char* s, int n);
+    int sputn(const char* s, int n) { return xsputn(s, n); }
+    int padn(char pad, int n);  
+    virtual int xsgetn(char* s, int n);
+    int sgetn(char* s, int n) { return xsgetn(s, n); }
+    int ignore(int);
+    virtual int get_column();
+    virtual int set_column(int);
+    long sgetline(char* buf, _G_size_t n, char delim, int putback_delim);
+    int sbumpc() {
+	if (_gptr >= _egptr && __underflow(this) == (-1) ) return (-1) ;
+	else return *(unsigned char*)_gptr++; }
+    int sgetc() {
+	if (_gptr >= _egptr && __underflow(this) == (-1) ) return (-1) ;
+	else return *(unsigned char*)_gptr; }
+    int snextc() {
+	if (_gptr >= _egptr && __underflow(this) == (-1) ) return (-1) ;
+	return _gptr++, sgetc(); }
+    int sputc(int c) {
+	if (_pptr >= _epptr) return __overflow(this, (unsigned char)c);
+	else return *_pptr++ = c, (unsigned char)c; }
+    void stossc() { if (_gptr < _egptr) _gptr++; }
+    int vscan(char const *fmt0, _G_va_list ap, ios* stream = __null );
+    int scan(char const *fmt0 ...);
+    int vform(char const *fmt0, _G_va_list ap);
+    int form(char const *fmt0 ...);
+};
+class backupbuf : public streambuf {
+    friend class streammarker;
+  protected:
+    backupbuf(int flags=0) : streambuf(flags| 0x4000 ) { }
+  public:
+    virtual int pbackfail(int c);
+    virtual int underflow();
+    virtual int overflow(int c = (-1) );
+};
+struct __file_fields {
+    short _fileno;
+    int _blksize;
+    _G_fpos_t _offset;
+};
+class filebuf : public backupbuf {
+  protected:
+    struct __file_fields _fb;
+    void init();
+  public:
+    static const int openprot;  
+    filebuf();
+    filebuf(int fd);
+    filebuf(int fd, char* p, int len);
+    ~filebuf();
+    filebuf* attach(int fd);
+    filebuf* open(const char *filename, const char *mode);
+    filebuf* open(const char *filename, ios::openmode mode, int prot = 0664);
+    virtual int underflow();
+    virtual int overflow(int c = (-1) );
+    int is_open() const { return _fb._fileno >= 0; }
+    int fd() const { return is_open() ? _fb._fileno : (-1) ; }
+    filebuf* close();
+    virtual int doallocate();
+    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
+    virtual streambuf* setbuf(char* p, int len);
+    int xsputn(const char* s, int n);
+    int xsgetn(char* s, int n);
+    virtual int sync();
+  protected:  
+    int is_reading() { return eback() != egptr(); }
+    char* cur_ptr() { return is_reading() ?  gptr() : pptr(); }
+    char* file_ptr() { return eGptr(); }
+    int do_write(const char *data, int to_do);
+    int do_flush() { return do_write(_pbase, _pptr-_pbase); }// ERROR - 
+    virtual _G_ssize_t sys_read(char* buf, _G_size_t size);
+    virtual _G_fpos_t sys_seek(_G_fpos_t, _seek_dir);
+    virtual _G_ssize_t sys_write(const void*, long);
+    virtual int sys_stat(void*);  
+    virtual int sys_close();
+};
+inline ios::ios(streambuf* sb  , ostream* tie  ) {
+		_state = sb ? ios::goodbit : ios::badbit; _exceptions=0;
+		_strbuf=sb; _tie = tie; _width=0; _fill=' ';
+		_flags=ios::skipws|ios::dec; _precision=6; }
+inline ios::~ios() {
+    if (!(_flags & (unsigned int)ios::dont_close)) delete _strbuf; }
+class istream; class ostream;
+typedef ios& (*__manip)(ios&);
+typedef istream& (*__imanip)(istream&);
+typedef ostream& (*__omanip)(ostream&);
+extern istream& ws(istream& ins);
+extern ostream& flush(ostream& outs);
+extern ostream& endl(ostream& outs);
+extern ostream& ends(ostream& outs);
+class ostream : virtual public ios
+{
+    void do_osfx();
+  public:
+    ostream() { }
+    ostream(streambuf* sb, ostream* tied=__null );
+    int opfx() {
+	if (!good()) return 0; else { if (_tie) _tie->flush(); return 1;} }
+    void osfx() { if (flags() & (ios::unitbuf|ios::stdio))
+		      do_osfx(); }
+    streambuf* ostreambuf() const { return _strbuf; }
+    ostream& flush();
+    ostream& put(char c) { _strbuf->sputc(c); return *this; }
+    ostream& put(unsigned char c) { return put((char)c); }
+    ostream& write(const char *s, int n);
+    ostream& write(const unsigned char *s, int n) { return write((const char*)s, n);}
+    ostream& put(signed char c) { return put((char)c); }
+    ostream& write(const signed char *s, int n) { return write((const char*)s, n);}
+    ostream& write(const void *s, int n) { return write((const char*)s, n);}
+    ostream& seekp(streampos);
+    ostream& seekp(streamoff, _seek_dir);
+    streampos tellp();
+    ostream& form(const char *format ...);
+    ostream& vform(const char *format, _G_va_list args);
+    ostream& operator<<(char c);
+    ostream& operator<<(unsigned char c) { return (*this) << (char)c; }
+    ostream& operator<<(signed char c) { return (*this) << (char)c; }
+    ostream& operator<<(const char *s);
+    ostream& operator<<(const unsigned char *s)
+	{ return (*this) << (const char*)s; }
+    ostream& operator<<(const signed char *s)
+	{ return (*this) << (const char*)s; }
+    ostream& operator<<(void *p);
+    ostream& operator<<(int n);
+    ostream& operator<<(unsigned int n);
+    ostream& operator<<(long n);
+    ostream& operator<<(unsigned long n);
+    ostream& operator<<(long long n);
+    ostream& operator<<(unsigned long long n);
+    ostream& operator<<(short n) {return operator<<((int)n);}
+    ostream& operator<<(unsigned short n) {return operator<<((unsigned int)n);}
+    ostream& operator<<(double n);
+    ostream& operator<<(float n) { return operator<<((double)n); }
+    ostream& operator<<(__omanip func) { return (*func)(*this); }
+    ostream& operator<<(__manip func) {(*func)(*this); return *this;}
+    ostream& operator<<(streambuf*);
+};
+class istream : virtual public ios
+{
+    _G_ssize_t _gcount;
+    int _skip_ws();
+  public:
+    istream() { _gcount = 0; }
+    istream(streambuf* sb, ostream*tied=__null );
+    streambuf* istreambuf() const { return _strbuf; }
+    istream& get(char* ptr, int len, char delim = '\n');
+    istream& get(unsigned char* ptr, int len, char delim = '\n')
+	{ return get((char*)ptr, len, delim); }
+    istream& get(char& c);
+    istream& get(unsigned char& c) { return get((char&)c); }
+    istream& getline(char* ptr, int len, char delim = '\n');
+    istream& getline(unsigned char* ptr, int len, char delim = '\n')
+	{ return getline((char*)ptr, len, delim); }
+    istream& get(signed char& c)  { return get((char&)c); }
+    istream& get(signed char* ptr, int len, char delim = '\n')
+	{ return get((char*)ptr, len, delim); }
+    istream& getline(signed char* ptr, int len, char delim = '\n')
+	{ return getline((char*)ptr, len, delim); }
+    istream& read(char *ptr, int n);
+    istream& read(unsigned char *ptr, int n) { return read((char*)ptr, n); }
+    istream& read(signed char *ptr, int n) { return read((char*)ptr, n); }
+    istream& read(void *ptr, int n) { return read((char*)ptr, n); }
+    istream& get(streambuf& sb, char delim = '\n');
+    istream& gets(char **s, char delim = '\n');
+    int ipfx(int need) {
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie && (need == 0 || rdbuf()->in_avail() < need)) _tie->flush();
+	if (!need && (flags() & ios::skipws)) return _skip_ws();
+	return 1;
+    }
+    int ipfx0() {  
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie) _tie->flush();
+	if (flags() & ios::skipws) return _skip_ws();
+	return 1;
+    }
+    int ipfx1() {  
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie && rdbuf()->in_avail() == 0) _tie->flush();
+	return 1;
+    }
+    int get() { if (!ipfx1()) return (-1) ;
+		int ch = _strbuf->sbumpc();
+		if (ch == (-1) ) set(ios::eofbit);
+		return ch; }
+    int peek() { if (!ipfx1()) return (-1) ;
+		int ch = _strbuf->sgetc();
+		if (ch == (-1) ) set(ios::eofbit);
+		return ch; }
+    _G_ssize_t gcount() { return _gcount; }
+    istream& ignore(int n=1, int delim = (-1) );
+    istream& seekg(streampos);
+    istream& seekg(streamoff, _seek_dir);
+    streampos tellg();
+    istream& putback(char ch) {
+	if (good() && _strbuf->sputbackc(ch) == (-1) ) clear(ios::badbit);
+	return *this;}
+    istream& unget() {
+	if (good() && _strbuf->sungetc() == (-1) ) clear(ios::badbit);
+	return *this;}
+    istream& scan(const char *format ...);
+    istream& vscan(const char *format, _G_va_list args);
+    istream& unget(char ch) { return putback(ch); }
+    int skip(int i);
+    istream& operator>>(char*);
+    istream& operator>>(unsigned char* p) { return operator>>((char*)p); }
+    istream& operator>>(signed char*p) { return operator>>((char*)p); }
+    istream& operator>>(char& c);
+    istream& operator>>(unsigned char& c) {return operator>>((char&)c);}
+    istream& operator>>(signed char& c) {return operator>>((char&)c);}
+    istream& operator>>(int&);
+    istream& operator>>(long&);
+    istream& operator>>(long long&);
+    istream& operator>>(short&);
+    istream& operator>>(unsigned int&);
+    istream& operator>>(unsigned long&);
+    istream& operator>>(unsigned long long&);
+    istream& operator>>(unsigned short&);
+    istream& operator>>(float&);
+    istream& operator>>(double&);
+    istream& operator>>( __manip func) {(*func)(*this); return *this;}
+    istream& operator>>(__imanip func) { return (*func)(*this); }
+    istream& operator>>(streambuf*);
+};
+class iostream : public istream, public ostream
+{
+    _G_ssize_t _gcount;
+  public:
+    iostream() { _gcount = 0; }
+    iostream(streambuf* sb, ostream*tied=__null );
+};
+extern istream cin;
+extern ostream cout, cerr, clog;  
+struct Iostream_init { } ;   
+inline ios& dec(ios& i)
+{ i.setf(ios::dec, ios::dec|ios::hex|ios::oct); return i; }
+inline ios& hex(ios& i)
+{ i.setf(ios::hex, ios::dec|ios::hex|ios::oct); return i; }
+inline ios& oct(ios& i)
+{ i.setf(ios::oct, ios::dec|ios::hex|ios::oct); return i; }
+extern char* form(const char*, ...);
+extern char* dec(long, int=0);
+extern char* dec(int, int=0);
+extern char* dec(unsigned long, int=0);
+extern char* dec(unsigned int, int=0);
+extern char* hex(long, int=0);
+extern char* hex(int, int=0);
+extern char* hex(unsigned long, int=0);
+extern char* hex(unsigned int, int=0);
+extern char* oct(long, int=0);
+extern char* oct(int, int=0);
+extern char* oct(unsigned long, int=0);
+extern char* oct(unsigned int, int=0);
+inline istream& WS(istream& str) { return ws(str); }
+typedef double *__gnuc_va_list;
+extern "C" {
+   typedef struct {
+	int		 __cnt;
+	unsigned char	*__ptr;
+	unsigned char	*__base;
+	unsigned short	 __flag;
+	unsigned char 	 __fileL;		 
+	unsigned char 	 __fileH;		 
+   } FILE;
+   typedef struct {
+	int		 __cnt;
+	unsigned char	*__ptr;
+	unsigned char	*__base;
+	unsigned short	 __flag;
+	unsigned char 	 __fileL;		 
+	unsigned char 	 __fileH;		 
+	unsigned char	*__bufendp;	 
+	unsigned char	 __smbuf[8 ];  
+   } _FILEX;
+     typedef unsigned int size_t;
+   typedef long int fpos_t;
+     typedef double *__va_list;
+   extern FILE __iob[];
+     extern int remove(const char *);
+     extern int rename(const char *, const char *);
+     extern FILE *tmpfile(void);
+     extern char *tmpnam(char *);
+     extern int fclose(FILE *);
+     extern int fflush(FILE *);
+     extern FILE *fopen(const char *, const char *);
+     extern FILE *freopen(const char *, const char *, FILE *);
+     extern void setbuf(FILE *, char *);
+     extern int setvbuf(FILE *, char *, int, size_t);
+     extern int fprintf(FILE *, const char *, ...);
+     extern int fscanf(FILE *, const char *,...);
+     extern int printf(const char *,...);
+     extern int scanf(const char *,...);
+     extern int sprintf(char *, const char *,...);
+     extern int sscanf(const char *, const char *,...);
+     extern int vprintf(const char *, __va_list);
+     extern int vfprintf(FILE *, const char *, __va_list);
+     extern int vsprintf(char *, const char *, __va_list);
+     extern int fgetc(FILE *);
+     extern char *fgets(char *, int, FILE *);
+     extern int fputc(int, FILE *);
+     extern int fputs(const char *, FILE *);
+     extern int getc(FILE *);
+     extern int getchar(void);
+     extern char *gets(char *);
+     extern int putc(int, FILE *);
+     extern int putchar(int);
+     extern int puts(const char *);
+     extern int ungetc(int, FILE *);
+     extern int fgetpos(FILE *, fpos_t *);
+     extern int fseek(FILE *, long int, int);
+     extern int fsetpos(FILE *, const fpos_t *);
+     extern long int ftell(FILE *);
+     extern void rewind(FILE *);
+     extern void clearerr(FILE *);
+     extern int feof(FILE *);
+     extern int ferror(FILE *);
+     extern void perror(const char *);
+       extern size_t fread(void *, size_t, size_t, FILE *);
+       extern size_t fwrite(const void *, size_t, size_t, FILE *);
+     extern int __flsbuf(unsigned char, FILE *);
+     extern int __filbuf(FILE *);
+     extern int fileno(FILE *);
+     extern FILE *fdopen(int, const char *);
+     extern int getw(FILE *);
+     extern int putw(int, FILE *);
+     extern int pclose(FILE *);
+     extern FILE *popen(const char *, const char *);
+     extern char *tempnam(const char *, const char *);
+     extern char *ctermid(char *);
+     extern char *cuserid(char *);
+     extern int nl_fprintf(FILE *, const char * ,...);
+     extern int nl_fscanf(FILE *, const char * ,...);
+     extern int nl_printf(const char * ,...);
+     extern int nl_scanf(const char * ,...);
+     extern int nl_sprintf(char *, const char * ,...);
+     extern int nl_sscanf(const char *, const char * ,...);
+   extern unsigned char *__bufendtab[];
+}
+extern "C" {
+   extern int __nl_char_size;
+   typedef struct {
+	int quot;	 
+	int rem;	 
+   } div_t;
+   typedef struct {
+	long int quot;	 
+	long int rem;	 
+   } ldiv_t;
+     typedef unsigned int wchar_t;
+       extern double atof(const char *);
+     extern int atoi(const char *);
+     extern long int atol(const char *);
+     extern double strtod(const char *, char **);
+     extern long int strtol(const char *, char **, int);
+     extern unsigned long int strtoul(const char *, char **, int);
+     extern int rand(void);
+     extern void srand(unsigned int);
+     extern int atexit(void (*) (void));
+     extern void exit(int);
+     extern char *getenv(const char *);
+     extern int system(const char *);
+       inline int abs(int d) { return (d>0)?d:-d; }
+     extern div_t div(int, int);
+     extern ldiv_t ldiv(long int, long int);
+     extern long int labs(long int);
+     extern int mblen(const char *, size_t);
+     extern int mbtowc(wchar_t *, const char *, size_t);
+     extern int wctomb(char *, wchar_t);
+     extern size_t mbstowcs(wchar_t *, const char *, size_t);
+     extern size_t wcstombs(char *, const wchar_t *, size_t);
+     extern void free(void *);
+     extern void qsort(void *, size_t, size_t, int (*)(const void *, const void *));
+       extern void abort(void);
+       extern void *bsearch(const void *, const void *, size_t, size_t, int (*) (const void *, const void *));
+       extern void *calloc(size_t, size_t);
+       extern void *malloc(size_t);
+       extern void *realloc(void *, size_t);
+     extern void setkey(const char *);
+     extern void lcong48( unsigned short [] );
+     extern double wcstod( const wchar_t *, wchar_t ** );
+     extern long wcstol( const wchar_t *, wchar_t **, int );
+     extern unsigned long wcstoul( const wchar_t *, wchar_t **, int );
+     extern double drand48(void);
+     extern double erand48(unsigned short []);
+     extern long jrand48(unsigned short []);
+     extern long lrand48(void);
+     extern long mrand48(void);
+     extern long nrand48(unsigned short []);
+     extern void srand48(long);
+     extern unsigned short *seed48(unsigned short []);
+     extern int putenv(const char *);
+    extern int clearenv(void);
+    extern int getopt(int, char * const [], const char *);
+    extern char *getpass(const char *);
+  extern char *optarg;
+  extern int optind;
+  extern int opterr;
+  struct mallinfo  {
+	int arena;	 
+	int ordblks;	 
+	int smblks;	 
+	int hblks;	 
+	int hblkhd;	 
+	int usmblks;	 
+	int fsmblks;	 
+	int uordblks;	 
+	int fordblks;	 
+	int keepcost;	 
+  };	
+     typedef struct {
+       unsigned int word1, word2, word3, word4;
+     } long_double;
+extern "C" {
+     typedef long gid_t;
+     typedef long uid_t;
+   struct passwd {
+	char	*pw_name;
+	char 	*pw_passwd;
+	uid_t	pw_uid;
+	gid_t	pw_gid;
+	char 	*pw_age;
+	char	*pw_comment;
+	char	*pw_gecos;
+	char	*pw_dir;
+	char	*pw_shell;
+	long	pw_audid;
+	int	pw_audflg;
+   };
+     extern struct passwd *getpwuid(uid_t);
+     extern struct passwd *getpwnam(const char *);
+   struct s_passwd {
+       char    *pw_name;
+       char    *pw_passwd;
+       char    *pw_age;
+       long     pw_audid;
+       int     pw_audflg;
+   };
+   struct comment {
+	char	*c_dept;
+	char	*c_name;
+	char	*c_acct;
+	char	*c_bin;
+   };
+     extern void setpwent(void);
+     extern void endpwent(void);
+     extern struct passwd *getpwent(void);
+     extern struct passwd *fgetpwent(FILE *);
+     extern struct s_passwd *getspwent(void);
+     extern struct s_passwd *getspwuid(int);
+     extern struct s_passwd *getspwaid(int);
+     extern struct s_passwd *getspwnam(char *);
+     extern struct s_passwd *fgetspwent(FILE *);
+}
+extern int errno;
+     extern "C" {
+         extern int errno;
+     }
+extern "C" {
+    extern void perror(const char*);
+    extern int sys_nerr;
+    extern char *sys_errlist[];
+    extern char *strerror (int);
+}
+     extern const char *fcvt(double, size_t, int *, int *);
+     extern char *gcvt(double, size_t, char *);
+     extern char *ecvt(double, size_t, int *, int *);
+     extern char *nl_gcvt(double, size_t, char *, int);
+     extern char *_ldecvt(long_double, size_t, int *, int *);
+     extern char *_ldfcvt(long_double, size_t, int *, int *);
+     extern char *_ldgcvt(long_double, size_t, char *);
+     extern int getpw(int, char *);
+     extern long a64l(const char *);
+     extern char *l64a(long);
+     extern void l3tol(long *, const char *, int);
+     extern void ltol3(char *, const long *, int);
+     extern char *getmsg(int, int, int, char *, int);
+     extern double nl_atof(const char *, int);
+     extern double nl_strtod(const char *, char **, int);
+     extern char *ltostr(long, int);
+     extern char *ultostr(unsigned long, int);
+     extern char *ltoa(long);
+     extern char *ultoa(unsigned long);
+     extern void memorymap(int);
+     extern struct mallinfo mallinfo(void);
+     extern int mallopt(int, int);
+}
+typedef void * POINTER;
+typedef FILE * FILE_PTR;
+typedef void (*DISPLAYER)   (POINTER obj, FILE_PTR fp, FILE_PTR errorFile)  ;
+typedef void (*DESTROYER)   (POINTER obj, FILE_PTR errorFile)  ;
+typedef void (*RCOUNT_INC)  (POINTER obj, FILE_PTR errorFile)  ;
+typedef int  (*COMPARE)     (POINTER obj1, POINTER obj2)  ;
+typedef	unsigned long (*HASH_ADDR)  (POINTER obj, FILE_PTR errorFile)  ;
+typedef	unsigned long (*HASH_SKIP)  (POINTER obj, FILE_PTR errorFile)  ;
+typedef POINTER
+	(*ACCESS_FCT)  (POINTER target, POINTER sample, FILE_PTR errorFile)  ;
+typedef POINTER DATA_PTR;
+     typedef long dev_t;		 
+     typedef unsigned long ino_t;	 
+     typedef unsigned short mode_t; 	 
+     typedef short nlink_t;		 
+     typedef long off_t;		 
+     typedef long pid_t;		 
+     typedef long time_t;		 
+      typedef int ssize_t;		 
+     typedef unsigned short __site_t;	 
+     typedef unsigned short __cnode_t;	 
+     typedef unsigned long clock_t;	 
+      typedef long key_t;		 
+   typedef unsigned short __ushort;	 
+   typedef long	__daddr_t;		 
+   typedef char *__caddr_t;		 
+   typedef long __swblk_t;
+   typedef unsigned char	u_char;	    
+   typedef unsigned short	u_short;    
+   typedef unsigned int		u_int;      
+   typedef unsigned long	u_long;     
+   typedef unsigned int		uint;	    
+   typedef unsigned short	ushort;	    
+   typedef __swblk_t		swblk_t;
+   typedef __daddr_t		daddr_t;
+   typedef __site_t		site_t;
+   typedef __cnode_t		cnode_t;
+     typedef __caddr_t		caddr_t;    
+   typedef long			paddr_t;
+   typedef short		cnt_t;
+   typedef unsigned int		space_t;
+   typedef unsigned int    	prot_t;
+   typedef unsigned long        cdno_t;
+   typedef unsigned short	use_t;
+   typedef struct _physadr { int r[1]; } *physadr;
+   typedef struct _quad { long val[2]; } quad;
+     typedef short cpu_t;
+     typedef struct label_t {
+	int	lbl_rp;
+       	int	lbl_sp;
+       	int	lbl_s[17];
+       	int	lbl_ss[1];
+	double	lbl_sf[4];
+     } label_t;
+   typedef char *dm_message;
+      typedef long	aid_t;
+   typedef pid_t		sid_t;	    
+     typedef long fd_mask;
+     typedef struct fd_set {
+       fd_mask fds_bits[ (((       2048   )+((  (sizeof(fd_mask) * 8)      )-1))/(  (sizeof(fd_mask) * 8)      )) ];
+     } fd_set;
+POINTER malloc  (size_t size )  ;
+POINTER calloc  (size_t n , size_t size )  ;
+void  free  (POINTER c )  ;
+void mem_report  (void )  ;
+typedef  int         BOOLEAN;
+typedef enum
+{
+  eNoErrors			= -1,
+  eUnknownProcessingError       = 0,
+  eAlgorithmFailure		= 100,
+  eAlreadyLocked                = 200,
+  eAttCount			= 300,
+  eAttRedefinition		= 400,
+  eBasicMatrixError		= 500,
+  eBadAddress			= 600,
+  eBadAttribute			= 700,
+  eBadFileNumber		= 800,
+  eBadMode			= 900,
+  eBadVersion			= 1000,
+  eColumnError			= 1100,
+  eConstraintError		= 1200,
+  eLBConstraintError		= 1300,
+  eUBConstraintError		= 1400,
+  eDatabaseError		= 1500,
+  eDataExists			= 1600,
+  eDataNotFound			= 1700,
+  eDictError			= 1800,
+  eDiffAtt			= 1900,
+  eDomain			= 2000,
+  eDuplicateAtt			= 2100,
+  eDuplicateKey			= 2200,
+  eElementMismatch		= 2300,
+  eEmptyAtt			= 2400,
+  eEmptyDict			= 2450,
+  eEmptyLink			= 2500,
+  eEmptyQueue			= 2600,
+  eEmptyStack			= 2700,
+  eEntityExists			= 2800,
+  eEntityNotFound		= 2900,
+  eEtaComputeError		= 3000,
+  eEtaFileError			= 3100,
+  eEtaInverseConsistency	= 3200,
+  eFileExists			= 3300,
+  eFileNotFound			= 3400,
+  eFunctionMismatch		= 3500,
+  eFunctionNotAvailable		= 3600,
+  eFunctionNotFound		= 3700,
+  eFunctionTypeConflict		= 3800,
+  eGraphError			= 3900,
+  eIllegalBMatrixOp		= 4000,
+  eIllegalData			= 4100,
+  eIllegalDeletion		= 4200,
+  eIllegalDictOp		= 4300,
+  eIllegalEtaFileOp		= 4400,
+  eIllegalFunctionRequest	= 4500,
+  eIllegalFunctionType		= 4600,
+  eIllegalGraphOp		= 4700,
+  eIllegalGraphType		= 4800,
+  eIllegalIndex			= 4900,
+  eIllegalInsertion		= 5000,
+  eIllegalListOp		= 5100,
+  eIllegalLPTokenOp		= 5200,
+  eIllegalLPTokenType		= 5300,
+  eIllegalMatrixOp		= 5400,
+  eIllegalMatrixSize		= 5500,
+  eIllegalMatrixState		= 5600,
+  eIllegalMatrixType		= 5700,
+  eIllegalNBMatrixOp		= 5800,
+  eIllegalOperation		= 5900,
+  eIllegalOption		= 6000,
+  eIllegalOverload		= 6100,
+  eIllegalSeek			= 6200,
+  eIllegalType			= 6300,
+  eIllegalVectorOp		= 6400,
+  eIllegalVectorType		= 6500,
+  eIllFormedADT			= 6600,
+  eInconsistentData		= 6700,
+  eInternalError		= 6800,
+  eInUse			= 6900,
+  eInvalidArgument		= 7000,
+  eInvalidAtt			= 7100,
+  eInvalidData			= 7200,
+  eInvalidIndex			= 7300,
+  eInvalidMatrixOp		= 7400,
+  eInvalidOperation		= 7500,
+  eInvalidOption		= 7600,
+  eInvalidParam			= 7700,
+  eInvalidVectorOp		= 7800,
+  eKeyNotFound			= 7900,
+  eLinkNotEmpty			= 8000,
+  eListError			= 8100,
+  eLockAccess			= 8200,
+  eLockExists			= 8300,
+  eLockNotFound			= 8400,
+  eLockReadOnly			= 8500,
+  eLockTrunc			= 8600,
+  eLPTokenError			= 8700,
+  eLPTokenMisuse		= 8800,
+  eMatrixError			= 8900,
+  eMatrixMismatch		= 9000,
+  eMatrixMultiplicationError	= 9100,
+  eMissingData			= 9200,
+  eMysteryError			= 9300,
+  eNameTooLong			= 9400,
+  eNeverLocked			= 9500,
+  eNoAccess			= 9600,
+  eNoLockReq			= 9800,
+  eNoMoreAtt			= 9900,
+  eNoMoreElements		= 10000,
+  eNonBasicMatrixError		= 10100,
+  eNonInvertibleMatrix		= 10200,
+  eNonsenseData			= 10300,
+  eNoSuchKey			= 10400,
+  eNotEnoughSpace		= 10500,
+  eNotFetched			= 10600,
+  eNotLocked			= 10700,
+  eNotSupported			= 10800,
+  eNullPointer			= 10900,
+  eNullInternalPointer		= 11000,
+  eNullCompare			= 11050,
+  eNullData			= 11070,
+  eNullDestroyer		= 11100,
+  eNullDisplayer		= 11200,
+  eNullFunction			= 11300,
+  eRemove			= 11400,
+  eRoundoff			= 11500,
+  eQueueNotEmpty		= 11600,
+  eSparseGraphError		= 11700,
+  eStackError			= 11800,
+  eStackNotEmpty		= 11900,
+  eTLRSProceduralError		= 12000,
+  eTooManyAtt			= 12100,
+  eTooManyLocks			= 12200,
+  eTypeConflict			= 12300,
+  eUnexpectedType		= 12400,
+  eUnixError			= 12500,
+  eVectorMismatch		= 12600,
+  eProcessingError		= 15000, 
+  eActionKludge			= 15100,
+  eNotImplemented		= 15200,
+  eNotStable			= 15300,
+  eNotReleased			= 15400,
+  eBeingWorkedOn		= 15500
+} eErrorState;
+extern "C" {
+extern	eErrorState	spider_errno;
+extern	char		err_string[];
+POINTER mallocate  (size_t n )  ;
+size_t pagesize  (void )  ;
+POINTER page_mallocate  (void )  ;
+POINTER make_memory_token  (int size , int page_cnt, const char *name)  ;
+POINTER mem_malloc  (POINTER mptr )  ;
+void mem_free  (POINTER mptr , POINTER obj )  ;
+const char *get_double_string  (char *buffer , double num )  ;
+int spider_strcat  (const char *proc , char *str1 , const char *str2 , int maxlen )  ;
+void init_errors  (void )  ;
+void append_abort  (const char *proc )  ;
+void append_message  (const char *proc , const char *msg )  ;
+void set_errno  (eErrorState err )  ;
+void spider_perror  (const char *proc , FILE_PTR errorFile )  ;
+void append_not_implemented  (const char *proc , int *target_errno )  ;
+const char *GetBooleanString  (BOOLEAN bool )  ;// ERROR - use of bool as identifier
+double truncate_value  (double x , double epsilon )  ;
+double log2  (double x )  ;
+int ceil_log2  (double x )  ;
+int floor_log2  (double x )  ;
+}
+extern "C" {
+extern  char char80[], char128[], char160[], char512[];
+extern  char char1000[], char2000[];
+extern  char char320[];	 
+BOOLEAN Get_EM_StderrFlag  (void )  ;
+void Set_EM_StderrFlag  (BOOLEAN printToStderr )  ;
+void CheckReleaseState  (eErrorState releaseState , const char *procName, 			  FILE_PTR errorFile )  ;
+void PrintErrorString  (const char *errorString , FILE_PTR errorFile )  ;
+const char *get_error_header  (eErrorState errorState )  ;
+void print_error_header  (eErrorState errorState , FILE_PTR errorFile )  ;
+void PrintErrorMessage  (eErrorState errorState , const char *message , 			  FILE_PTR errorFile )  ;
+}
+extern "C" {
+extern short show_increment_rcount;
+extern int errno;
+extern int bmk_errno;
+extern int ck_errno;
+extern int db_errno;
+extern int dict_errno;
+extern int glh_errno;
+extern int graph_errno;
+extern int hash_errno;
+extern int link_errno;
+extern int lp_errno;
+extern int matrix_errno;
+extern int nbmk_errno;
+extern int network_errno;
+extern int queue_errno;
+extern int set_kernel_errno;
+extern int stack_errno;
+}
+extern "C" {
+const char *spider_version_string  (void )  ;
+int  spider_version  (void )  ;
+const char *spider_errstring  (void )  ;
+void append_perror  (const char *s )  ;
+void unix_perror  (const char *s )  ;
+}
+typedef struct node a_dict_node, * DICT_NODE;
+struct node {
+	POINTER info;		 
+	DICT_NODE left;		 
+	DICT_NODE right;	 
+	DICT_NODE prev;		 
+	DICT_NODE next;		 
+};
+typedef struct tree a_dict, * DICT;
+struct tree {
+	int	  size;			 
+	COMPARE   comp; 		 
+	DICT_NODE header;		 
+	DICT_NODE last_accessed;	 
+	DICT_NODE list_head;		 
+	DICT_NODE list_tail;		 
+};
+typedef enum { PREORDER = -1, INORDER, POSTORDER } traversal_t;
+extern "C" {
+void dict_set_nopages  (int desired_nopages )  ;
+void dict_err  (void )  ;
+const char *traversal_string  (traversal_t tr )  ;
+DICT make_dictionary  (COMPARE cmp )  ;
+int dict_insert  (POINTER item , DICT dict )  ;
+int dict_delete  (POINTER item , DICT dict )  ;
+POINTER dict_access  (POINTER item , DICT dict )  ;
+POINTER dict_low  (DICT dict )  ;
+POINTER dict_nlow  (DICT dict )  ;
+POINTER dict_big  (DICT dict )  ;
+POINTER dict_nbig  (DICT dict )  ;
+POINTER dict_first  (DICT dict )  ;
+POINTER dict_next  (DICT dict )  ;
+POINTER dict_last  (DICT dict )  ;
+POINTER dict_prev  (DICT dict )  ;
+int clear_dictionary  (DICT dict , DESTROYER destroy , FILE *errorFile )  ;
+int dict_size  (const a_dict *dict )  ;
+POINTER dict_elem  (int index , DICT dict )  ;
+int dict_compare  (DICT d1 , DICT d2 )  ;
+DICT dict_copy  (DICT di , COMPARE cmp )  ;
+int dict_change_compare  (DICT di , COMPARE cmp )  ;
+int dict_height  (DICT di )  ;
+void dict_print_stats  (FILE *fp , DICT di )  ;
+void dict_print  (FILE *fp , DICT di , traversal_t tr , DISPLAYER display )  ;
+const char *dict_version  (void )  ;
+void init_dict_errors  (void )  ;
+const char *dict_errstring  (void )  ;
+void dict_append_perror  (const char *s )  ;
+void dict_perror  (const char *s )  ;
+extern int  dict_errno;
+}
+typedef struct q_item {
+  struct q_item *next;
+  POINTER data;
+} a_q_item, *Q_ITEM;
+typedef struct {
+  int rcount;
+  Q_ITEM first;
+  Q_ITEM last;
+  int count;
+} a_queue, *QUEUE;
+extern "C" {
+void queue_err  (void)  ;
+void queue_set_nopages  (int desired_nopages)  ;
+QUEUE make_queue  (void )  ;
+POINTER queue_look  (const a_queue * Q )  ;
+POINTER queue_last  (const a_queue * Q )  ;
+POINTER queue_remove  (QUEUE Q )  ;
+int queue_append  (QUEUE Q , POINTER data )  ;
+int queue_size  (const a_queue * Q )  ;
+void queue_destroy  (POINTER ptr , FILE_PTR errorFile )  ;
+void IncrementQRCount  (POINTER ptr , FILE_PTR errorFile )  ;
+const char *queue_version  (void )  ;
+void init_queue_errors  (void )  ;
+const char *queue_errstring  (void )  ;
+void queue_append_perror  (const char *s )  ;
+void queue_perror  (const char *s )  ;
+extern int queue_errno;
+}
+typedef struct s_item {
+  struct s_item *next;
+  POINTER data;
+} a_s_item, *S_ITEM;
+typedef struct stack {
+  int rcount;
+  S_ITEM top;
+  int count;
+} a_stack, *STACK;
+extern "C" {
+void stack_err  (void)  ;
+void stack_set_nopages  (int desired_nopages)  ;
+STACK make_stack  (void )  ;
+POINTER stack_look  (const a_stack * S )  ;
+POINTER stack_pop  (STACK S )  ;
+int stack_push  (STACK S , POINTER data )  ;
+int stack_size  (const a_stack * S )  ;
+void stack_destroy  (POINTER ptr , FILE_PTR errorFile )  ;
+void IncrementSRCount  (POINTER ptr , FILE_PTR errorFile )  ;
+const char *stack_version  (void )  ;
+void init_stack_errors  (void )  ;
+const char *stack_errstring  (void )  ;
+void stack_append_perror  (const char *s )  ;
+void stack_perror  (const char *s )  ;
+extern int stack_errno;
+}
+typedef const char *(*STRINGER)(const void *ptr);
+int default_compare(const void *p1, const void *p2);
+void default_displayer(const void *ptr, FILE *fp, FILE *errorFile);
+const char *default_stringer(const void *ptr);
+const char *object_stringer(const void *ptr);
+class object {
+	static long current_id;
+	static long next_id();
+protected:
+	void display2(ostream &fp = cout) const;
+	long id;
+public:
+	object()                  { id = next_id(); }
+	object(const object &obj) { id = next_id(); }
+	virtual ~object()
+	{
+		if (799  >=  999 ) cout <<   "~object() executing..."  << '\n'; ;
+	}
+	object & operator = (const object & obj)
+	{
+		return( *this );
+	}
+	virtual int compare(const void *p2) const;
+	virtual void display(ostream & fp = cout) const
+	{
+		display2(fp);
+	}
+	operator char *() const;
+};
+ostream & operator << (ostream & fp, object & obj);
+int operator < (object & obj1, object & obj2);
+int operator <= (object & obj1, object & obj2);
+int operator > (object & obj1, object & obj2);
+int operator >= (object & obj1, object & obj2);
+int operator == (object & obj1, object & obj2);
+int operator != (object & obj1, object & obj2);
+void null_destroy(void *p, FILE *errorFile);
+void object_destroy(void *p, FILE *errorFile);
+int  object_compare(const void *p1, const void *p2);
+void object_display(const void *p, FILE *fp, FILE *errorFile);
+class dict : public object {
+	class internal {
+	public:
+		DICT di;
+		int errno;
+		COMPARE compare_f;
+		DISPLAYER display_f;
+		DESTROYER destroy_f;
+		STRINGER string_f;
+		int count;
+		void append_error(int expr, const char *proc)
+		{
+			if (expr) dict_append_perror(proc);
+			errno = dict_errno;
+		}
+		void obj_error(int expr, const char *proc, const void *obj)
+		{
+			if (expr) {
+				dict_append_perror((*string_f)(obj));
+				dict_append_perror(proc);
+			}
+			errno = dict_errno;
+		}
+		internal(COMPARE cmp, DESTROYER destroyer,
+			 DISPLAYER displayer, STRINGER str_f)
+		{// ERROR - candidate for bad call
+			if (799  >=  800 ) cout <<  "Creating new dictionary..."  << '\n'; ;
+			if (cmp == __null )       cmp = &default_compare;
+			if (displayer == __null ) displayer = &default_displayer;
+			if (str_f == __null )     str_f = &default_stringer;
+			compare_f = cmp;
+			display_f = displayer;
+			destroy_f = destroyer;
+			string_f  = str_f;
+			di = make_dictionary(compare_f);
+			append_error(di == __null , "dict internal");
+			if (di == __null ) {
+				dict_perror("build dictionary");
+				exit(errno);
+			}
+			count = 1;
+		}
+		~internal()
+		{
+			if (799  >=  800 ) cout <<  "dict ~internal executing"  << '\n'; ;
+			int err = clear_dictionary(di, destroy_f, (&__iob[2]) );
+			append_error(err, "clear dictionary");
+			if (err) dict_perror("dict ~internal");
+			free((void *)di);
+		}
+	};// ERROR - candidate list for bad call
+	internal *rep;
+protected:
+	int & errno()         { return( rep->errno );     }
+	COMPARE compare_f()   { return( rep->compare_f ); }
+	DISPLAYER display_f() { return( rep->display_f ); }
+	DESTROYER destroy_f() { return( rep->destroy_f ); }
+	STRINGER string_f()   { return( rep->string_f  ); }
+	void append_error(int expr, const char *proc)
+	{
+		rep->append_error(expr, proc);
+	}
+	void obj_error(int expr, const char *proc, const void *obj)
+	{
+		rep->obj_error(expr, proc, obj);
+	}
+public:
+	static int err;
+	static int val;
+	static void *p;
+	dict()
+	{
+		if (799  >=  800 ) cout <<  "Default constructor executing..."  << '\n'; ;
+		rep = new internal( &default_compare,   &null_destroy,
+				    &default_displayer, &default_stringer);// ERROR - no matching fn call
+	}
+	dict(COMPARE cmp,
+	     DESTROYER destroyer = __null ,
+	     DISPLAYER displayer = &default_displayer,
+	     STRINGER str_f = &default_stringer)
+	{// ERROR - invalid type for default argument -- not expecting const
+		rep = new internal(cmp, destroyer, displayer, str_f);
+	}
+	dict(const dict &di2)
+	{
+		rep = di2.rep;
+		rep->count ++;
+		if (799  >=  800 ) cout <<  "Incrementing count to " << rep->count  << '\n'; ;
+	}
+	dict & operator = (const dict &di2)
+	{
+		di2.rep->count ++;   
+		if (799  >=  800 ) cout <<  "Incrementing di2 count to " << di2.rep->count  << '\n'; ;
+		if (799  >=  800 ) cout <<  "Decrementing lvalue count to " << rep->count-1  << '\n'; ;
+		if (--rep->count <= 0) {
+			delete rep;
+		}
+		rep = di2.rep;
+		return( *this );
+	}
+	~dict()
+	{
+		if (799  >=  800 ) cout <<  "~dict executing..."  << '\n'; ;
+		if (799  >=  800 ) cout <<  "Decrementing dict::internal count to " << rep->count-1  << '\n'; ;
+		if (--rep->count <= 0) delete rep;
+	}
+	int insert(POINTER item)
+	{
+		err = dict_insert(item, rep->di);
+		obj_error(err, "insert", item);
+		return errno();
+	}
+	int remove(POINTER item)
+	{
+		err = dict_delete(item, rep->di);
+		obj_error(err, "remove", item);
+		return errno();
+	}
+	POINTER access(POINTER item)
+	{
+		p = dict_access(item, rep->di);
+		obj_error(p == __null , "access", item);
+		return(p);
+	}
+	POINTER low()
+	{
+		p = dict_low(rep->di);
+		append_error(p == __null , "low");
+		return(p);
+	}
+	POINTER nlow()
+	{
+		p = dict_nlow(rep->di);
+		append_error(p == __null , "nlow");
+		return(p);
+	}
+	POINTER big()
+	{
+		p = dict_big(rep->di);
+		append_error(p == __null , "big");
+		return(p);
+	}
+	POINTER nbig()
+	{
+		p = dict_nbig(rep->di);
+		append_error(p == __null , "nbig");
+		return(p);
+	}
+	POINTER first()
+	{
+		p = dict_first(rep->di);
+		append_error(p == __null , "first");
+		return(p);
+	}
+	POINTER last()
+	{
+		p = dict_last(rep->di);
+		append_error(p == __null , "last");
+		return(p);
+	}
+	POINTER next()
+	{
+		p = dict_next(rep->di);
+		append_error(p == __null , "next");
+		return(p);
+	}
+	POINTER prev()
+	{
+		p = dict_prev(rep->di);
+		append_error(p == __null , "prev");
+		return(p);
+	}
+	int clear(DESTROYER destroy, FILE *fp = (&__iob[2]) )
+	{
+		err = clear_dictionary(rep->di, destroy, fp);
+		append_error(err, "clear");
+		return errno();
+	}
+	int clear(FILE *fp = (&__iob[2]) )
+	{
+		err = clear_dictionary(rep->di, rep->destroy_f, fp);
+		append_error(err, "clear");
+		return errno();
+	}
+	int size()
+	{
+		val = dict_size(rep->di);
+		append_error(val < 0, "size");
+		return(val);
+	}
+	POINTER elem(int index)
+	{
+		p = dict_elem(index, rep->di);
+		append_error(p == __null , "elem");
+		return(p);
+	}
+	int compare(dict &di2)
+	{
+		val = dict_compare(rep->di, di2.rep->di);
+		return(val);
+	}
+	int height()
+	{
+		val = dict_height(rep->di);
+		append_error(val < 0, "height");
+		return(val);
+	}
+	const char * version()
+	{
+		return( dict_version() );
+	}
+	void display(FILE *fp = (&__iob[1]) )
+	{
+		dict_print_stats(fp, rep->di);
+	}
+	void print(FILE *fp = (&__iob[1]) , traversal_t tr = INORDER)
+	{
+		fprintf(fp, "====== DICTIONARY (count=%d) ======\n",
+			rep->count);
+		dict_print(fp, rep->di, tr, rep->display_f);
+	}
+	void print(traversal_t tr, FILE *fp = (&__iob[1]) )
+	{
+		fprintf(fp, "====== DICTIONARY (count=%d) ======\n",
+			rep->count);
+		dict_print(fp, rep->di, tr, rep->display_f);
+	}
+	void error(const char *s = "class dict")
+	{
+		dict_errno = errno();
+		dict_perror(s);
+		errno() = 0;
+	}
+	void error_append(const char *s = "class dict")
+	{
+		dict_append_perror(s);
+	}
+	const char * errstring()
+	{
+		return( dict_errstring() );
+	}
+};
+ostream & operator << (ostream & fp, traversal_t tr);
+class queue : public object {
+	class internal {
+	public:
+		QUEUE Q;
+		QUEUE Q2;
+		int errno;
+		DISPLAYER display_f;
+		DESTROYER destroy_f;
+		STRINGER string_f;
+		int count;
+	        int swap()
+		{
+			QUEUE tmp = Q;
+			Q = Q2;
+			Q2 = tmp;
+		}
+		void append_error(int expr, const char *proc)
+		{
+			if (expr) queue_append_perror(proc);
+			errno = queue_errno;
+		}
+		void obj_error(int expr, const char *proc, const void *obj)
+		{
+			if (expr) {
+				queue_append_perror((*string_f)(obj));
+				queue_append_perror(proc);
+			}
+			errno = queue_errno;
+		}
+		internal(DESTROYER destroyer,
+		         DISPLAYER displayer, STRINGER str_f)
+		{// ERROR - candidate for bad call
+			if (799  >=  800 ) cout <<  "Creating new queue..."  << '\n'; ;
+			if (displayer == __null ) displayer = &default_displayer;
+			if (str_f == __null )     str_f = &default_stringer;
+			display_f = displayer;
+			destroy_f = destroyer;
+			string_f  = str_f;
+			Q = make_queue();
+			append_error(Q == __null , "queue internal");
+			errno = queue_errno;
+			if (Q == __null ) {
+				queue_perror("build queue");
+				exit(errno);
+			}
+			Q2 = make_queue();
+			append_error(Q2 == __null , "queue internal");
+			if (Q2 == __null ) {
+				queue_perror("build second queue");
+				exit(errno);
+			}
+			count = 1;
+		}
+		~internal()
+		{
+			if (799  >=  800 ) cout <<  "queue ~internal executing"  << '\n'; ;
+			while ((p = queue_remove(Q)) != __null ) {
+				if (destroy_f != __null ) {
+					(*destroy_f)((POINTER)&p, (&__iob[2]) );
+				}
+			}
+			queue_errno = 0;
+			queue_destroy((POINTER)&Q, (&__iob[2]) );
+			if (queue_errno) {
+				append_error(queue_errno,
+					     "queue_destroy(Q)");
+				queue_perror("queue ~internal");
+			}
+			queue_errno = 0;
+			queue_destroy((POINTER)&Q2, (&__iob[2]) );
+			if (queue_errno) {
+				append_error(queue_errno,
+					     "queue_destroy(Q2)");
+				queue_perror("queue ~internal");
+			}
+		}
+	};// ERROR - list of candidates for bad call
+	internal *rep;
+protected:
+	int & errno()         { return( rep->errno );     }
+	DISPLAYER display_f() { return( rep->display_f ); }
+	DESTROYER destroy_f() { return( rep->destroy_f ); }
+	STRINGER string_f()   { return( rep->string_f  ); }
+	void append_error(int expr, const char *proc)
+	{
+		rep->append_error(expr, proc);
+	}
+	void obj_error(int expr, const char *proc, const void *obj)
+	{
+		rep->obj_error(expr, proc, obj);
+	}
+public:
+	static int err;
+	static int val;
+	static void *p;
+	queue()
+	{
+		if (799  >=  800 ) cout <<  "Default constructor executing..."  << '\n'; ;
+		rep = new internal( &null_destroy,
+				    &default_displayer, &default_stringer);// ERROR - no matching fn for call
+	}
+	queue(DESTROYER destroyer = __null ,
+	      DISPLAYER displayer = &default_displayer,
+	      STRINGER str_f = &default_stringer)
+	{// ERROR - invalid type for default argument -- not expecting const 
+		rep = new internal(destroyer, displayer, str_f);
+	}
+	queue(const queue &Q2)
+	{
+		rep = Q2.rep;
+		rep->count ++;
+		if (799  >=  800 ) cout <<  "Incrementing count to " << rep->count  << '\n'; ;
+	}
+	queue & operator = (const queue &Q2)
+	{
+		Q2.rep->count ++;   
+		if (799  >=  800 ) cout <<  "Incrementing Q2 count to " << Q2.rep->count  << '\n'; ;
+		if (799  >=  800 ) cout <<  "Decrementing lvalue count to " << rep->count-1  << '\n'; ;
+		if (--rep->count <= 0) {
+			delete rep;
+		}
+		rep = Q2.rep;
+		return( *this );
+	}
+	~queue()
+	{
+		if (799  >=  800 ) cout <<  "~queue executing..."  << '\n'; ;
+		if (799  >=  800 ) cout <<  "Decrementing queue::internal count to " << rep->count-1  << '\n'; ;
+		if (--rep->count <= 0) delete rep;
+	}
+	void error(const char *s = "class queue")
+	{
+		queue_errno = errno();
+		queue_perror(s);
+		errno() = 0;
+	}
+	void error_append(const char *s = "class queue")
+	{
+		queue_append_perror(s);
+	}
+	const char * errstring()
+	{
+		return( queue_errstring() );
+	}
+	int append(POINTER item)
+	{
+		err = queue_append(rep->Q, (POINTER)item);
+		obj_error(err, "append", item);
+		return errno();
+	}
+	POINTER remove()
+	{
+		p = queue_remove(rep->Q);
+		append_error(p == __null , "remove");
+		return(p);
+	}
+	POINTER look(POINTER item)
+	{
+		p = queue_look(rep->Q);
+		append_error(p == __null , "look");
+		return(p);
+	}
+	POINTER last(POINTER item)
+	{
+		p = queue_last(rep->Q);
+		append_error(p == __null , "last");
+		return(p);
+	}
+	int size()
+	{
+		val = queue_size(rep->Q);
+		append_error(val < 0, "size");
+		return(val);
+	}
+	const char * version()
+	{
+		return( queue_version() );
+	}
+	void display(FILE *fp = (&__iob[1]) )
+	{
+		int i = 1;
+		POINTER ptr;
+		fprintf(fp, "====== QUEUE DISPLAY (size %d) ======\n",
+			size());
+		while (ptr = remove()) {
+			err = queue_append(rep->Q2, ptr);
+			if (err) {
+				obj_error(err, "append", ptr);
+				error("queue_append(rep->Q2)");
+			}
+			fprintf(fp, "[%d] ", i++);
+			(*rep->display_f)(ptr, fp, (&__iob[2]) );
+		}
+		rep->swap();
+	}
+};
+long object::current_id = 0;
+long object::next_id()
+{
+	return( ++current_id );
+}
+void object::display2(ostream & fp) const
+{
+	fp << "object #" << id;
+}
+ostream & operator << (ostream & fp, object & obj)
+{
+	obj.display(fp);
+	return(fp);
+}
+int object::compare(const void *p2) const
+{
+	const object & z2 = *(const object *) p2;
+	if (799  >=  1000 ) cout <<  "*** object::compare " << *this << " with " << z2  << '\n'; ;
+	return( id - z2.id );
+}
+int operator < (object & obj1, object & obj2)
+{
+	if (obj1.compare( &obj2 ) < 0) return(1);
+	else return(0);
+}
+int operator <= (object & obj1, object & obj2)
+{
+	if (obj1.compare( &obj2 ) <= 0) return(1);
+	else return(0);
+}
+int operator > (object & obj1, object & obj2)
+{
+	if (obj1.compare( &obj2 ) > 0) return(1);
+	else return(0);
+}
+int operator >= (object & obj1, object & obj2)
+{
+	if (obj1.compare( &obj2 ) >= 0) return(1);
+	else return(0);
+}
+int operator == (object & obj1, object & obj2)
+{
+	if (obj1.compare( &obj2 ) == 0) return(1);
+	else return(0);
+}
+int operator != (object & obj1, object & obj2)
+{
+	if (obj1.compare( &obj2 ) != 0) return(1);
+	else return(0);
+}
+void null_destroy(void *p, FILE *errorFile)
+{
+}
+int object_compare(const void *p1, const void *p2)
+{
+	const object *obj1 = (const object *) p1;
+	if (799  >=  1000 ) cout <<   "*** Comparing " << *obj1 << " to address " << long(p2)  << '\n'; ;
+	return( obj1->compare(p2) );
+}
+void object_display(const void *p, FILE *fp, FILE *errorFile)
+{
+	cout << *(object *)p << '\n';
+}
+void object_destroy(void *p, FILE *errorFile)
+{
+	object **pObj = (object **)p;
+	object *obj = *pObj;
+	if (obj == __null ) {
+		if (799  >=  10 ) cout <<   "+ object_destroy: NIL object passed in"  << '\n'; ;
+		return;
+	}
+	if (799  >=  998 ) cout <<   "+ object_destroy: delete obj:"  << '\n'; ;
+	if (799  >=  998 ) cout <<   *obj  << '\n'; ;
+	if (799  >=  998 ) cout <<   "===================================================="  << '\n'; ;
+	delete obj;
+	*pObj = __null ;
+}
+int default_compare(const void *p1, const void *p2)
+{
+	long L1 = long(p1);
+	long L2 = long(p2);
+	if (799  >=  1000 ) cout <<  "+ default_compare " << long(p1) << ',' << long(p2)  << '\n'; ;
+	if (L1 < L2) return(-1);
+	else if (L1 > L2) return(1);
+	else return(0);
+}
+const char * default_stringer(const void *ptr)
+{
+	static char buf[100];
+	sprintf(buf, "ADDRESS %lu", (unsigned long)ptr);
+	return(buf);
+}
+void default_displayer(const void *ptr, FILE *fp, FILE *errorFile)
+{
+	fprintf(fp, "%s\n", default_stringer(ptr));
+}
+object::operator char *() const
+{
+	const int max = 10;
+	const int maxChar = 16;
+	static char buf[max][maxChar];
+	static int index = 0;
+	char *s = buf[index++ % max];
+	sprintf(s, "object #%d", id);
+	return(s);
+}
+const char * object_stringer(const void *ptr)
+{
+	object & obj = *(object *)ptr;
+	return((char *)obj);
+}
+int dict::err;
+int dict::val;
+POINTER dict::p;
+ostream & operator << (ostream & fp, traversal_t tr)
+{
+	fp << traversal_string(tr);
+	return(fp);
+}
+int queue::err;
+int queue::val;
+POINTER queue::p;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash2.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash2.C
new file mode 100755
index 0000000..ad6e040
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash2.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed old-abort
+// The compiler used to crash on this example.
+
+class x {
+public:
+  x();
+  static const x y[23];
+};
+const x x::y[23];
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash20.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash20.C
new file mode 100755
index 0000000..7704b98
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash20.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed old-abort
+#include <complex>
+typedef complex<double> Complex;
+
+Complex ComputeVVself()
+{
+Complex temp1;
+Complex self[3][3];
+
+   self[1][2] = 100.0;
+   return self[1][2];
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash22.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash22.C
new file mode 100755
index 0000000..f7db97d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash22.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed old-abort
+struct A {
+    void a1();
+    void a2();
+};
+
+struct B {
+    void A::a1(); // this used to die in chainon(), now grokdeclarator should// ERROR -  cannot declare.*
+    void A::a2(); // should be fixed by the 930629 change.// ERROR -  cannot declare.*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash23.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash23.C
new file mode 100755
index 0000000..03ffee6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash23.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed old-abort
+// This used to die in chainon; it shouldn't any more.
+
+class A
+{
+public:
+  class B {
+  public:
+    void f ();
+    void g (int);
+  };
+  void B::f () {}// ERROR - .*
+  void B::g (int val) {}// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash24.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash24.C
new file mode 100755
index 0000000..af1c301
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash24.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// Special g++ Options: -O
+// GROUPS passed old-abort
+// gcc puts the array into a register, and then the store_bit_field () code
+// in expmed.c gets confused when it tries to store zero past the end of the
+// register (because the index is past the array bounds).   It ends up calling
+// store_split_bit_field, which then aborts, because we don't have a split bit
+// field.
+//
+// Seems easiest to detect this case in the front end, i.e. access outside the
+// array bounds, and then force the array to be allocated on the stack instead
+// of a register.
+
+main()
+{
+  char i[1];
+
+  i[1] = 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash25.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash25.C
new file mode 100755
index 0000000..625eaf8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash25.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class memo{
+public:
+	static int rep;
+};
+
+class port_head : public memo {
+public:
+	static 	int rep;
+	unsigned cap();
+};
+
+class buff_head : private port_head {
+public:
+	static int rep;
+	port_head::cap;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash26.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash26.C
new file mode 100755
index 0000000..9b6643d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash26.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed old-abort
+struct B {
+    B();
+};
+ 
+class C : virtual public B
+{
+  public:
+    C() { }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash27.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash27.C
new file mode 100755
index 0000000..62acbe0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash27.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class First {
+public:
+  First(const First& a);
+};
+
+class Second {
+  int i;
+  First f;
+public:
+  ~Second() {}
+  Second func();
+};
+
+void foo()
+{
+  extern Second x;
+  x = x.func();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash28.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash28.C
new file mode 100755
index 0000000..08adee9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash28.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed old-abort
+    class abc
+    {
+     public: 
+      void F()       { return; }
+
+     private:
+      typedef int myint;
+      typedef struct { int b; } mystruct;
+      typedef union  { int c; } myunion;
+    };
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash29.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash29.C
new file mode 100755
index 0000000..72bbdc7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash29.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed old-abort
+
+union Value
+{
+	Value(){}
+};
+
+struct GlobalAddress
+{
+	GlobalAddress(Value *nvar){}// ERROR - .*
+};// ERROR -  candidates .*
+
+int
+main()
+{
+	new GlobalAddress(Value());		// internal error occured here// ERROR -  no matching function .*
+	//new GlobalAddress(new Value());	// This line is correct code
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash3.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash3.C
new file mode 100755
index 0000000..b3b8354
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash3.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed old-abort
+int	strcmp();
+
+extern "C" {
+      // dies in common_type, cuz the TREE_TYPE of t2 is 0, so it can't get its
+      // TYPE_MAIN_VARIANT value.
+      // <void_type 184510 void permanent VOID
+      //  size <integer_cst 1844e0 type <integer_type 182548 int> constant permanent 0
+      //    align 1 symtab 0
+      //    pointer_to_this <pointer_type 1845e0>
+
+int       strcmp(const char*, const char*);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash30.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash30.C
new file mode 100755
index 0000000..707e898
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash30.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed old-abort
+#include <string>
+
+int
+main(void) {
+
+  string a[] = {"Hello"};
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash31.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash31.C
new file mode 100755
index 0000000..d5b7e54
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash31.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed old-abort
+struct mbuf {
+	struct mbuf *next;
+};
+
+void* malloc(int);
+struct mbuf *
+mbuf_allocate(int size)
+{
+    struct mbuf *bp;
+
+    bp = (struct mbuf *) malloc( 10 /*(unsigned) (size + sizeof(struct mbuf))*/);
+    return bp;
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash32.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash32.C
new file mode 100755
index 0000000..ebca5a4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash32.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// Special g++ Options: -fshort-enums
+// GROUPS passed old-abort
+enum Bool { FALSE, TRUE };
+Bool foo () { return TRUE; }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash33.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash33.C
new file mode 100755
index 0000000..d89fa7b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash33.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed old-abort
+extern void foo(void *);
+int
+main() {
+	foo((struct bar *)0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash34.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash34.C
new file mode 100755
index 0000000..a147b62
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash34.C
@@ -0,0 +1,3 @@
+// Build don't link: 
+// GROUPS passed old-abort
+operator int () {}// ERROR - .*// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash35.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash35.C
new file mode 100755
index 0000000..e32b7c1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash35.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed old-abort
+const unsigned int ENET_INTERRUPT_MID = 5;
+
+extern "C" void ENET_RxP();
+
+class EnetReceiver
+    {
+    public:
+        friend void ENET_RxP();
+        void  receiveMessage();
+        int *messagePointer;
+    };
+
+void EnetReceiver::receiveMessage()
+    {
+    if (*((unsigned int*) messagePointer) == ENET_INTERRUPT_MID)
+        {
+        }
+    }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash36.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash36.C
new file mode 100755
index 0000000..1053453
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash36.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed old-abort
+struct wait { int w_status; };
+int wait();
+extern "C" int wait(int*);
+
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash37.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash37.C
new file mode 100755
index 0000000..18eb64a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash37.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed old-abort
+typedef int _sigset_t;
+extern "C" {
+        extern int sigaction(int signo, const struct sigaction *action_spec_p, struct sigaction *old_action_p);
+}
+extern "C" {
+        extern void foo();
+};
+class SS {
+        friend void foo();
+protected:
+        void goo();
+};
+inline void
+SS::goo() { }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash38.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash38.C
new file mode 100755
index 0000000..eeb70e1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash38.C
@@ -0,0 +1,43 @@
+// Build don't link: 
+// GROUPS passed old-abort
+/*
+   I received the following message when using g++ (version 2.3.3):
+
+   main.cc: In method 'Implicit<implicit<INTEGER,2>,3>::Implicit()':
+   main.cc: Internal compiler error 241.
+   main.cc: Please report this to 'bug-g++@prep.ai.mit.edu'
+   */
+
+#include <stream.h>
+
+class INTEGER {
+int x;
+public:
+   typedef int BASE;
+   INTEGER(int y) : x(y) {}
+   INTEGER() {}
+   void encode() { cout << "Integer encoder";}
+   int operator=(int y) { x=y; return x; }
+   operator int() {return x; }
+};
+
+template< class T,  int n> class Implicit : public T {
+   public:
+     typedef typename T::BASE BASE;
+     Implicit(BASE value ): T(value) {};
+     Implicit() : T() {};
+     int myTag() { return n; }
+     void encode() { T::encode(); }
+     BASE operator=(BASE t) { return T::operator=(t); }
+};
+
+int
+main() 
+{
+  Implicit<Implicit<INTEGER, 2> ,  3> y;
+
+  y = 10;
+};
+
+
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash39.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash39.C
new file mode 100755
index 0000000..a191872
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash39.C
@@ -0,0 +1,33 @@
+// Build don't link: 
+// Special g++ Options: -w
+// GROUPS passed old-abort
+//#include <GetOpt.h>
+#include <stdio.h>
+
+class GetOpt
+{
+private:
+  static char *nextchar;
+   enum OrderingEnum { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER };
+   OrderingEnum ordering;
+  static int first_nonopt;
+  static int last_nonopt;
+  void exchange (char **argv);
+public:
+  char *optarg;
+  int optind;
+  int opterr;
+  
+  int    nargc;
+  char **nargv;
+  const char  *noptstring;
+  
+  GetOpt (int argc, char **argv, const char *optstring);
+  int operator () (void);
+};
+//end <GetOpt.h>
+#include <string>
+
+class foo {public: foo () {}};
+class bar {public: bar (const foo& dflt);};
+class baz: public bar {public: baz (): bar (foo ()) {}};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash4.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash4.C
new file mode 100755
index 0000000..1f8a3ff
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash4.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed old-abort
+typedef struct Thing {
+		Thing();
+	int	x;
+} Thing;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash40.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash40.C
new file mode 100755
index 0000000..dcebfbe
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash40.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class foo {
+
+public:
+
+	virtual foo &operator <<(foo &(foo::*)(foo &));
+};
+
+
+foo &foo::operator<<(foo &(foo::*manip)(foo &))
+{
+ 
+   (this->*manip)(*this);
+ 
+   return *this;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash41.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash41.C
new file mode 100755
index 0000000..5d533b8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash41.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed old-abort
+typedef void (**ppfn)(void);
+
+int main() {
+    ppfn fn;
+
+    fn = new (void(*)(void));
+
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash42.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash42.C
new file mode 100755
index 0000000..1b92f5d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash42.C
@@ -0,0 +1,6 @@
+// GROUPS passed old-abort
+// Build don't link: 
+int fn();// ERROR -  ambiguates.*
+int x;
+int& fn() {// ERROR -  new decl.*
+return x;}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash43.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash43.C
new file mode 100755
index 0000000..5fe5423
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash43.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// Special g++ Options: -g -fno-strict-prototype
+// GROUPS passed old-abort
+// excess errors test - XFAIL sparc64-*-elf
+extern "C" { typedef int jmp_buf[12]; }
+
+enum Error { NO_ERROR };
+class ErrorHandler
+{
+    ErrorHandler *previous;
+    static ErrorHandler *error_stack;
+    jmp_buf error_buffer;
+protected:
+    static void pop()
+    {
+	error_stack = error_stack->previous;
+    }
+public:
+    jmp_buf *push()
+    {
+	previous = error_stack;
+	error_stack = this;
+	return &error_buffer;
+    }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash44.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash44.C
new file mode 100755
index 0000000..00a4df4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash44.C
@@ -0,0 +1,27 @@
+// Build don't link: 
+// GROUPS passed old-abort
+template <class T> class bug {
+
+public:
+    void		Foo(const int = 0);
+    void		NotRedeclared(const int);
+
+private:
+	T		TheItem;
+};
+
+template <class T> void bug<T>::NotRedeclared(const int)
+{
+}
+
+template <class T> void bug<T>::Foo(const int)
+{
+}
+
+int
+main()
+{
+	bug<char>	InstantiatedBug;
+
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash45.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash45.C
new file mode 100755
index 0000000..269a519
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash45.C
@@ -0,0 +1,3 @@
+// Build don't link: 
+// GROUPS passed old-abort
+void foo() { static const char *const v[] = { 0 }; }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash46.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash46.C
new file mode 100755
index 0000000..64d8d59
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash46.C
@@ -0,0 +1,26 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class Rational {
+public:
+    Rational(int v): value(v)
+	{  }
+
+    int value;
+};
+typedef Rational __Rational;
+
+extern int operator>(const Rational&, const Rational&);
+
+class V {
+public:
+    class Rational {
+    public:
+	static int x(const __Rational& value);
+    };
+};
+
+int
+V::Rational::x(const __Rational& value)
+{
+    return value > 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash47.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash47.C
new file mode 100755
index 0000000..9bdbb11
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash47.C
@@ -0,0 +1,94 @@
+// Build don't link: 
+// GROUPS passed old-abort
+const int TRUE = 1;
+const int FALSE = 0;
+
+class Rep {
+protected:
+    Rep(): count(0)
+	{ }
+    Rep(const Rep& other): count(0)
+	{ }
+
+    Rep& operator=(const Rep& other)
+	{ /* DO NOT copy over other.count */
+	  return *this; }
+
+public:		// TODO - for now
+    // Because it is to hard to restrict these operations to the descendants
+    // of Rep<REP> that we haven't named yet.  So we just make them public.
+    void inc()
+	{ count++; }
+    void dec()
+	{ if (0 == --count) delete this; }
+private:
+    unsigned count;
+};
+
+template<class REP>
+class Ref {
+public:
+    Ref(): rep(0)
+	{ }
+    Ref(const Ref<REP>& other): rep(other.rep)
+	{ if (rep) rep->inc(); }
+    ~Ref()
+	{ if (rep) rep->dec();
+	  rep = 0; }
+
+    Ref<REP>& operator=(const Ref<REP>& other)
+	{ if (rep != other.rep) {
+	    if (rep) rep->dec();
+	    rep = other.rep;
+	    if (rep) rep->inc(); }
+	  return *this; }
+
+    bool null() const
+	{ return 0 == rep ? TRUE: FALSE; }
+    bool valid() const
+	{ return 0 != rep ? TRUE: FALSE; }
+
+    REP* operator->() const		// should be a valid() reference
+	{ return rep; }
+    operator REP*() const;		// should be a valid() reference
+
+protected:
+    REP *rep;
+
+    Ref(REP *r): rep(r)
+	{ if (rep) rep->inc(); }
+
+    Ref<REP>& operator=(REP *r)
+	{ if (rep != r) {
+	    if (rep) rep->dec();
+	    rep = r;
+	    if (rep) rep->inc(); }
+	  return *this; }
+};
+
+template<class REP>
+Ref<REP>::operator REP*() const		// should be a valid() reference
+{ return rep; }
+
+template<class REP> 
+inline int
+operator==(const Ref<REP>& a, const Ref<REP>& b)
+{ return (REP *) a == (REP *) b; }
+
+template<class REP> 
+inline int
+operator!=(const Ref<REP>& a, const Ref<REP>& b)
+{ return (REP *) a != (REP *) b; }
+
+class XRep: public Rep {
+public:
+    int i;
+};
+
+int
+main()
+{
+    Ref<XRep> y;
+
+    return y != y;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash48.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash48.C
new file mode 100755
index 0000000..6dc9da0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash48.C
@@ -0,0 +1,22 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class internal {
+	int field;
+	int anotherfield;
+}; // ERROR - candidates are
+
+class bug {
+	internal* numbers;
+	bug(int size);
+}; // ERROR - several errors
+
+bug::bug(int size)
+{ // ERROR - candidates
+	numbers = new internal(size * size);// ERROR -  no match.*
+}
+
+int
+main()
+{
+	bug test;// ERROR -  no match
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash49.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash49.C
new file mode 100755
index 0000000..98a580d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash49.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed old-abort
+#include<iostream.h>
+
+const int keys = 10;
+const int key[keys] = {6, key[1], 2, keys, 1, 7, 6, key[2], key[8]};
+
+void main()
+{ // ERROR - return type for main
+        for(int i = 0; i < keys;) cout << key[i++] << " ";
+        endl(cout);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash5.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash5.C
new file mode 100755
index 0000000..0e82e16
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash5.C
@@ -0,0 +1,107 @@
+// Build don't link: 
+// GROUPS passed old-abort
+// Should have been fixed by:
+//
+// Sun Jun 13 12:55:22 1993  Brendan Kehoe  (brendan@lisa.cygnus.com)
+// 
+// 	* cp-cvt.c (build_default_binary_type_conversion): Look deeper into
+// 	what ARG1 and ARG2 are if they're POINTER_TYPEs.
+
+volatile void exit(int);
+
+class CountableSet
+{
+	public:
+		virtual	~CountableSet() { }		
+};	
+
+template<class T>
+class FixedSet : virtual public CountableSet
+{
+	public:
+		virtual	int Get(int, T&) = 0;		 
+		virtual	~FixedSet() { }		
+};
+
+class ShrinkableSet
+{
+	public:
+		virtual int Remove(int) = 0;   
+};
+
+template<class T>
+class PVSet : virtual public FixedSet<T>, virtual public ShrinkableSet
+{
+	public:
+		virtual	void Append(const T&) = 0;
+		virtual	void operator+=(const T& a) { Append(a); }
+		virtual	~PVSet() { }		
+};
+
+template<class T>
+class MutSet : virtual public FixedSet<T>, virtual public FixedSet<T *>
+{
+	protected:
+		typedef	T	*Tp;
+
+	public:
+		void Append(const Tp& tp) { Append(*tp); }
+
+		T&	Access(int p)
+		{
+			Tp	tp;
+			Get(p, tp);
+			return *tp;
+		}
+		virtual	~MutSet() { }		
+};
+
+template <class T>
+class	SimpleSet : virtual public MutSet<T>
+{
+	protected:
+		T	*array;
+		int	size;
+
+		virtual	void	Allocate(int s)
+		{
+			array = new T[s];
+		}
+	public:
+		SimpleSet()
+		{
+			size = 0;
+			array = ((void*)0) ; // ERROR - implicit conversion
+		}
+ 		int	Get(int p, T& t)
+		{
+			t = array[p-1];
+			return 1;
+		}
+		int	Get(int p, T *& t)
+		{
+			t = &array[p-1];
+			return 1;
+		}
+		inline void Append(const T& a)
+		{
+			array[size-1] = a;
+		}
+		inline int Remove(int n) { return 0; }
+};
+
+class	Dummy
+{
+	public:
+		Dummy()	{}
+};
+
+int
+main()
+{
+	SimpleSet<Dummy *>		bs1;
+	int	i, j;
+	Dummy	foo;
+
+	bs1+=&foo;// ERROR -  no .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash50.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash50.C
new file mode 100755
index 0000000..fd87d75
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash50.C
@@ -0,0 +1,29 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class B
+        {
+public:
+        int i;
+        };
+int operator & (const B &s) { return ( s.i  );};
+
+
+
+
+
+class C
+        {
+public:
+        C &operator = (const C &x)
+                {
+                return *this;
+                };
+        };
+
+C &(C::*DD)(const C &x) = &C::operator=;
+
+int main()
+{
+        &DD;
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash51.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash51.C
new file mode 100755
index 0000000..3586eb4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash51.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class obj;
+
+typedef obj *obj_t;
+
+class obj {
+public:
+    obj( const obj& o );
+};   
+
+extern obj nowhere;
+
+class set: public obj {
+    unsigned  bit_vector;
+public:
+    set( const obj& o );
+    set&      operator|=( const int q );
+};   
+
+enum pin_enum { E_F, O_C, O_D, O_S, P_D, P_U, R, T, A, C };
+
+set t_q = ( ( ( ( ( ( set( nowhere ) |= E_F ) |= O_C ) |= O_D ) |= O_S )
+              |= P_U ) |= P_D ) |= T;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash52.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash52.C
new file mode 100755
index 0000000..d10afdc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash52.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed old-abort
+#include <iostream.h>
+
+class A {
+public:
+  friend A f(A &a);// ERROR -  ambiguates.*
+};
+
+A &f(A &a) {// ERROR -  new decl.*
+  cout << "Blah\n";
+} // ERROR - non-void function
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash53.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash53.C
new file mode 100755
index 0000000..163f8e6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash53.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class A
+{
+  public:
+    class B
+    {
+      public:
+        virtual ~B();
+    };
+};
+
+template<int I>
+class C
+{
+  public:
+    class B
+    : public A::B
+    {
+    }; // bug2.cc:18: Internal compiler error 233.
+       // bug2.cc:18: Please submit a full bug report to `bug-g++@prep.ai.mit.edu'.
+};
+
+C<0> c;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash54.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash54.C
new file mode 100755
index 0000000..7d2a8a0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash54.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed old-abort
+int main()
+{
+    int a[100], **p;
+
+    p = &a[50];// ERROR -  assignment to.*
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash55.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash55.C
new file mode 100755
index 0000000..47a7424
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash55.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed old-abort
+      extern f(int);// ERROR -  ambiguates.*
+
+      int& f(int x)
+      {// ERROR -  new declaration.*
+          int local;// ERROR -  warning
+
+          local = x+2;
+      
+          return local;
+      }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash56.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash56.C
new file mode 100755
index 0000000..b5e997c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash56.C
@@ -0,0 +1,385 @@
+// Build don't link: 
+// GROUPS passed old-abort
+// Special g++ Options:
+
+const bool FALSE = 0;
+const bool TRUE = 1;
+class ListDProto {
+public:
+    ListDProto();
+    ListDProto(const ListDProto&);
+    virtual ~ListDProto();
+    void operator=(const ListDProto&);
+    unsigned length() const;
+    bool empty() const;
+    void clear();
+    void remove_head();
+    void remove_tail();
+    class link;
+    class Vix {
+    public:
+	Vix();
+	friend int operator==(void *v, const Vix& x)
+	    { return v == x.item; }// ERROR - list of candidates
+	friend int operator==(const Vix& x, void *v)
+	    { return v == x.item; }// ERROR - candidate for call
+	friend int operator!=(void *v, const Vix& x)
+	    { return v != x.item; }
+	friend int operator!=(const Vix& x, void *v)
+	    { return v != x.item; }
+	friend int operator==(const Vix& x1, const Vix& x2)
+	    { return x1.owner == x2.owner && x1.item == x2.item; }// ERROR - candidate for call
+	friend int operator!=(const Vix& x1, const Vix& x2)
+	    { return x1.owner != x2.owner || x1.item != x2.item; }
+	bool first;		 
+	bool last;		 
+    protected:
+        friend class ListDProto;
+	Vix(const ListDProto *o, link *i);
+	const ListDProto *owner;
+    private:
+	link *item;
+    };
+    enum Action { NORMAL, REMOVE_CURRENT };
+    Vix first() const;
+    void first(Vix& x) const;
+    void next(Vix& x) const;
+    void next(Vix& x, Action a = NORMAL);
+    Vix last() const;
+    void last(Vix& x) const;
+    void prev(Vix& x) const;
+    void prev(Vix& x, Action a = NORMAL);
+protected:
+    struct link {
+	link *next;
+	link *prev;
+	link(link *n = 0, link *p = 0);
+	virtual ~link();
+    private:
+	link(const link&);
+	void operator=(const link&);
+    };
+    unsigned count;
+    link *list_head;		 
+    link *list_tail;		 
+    virtual link *copy_item(link *old_item) const = 0;
+    void prepend(link *item);
+    void append(link *item);
+    void prepend(const ListDProto& proto);
+    void append(const ListDProto& proto);
+    void remove(link *item);
+    link *ref(const Vix&) const;
+};
+template<class T>
+class ListD: public ListDProto {
+public:
+    void prepend(const T& item);
+    void append(const T& item);
+    const T& head() const;
+    T& head();
+    void head(T& fill) const;
+    void remove_head()
+	{ ListDProto::remove_head(); }
+    void remove_head(T& fill);
+    const T& tail() const;
+    T& tail();
+    void tail(T& fill) const;
+    void remove_tail()
+	{ ListDProto::remove_tail(); }
+    void remove_tail(T& fill);
+    class Vix: public ListDProto::Vix {
+    public:
+	Vix(): ListDProto::Vix()
+	    { }
+    protected:
+        friend class ListD<T>;
+	Vix(const ListDProto::Vix& x): ListDProto::Vix(x)
+	    { }
+    };
+    Vix first() const
+	{ return ListDProto::first(); };
+    void first(Vix& x) const
+	{ ListDProto::first(x); };
+    void next(Vix& x, ListDProto::Action a = NORMAL) const
+	{ ListDProto::next(x, a); }// ERROR - .*// ERROR - .*
+    Vix last() const
+	{ return ListDProto::last(); }
+    void last(Vix& x) const
+	{ return ListDProto::last(x); }
+    void prev(Vix& x, ListDProto::Action a = NORMAL) const
+	{ return ListDProto::prev(x, a); }
+protected:
+    struct link_item: public ListDProto::link {
+	T item;
+	link_item(const T& i): link(0, 0), item(i)
+	    { }
+    private:
+	link_item(const link_item&);
+	void operator=(const link_item&);
+    };
+public:
+    T& operator()(const Vix& x)
+	{ link_item *li = (link_item *) ref(x);
+	  return li->item; }
+    const T& operator()(const Vix& x) const
+	{ link_item *li = (link_item *) ref(x);
+	  return li->item; }
+private:
+    ListDProto::link *copy_item(ListDProto::link *old_item) const;
+};
+template<class T>
+class SetLD: private ListD<T> {
+public:
+    SetLD();			 
+    SetLD(const ListD<T>&);	 
+    void add(const T& item);
+    void add(const ListD<T>& other);
+    void add(const SetLD<T>& other);
+    void remove(const T& item);
+    bool contains(const T& item) const;
+    ListD<T>::length;
+    ListD<T>::empty;
+    ListD<T>::clear;
+    typedef ListD<T>::Vix Vix;
+    ListD<T>::first;
+    ListD<T>::next;
+    ListD<T>::operator();
+};
+extern "C" {
+extern void __eprintf (const char *, const char *, unsigned, const char *);
+}
+extern "C" {
+extern void __eprintf (const char *, const char *, unsigned, const char *);
+}
+template<class T>
+void
+ListD<T>::prepend(const T& item)
+{
+    link *newl = new link_item(item);
+    ListDProto::prepend(newl);
+}
+template<class T>
+void
+ListD<T>::append(const T& item)
+{
+    link *newl = new link_item(item); 
+    ListDProto::append(newl);
+}
+template<class T>
+const T&
+ListD<T>::head() const
+{
+    ((void) (( 0 != list_head ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",	  "/home/wbaker/work/include/templates/ListD.body.h" ,   50 ,  "0 != list_head" ), 0) )) ;
+    link_item *h = (link_item *) list_head;
+    return h->item;
+}
+template<class T>
+T&
+ListD<T>::head()
+{
+    ((void) (( 0 != list_head ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",	  "/home/wbaker/work/include/templates/ListD.body.h" ,   59 ,  "0 != list_head" ), 0) )) ;
+    link_item *h = (link_item *) list_head;
+    return h->item;
+}
+template<class T>
+void
+ListD<T>::head(T& fill) const
+{
+    ((void) (( 0 != list_head ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",	  "/home/wbaker/work/include/templates/ListD.body.h" ,   68 ,  "0 != list_head" ), 0) )) ;
+    link_item *h = (link_item *) list_head;
+    fill = h->item;
+}
+template<class T>
+void
+ListD<T>::remove_head(T& fill)
+{
+    head(fill);
+    remove_head();
+}
+template<class T>
+const T&
+ListD<T>::tail() const
+{
+    ((void) (( 0 != list_tail ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",	  "/home/wbaker/work/include/templates/ListD.body.h" ,   85 ,  "0 != list_tail" ), 0) )) ;
+    link_item *h = (link_item *) list_tail;
+    return h->item;
+}
+template<class T>
+T&
+ListD<T>::tail()
+{
+    ((void) (( 0 != list_tail ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",	  "/home/wbaker/work/include/templates/ListD.body.h" ,   94 ,  "0 != list_tail" ), 0) )) ;
+    link_item *h = (link_item *) list_tail;
+    return h->item;
+}
+template<class T>
+void
+ListD<T>::tail(T& fill) const
+{
+    ((void) (( 0 != list_tail ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",	  "/home/wbaker/work/include/templates/ListD.body.h" ,   103 ,  "0 != list_tail" ), 0) )) ;
+    link_item *h = (link_item *) list_tail;
+    fill = h->item;
+}
+template<class T>
+void
+ListD<T>::remove_tail(T& fill)
+{
+    ((void) (( 0 != list_tail ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",	  "/home/wbaker/work/include/templates/ListD.body.h" ,   112 ,  "0 != list_tail" ), 0) )) ;
+    link_item *h = (link_item *) list_tail;
+    fill = h->item;
+}
+template<class T>
+ListDProto::link *
+ListD<T>::copy_item(ListDProto::link *old) const
+{
+    link_item *old_item = (link_item *) old;
+    link_item *new_item = new link_item(old_item->item);
+    return new_item;
+}
+template<class T>
+SetLD<T>::SetLD():
+ListD<T>()
+{ }
+template<class T>
+SetLD<T>::SetLD(const ListD<T>& other):
+ListD<T>(other)
+{ }
+template<class T>
+void
+SetLD<T>::add(const T& item)
+{
+    if ( ! contains(item) )
+	append(item);
+}
+template<class T>
+void
+SetLD<T>::add(const ListD<T>& other)
+{
+    ListD<T>::Vix x;
+    for (first(x); 0 != x; next(x))
+	add(other(x));
+}
+template<class T>
+void
+SetLD<T>::add(const SetLD<T>& other)
+{
+    const ListD<T>& lother = other;
+    add(lother);
+}
+template<class T>
+void
+SetLD<T>::remove(const T& item)
+{
+    Action a = NORMAL;
+    Vix x;
+    for (first(x); 0 != x && REMOVE_CURRENT != a; next(x, a))
+	a = operator()(x) == item ? REMOVE_CURRENT: NORMAL;// ERROR - .*
+}
+template<class T>
+bool
+SetLD<T>::contains(const T& item) const
+{
+    Vix x;
+    for (first(x); 0 != x; next(x)) {
+	if (operator()(x) == item)// ERROR - .*
+	    return TRUE;
+    }
+    return FALSE;
+}
+template<class T>
+int
+operator==(const SetLD<T>& a, const SetLD<T>& b)
+{
+    if (a.length() != b.length())
+	return FALSE;
+    SetLD<T>::Vix x;
+    for (a.first(x); 0 != x; a.next(x)) {
+	if ( ! b.contains(a(x)) )
+	    return FALSE;
+    }
+    for (b.first(x); 0 != x; b.next(x)) {
+	if ( ! a.contains(b(x)) )
+	    return FALSE;
+    }
+    return TRUE;
+}
+template<class T>
+int
+operator!=(const SetLD<T>& a, const SetLD<T>& b)
+{ return ! (a == b); }
+template<class T>
+int
+operator<=(const SetLD<T>& a, const SetLD<T>& b)
+{
+    if (a.length() > b.length())
+	return FALSE;
+    SetLD<T>::Vix x;
+    for (x=a.first(); 0 != x; a.next(x)) {
+	if ( ! b.contains(a(x)) )
+	    return FALSE;
+    }
+    return TRUE;
+}
+template<class T>
+int
+operator<(const SetLD<T>& a, const SetLD<T>& b)
+{
+    if (a.length() >= b.length())
+	return FALSE;
+    return a <= b;
+}
+template<class T>
+int
+operator>(const SetLD<T>& a, const SetLD<T>& b)
+{ return ! (a <= b); }
+template<class T>
+int
+operator>=(const SetLD<T>& a, const SetLD<T>& b)
+{ return ! (a < b); }
+class String { };
+class IcaseString: public String { };
+class SetLD< IcaseString >: public SetLD<    String  > {	public:	 SetLD (): SetLD<    String  >() { };	 SetLD (const ListD<   IcaseString  >& other): SetLD<    String  >()	{ ListD<   IcaseString  >::Vix x;	for (other.first(x); 0 != x; other.next(x))	add(other(x)); };	 SetLD (const  SetLD & other): SetLD<    String  >(other) { };	const    IcaseString  & operator()(const Vix& x) const	{ return (   IcaseString  &) SetLD<    String  >::operator()(x); }	}; 	typedef SetLD<  String > SetLD_String_IcaseString_old_tmp99;	typedef SetLD< IcaseString > SetLD_String_IcaseString_new_tmp99;	
+inline int	 operator== (const SetLD_String_IcaseString_new_tmp99& a,	const SetLD_String_IcaseString_new_tmp99& b)
+{// ERROR - candidate for call
+const SetLD_String_IcaseString_old_tmp99& oa = a;
+const SetLD_String_IcaseString_old_tmp99& ob = b;
+return  operator== (oa, ob);	} 	
+inline int	 operator!= (const SetLD_String_IcaseString_new_tmp99& a,	const SetLD_String_IcaseString_new_tmp99& b)
+{
+const SetLD_String_IcaseString_old_tmp99& oa = a;
+const SetLD_String_IcaseString_old_tmp99& ob = b;
+return  operator!= (oa, ob);	} 	
+inline int	 operator< (const SetLD_String_IcaseString_new_tmp99& a,	const SetLD_String_IcaseString_new_tmp99& b)
+{
+const SetLD_String_IcaseString_old_tmp99& oa = a;
+const SetLD_String_IcaseString_old_tmp99& ob = b;
+return  operator< (oa, ob);	} 	
+inline int	 operator<= (const SetLD_String_IcaseString_new_tmp99& a,	const SetLD_String_IcaseString_new_tmp99& b)
+{
+const SetLD_String_IcaseString_old_tmp99& oa = a;
+const SetLD_String_IcaseString_old_tmp99& ob = b;
+return  operator<= (oa, ob);	} 	
+inline int	 operator> (const SetLD_String_IcaseString_new_tmp99& a,	const SetLD_String_IcaseString_new_tmp99& b)
+{
+const SetLD_String_IcaseString_old_tmp99& oa = a;
+const SetLD_String_IcaseString_old_tmp99& ob = b;
+return  operator> (oa, ob);	} 	
+inline int	 operator>= (const SetLD_String_IcaseString_new_tmp99& a,	const SetLD_String_IcaseString_new_tmp99& b)
+{
+const SetLD_String_IcaseString_old_tmp99& oa = a;
+const SetLD_String_IcaseString_old_tmp99& ob = b;
+return  operator>= (oa, ob);	}   ;
+typedef SetLD<IcaseString> SLDiS;
+static void
+nop(int i)
+{
+    SetLD<IcaseString> x, y;
+    nop(x == y);
+ nop(x != y);
+nop(x < y);
+nop(x <= y);
+nop(x > y);
+nop(x >= y);
+}
+
+template class SetLD<String>;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash57.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash57.C
new file mode 100755
index 0000000..5032b3f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash57.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class foo {
+private:
+  char buffer[1024];
+public:
+  foo();
+};
+
+int main()
+{
+  static foo& a = *(new foo);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash58.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash58.C
new file mode 100755
index 0000000..922290f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash58.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class X {
+public:
+void doit();
+};
+
+X::::doit()// ERROR -  (syntax|parse) error.*
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash59.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash59.C
new file mode 100755
index 0000000..ab6e559
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash59.C
@@ -0,0 +1,1374 @@
+// Build don't link: 
+// Special g++ Options: -w
+// GROUPS passed old-abort
+typedef char * __gnuc_va_list;
+void va_end (__gnuc_va_list);		 
+enum __va_type_classes {
+  __no_type_class = -1,
+  __void_type_class,
+  __integer_type_class,
+  __char_type_class,
+  __enumeral_type_class,
+  __boolean_type_class,
+  __pointer_type_class,
+  __reference_type_class,
+  __offset_type_class,
+  __real_type_class,
+  __complex_type_class,
+  __function_type_class,
+  __method_type_class,
+  __record_type_class,
+  __union_type_class,
+  __array_type_class,
+  __string_type_class,
+  __set_type_class,
+  __file_type_class,
+  __lang_type_class
+};
+typedef __gnuc_va_list va_list;
+typedef	int jmp_buf[9 ];
+typedef	int sigjmp_buf[9 +1];
+int	setjmp  (jmp_buf)  ;
+int	_setjmp  (jmp_buf)  ;
+int	sigsetjmp  (sigjmp_buf, int)  ;
+void	longjmp  (jmp_buf, int)  ;
+void	_longjmp  (jmp_buf, int)  ;
+void	siglongjmp  (sigjmp_buf, int)  ;
+const int BOR_C_DIR	= 0;		 
+const int BOR_C_REV	= 1;		 
+const int BOR_C		= 0x1;
+const int BOR_BD_DIR	= (0<<1);	 
+const int BOR_BD_REV	= (1<<1);	 
+const int BOR_BD	= 0x2;
+const int SERVICE_DATA	 = (1<<( 0 )) ;	 
+const int SERVICE_CLASS1 = (1<<( 1 )) ;	 
+const int SERVICE_CLASS2 = (1<<( 2 )) ;	 
+const int SERVICE_CLASS20 = (1<<( 3 )) ;	 
+const int SERVICE_VOICE	 = (1<<( 8 )) ;	 
+const int SERVICE_ALL	 = (1<<( 9 )) -1;
+const int VR_NORMAL	= 0;		 
+const int VR_FINE	= 1;		 
+const int VR_ALL	= (1<<( VR_FINE+1 )) -1;
+const int BR_2400	= 0;		 
+const int BR_4800	= 1;		 
+const int BR_7200	= 2;		 
+const int BR_9600	= 3;		 
+const int BR_12000	= 4;		 
+const int BR_14400	= 5;		 
+const int BR_ALL	= (1<<( BR_14400+1 )) -1;
+const int WD_1728	= 0;		 
+const int WD_2048	= 1;		 
+const int WD_2432	= 2;		 
+const int WD_1216	= 3;		 
+const int WD_864	= 4;		 
+const int WD_ALL	= (1<<( WD_864+1 )) -1;
+const int LN_A4		= 0;		 
+const int LN_B4		= 1;		 
+const int LN_INF	= 2;		 
+const int LN_ALL	= (1<<( LN_INF+1 )) -1;
+const int DF_1DMR	= 0;		 
+const int DF_2DMR	= 1;		 
+const int DF_2DMRUNCOMP	= 2;		 
+const int DF_2DMMR	= 3;		 
+const int DF_ALL	= (1<<( DF_2DMMR+1 )) -1;
+const int EC_DISABLE	= 0;		 
+const int EC_ENABLE	= 1;		 
+const int EC_ALL	= 0x3;
+const int BF_DISABLE	= 0;		 
+const int BF_ENABLE	= 1;		 
+const int BF_ALL	= 0x3;
+const int ST_0MS	= 0;		 
+const int ST_5MS	= 1;		 
+const int ST_10MS2	= 2;		 
+const int ST_10MS	= 3;		 
+const int ST_20MS2	= 4;		 
+const int ST_20MS	= 5;		 
+const int ST_40MS2	= 6;		 
+const int ST_40MS	= 7;		 
+const int ST_ALL	= (1<<( ST_40MS+1 )) -1;
+const int PPM_MPS	= 0;		 
+const int PPM_EOM	= 1;		 
+const int PPM_EOP	= 2;		 
+const int PPM_PRI_MPS	= 4;		 
+const int PPM_PRI_EOM	= 5;		 
+const int PPM_PRI_EOP	= 6;		 
+const int PPR_MCF	= 1;		 
+const int PPR_RTN	= 2;		 
+const int PPR_RTP	= 3;		 
+const int PPR_PIN	= 4;		 
+const int PPR_PIP	= 5;		 
+const int DLE = 16;		 
+const int SUB = 26;		 
+const int ETX = 3;		 
+const int DC1 = 17;		 
+const int DC2 = 18;		 
+const int CAN = 24;		 
+typedef	int		sigset_t;	 
+typedef	unsigned int	speed_t;	 
+typedef	unsigned long	tcflag_t;	 
+typedef	unsigned char	cc_t;		 
+typedef	int		pid_t;		 
+typedef	unsigned short	mode_t;		 
+typedef	short		nlink_t;	 
+typedef	long		clock_t;	 
+typedef	long		time_t;		 
+typedef __SIZE_TYPE__ size_t;		 
+typedef int ptrdiff_t;	 
+typedef __wchar_t wchar_t;	 
+extern unsigned int _mb_cur_max;
+extern void	abort( );
+extern int	abs  (int)  ;
+extern double	atof  (const char *)  ;
+extern int	atoi  (const char *)  ;
+extern long int	atol  (const char *)  ;
+extern char *	bsearch  (const void *, const void *, long unsigned int , long unsigned int , int (*) (const void *, const void *))  ;
+extern void *	calloc  (long unsigned int , long unsigned int )  ;
+extern void	exit  (int)  ;
+extern void	free  (void *)  ;
+extern char *	getenv  (const char *)  ;
+extern void *	malloc  (long unsigned int )  ;
+extern int	qsort  (void *, long unsigned int , long unsigned int , int (*) (const void *, const void *))  ;
+extern int	rand( );
+extern void *	realloc  (void *, long unsigned int )  ;
+extern int	srand  (unsigned int)  ;
+extern int    mbtowc  (__wchar_t *, const char *, long unsigned int )  ;
+extern int    wctomb  (char *, __wchar_t )  ;
+extern size_t mbstowcs  (__wchar_t *, const char *, long unsigned int )  ;
+extern size_t wcstombs  (char *, const __wchar_t *, long unsigned int )  ;
+extern int atexit (void (*) (void));
+extern long int labs (long int);
+extern int putenv (char *);
+extern double strtod (const char *, char **);
+extern long int strtol (const char *, char **, int);
+extern long unsigned int strtoul (const char *, char **, int);
+extern int system (const char *);
+extern char *	strcat  (char *, const char *)  ;
+extern char *	strchr  (const char *, int)  ;
+extern int	strcmp  (const char *, const char *)  ;
+extern char *	strcpy  (char *, const char *)  ;
+extern size_t	strcspn  (const char *, const char *)  ;
+extern char *	strdup  (const char *)  ;
+extern size_t	strlen  (const char *)  ;
+extern char *	strncat  (char *, const char *, long unsigned int )  ;
+extern int	strncmp  (const char *, const char *, long unsigned int )  ;
+extern char *	strncpy  (char *, const char *, long unsigned int )  ;
+extern char *	strpbrk  (const char *, const char *)  ;
+extern char *	strrchr  (const char *, int)  ;
+extern size_t	strspn  (const char *, const char *)  ;
+extern char *	strstr  (const char *, const char *)  ;
+extern char *	strtok  (char *, const char *)  ;
+extern void * memchr (const void *, int, long unsigned int );
+extern int memcmp (const void *, const void *, long unsigned int );
+extern void * memcpy (void *, const void *, long unsigned int );
+extern void * memmove (void *, const void *, long unsigned int );
+extern void * memset (void *, int, long unsigned int );
+extern int strcoll (const char *, const char *);
+extern char * strerror (int);
+extern long unsigned int strxfrm (char *, const char *, long unsigned int );
+extern "C" {
+extern void __eprintf (const char *, const char *, unsigned, const char *);
+}
+extern	struct	_iobuf {
+	int	_cnt;
+	unsigned char *_ptr;
+	unsigned char *_base;
+	int	_bufsiz;
+	short	_flag;
+	char	_file;		 
+} _iob[];
+extern struct _iobuf 	*fopen  (const char *, const char *)  ;
+extern struct _iobuf 	*fdopen  (int, const char *)  ;
+extern struct _iobuf 	*freopen  (const char *, const char *, struct _iobuf  *)  ;
+extern struct _iobuf 	*popen  (const char *, const char *)  ;
+extern struct _iobuf 	*tmpfile();
+extern long	ftell  (struct _iobuf  *)  ;
+extern char	*fgets  (char *, int, struct _iobuf  *)  ;
+extern char	*gets  (char *)  ;
+extern char	*sprintf  (char *, const char *, ...)  ;
+extern char	*ctermid  (char *)  ;
+extern char	*cuserid  (char *)  ;
+extern char	*tempnam  (const char *, const char *)  ;
+extern char	*tmpnam  (char *)  ;
+extern int fclose (struct _iobuf  *);
+extern int fflush (struct _iobuf  *);
+extern int fgetc (struct _iobuf  *);
+extern int fgetpos (struct _iobuf  *, long *);
+extern int fprintf (struct _iobuf  *, const char *, ...);
+extern int fputc (int, struct _iobuf  *);
+extern int fputs (const char *, struct _iobuf  *);
+extern long unsigned int fread (void *, long unsigned int , long unsigned int , struct _iobuf  *);
+extern int fscanf (struct _iobuf  *, const char *, ...);
+extern int fseek (struct _iobuf  *, long int, int);
+extern int fsetpos (struct _iobuf  *, const long *);
+extern long unsigned int fwrite (const void *, long unsigned int , long unsigned int , struct _iobuf  *);
+extern int pclose (struct _iobuf  *);
+extern void perror (const char *);
+extern int printf (const char *, ...);
+extern int puts (const char *);
+extern int remove (const char *);
+extern int rename (const char *, const char *);
+extern void rewind (struct _iobuf  *);
+extern int scanf (const char *, ...);
+extern void setbuf (struct _iobuf  *, char *);
+extern int setvbuf (struct _iobuf  *, char *, int, long unsigned int );
+extern int sscanf (const char *, const char *, ...);
+extern int vprintf (const char *, __gnuc_va_list);
+extern int vsprintf (char *, const char *, __gnuc_va_list);
+extern int vfprintf (struct _iobuf  *, const char *, __gnuc_va_list);
+extern int ungetc (int, struct _iobuf  *);
+extern int _flsbuf (unsigned int, struct _iobuf  *);
+extern int _filbuf (struct _iobuf  *);
+typedef long _G_clock_t;
+typedef short _G_dev_t;
+typedef long   _G_fpos_t;
+typedef unsigned short _G_gid_t;
+typedef unsigned long _G_ino_t;
+typedef unsigned short _G_mode_t;
+typedef short _G_nlink_t;
+typedef long _G_off_t;
+typedef int _G_pid_t;
+typedef int _G_ptrdiff_t;
+typedef int _G_sigset_t;
+typedef long unsigned int _G_size_t;
+typedef long _G_time_t;
+typedef unsigned short _G_uid_t;
+typedef __wchar_t _G_wchar_t;
+typedef int   _G_ssize_t;
+typedef int _G_wint_t;
+typedef char * _G_va_list;
+typedef signed char _G_int8_t;
+typedef unsigned char _G_uint8_t;
+typedef short _G_int16_t;
+typedef unsigned short _G_uint16_t;
+typedef long _G_int32_t;
+typedef unsigned long _G_uint32_t;
+const size_t NPOS = (size_t)(-1);
+typedef void fvoid_t();
+typedef _G_wint_t wint_t;
+enum capacity { default_size, reserve };
+extern "C" fvoid_t *set_new_handler(fvoid_t *);
+extern fvoid_t *__new_handler;
+extern "C" void __default_new_handler();
+inline void *operator new(size_t, void *place) { return place; }
+inline void *operator new[](size_t, void *place) { return place; }
+typedef	unsigned char	u_char;
+typedef	unsigned short	u_short;
+typedef	unsigned int	u_int;
+typedef	unsigned long	u_long;
+typedef	unsigned short	ushort;		 
+typedef	unsigned int	uint;		 
+typedef	struct  _physadr_t { int r[1]; } *physadr_t;
+typedef	struct label_t {
+	int	val[2];
+} label_t;
+typedef	struct	_quad_t { long val[2]; } quad_t;
+typedef	long	daddr_t;
+typedef	char *	caddr_t;
+typedef	unsigned long	ino_t;
+typedef	short	dev_t;
+typedef	long	off_t;
+typedef	unsigned short	uid_t;
+typedef	unsigned short	gid_t;
+typedef	long	key_t;
+typedef	char *	addr_t;
+typedef	long	fd_mask;
+typedef	struct fd_set {
+	fd_mask	fds_bits[((( 256  )+((  (sizeof (fd_mask) * 8 )  )-1))/(  (sizeof (fd_mask) * 8 )  )) ];
+} fd_set;
+extern "C" {
+extern int mkstemp(char *);
+extern int strncasecmp(const char*, const char*, size_t);
+extern int strcasecmp(const char*, const char*);
+extern long random(void);
+extern int seteuid(uid_t);
+extern int setegid(gid_t);
+extern int ftruncate(int, off_t);
+extern int getdtablesize(void);
+struct fd_set;
+struct timeval;
+extern int select(int,struct fd_set*,struct fd_set*,struct fd_set*,struct timeval*);
+extern int ioctl(int, int, ...);
+extern int fchown(int, uid_t, gid_t);
+extern int gethostname(char*, int);
+extern char* optarg;
+extern int opterr;
+extern int optind;
+extern char* mktemp(char*);
+extern void syslog(int, const char*, ...);
+extern void vsyslog(int, const char*, va_list);
+extern void closelog(void);
+extern void openlog(const char*, int, int);
+extern int fchmod(int, mode_t);
+struct timezone;
+struct timeval;
+extern int gettimeofday(struct timeval*, struct timezone*);
+extern void endpwent(void);
+extern int getpeername(int,void*,int*);
+extern int getsockname(int,void*,int*);
+extern int socket(int, int, int);
+extern int connect(int, const void*, int);
+extern int flock(int, int);
+}
+typedef unsigned char fxBool;
+inline int fxmin(int a, int b)		{ return (a < b) ? a : b; }
+inline u_long fxmin(u_long a, u_long b)	{ return (a < b) ? a : b; }
+inline u_int fxmin(u_int a, u_int b)	{ return (a < b) ? a : b; }
+inline int fxmax(int a, int b)		{ return (a > b) ? a : b; }
+inline u_long fxmax(u_long a, u_long b)	{ return (a > b) ? a : b; }
+inline u_int fxmax(u_int a, u_int b)	{ return (a > b) ? a : b; }
+extern "C" void _fxassert(const char*, const char*, int);
+class fxObj {
+public:
+    fxObj();
+    virtual ~fxObj();
+    void inc();
+    void dec();
+    u_long getReferenceCount();
+    virtual const char* className() const;
+    int compare(const fxObj *) const;
+    virtual void subClassMustDefine(const char* method) const;
+protected:
+    u_long	referenceCount;
+};
+inline fxObj::fxObj()				{ referenceCount = 0; }
+inline void fxObj::inc()			{ ++referenceCount; }
+inline void fxObj::dec() {
+    if ( referenceCount>0 ); else _fxassert( "Bogus object reference count" ,"../util/Obj.h",54); ;
+    if (0 >= --referenceCount) delete this;
+}
+inline u_long fxObj::getReferenceCount()	{ return referenceCount; }
+class fxStr;
+class fxTempStr {
+public:
+    fxTempStr(fxTempStr const &other);
+    ~fxTempStr();
+    friend fxTempStr operator|(fxStr const&, fxStr const&);
+    friend fxTempStr operator|(fxStr const&, char const*);
+    friend fxTempStr operator|(char const*, fxStr const&);
+    friend fxTempStr& operator|(const fxTempStr&, fxStr const& b);
+    friend fxTempStr& operator|(const fxTempStr&, char const* b);
+    operator char*() const;
+    operator int() const;
+    operator float() const;
+    operator double() const;
+    u_int length() const;
+protected:
+    char	indata[100];		 
+    char*	data;			 
+    u_int	slength;		 
+    friend class fxStr;
+    fxTempStr(char const *, u_int, char const *, u_int);
+    fxTempStr& concat(char const* b, u_int bl);
+};
+inline fxTempStr::operator char*() const	{ return data; }
+inline fxTempStr::operator int() const		{ return atoi(data); }
+inline fxTempStr::operator float() const	{ return float(atof(data)); }
+inline fxTempStr::operator double() const	{ return double(atof(data)); }
+inline u_int fxTempStr::length() const		{ return slength - 1; }
+class fxStr {
+    friend class fxTempStr;
+public:
+    fxStr(u_int l=0);
+    fxStr(char const *s);
+    fxStr(char const *s, u_int len);
+    fxStr(fxStr const&);
+    fxStr(int, char const* format);
+    fxStr(long, char const* format);
+    fxStr(float, char const* format);
+    fxStr(double, char const* format);
+    fxStr(const fxTempStr&);
+    ~fxStr();
+    u_long hash() const;
+    operator char*() const
+	{ return data; }
+    operator int() const
+	{ return atoi(data); }
+    operator float() const
+	{ return float(atof(data)); }
+    operator double() const
+	{ return double(atof(data)); }
+    u_int length() const { return slength-1; }
+    char& operator[](u_int i) const
+    {   if ( i<slength-1 ); else _fxassert( "Invalid Str[] index" ,"../util/Str.h",109); ;
+	return data[i]; }
+    void operator=(const fxTempStr& s);
+    void operator=(fxStr const& s);
+    void operator=(char const *s);
+    friend fxBool operator==(fxStr const&, fxStr const&);
+    friend fxBool operator==(fxStr const&, char const*);
+    friend fxBool operator==(fxStr const&, char *);
+    friend fxBool operator==(char const*, fxStr const&);
+    friend fxBool operator!=(fxStr const&, fxStr const&);
+    friend fxBool operator!=(fxStr const&, char const*);
+    friend fxBool operator!=(char const*, fxStr const&);
+    friend fxBool operator>=(fxStr const&, fxStr const&);
+    friend fxBool operator>=(fxStr const&, char const*);
+    friend fxBool operator>=(char const*, fxStr const&);
+    friend fxBool operator<=(fxStr const&, fxStr const&);
+    friend fxBool operator<=(fxStr const&, char const*);
+    friend fxBool operator<=(char const*, fxStr const&);
+    friend fxBool operator>(fxStr const&, fxStr const&);
+    friend fxBool operator>(fxStr const&, char const*);
+    friend fxBool operator>(char const*, fxStr const&);
+    friend fxBool operator<(fxStr const&, fxStr const&);
+    friend fxBool operator<(fxStr const&, char const*);
+    friend fxBool operator<(char const*, fxStr const&);
+    int compare(fxStr const *a) const { return ::compare(*this, *a); }
+    friend int compare(fxStr const&, fxStr const&);
+    friend int compare(fxStr const&, char const*);
+    friend int compare(char const*, fxStr const&);
+    friend fxTempStr& operator|(const fxTempStr&, fxStr const&);
+    friend fxTempStr& operator|(const fxTempStr&, char const*);
+    friend fxTempStr operator|(fxStr const&, fxStr const&);
+    friend fxTempStr operator|(fxStr const&, char const*);
+    friend fxTempStr operator|(char const*, fxStr const&);
+    fxStr copy() const;
+    fxStr extract(u_int start,u_int len) const;
+    fxStr cut(u_int start,u_int len);
+    fxStr head(u_int) const;
+    fxStr tail(u_int) const;
+    void lowercase(u_int posn=0, u_int len=0);
+    void raisecase(u_int posn=0, u_int len=0);
+    void remove(u_int posn,u_int len=1);
+    void resize(u_int len, fxBool reallocate = ((fxBool)0) );
+    void setMaxLength(u_int maxlen);
+    void append(char a);
+    void append(char const *s, u_int len=0);
+    void append(const fxTempStr& s)
+	{ append((char*)s, s.slength-1); }
+    void append(fxStr const& s)
+	{ append((char*)s, s.slength-1); }
+    void insert(char a, u_int posn=0);
+    void insert(char const *, u_int posn=0, u_int len=0);
+    void insert(const fxTempStr& s, u_int posn=0)
+	{ insert((char*)s, posn, s.slength-1); }
+    void insert(fxStr const& s, u_int posn=0)
+	{ insert((char*)s, posn, s.slength-1); }
+    u_int next(u_int posn, char delimiter) const;
+    u_int next(u_int posn, char const *delimiters, u_int len=0) const;
+    u_int next(u_int posn, fxStr const& delimiters) const
+	{ return next(posn, (char*)delimiters, delimiters.slength-1); }
+    u_int nextR(u_int posn, char delimiter) const;
+    u_int nextR(u_int posn, char const*, u_int len=0) const;
+    u_int nextR(u_int posn, fxStr const& delimiters) const
+	{ return nextR(posn, (char*)delimiters, delimiters.slength-1); }
+    u_int skip(u_int posn, char a) const; 
+    u_int skip(u_int posn, char const *, u_int len=0) const;
+    u_int skip(u_int posn, fxStr const& delimiters) const
+	{ return skip(posn, (char*)delimiters, delimiters.slength-1); }
+    u_int skipR(u_int posn, char a) const;
+    u_int skipR(u_int posn, char const *, u_int len=0) const;
+    u_int skipR(u_int posn, fxStr const& delimiters) const
+	{ return skipR(posn, (char*)delimiters, delimiters.slength-1); }
+    fxStr token(u_int & posn, char delimiter) const;
+    fxStr token(u_int & posn, char const * delimiters,
+	u_int delimiters_len = 0) const;
+    fxStr token(u_int & posn, fxStr const & delimiters) const
+	{ return token(posn, delimiters.data, delimiters.slength-1); }
+    fxStr tokenR(u_int & posn, char delimiter) const;
+    fxStr tokenR(u_int & posn, char const * delimiters,
+	u_int delimiters_len = 0) const;
+    fxStr tokenR(u_int & posn, fxStr const & delimiters) const
+	{ return tokenR(posn, delimiters.data, delimiters.slength-1); }
+protected:
+    u_int slength;
+    char * data; 
+    static char emptyString;
+    void fxStr::resizeInternal(u_int);
+    int findEndBuffer(const char *, u_int buflen) const;
+    int findBuffer(const char *buf, u_int buflen) const;
+    void bracketBuffer(const char *, u_int buflen, int &, int &) const;
+};
+struct Class2Params {
+    u_int vr;		 
+    u_int br;		 
+    u_int wd;		 
+    u_int ln;		 
+    u_int df;		 
+    u_int ec;		 
+    u_int bf;		 
+    u_int st;		 
+    static u_int vrDISTab[2];		 
+    static u_int dfDISTab[4];		 
+    static u_int wdDISTab[8];		 
+    static u_int lnDISTab[3];		 
+    static u_int stDISTab[8];		 
+    static u_int stDCSTab[8];		 
+    static u_int brDISTab[8];		 
+    static u_int brDCSTab[8];		 
+    static u_int DISvrTab[2];		 
+    static u_int DISdfTab[2];		 
+    static u_int DISwdTab[4];		 
+    static u_int DISlnTab[4];		 
+    static u_int DISstTab[8];		 
+    static u_int DISbrTab[16];		 
+    static u_int DCSbrTab[16];		 
+    static const char* bitRateNames[8];		 
+    static const char* dataFormatNames[4];	 
+    static const char* vresNames[2];		 
+    static const char* pageWidthNames[8];	 
+    static const char* pageLengthNames[4];	 
+    static const char* scanlineTimeNames[8];	 
+    Class2Params();
+    int operator==(const Class2Params&) const;
+    int operator!=(const Class2Params&) const;
+    fxStr cmd() const;			 
+    void setFromDIS(u_int dis, u_int xinfo = 0);
+    void setFromDCS(u_int dcs, u_int xinfo = 0);
+    u_int getDCS() const;
+    fxBool is2D() const;
+    u_int pageWidth() const;
+    u_int transferSize(u_int ms) const;
+    u_int minScanlineSize() const;
+    fxStr encode() const;		 
+    void decode(const fxStr&);		 
+};
+typedef	struct {
+	unsigned short tiff_magic;	 
+	unsigned short tiff_version;	 
+	unsigned long  tiff_diroff;	 
+} TIFFHeader;
+typedef	struct {
+	unsigned short tdir_tag;	 
+	unsigned short tdir_type;	 
+	unsigned long  tdir_count;	 
+	unsigned long  tdir_offset;	 
+} TIFFDirEntry;
+typedef	enum {
+	TIFF_NOTYPE	= 0,	 
+	TIFF_BYTE	= 1,	 
+	TIFF_ASCII	= 2,	 
+	TIFF_SHORT	= 3,	 
+	TIFF_LONG	= 4,	 
+	TIFF_RATIONAL	= 5,	 
+	TIFF_SBYTE	= 6,	 
+	TIFF_UNDEFINED	= 7,	 
+	TIFF_SSHORT	= 8,	 
+	TIFF_SLONG	= 9,	 
+	TIFF_SRATIONAL	= 10,	 
+	TIFF_FLOAT	= 11,	 
+	TIFF_DOUBLE	= 12	 
+} TIFFDataType;
+typedef	struct tiff TIFF;
+extern int fclose (struct _iobuf  *);
+extern int fflush (struct _iobuf  *);
+extern int fgetc (struct _iobuf  *);
+extern int fgetpos (struct _iobuf  *, long *);
+extern int fprintf (struct _iobuf  *, const char *, ...);
+extern int fputc (int, struct _iobuf  *);
+extern int fputs (const char *, struct _iobuf  *);
+extern long unsigned int fread (void *, long unsigned int , long unsigned int , struct _iobuf  *);
+extern int fscanf (struct _iobuf  *, const char *, ...);
+extern int fseek (struct _iobuf  *, long int, int);
+extern int fsetpos (struct _iobuf  *, const long *);
+extern long unsigned int fwrite (const void *, long unsigned int , long unsigned int , struct _iobuf  *);
+extern int pclose (struct _iobuf  *);
+extern void perror (const char *);
+extern int printf (const char *, ...);
+extern int puts (const char *);
+extern int remove (const char *);
+extern int rename (const char *, const char *);
+extern void rewind (struct _iobuf  *);
+extern int scanf (const char *, ...);
+extern void setbuf (struct _iobuf  *, char *);
+extern int setvbuf (struct _iobuf  *, char *, int, long unsigned int );
+extern int sscanf (const char *, const char *, ...);
+extern int vprintf (const char *, __gnuc_va_list);
+extern int vsprintf (char *, const char *, __gnuc_va_list);
+extern int vfprintf (struct _iobuf  *, const char *, __gnuc_va_list);
+extern int ungetc (int, struct _iobuf  *);
+extern int _flsbuf (unsigned int, struct _iobuf  *);
+extern int _filbuf (struct _iobuf  *);
+typedef	void (*TIFFErrorHandler)(const char* module, const char* fmt, va_list);
+typedef	int (*TIFFReadWriteProc)(void*, char*, unsigned long);
+typedef	long (*TIFFSeekProc)(void*, long, int);
+typedef	int (*TIFFCloseProc)(void*);
+typedef	long (*TIFFSizeProc)(void*);
+typedef	int (*TIFFMapFileProc)(void*, char**, long*);
+typedef	void (*TIFFUnmapFileProc)(void*, char*, long);
+extern "C" {
+extern	const char* TIFFGetVersion();
+extern	void TIFFClose(TIFF*);
+extern	int TIFFFlush(TIFF*);
+extern	int TIFFFlushData(TIFF*);
+extern	int TIFFGetField(TIFF*, unsigned int, ...);
+extern	int TIFFVGetField(TIFF*, unsigned int, va_list);
+extern	int TIFFGetFieldDefaulted(TIFF*, unsigned int, ...);
+extern	int TIFFVGetFieldDefaulted(TIFF*, unsigned int, va_list);
+extern	int TIFFReadDirectory(TIFF*);
+extern	unsigned long TIFFScanlineSize(TIFF*);
+extern	unsigned long TIFFStripSize(TIFF*);
+extern	unsigned long TIFFVStripSize(TIFF*, unsigned long);
+extern	unsigned long TIFFTileRowSize(TIFF*);
+extern	unsigned long TIFFTileSize(TIFF*);
+extern	unsigned long TIFFVTileSize(TIFF*, unsigned long);
+extern	int TIFFFileno(TIFF*);
+extern	int TIFFGetMode(TIFF*);
+extern	int TIFFIsTiled(TIFF*);
+extern	long TIFFCurrentRow(TIFF*);
+extern	int TIFFCurrentDirectory(TIFF*);
+extern	int TIFFCurrentStrip(TIFF*);
+extern	int TIFFCurrentTile(TIFF*);
+extern	int TIFFReadBufferSetup(TIFF*, char*, unsigned long);
+extern	int TIFFLastDirectory(TIFF*);
+extern	int TIFFSetDirectory(TIFF*, int);
+extern	int TIFFSetField(TIFF*, unsigned int, ...);
+extern	int TIFFVSetField(TIFF*, unsigned int, va_list);
+extern	int TIFFWriteDirectory(TIFF *);
+extern	void TIFFPrintDirectory(TIFF*, struct _iobuf *, long = 0);
+extern	int TIFFReadScanline(TIFF*, unsigned char*, unsigned, unsigned = 0);
+extern	int TIFFWriteScanline(TIFF*, unsigned char*, unsigned, unsigned = 0);
+extern	int TIFFReadRGBAImage(TIFF*,
+	    unsigned long, unsigned long, unsigned long*, int stop = 0);
+extern	TIFF* TIFFOpen(const char*, const char*);
+extern	TIFF* TIFFFdOpen(int, const char*, const char*);
+extern	TIFF* TIFFClientOpen(const char* name, const char* mode,
+	    void* clientdata,
+	    TIFFReadWriteProc readproc, TIFFReadWriteProc writeproc,
+	    TIFFSeekProc seekproc, TIFFCloseProc closeproc,
+	    TIFFSizeProc sizeproc,
+	    TIFFMapFileProc mapproc, TIFFUnmapFileProc unmapproc);
+extern	const char* TIFFFileName(TIFF*);
+extern	void TIFFError(const char*, const char*, ...);
+extern	void TIFFWarning(const char*, const char*, ...);
+extern	TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler handler);
+extern	TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler handler);
+extern	unsigned int TIFFComputeTile(TIFF*,
+	    unsigned long, unsigned long, unsigned long, unsigned int);
+extern	int TIFFCheckTile(TIFF*,
+	    unsigned long, unsigned long, unsigned long, unsigned);
+extern	unsigned int TIFFNumberOfTiles(TIFF*);
+extern	int TIFFReadTile(TIFF*,
+	    unsigned char*,
+	    unsigned long, unsigned long, unsigned long,
+	    unsigned int);
+extern	int TIFFWriteTile(TIFF*,
+	    unsigned char*,
+	    unsigned long, unsigned long, unsigned long,
+	    unsigned int);
+extern	unsigned int TIFFComputeStrip(TIFF*, unsigned long, unsigned int);
+extern	unsigned int TIFFNumberOfStrips(TIFF*);
+extern	int TIFFReadEncodedStrip(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	int TIFFReadRawStrip(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	int TIFFReadEncodedTile(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	int TIFFReadRawTile(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	int TIFFWriteEncodedStrip(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	int TIFFWriteRawStrip(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	int TIFFWriteEncodedTile(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	int TIFFWriteRawTile(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	void TIFFSetWriteOffset(TIFF*, unsigned long);
+extern	void TIFFSwabShort(unsigned short *);
+extern	void TIFFSwabLong(unsigned long *);
+extern	void TIFFSwabArrayOfShort(unsigned short *, unsigned long);
+extern	void TIFFSwabArrayOfLong(unsigned long *, unsigned long);
+extern	void TIFFReverseBits(unsigned char *, unsigned long);
+extern	const unsigned char* TIFFGetBitRevTable(int);
+}
+struct G3Base {
+    short	data;		 
+    short	bit;		 
+    fxBool	is2D;		 
+    enum { G3_1D, G3_2D } tag;	 
+    const u_char* bitmap;	 
+    static const u_char zeroruns[256];
+    static const u_char oneruns[256];
+    static int findspan(const u_char**, int, int, const u_char*);
+    static int finddiff(const u_char*, int, int);
+    static void fillspan(u_char* cp, int x, int count);
+    void setup(const u_char*, fxBool is2d);
+};
+class fxStackBuffer;
+class G3Decoder : private G3Base {
+private:
+    short	bytePending;	 
+    short	prevByte;	 
+    u_char*	refline;	 
+    fxStackBuffer* recvBuf;	 
+    fxBool	decode1DRow(u_char*, u_int);
+    fxBool	decode2DRow(u_char*, u_int);
+    int		nextBit();
+    void	ungetBit();
+    int		nextByte();
+    int		decodeWhiteRun();
+    int		decodeBlackRun();
+    int		decodeUncompCode();
+    void	skipToEOL(int len);
+protected:
+    G3Decoder();
+    void	raiseEOF();
+    void	raiseRTC();
+    void	setPendingByte(u_char);
+    virtual int decodeNextByte() = 0;
+    void	setRefLine(u_char*);
+    u_char*	getRefLine();
+    virtual void invalidCode(const char* type, int x);
+    virtual void prematureEOL(const char* type, int x);
+    virtual void badPixelCount(const char* type, int x);
+    virtual void badDecodingState(const char* type, int x);
+public:
+    sigjmp_buf	jmpEOF;		 
+    sigjmp_buf	jmpRTC;		 
+    virtual ~G3Decoder();
+    void	setupDecoder(u_int, fxBool is2D);
+    void	decode(void* raster, u_int w, u_int h);
+    void	skip(u_int h);
+    void	skipLeader();
+    fxBool	decodeRow(void* scanline, u_int w);
+    void	skipRow();
+    fxBool	isLastRow1D();
+    fxBool	isNextRow1D();
+    fxBool	isByteAligned();
+    void	setRecvBuf(fxStackBuffer&);
+    fxStackBuffer* getRecvBuf();
+    void	flushRecvBuf();
+};
+inline void G3Decoder::setRecvBuf(fxStackBuffer& b){ recvBuf = &b; }
+inline fxStackBuffer* G3Decoder::getRecvBuf()	{ return recvBuf; }
+inline void G3Decoder::setRefLine(u_char* b)	{ refline = b; }
+inline u_char* G3Decoder::getRefLine()		{ return refline; }
+inline fxBool G3Decoder::isLastRow1D()		{ return tag == G3_1D; }
+enum FaxSendStatus {
+    send_retry,			 
+    send_failed,		 
+    send_done,			 
+    send_reformat,		 
+};
+class FaxServer;
+class FaxMachineInfo;
+class ModemConfig;
+class fxStackBuffer;
+class FaxFont;
+class FaxRequest;
+typedef unsigned int CallStatus;	 
+typedef	unsigned int CallType;		 
+typedef	unsigned int AnswerType;	 
+typedef unsigned int SpeakerVolume;
+typedef	unsigned int ATResponse;	 
+typedef	unsigned int BaudRate;		 
+typedef	unsigned int FlowControl;	 
+typedef	unsigned int SetAction;		 
+typedef struct {
+    const char*	msg;		 
+    u_short	len;		 
+    ATResponse	expect;		 
+    CallStatus	status;		 
+    CallType	type;		 
+} AnswerMsg;
+class FaxModem : public G3Decoder {
+public:
+    static FaxModem* deduceModem(FaxServer&, const ModemConfig& config);
+    enum {			 
+	OK	   = 0,		 
+	BUSY	   = 1,		 
+	NOCARRIER  = 2,		 
+	NOANSWER   = 3,		 
+	NODIALTONE = 4,		 
+	ERROR	   = 5,		 
+	FAILURE	   = 6,		 
+	NOFCON	   = 7,		 
+	DATACONN   = 8,		 
+    };
+    enum {			 
+	CALLTYPE_ERROR	= 0,	 
+	CALLTYPE_DATA	= 1,	 
+	CALLTYPE_FAX	= 2,	 
+	CALLTYPE_VOICE	= 3,	 
+	CALLTYPE_UNKNOWN = 4,	 
+    };
+    enum {			 
+	OFF	= 0,		 
+	QUIET	= 1,		 
+	LOW	= 2,		 
+	MEDIUM	= 3,		 
+	HIGH	= 4,		 
+    };
+    enum {			 
+	BR0	= 0,		 
+	BR300	= 1,		 
+	BR1200	= 2,		 
+	BR2400	= 3,		 
+	BR4800	= 4,		 
+	BR9600	= 5,		 
+	BR19200	= 6,		 
+	BR38400	= 7,		 
+	BR57600	= 8,		 
+	BR76800	= 9,		 
+    };
+    enum {			 
+	FLOW_NONE	= 0,	 
+	FLOW_XONXOFF	= 1,	 
+	FLOW_RTSCTS	= 2	 
+    };
+    enum {			 
+	ACT_NOW		= 0,	 
+	ACT_DRAIN	= 1,	 
+	ACT_FLUSH	= 2,	 
+    };
+    enum {			 
+	ANSTYPE_ANY	= 0,	 
+	ANSTYPE_DATA	= 1,	 
+	ANSTYPE_FAX	= 2,	 
+	ANSTYPE_VOICE	= 3,	 
+    };
+    enum {			 
+	AT_NOTHING	= 0,	 
+	AT_OK		= 1,	 
+	AT_CONNECT	= 2,	 
+	AT_NOANSWER	= 3,	 
+	AT_NOCARRIER	= 4,	 
+	AT_NODIALTONE	= 5,	 
+	AT_BUSY		= 6,	 
+	AT_OFFHOOK	= 7,	 
+	AT_RING		= 8,	 
+	AT_ERROR	= 9,	 
+	AT_EMPTYLINE	= 10,	 
+	AT_TIMEOUT	= 11,	 
+	AT_OTHER	= 12,	 
+    };
+private:
+    FaxServer&	server;		 
+    fxStr	resetCmds;	 
+    long	dataTimeout;	 
+    BaudRate	rate;		 
+    FlowControl	iFlow;		 
+    FlowControl	oFlow;		 
+    u_int	pageNumber;	 
+    FaxFont*	tagLineFont;	 
+    u_int	tagLineSlop;	 
+    fxStr	tagLine;	 
+    u_int	tagLineFields;	 
+    void	setupTagLine(const FaxRequest&);
+    u_int	cblc;		 
+    fxBool	lastRowBad;	 
+    u_long	recvEOLCount;	 
+    u_long	recvBadLineCount;
+    u_long	recvConsecutiveBadLineCount;
+    u_int	recvCC;		 
+    fxStackBuffer* recvBuf;	 
+    u_long	savedWriteOff;	 
+    void	recvRow(TIFF* tif, fxStackBuffer& row, u_char* buf);
+    void	invalidCode(const char* type, int x);
+    void	prematureEOL(const char* type, int x);
+    void	badPixelCount(const char* type, int x);
+    void	badDecodingState(const char* type, int x);
+protected:
+    const ModemConfig& conf;	 
+    FlowControl	flowControl;	 
+    u_int	modemServices;	 
+    fxStr	modemMfr;	 
+    fxStr	modemModel;	 
+    fxStr	modemRevision;	 
+    Class2Params modemParams;	 
+    char	rbuf[1024];	 
+    ATResponse	lastResponse;	 
+    fxStr	mfrQueryCmd;	 
+    fxStr	modelQueryCmd;	 
+    fxStr	revQueryCmd;	 
+    static const char* serviceNames[9];	  
+    static const u_char digitMap[12*2+1]; 
+    static const char* callStatus[9];	  
+    FaxModem(FaxServer&, const ModemConfig&);
+    virtual fxBool selectBaudRate(BaudRate max, FlowControl i, FlowControl o);
+    virtual fxBool setupModem() = 0;
+    virtual fxBool setupManufacturer(fxStr& mfr);
+    virtual fxBool setupModel(fxStr& model);
+    virtual fxBool setupRevision(fxStr& rev);
+    fxBool doQuery(const fxStr& queryCmd, fxStr& result, long ms = 30*1000);
+    virtual const AnswerMsg* findAnswer(const char* s);
+    virtual CallType answerResponse(fxStr& emsg);
+    virtual CallStatus dialResponse(fxStr& emsg) = 0;
+    void	setDataTimeout(long secs, u_int br);
+    long	getDataTimeout() const;
+    void	pause(u_int ms);
+    void	countPage();
+    void	modemTrace(const char* fmt, ...);
+    void	modemSupports(const char* fmt, ...);
+    void	modemCapability(const char* fmt, ...);
+    void	protoTrace(const char* fmt, ...);
+    void	recvTrace(const char* fmt, ...);
+    void	copyQualityTrace(const char* fmt, ...);
+    void	serverTrace(const char* fmt, ...);
+    void	traceBits(u_int bits, const char* bitNames[]);
+    void	traceModemParams();
+    void	tracePPR(const char* dir, u_int ppr);
+    void	tracePPM(const char* dir, u_int ppm);
+    void	trimModemLine(char buf[], int& cc);
+    int		getModemLine(char buf[], u_int bufSize, long ms = 0);
+    void	beginTimedTransfer();
+    void	endTimedTransfer();
+    fxBool	wasTimeout();
+    void	setTimeout(fxBool);
+    void	flushModemInput();
+    fxBool	putModem(void* data, int n, long ms = 0);
+    fxBool	putModemData(void* data, int n);
+    fxBool	putModemDLEData(const u_char* data, u_int,
+		    const u_char* brev, long ms);
+    fxBool	putModemLine(const char* cp);
+    int		getModemChar(long ms = 0);
+    int		getModemDataChar();
+    void	startTimeout(long ms);
+    void	stopTimeout(const char* whichdir);
+    static const char* ATresponses[13];
+    virtual ATResponse atResponse(char* buf, long ms = 30*1000);
+    virtual fxBool waitFor(ATResponse wanted, long ms = 30*1000);
+    fxBool	atCmd(const fxStr& cmd, ATResponse = AT_OK, long ms = 30*1000);
+    fxBool	atQuery(const char* what, u_int& v, long ms = 30*1000);
+    fxBool	atQuery(const char* what, fxStr& v, long ms = 30*1000);
+    u_int	fromHex(const char*, int = -1);
+    fxStr	toHex(int, int ndigits);
+    fxBool	parseRange(const char*, u_int&);
+    fxBool	vparseRange(const char*, int nargs ...);
+    fxBool	vatFaxCmd(ATResponse resp, const char* cmd ... );
+    fxBool	sendBreak(fxBool pause);
+    fxBool	setBaudRate(BaudRate rate);
+    fxBool	setBaudRate(BaudRate rate, FlowControl i, FlowControl o);
+    fxBool	setXONXOFF(FlowControl i, FlowControl o, SetAction);
+    fxBool	setDTR(fxBool on);
+    fxBool	setInputBuffering(fxBool on);
+    fxBool	modemStopOutput();
+    FlowControl	getInputFlow();
+    FlowControl	getOutputFlow();
+    fxBool	getProtocolTracing();
+    fxBool	getHDLCTracing();
+    FaxSendStatus sendSetupParams(TIFF*, Class2Params&,
+		    FaxMachineInfo&, fxStr&);
+    fxBool	recvCheckTSI(const fxStr&);
+    void	recvCSI(fxStr&);
+    void	recvDCS(Class2Params&);
+    void	recvNSF(u_int nsf);
+    void	recvSetupPage(TIFF* tif, long group3opts, int fillOrder);
+    void	recvResetPage(TIFF* tif);
+    fxBool	abortRequested();
+    fxBool	decodePPM(const fxStr& pph, u_int& ppm, fxStr& emsg);
+    fxBool	recvPageDLEData(TIFF* tif, fxBool checkQuality,
+		    const Class2Params& params, fxStr& emsg);
+    virtual void abortPageRecv() = 0;
+    virtual int decodeNextByte();
+    fxBool	checkQuality();
+    fxBool	isQualityOK(const Class2Params&);
+    u_long	getRecvEOLCount() const;
+    u_long	getRecvBadLineCount() const;
+    u_long	getRecvConsecutiveBadLineCount() const;
+    fxBool	setupTagLineSlop(const Class2Params&);
+    u_int	getTagLineSlop() const;
+    u_char*	imageTagLine(u_char* buf, u_int fillorder, const Class2Params&);
+public:
+    virtual ~FaxModem();
+    virtual fxBool dataService();		 
+    virtual fxBool voiceService();		 
+    virtual fxBool sync(long ms = 0);		 
+    virtual fxBool reset(long ms = 5*1000);	 
+    virtual void hangup();			 
+    virtual void setSpeakerVolume(SpeakerVolume);
+    virtual void setLID(const fxStr& number) = 0;
+    const fxStr& getModel() const;
+    const fxStr& getManufacturer() const;
+    const fxStr& getRevision() const;
+    virtual fxBool supports2D() const;
+    virtual fxBool supportsEOLPadding() const;
+    virtual fxBool supportsVRes(float res) const;
+    virtual fxBool supportsPageWidth(u_int w) const;
+    virtual fxBool supportsPageLength(u_int l) const;
+    virtual fxBool supportsPolling() const;
+    virtual int selectSignallingRate(int br) const;
+    u_int getBestSignallingRate() const;
+    u_int getBestScanlineTime() const;
+    virtual int selectScanlineTime(int st) const;
+    u_int getBestVRes() const;
+    u_int getBestDataFormat() const;
+    u_int getBestPageWidth() const;
+    u_int getBestPageLength() const;
+    u_int modemDIS() const;
+    virtual CallStatus dial(const char* number,
+	const Class2Params& dis, fxStr& emsg);
+    virtual void sendBegin(const FaxRequest&);
+    virtual fxBool getPrologue(Class2Params&,
+	u_int& nsf, fxStr& csi, fxBool& hasDoc) = 0;
+    virtual void sendSetupPhaseB();
+    virtual FaxSendStatus sendPhaseB(TIFF*, Class2Params&, FaxMachineInfo&,
+	fxStr& pph, fxStr& emsg) = 0;
+    virtual void sendEnd();
+    virtual void sendAbort() = 0;
+    virtual fxBool waitForRings(u_int rings);
+    virtual CallType answerCall(AnswerType, fxStr& emsg);
+    virtual fxBool recvBegin(fxStr& emsg) = 0;
+    virtual fxBool recvPage(TIFF*, int& ppm, fxStr& em) = 0;
+    virtual fxBool recvEnd(fxStr& emsg) = 0;
+    virtual void recvAbort() = 0;
+    virtual fxBool requestToPoll() = 0;
+    virtual fxBool pollBegin(const fxStr& pollID, fxStr& emsg) = 0;
+};
+inline long FaxModem::getDataTimeout() const		{ return dataTimeout; }
+inline const fxStr& FaxModem::getModel() const		{ return modemModel; }
+inline const fxStr& FaxModem::getManufacturer() const	{ return modemMfr; }
+inline const fxStr& FaxModem::getRevision() const	{ return modemRevision; }
+inline FlowControl FaxModem::getInputFlow()		{ return iFlow; }
+inline FlowControl FaxModem::getOutputFlow()		{ return oFlow; }
+inline u_int FaxModem::getTagLineSlop() const		{ return tagLineSlop; }
+struct ModemConfig {
+    fxStr	type;			 
+    fxStr	resetCmds;		 
+    fxStr	dialCmd;		 
+    fxStr	answerAnyCmd;		 
+    fxStr	answerDataCmd;		 
+    fxStr	answerFaxCmd;		 
+    fxStr	answerVoiceCmd;		 
+    fxStr	flowControlCmd;		 
+    fxStr	setupDTRCmd;		 
+    fxStr	setupDCDCmd;		 
+    fxStr	setupAACmd;		 
+    fxStr	noAutoAnswerCmd;	 
+    fxStr	setVolumeCmd[5];	 
+    fxStr	echoOffCmd;		 
+    fxStr	verboseResultsCmd;	 
+    fxStr	resultCodesCmd;		 
+    fxStr	onHookCmd;		 
+    fxStr	softResetCmd;		 
+    fxStr	waitTimeCmd;		 
+    fxStr	pauseTimeCmd;		 
+    fxStr	mfrQueryCmd;		 
+    fxStr	modelQueryCmd;		 
+    fxStr	revQueryCmd;		 
+    fxStr	answerAnyBeginCmd;	 
+    fxStr	answerDataBeginCmd;	 
+    fxStr	answerFaxBeginCmd;	 
+    fxStr	answerVoiceBeginCmd;	 
+    fxStr	sendBeginCmd;		 
+    u_int	t1Timer;		 
+    u_int	t2Timer;		 
+    u_int	t4Timer;		 
+    u_int	dialResponseTimeout;	 
+    u_int	answerResponseTimeout;	 
+    u_int	pageStartTimeout;	 
+    u_int	pageDoneTimeout;	 
+    fxStr	class1Cmd;		 
+    u_int	class1TCFResponseDelay;	 
+    u_int	class1SendPPMDelay;	 
+    u_int	class1SendTCFDelay;	 
+    u_int	class1TrainingRecovery;	 
+    u_int	class1RecvAbortOK;	 
+    u_int	class1FrameOverhead;	 
+    u_int	class1RecvIdentTimer;	 
+    u_int	class1TCFMaxNonZero;	 
+    u_int	class1TCFMinRun;	 
+    fxStr	class2Cmd;		 
+    fxStr	class2DCCQueryCmd;	 
+    fxStr	class2CQQueryCmd;	 
+    fxStr	class2BORCmd;		 
+    fxStr	class2RELCmd;		 
+    fxStr	class2CQCmd;		 
+    fxStr	class2AbortCmd;		 
+    fxStr	class2TBCCmd;		 
+    fxStr	class2CRCmd;		 
+    fxStr	class2PHCTOCmd;		 
+    fxStr	class2BUGCmd;		 
+    fxStr	class2LIDCmd;		 
+    fxStr	class2DCCCmd;		 
+    fxStr	class2DISCmd;		 
+    fxStr	class2DDISCmd;		 
+    fxStr	class2CIGCmd;		 
+    fxStr	class2SPLCmd;		 
+    fxStr	class2PTSCmd;		 
+    fxStr	class2RecvDataTrigger;	 
+    fxBool	class2XmitWaitForXON;	 
+    fxStr	class2PIECmd;		 
+    fxStr	class2NRCmd;		 
+    FlowControl	flowControl;		 
+    BaudRate	maxRate;		 
+    u_int	recvFillOrder;		 
+    u_int	sendFillOrder;		 
+    u_int	frameFillOrder;		 
+    u_int	resetDelay;		 
+    u_int	baudRateDelay;		 
+    u_int	maxPacketSize;		 
+    u_int	interPacketDelay;	 
+    u_int	percentGoodLines;	 
+    u_int	maxConsecutiveBadLines;	 
+    fxBool	waitForConnect;		 
+    fxStr	tagLineFmt;		 
+    fxStr	tagLineFontFile;	 
+    ModemConfig();
+    ~ModemConfig();
+    fxBool parseItem(const char* tag, const char* value);
+    void setVolumeCmds(const fxStr& value);
+    fxStr parseATCmd(const char*);
+};
+ModemConfig::ModemConfig()
+    : type("unknown")
+    , dialCmd("DT%s")			 
+    , noAutoAnswerCmd("S0=0")
+    , echoOffCmd("E0")
+    , verboseResultsCmd("V1")
+    , resultCodesCmd("Q0")
+    , onHookCmd("H0")
+    , softResetCmd("Z")
+    , waitTimeCmd("S7=30")		 
+    , pauseTimeCmd("S8=2")		 
+    , class1Cmd("+FCLASS=1")		 
+    , class2CQQueryCmd("+FCQ=?")	 
+    , tagLineFmt("From %%n|%c|Page %%p of %%t")
+{
+    class2XmitWaitForXON = ((fxBool)1) ;	 
+    setVolumeCmds("M0 L0M1 L1M1 L2M1 L3M1");
+    answerAnyCmd = "A";
+    flowControl = FaxModem::FLOW_NONE;	 
+    maxRate = FaxModem::BR19200;	 
+    sendFillOrder = 2 ;	 
+    recvFillOrder = 2 ;	 
+    frameFillOrder = 2 ;	 
+    resetDelay = 2600;			 
+    baudRateDelay = 0;			 
+    t1Timer = ((35+5)*1000) ;			 
+    t2Timer = ((6+1)*1000) ;			 
+    t4Timer = 3100 ;			 
+    dialResponseTimeout = 3*60*1000;	 
+    answerResponseTimeout = 3*60*1000;	 
+    pageStartTimeout = 3*60*1000;	 
+    pageDoneTimeout = 3*60*1000;	 
+    class1TCFResponseDelay = 75;	 
+    class1SendPPMDelay = 75;		 
+    class1SendTCFDelay = 75;		 
+    class1TrainingRecovery = 1500;	 
+    class1RecvAbortOK = 200;		 
+    class1FrameOverhead = 4;		 
+    class1RecvIdentTimer = t1Timer;	 
+    class1TCFMinRun = (2*1500 )/3; 
+    class1TCFMaxNonZero = 10;		 
+    maxPacketSize = 16*1024;		 
+    interPacketDelay = 0;		 
+    waitForConnect = ((fxBool)0) ;		 
+    percentGoodLines = 95;		 
+    maxConsecutiveBadLines = 5;		 
+}
+ModemConfig::~ModemConfig()
+{
+}
+static fxBool getBoolean(const char* cp)
+    { return ((strcasecmp( cp ,  "on" )==0)  || (strcasecmp( cp ,  "yes" )==0) ); }
+static BaudRate
+findRate(const char* cp)
+{
+    static const struct {
+	const char* name;
+	BaudRate    br;
+    } rates[] = {
+	{   "300", FaxModem::BR300 },
+	{  "1200", FaxModem::BR1200 },
+	{  "2400", FaxModem::BR2400 },
+	{  "4800", FaxModem::BR4800 },
+	{  "9600", FaxModem::BR9600 },
+	{ "19200", FaxModem::BR19200 },
+	{ "38400", FaxModem::BR38400 },
+	{ "57600", FaxModem::BR57600 },
+	{ "76800", FaxModem::BR76800 },
+    };
+    for (int i = (sizeof ( rates ) / sizeof ( rates [0])) -1; i >= 0; i--)
+	if ((strcasecmp( cp ,  rates[i].name )==0) )
+	    return (rates[i].br);
+    return (FaxModem::BR0);
+}
+static BaudRate
+getRate(const char* cp)
+{
+    BaudRate br = findRate(cp);
+    if (br == FaxModem::BR0) {
+	syslog(3 , "Unknown baud rate \"%s\", using 19200", cp);
+	br = FaxModem::BR19200;			 
+    }
+    return (br);
+}
+static u_int
+getFill(const char* cp)
+{
+    if ((strcasecmp( cp ,  "LSB2MSB" )==0) )
+	return (2 );
+    else if ((strcasecmp( cp ,  "MSB2LSB" )==0) )
+	return (1 );
+    else {
+	syslog(3 , "Unknown fill order \"%s\"", cp);
+        return ((u_int) -1);
+    }
+}
+static FlowControl
+getFlow(const char* cp)
+{
+    if ((strcasecmp( cp ,  "xonxoff" )==0) )
+	return (FaxModem::FLOW_XONXOFF);
+    else if ((strcasecmp( cp ,  "rtscts" )==0) )
+	return (FaxModem::FLOW_RTSCTS);
+    else if ((strcasecmp( cp ,  "none" )==0) )
+	return (FaxModem::FLOW_NONE);
+    else {
+	syslog(3 , "Unknown flow control \"%s\", using xonxoff", cp);
+	return (FaxModem::FLOW_XONXOFF);	 
+    }
+}
+void
+ModemConfig::setVolumeCmds(const fxStr& tag)
+{
+    u_int l = 0;
+    for (int i = FaxModem::OFF; i <= FaxModem::HIGH; i++) {
+	fxStr tmp = tag.token(l, " \t");		 
+	setVolumeCmd[i] = parseATCmd(tmp);
+    }
+}
+fxStr
+ModemConfig::parseATCmd(const char* cp)
+{
+    fxStr cmd(cp);
+    u_int pos = 0;
+    while ((pos = cmd.next(pos, '<')) != cmd.length()) {
+	u_int epos = pos+1;
+	fxStr esc = cmd.token(epos, '>');
+	esc.lowercase();
+	char ecode;
+	if (esc == "xon")
+	    ecode = (0x80|0xf) ;
+	else if (esc == "rts")
+	    ecode = (0x80|0xe) ;
+	else if (esc == "none")
+	    ecode = (0x80|0xd) ;
+	else if (esc == "")		 
+	    ecode = '<';
+	else {
+	    BaudRate br = findRate(esc);
+	    if (br == FaxModem::BR0) {
+		syslog(3 , "Unknown AT escape code \"%s\"", (char*) esc);
+		pos = epos;
+		continue;
+	    }
+	    ecode = 0x80| ((int)( br )) ;
+	}
+	cmd.remove(pos, epos-pos);
+	cmd.insert(ecode, pos);
+    }
+    return (cmd);
+}
+static const struct {
+    const char*		 name;
+    fxStr ModemConfig::* p;
+} atcmds[] = {
+    { "ModemAnswerCmd",			&ModemConfig::answerAnyCmd },
+    { "ModemAnswerAnyCmd",		&ModemConfig::answerAnyCmd },
+    { "ModemAnswerFaxCmd",		&ModemConfig::answerFaxCmd },
+    { "ModemAnswerDataCmd",		&ModemConfig::answerDataCmd },
+    { "ModemAnswerVoiceCmd",		&ModemConfig::answerVoiceCmd },
+    { "ModemAnswerFaxBeginCmd",		&ModemConfig::answerFaxBeginCmd },
+    { "ModemAnswerDataBeginCmd",	&ModemConfig::answerDataBeginCmd },
+    { "ModemAnswerVoiceBeginCmd",	&ModemConfig::answerVoiceBeginCmd },
+    { "ModemResetCmds",			&ModemConfig::resetCmds },
+    { "ModemResetCmd",			&ModemConfig::resetCmds },
+    { "ModemDialCmd",			&ModemConfig::dialCmd },
+    { "ModemFlowControlCmd",		&ModemConfig::flowControlCmd },
+    { "ModemSetupAACmd",		&ModemConfig::setupAACmd },
+    { "ModemSetupDTRCmd",		&ModemConfig::setupDTRCmd },
+    { "ModemSetupDCDCmd",		&ModemConfig::setupDCDCmd },
+    { "ModemNoAutoAnswerCmd",		&ModemConfig::noAutoAnswerCmd },
+    { "ModemEchoOffCmd",		&ModemConfig::echoOffCmd },
+    { "ModemVerboseResultsCmd",		&ModemConfig::verboseResultsCmd },
+    { "ModemResultCodesCmd",		&ModemConfig::resultCodesCmd },
+    { "ModemOnHookCmd",			&ModemConfig::onHookCmd },
+    { "ModemSoftResetCmd",		&ModemConfig::softResetCmd },
+    { "ModemWaitTimeCmd",		&ModemConfig::waitTimeCmd },
+    { "ModemCommaPauseTimeCmd",		&ModemConfig::pauseTimeCmd },
+    { "ModemMfrQueryCmd",		&ModemConfig::mfrQueryCmd },
+    { "ModemModelQueryCmd",		&ModemConfig::modelQueryCmd },
+    { "ModemRevQueryCmd",		&ModemConfig::revQueryCmd },
+    { "ModemSendBeginCmd",		&ModemConfig::sendBeginCmd },
+    { "Class1Cmd",			&ModemConfig::class1Cmd },
+    { "Class2Cmd",			&ModemConfig::class2Cmd },
+    { "Class2BORCmd",			&ModemConfig::class2BORCmd },
+    { "Class2RELCmd",			&ModemConfig::class2RELCmd },
+    { "Class2CQCmd",			&ModemConfig::class2CQCmd },
+    { "Class2AbortCmd",			&ModemConfig::class2AbortCmd },
+    { "Class2CQQueryCmd",		&ModemConfig::class2CQQueryCmd },
+    { "Class2DCCQueryCmd",		&ModemConfig::class2DCCQueryCmd },
+    { "Class2TBCCmd",			&ModemConfig::class2TBCCmd },
+    { "Class2CRCmd",			&ModemConfig::class2CRCmd },
+    { "Class2PHCTOCmd",			&ModemConfig::class2PHCTOCmd },
+    { "Class2BUGCmd",			&ModemConfig::class2BUGCmd },
+    { "Class2LIDCmd",			&ModemConfig::class2LIDCmd },
+    { "Class2DCCCmd",			&ModemConfig::class2DCCCmd },
+    { "Class2DISCmd",			&ModemConfig::class2DISCmd },
+    { "Class2DDISCmd",			&ModemConfig::class2DDISCmd },
+    { "Class2CIGCmd",			&ModemConfig::class2CIGCmd },
+    { "Class2PTSCmd",			&ModemConfig::class2PTSCmd },
+    { "Class2SPLCmd",			&ModemConfig::class2SPLCmd },
+    { "Class2PIECmd",			&ModemConfig::class2PIECmd },
+    { "Class2NRCmd",			&ModemConfig::class2NRCmd },
+    { "TagLineFont",			&ModemConfig::tagLineFontFile },
+    { "TagLineFormat",			&ModemConfig::tagLineFmt },
+};
+static const struct {
+    const char*		 name;
+    u_int ModemConfig::* p;
+} fillorders[] = {
+    { "ModemRecvFillOrder",		&ModemConfig::recvFillOrder },
+    { "ModemSendFillOrder",		&ModemConfig::sendFillOrder },
+    { "ModemFrameFillOrder",		&ModemConfig::frameFillOrder },
+};
+static const struct {
+    const char*		 name;
+    u_int ModemConfig::* p;
+} numbers[] = {
+    { "ModemResetDelay",		&ModemConfig::resetDelay },
+    { "ModemBaudRateDelay",		&ModemConfig::baudRateDelay },
+    { "ModemMaxPacketSize",		&ModemConfig::maxPacketSize },
+    { "ModemInterPacketDelay",		&ModemConfig::interPacketDelay },
+    { "FaxT1Timer",			&ModemConfig::t1Timer },
+    { "FaxT2Timer",			&ModemConfig::t2Timer },
+    { "FaxT4Timer",			&ModemConfig::t4Timer },
+    { "ModemDialResponseTimeout",	&ModemConfig::dialResponseTimeout },
+    { "ModemAnswerResponseTimeout",	&ModemConfig::answerResponseTimeout },
+    { "ModemPageStartTimeout",		&ModemConfig::pageStartTimeout },
+    { "ModemPageDoneTimeout",		&ModemConfig::pageDoneTimeout },
+    { "Class1TCFResponseDelay",		&ModemConfig::class1TCFResponseDelay },
+    { "Class1SendPPMDelay",		&ModemConfig::class1SendPPMDelay },
+    { "Class1SendTCFDelay",		&ModemConfig::class1SendTCFDelay },
+    { "Class1TrainingRecovery",		&ModemConfig::class1TrainingRecovery },
+    { "Class1RecvAbortOK",		&ModemConfig::class1RecvAbortOK },
+    { "Class1FrameOverhead",		&ModemConfig::class1FrameOverhead },
+    { "Class1RecvIdentTimer",		&ModemConfig::class1RecvIdentTimer },
+    { "Class1TCFMaxNonZero",		&ModemConfig::class1TCFMaxNonZero },
+    { "Class1TCFMinRun",		&ModemConfig::class1TCFMinRun },
+    { "PercentGoodLines",		&ModemConfig::percentGoodLines },
+    { "MaxConsecutiveBadLines",		&ModemConfig::maxConsecutiveBadLines },
+};
+fxBool
+ModemConfig::parseItem(const char* tag, const char* value)
+{
+    int i;
+    for (i = (sizeof ( atcmds ) / sizeof ( atcmds [0])) -1; i >= 0; i--)
+	if ((strcasecmp( tag ,  atcmds[i].name )==0) ) {
+	    (*this).*atcmds[i].p = parseATCmd(value);
+	    return (((fxBool)1) );
+	}
+    for (i = (sizeof ( fillorders ) / sizeof ( fillorders [0])) -1; i >= 0 ; i--)
+	if ((strcasecmp( tag ,  fillorders[i].name )==0) ) {
+	    (*this).*fillorders[i].p = getFill(value);
+	    return (((fxBool)1) );
+	}
+    for (i = (sizeof ( numbers ) / sizeof ( numbers [0])) -1; i >= 0 ; i--)
+	if ((strcasecmp( tag ,  numbers[i].name )==0) ) {
+	    (*this).*numbers[i].p = atoi(value);
+	    return (((fxBool)1) );
+	}
+    fxBool recognized = ((fxBool)1) ;
+    if ((strcasecmp( tag ,  "ModemType" )==0) )
+	type = value;
+    else if ((strcasecmp( tag ,  "ModemSetVolumeCmd" )==0) )
+	setVolumeCmds(value);
+    else if ((strcasecmp( tag ,  "ModemFlowControl" )==0) )
+	flowControl = getFlow(value);
+    else if ((strcasecmp( tag ,  "ModemMaxRate" )==0)  || (strcasecmp( tag ,  "ModemRate" )==0) )
+	maxRate = getRate(value);
+    else if ((strcasecmp( tag ,  "ModemWaitForConnect" )==0) )
+	waitForConnect = getBoolean(value);
+    else if ((strcasecmp( tag ,  "Class2RecvDataTrigger" )==0) )
+	class2RecvDataTrigger = value;
+    else if ((strcasecmp( tag ,  "Class2XmitWaitForXON" )==0) )
+	class2XmitWaitForXON = getBoolean(value);
+    else
+	recognized = ((fxBool)0) ;
+    return (recognized);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash6.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash6.C
new file mode 100755
index 0000000..a6527a5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash6.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed old-abort
+// Should be fixed by:
+// Sun Jun 13 12:55:22 1993  Brendan Kehoe  (brendan@lisa.cygnus.com)
+// 
+// 	* cp-decl.c (start_function): Avoid a null-reference on CTYPE.
+
+template<int>
+class Program {
+} ;
+
+class Program<0> {
+public:
+   inline friend float EvalNextArg()
+        { return 1.0 ; }
+} ;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash60.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash60.C
new file mode 100755
index 0000000..b2af431
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash60.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class X
+{
+public:
+    X ();
+    int	f[4];
+};
+
+// Note that we mistakenly initialize the array data member as if it
+// was scalar
+X::X () : f (0) {}// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash61.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash61.C
new file mode 100755
index 0000000..4d3bbc4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash61.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed old-abort
+        template <class TP> class sapp { };
+        class foo {};
+        extern foo& __iomanip_setw (foo&, TP);// ERROR -  type spec.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash62.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash62.C
new file mode 100755
index 0000000..77b9fc8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash62.C
@@ -0,0 +1,32 @@
+// Build don't link: 
+// GROUPS passed old-abort
+#include <iostream.h>
+
+	void
+	fubar(ostream* out, const char* string)
+	{
+  	  (*out) << string << endl;
+  	  return;
+	}
+
+	int
+	main()
+	{
+  	  // Declare a ref and a pointer to the same ostream.
+  	  //
+  	  ostream* out = &cerr;
+  	  ostream& die = cerr;
+
+  	  // Valid call to fubar.
+  	  //
+  	  fubar(out, "First line.");
+  
+  	  // Invalid call to fubar. (1st arg is an ostream&. fubar expects
+  	  // ostream*.)This should be a syntax error, but g++ does not catch it.
+  	  // Call to this function results in a bus error in fubar when the 1st
+  	  // arg is dereferenced.
+  	  //
+  	  fubar(die, "Second line.");// ERROR -  cannot convert .die.*
+  
+  	  return 1;
+	}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash63.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash63.C
new file mode 100755
index 0000000..84f8fc5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash63.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class String
+   {
+ public:
+   String (const char *str);
+   };
+
+class UnitList 
+   {
+ public:
+   UnitList (...);
+   };
+
+UnitList unit_list (String("keV"));
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash64.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash64.C
new file mode 100755
index 0000000..3102418
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash64.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed old-abort
+typedef long unsigned int size_t;
+typedef void (*RF_Ptr)(void *);
+
+struct _im_pers_mem_spec {
+  inline _im_pers_mem_spec(void );
+  inline _im_pers_mem_spec(auto int of, auto int n);
+};
+
+struct _type_desc {
+  _type_desc(char *, int , RF_Ptr , int , int ,...);
+};
+
+struct metatype { int base_list; };
+
+static _type_desc _type_metatype("metatype", sizeof(metatype),
+  (RF_Ptr)0, 0, 1, 1,
+  _im_pers_mem_spec( ((size_t)&((( metatype *)0)-> base_list )) , 1));
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash65.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash65.C
new file mode 100755
index 0000000..132651e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash65.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class X {
+public:  
+  virtual const char* 	XY(const void* val) const = 0;
+};
+
+
+class Y : public X {
+public:
+  using X::xy;// ERROR -  no memb.*
+
+  using X::z;// ERROR -  no memb.*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash66.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash66.C
new file mode 100755
index 0000000..878957b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash66.C
@@ -0,0 +1,137 @@
+// Build don't link: 
+// Special g++ Options: -O
+// GROUPS passed old-abort
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned long ulong;
+extern int swap_endian;			 
+inline ushort
+swapshort(ushort value)
+{
+    value &= 0xffff;
+    return ((value << 8) | (value >> 8));
+}
+struct eshort
+{
+    ushort	data;			 
+    operator ushort() { return swap_endian ? swapshort(data) : data;}
+    eshort(ushort t) { data = swap_endian ? swapshort(t) : t;}
+    eshort() {}
+};
+inline ulong
+swaplong(ulong value)
+{
+    ulong v = (value << 16) | (value >> 16);
+    return ((v >> 8) & 0x00ff00ff) | ((v << 8) & 0xff00ff00);
+};
+struct elong
+{
+    ulong	data;			 
+    operator ulong() { return swap_endian ? swaplong(data) : data;}
+    elong(ulong t) { data = swap_endian ? swaplong(t) : t; }
+    elong() {}
+};
+struct digiheader
+{
+    uchar	type[2];		 
+    eshort	soft_version;		 
+    eshort	lo_boot_rev;		 
+    eshort	hi_boot_rev;		 
+    eshort	load_segment;		 
+    eshort	length;			 
+    eshort	exec_start;		 
+    eshort	image_offset;		 
+    elong	startup_code[2];	 
+    elong	checksum;		 
+};
+extern void uncompress(uchar* buf, ulong len);
+extern ulong compress(char* filename, uchar* buffer, ulong);
+struct filehdr
+{
+    eshort	f_magic;		 
+    eshort	f_nscns;		 
+    elong	f_timdat;		 
+    elong	f_symptr;		 
+    elong	f_nsyms;		 
+    eshort	f_opthdr;		 
+    eshort	f_flags;		 
+};
+struct aouthdr
+{
+    eshort	magic;			 
+    eshort	vstamp;			 
+    elong	tsize;			 
+    elong	dsize;			 
+    elong	bsize;			 
+    elong	entry;			 
+    elong	text_start;		 
+    elong	data_start;		 
+    elong	bss_start;		 
+    elong	gprmask;		 
+    elong	cprmask[4];		 
+    elong	gp_value;		 
+};
+struct scnhdr
+{
+    char	s_name[8];		 
+    elong	s_paddr;		 
+    elong	s_vaddr;		 
+    elong	s_size;			 
+    elong	s_scnptr;		 
+    elong	s_relptr;		 
+    elong	s_lnnoptr;		 
+    eshort	s_nreloc;		 
+    eshort	s_nlnno;		 
+    elong	s_flags;		 
+};
+int file_little_endian;			 
+int host_little_endian;			 
+int swap_endian;			 
+int docheck;				 
+int expand;				 
+ulong memsize;				 
+ulong compression_quality;		 
+char *compressfile;			 
+int debug_level;			 
+extern "C" int getopt (int, char**, char*);
+int
+main(int argc, char** argv)
+{
+    uchar checksum;
+    uchar docrc;
+    ulong len;
+    ulong maxlen;
+    int i;
+    int c;
+    int magic;
+    int tsize;
+    int dsize;
+    int quality;
+    char dummy;
+    uchar* code;
+    uchar* buf;
+    char* ap;
+    digiheader *dh;
+    compression_quality = 10000;
+    docheck = 0;
+    while ((c = getopt(argc, argv, "Ccdf:k:q:x:")) != -1)
+    {
+	switch (c)
+	{
+	default:
+	    goto usage;
+	}
+    }
+    if ((expand && (docheck || compressfile || quality)) ||
+	(quality && !compressfile))
+    {
+    usage:
+	return(2);
+    }
+    if (compressfile)
+    {
+	dh->image_offset = len;
+	
+	len += compress(compressfile, code + len, maxlen - len);
+    }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash67.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash67.C
new file mode 100755
index 0000000..f63ba5d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash67.C
@@ -0,0 +1,3 @@
+// Build don't link: 
+// GROUPS passed old-abort
+#pragma comment(exestr, "@(#) errno.h 10.2 92/03/26 ")
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash68.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash68.C
new file mode 100755
index 0000000..b209bd8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash68.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// Special g++ Options: -w -O
+// GROUPS passed old-abort
+class   RWDlist
+{
+public:
+  RWDlist& operator=(const RWDlist&);
+};
+class DataItemRWGDlist : public RWDlist {};
+
+class Base {};
+class DataItemList : public Base
+{
+  private:
+  DataItemRWGDlist m_diList;
+};      
+
+class StatementGroup
+{
+  public:
+    DataItemList   dataItemList;
+    StatementGroup(const StatementGroup&);
+};
+
+StatementGroup::StatementGroup(const StatementGroup& sg)
+{
+  dataItemList = sg.dataItemList;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash7.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash7.C
new file mode 100755
index 0000000..19476fc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash7.C
@@ -0,0 +1,48 @@
+// Build don't link: 
+// GROUPS passed templates
+
+template<class T>
+class Vector
+{
+  int sz;
+  T *v;
+public:
+  Vector (int s) : sz (s) { v = new T[sz]; }
+  ~Vector () { delete[] v; }
+  T &operator[] (int i) { return v[i]; }
+  int size () { return sz; }
+};
+
+template<class T>// ERROR - previous definition of T
+struct Comparator
+{
+  typedef T T;// ERROR - use of template type T in typedef to T
+  static int lessthan (T &a, T &b) { return a < b; }
+};
+
+template<class Comp>
+struct Sort
+{
+  static void sort (Vector<Comp::T> &);// ERROR - use of bad T
+};
+
+template<class Comp>
+void Sort<Comp>::sort (Vector<Comp::T> &v)// ERROR - use of bad T
+{
+  int n = v.size ();
+
+  for (int i = 0; i < n - 1; i++)
+    for (int j = n - 1; i < j; j--)
+      if (Comp::lessthan (v[j], v[j - 1]))
+	{
+	  typename Comp::T temp = v[j];
+	  v[j] = v[j - 1];
+	  v[j - 1] = temp;
+	}
+}
+
+void
+f (Vector<int> &vi)
+{
+  Sort<Comparator<int> >::sort (vi);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash8.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash8.C
new file mode 100755
index 0000000..8990c46
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash8.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed old-abort
+template<int a, int b>
+class Elvis
+{// ERROR - in template.*
+} ;
+
+template<int a>
+class Elvis<0>
+{ // ERROR - incorrect number of parameters
+   int geta() { return a ; }
+} ;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash9.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash9.C
new file mode 100755
index 0000000..a4155ef
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash9.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class A {};
+
+class SimQuery
+{
+public:
+  SimQuery();
+  ~SimQuery();
+  int SetMeshFile(char name[]);
+protected:
+  A& scaling;
+  A* mesh;
+};
+
+SimQuery::SimQuery():scaling(A) {}// ERROR - .*
+
+SimQuery::~SimQuery() {}// ERROR - 
+
+int SimQuery::SetMeshFile(char name[])
+{// ERROR - 
+  mesh = new C;// ERROR - .*
+  return 0; // needed to avoid warning of reaching end of non-void fn
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ctors1.C b/gcc/testsuite/g++.old-deja/g++.brendan/ctors1.C
new file mode 100755
index 0000000..eaf4871
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ctors1.C
@@ -0,0 +1,27 @@
+// GROUPS passed constructors
+// Check that global level object constructors get called.
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	int f1;
+	int f2;
+	base (int arg1, int arg2);
+};
+
+
+base global_base(0x55, 0xff);
+
+int main ()
+{
+	if ((global_base.f1 != 0x55) || (global_base.f2 != 0xff))
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+}
+
+base::base(int arg1, int arg2)
+{
+	f1 = arg1;
+	f2 = arg2;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ctors2.C b/gcc/testsuite/g++.old-deja/g++.brendan/ctors2.C
new file mode 100755
index 0000000..2f83ce1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ctors2.C
@@ -0,0 +1,28 @@
+// GROUPS passed constructors
+// Check that sub-words sized class members are correctly set
+// by constructors.
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	int f1 : 8;
+	int f2 : 8;
+	base (int arg1, int arg2);
+};
+
+
+base global_base(0x55, 0x7e);
+
+int main ()
+{
+	if ((global_base.f1 != 0x55) || (global_base.f2 != 0x7e))
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+}
+
+base::base(int arg1, int arg2)
+{
+	f1 = arg1;
+	f2 = arg2;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ctors3.C b/gcc/testsuite/g++.old-deja/g++.brendan/ctors3.C
new file mode 100755
index 0000000..755d547
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ctors3.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed constructors
+class A;
+
+class B {
+public:
+    B();
+static A sa;
+};
+
+class A {
+public:
+    A(int i);
+};
+
+A B::sa(1);
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/cvt1.C b/gcc/testsuite/g++.old-deja/g++.brendan/cvt1.C
new file mode 100755
index 0000000..57f3b42
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/cvt1.C
@@ -0,0 +1,44 @@
+// Build don't link: 
+// GROUPS passed conversions
+#include <iostream.h>
+
+class Thing
+{
+public:
+      typedef enum { GOOD_THING, BAD_THING, } ThingType ; // ERROR - comma
+	Thing (ThingType type) : thingType (type) { }
+	~Thing () { }
+private:
+	ThingType thingType ;
+} ;
+
+class Group
+{
+public:
+      typedef enum { THIS_GROUP, THAT_GROUP, } GroupType ; // ERROR - comma
+	Group (GroupType type) : groupType (type), groupCount (0) { }
+	~Group () { }
+	void append (Thing* const &entry) { groupCount ++ ; }
+	operator GroupType () const { return groupType ; }
+	operator int () const { return groupCount ; } // remove this and problem gone
+
+private:
+	int groupCount ;
+	GroupType groupType ;
+} ;
+
+inline Group& operator += (Group& g, Thing* const t)
+{
+	g.append (t) ;
+	return g ; // complaint is here
+}
+
+int
+main (int argc, char** argv)
+{
+	Group g (Group::THIS_GROUP) ;
+
+	g += new Thing (Thing::GOOD_THING) ;
+	cout << "Group type is " << (Group::GroupType) g << endl ;
+	return 0 ;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/cvt2.C b/gcc/testsuite/g++.old-deja/g++.brendan/cvt2.C
new file mode 100755
index 0000000..76ae156
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/cvt2.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed conversions
+void f(const short & s) { }
+
+   int
+main() {
+   f(0);
+   return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/cvt3.C b/gcc/testsuite/g++.old-deja/g++.brendan/cvt3.C
new file mode 100755
index 0000000..6ab8465
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/cvt3.C
@@ -0,0 +1,48 @@
+// Build don't link: 
+// GROUPS passed conversions
+class GttObject {};
+class GctObject: virtual public GttObject {};
+class NDAMObject: virtual public GttObject, virtual public GctObject {};
+class GctHashObject: virtual public GctObject {};
+
+class GctRef: virtual public GctHashObject
+{ public: operator void*() const; };
+
+class NDAMAssemblerObject: virtual public NDAMObject {};
+class GctReferenceObject: virtual public GctHashObject {};
+class NDAMValue: virtual public NDAMAssemblerObject, public GctReferenceObject {};
+
+class nnyacc;
+class NDAMValueRef : virtual public NDAMObject, public GctRef 
+{
+  NDAMValue *operator->() const;	 
+  operator NDAMValue *() const;	 
+friend class nnyacc;
+};
+
+typedef void* Pix;
+class NDAMValueRefSLList
+{
+public:
+  NDAMValueRefSLList();
+  NDAMValueRefSLList(const NDAMValueRefSLList& a);
+  ~NDAMValueRefSLList();
+  NDAMValueRef& operator () (Pix p) const;
+};
+
+struct bar
+{
+  NDAMValueRefSLList *valueList;
+};
+
+class nnyacc
+{
+public:
+      static void assign(void*& lval, void*& rval); // ERROR - candidates
+};
+
+void
+foo (bar yylval, bar *yyvsp)
+{
+  nnyacc::assign(yylval.valueList, yyvsp[0].valueList);// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/cvt4.C b/gcc/testsuite/g++.old-deja/g++.brendan/cvt4.C
new file mode 100755
index 0000000..3d9f475
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/cvt4.C
@@ -0,0 +1,27 @@
+// Build don't link: 
+// GROUPS passed conversions
+class A {};
+
+template <class TP>
+class B
+{
+  A &(*_f) (A &, TP);
+  TP _a;
+public:
+  B (A &(*f) (A &, TP), TP a) : _f (f), _a (a) {}
+  friend A &operator<< (A &o, const B<TP> &m)
+    { (*m._f) (o, m._a); return o; }
+};
+
+A &setw (A &, int);
+B<int> setw (int n)
+{
+  return B<int> (setw, n);
+}
+
+A x;
+
+void f ()
+{
+  x << setw (2);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/cvt5.C b/gcc/testsuite/g++.old-deja/g++.brendan/cvt5.C
new file mode 100755
index 0000000..5eeea6e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/cvt5.C
@@ -0,0 +1,27 @@
+// GROUPS passed conversions
+// Build don't link:
+typedef unsigned long Array[3];
+
+void sample(const unsigned long (&an_array)[3]);
+
+class Sample
+  {
+ public:
+  void simple(const Array &an_array);
+  static void sample(const Array &an_array);
+  };
+
+class A
+  {
+ public:
+  Array array;
+  };
+
+  Sample s;
+
+  void simple(const A &a)
+    {
+    s.simple(a.array);
+    sample(a.array);
+    Sample::sample(a.array);
+    }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/def-args1.C b/gcc/testsuite/g++.old-deja/g++.brendan/def-args1.C
new file mode 100755
index 0000000..55efc52
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/def-args1.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// PRMS Id: 10860
+class Beige
+{
+public:
+    static int yellow();
+    void white(int green = yellow());
+    void aqua(int green = Beige::yellow());
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/def-fns1.C b/gcc/testsuite/g++.old-deja/g++.brendan/def-fns1.C
new file mode 100755
index 0000000..af97526
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/def-fns1.C
@@ -0,0 +1,22 @@
+// Build don't link: 
+// GROUPS passed default-functions
+class dictionary {
+public:
+  dictionary (int);
+};
+
+class symbol {
+public:
+  symbol ();
+};
+
+// a default ctor should not be generated for hyphenation_language,
+// since a ctor has already been declared; if one is generated, there
+// will be an error about not enough args to the ctor for dictionary,
+// since dictionary only defines a ctor taking an int (it ALSO should
+// not get a default ctor)
+struct hyphenation_language {
+  symbol name;
+  dictionary exceptions;
+  hyphenation_language(symbol nm) : name(nm), exceptions(501) {}
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/delete1.C b/gcc/testsuite/g++.old-deja/g++.brendan/delete1.C
new file mode 100755
index 0000000..816c300
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/delete1.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed operator-delete
+/* ARM $5.3.4 */
+void f(char *p, char *q[], const char *r, const char *s[])
+{
+  delete 0;             /* illegal: non-pointer */// ERROR - .*expected pointer.*
+  delete (char*)0;      /* no effect */
+  delete p;
+  delete[] q;
+  delete[4] q;          /* ANSI forbids size arg */// ERROR -  anachronistic .*
+  delete r;             /* no longer illegal: const */
+  delete[] s;
+  delete[4] s;          /* ANSI forbids size arg */// ERROR -  anachronistic.*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/delete2.C b/gcc/testsuite/g++.old-deja/g++.brendan/delete2.C
new file mode 100755
index 0000000..f2bacde
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/delete2.C
@@ -0,0 +1,25 @@
+// GROUPS passed operator-delete
+// Check that using the delete operator with a null pointer
+// is allowed (as called for by The Book, pg. 259)
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	int member;
+};
+
+base* bp;
+
+void test ()
+{
+	delete bp;
+}
+
+int main ()
+{
+	bp = (base *) 0;
+	test ();
+
+	printf ("PASS\n");
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/dtors1.C b/gcc/testsuite/g++.old-deja/g++.brendan/dtors1.C
new file mode 100755
index 0000000..dbbfa80
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/dtors1.C
@@ -0,0 +1,56 @@
+// GROUPS passed destructors
+// Check that when an object of a derived class is (implicitly)
+// destructed (on exit from the block in which it is declared)
+// that the destructor for the base class also gets executed.
+//
+// (also check that this execution doesn't seg-fault)
+
+extern "C" void printf (char *, ...); 
+
+int derived_destructed;
+int base_destructed;
+
+struct base {
+  int base_data_member;
+
+  base()
+  {
+    base_data_member = 0x5e5e;
+  }
+  ~base()
+  {
+    base_destructed = 0x781f;
+  }
+};
+
+struct derived : public base {
+  int derived_data_member;
+
+  derived()
+  {
+    derived_data_member = 0xe5e5;
+  }
+  ~derived()
+  {
+    derived_destructed = 0xf178;
+  }
+};
+
+
+void test2 ();
+
+int main ()
+{
+	test2 ();
+	if ((base_destructed != 0x781f) || (derived_destructed != 0xf178))
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+}
+
+void test2 ()
+{
+	derived derived_object;
+
+	derived_object.derived_data_member = 99;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/dtors2.C b/gcc/testsuite/g++.old-deja/g++.brendan/dtors2.C
new file mode 100755
index 0000000..511ab7f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/dtors2.C
@@ -0,0 +1,74 @@
+// GROUPS passed destructors
+// Check that virtual destructors work correctly.  Specifically,
+// check that when you destruct an object of a derived class for
+// which the base class had an explicitly declared virtual destructor
+// no infinite recursion occurs.
+//
+// Bug description:
+//    The generated g++ code apparently calls the base class destructor via
+//    the virtual table, rather than directly. This, of course, results in the
+//    infinite recursion.
+
+extern "C" void printf (char *, ...); 
+
+int errors = 0;
+
+struct base {
+	int member;
+	base();
+	virtual ~base();
+};
+  
+base::base()
+{
+}
+
+base::~base()
+{
+}
+
+struct derived : public base
+{
+	int member;
+	derived();
+	~derived();
+};
+  
+derived::derived() : base()
+{
+}
+
+int derived_destructor_calls = 0;
+
+extern void exit (int);
+
+derived::~derived()
+{
+	if (++derived_destructor_calls > 2)
+		errors++;
+}
+
+void test ();
+
+int main ()
+{
+	test ();
+
+	if (errors)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
+
+base* bp;
+
+void test()
+{
+	derived a;
+
+	a.member = 99;
+	bp = new derived;
+	delete bp;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/dtors3.C b/gcc/testsuite/g++.old-deja/g++.brendan/dtors3.C
new file mode 100755
index 0000000..a1ca853
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/dtors3.C
@@ -0,0 +1,66 @@
+// GROUPS passed destructors
+// Check that member and base classes get properly destructed
+// when an object of a derived class is destructed via a pointer
+// to it which only has a "compile-time" type of "pointer-to-base".
+//
+// Note that in order for this test to work properly, the destructor
+// for the base class should be explicitly declared to be virtual.
+
+extern "C" void printf (char *, ...); 
+
+int member_destructor_calls = 0;
+int middle_destructor_calls = 0;
+
+struct member_type {
+	int data_member;
+	member_type () {}
+	~member_type ();
+};
+
+struct base {
+	int data_member;
+	base () {}
+	virtual ~base ();
+};
+
+struct middle : public base {
+	member_type member1;
+	member_type member2;
+	middle () {}
+	~middle ();		// should be implicitly virtual
+};
+
+struct derived : public middle {
+	member_type member1;
+	member_type member2;
+	//~derived () {}
+};
+
+int main ()
+{
+	base* bp = new derived;
+	delete bp;
+	derived *dp = new derived;
+	delete dp;
+
+	if ((member_destructor_calls != 8) || (middle_destructor_calls != 2))
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
+
+member_type::~member_type ()
+{
+	member_destructor_calls++;
+}
+
+base::~base ()
+{
+}
+
+middle::~middle ()
+{
+	middle_destructor_calls++;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/eh1.C b/gcc/testsuite/g++.old-deja/g++.brendan/eh1.C
new file mode 100755
index 0000000..a668306
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/eh1.C
@@ -0,0 +1,62 @@
+// Special g++ Options: -O
+// PRMS Id: 10776
+
+extern "C" void printf (char *, ...);
+
+class Foo 
+{
+  public:
+    Foo(int n) : n_(n) { }
+    int f() { return n_; }
+    
+    int badTest();
+    int goodTest();
+    
+  private:
+
+    int n_;
+};
+
+int Foo::badTest()
+{
+    try {
+	throw int(99);
+    }
+
+    catch (int &i) {
+	n_ = 16;
+    }
+
+    return n_;
+        // On the sparc, the return will use a ld [%l0],%i0 instruction.
+        // However %l0 was clobbered at the end of the catch block.  It was
+        // used to do an indirect call.
+}
+
+
+int Foo::goodTest()
+{
+    int	n;
+
+    try {
+	throw int(99);
+    }
+
+    catch (int &i) {
+	n = 16;
+    }
+
+    return n_;
+        // The return will use a ld [%l2],%i0 instruction.  Since %l2
+        // contains the "this" pointer this works.
+}
+
+int main() 
+{
+    Foo foo(5);
+    foo.goodTest();
+    foo.badTest();
+
+    // the badTest will have failed
+    printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum-clash.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum-clash.C
new file mode 100755
index 0000000..68639a1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum-clash.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed arm
+enum color {red, yellow, green=20, blue};
+color c = 1;	// this should be an error// ERROR - .*
+int i = yellow;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum1.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum1.C
new file mode 100755
index 0000000..9cc3ed8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum1.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed enums
+class foo {
+public:
+  enum bar { baz = 1, bat = 7 };
+};
+
+class derv : public foo { };
+
+int main()
+{
+  foo::bar x = foo::baz;
+  derv::bar y = derv::bat;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum10.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum10.C
new file mode 100755
index 0000000..5c955d3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum10.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed enums
+class Type
+{
+	public:
+
+		enum name
+		{
+			A
+		};
+};
+
+class A
+{
+};
+
+class B: public A
+{
+	public:
+		B();
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum11.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum11.C
new file mode 100755
index 0000000..7705aa3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum11.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed enums
+class X
+{
+    enum
+    {
+       oneMask = 0x0000FFFF,
+       twoMask  = 0x000F0000,
+       thiMask = 0xFFF00000,
+    }; // ERROR - comma
+    unsigned int foo;
+
+public:
+    X (int) : foo (oneMask | twoMask ) {}               // No warning
+    X ()    : foo (oneMask | twoMask | thiMask) {}      // Warning
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum12.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum12.C
new file mode 100755
index 0000000..7d4eb7d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum12.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed enums
+enum Bool { False, True };
+
+enum Bool object;
+
+struct S
+{
+  Bool field:1;
+
+  void copy_enum_bit_field () const { object = field; }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum13.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum13.C
new file mode 100755
index 0000000..ea6dfa7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum13.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed enums
+enum COLOR { red, green, blue };
+ 
+struct S {
+    COLOR       color:2;
+};
+ 
+COLOR color;
+S object;
+ 
+void fubar ()
+{
+    color = object.color;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum14.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum14.C
new file mode 100755
index 0000000..192a2b4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum14.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// Special g++ Options: -fshort-enums
+// GROUPS passed enums
+  enum E { A = 0x80000000 };
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum2.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum2.C
new file mode 100755
index 0000000..1c5c50b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum2.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed enums
+class foo {
+public:
+  enum bar { baz = 1, bat = 7 };
+};
+
+class foo2 {
+public:
+  enum bar2 { baz2 = 1, bat2 = 7 };
+};
+
+class derv : public foo, public foo2 { };
+
+int main()
+{
+  foo::bar x = foo::baz;
+  derv::bar2 y = derv::bat2;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum3.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum3.C
new file mode 100755
index 0000000..38b7d3c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum3.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed enums
+enum foo
+{
+  x = 0
+};
+
+enum bar
+{
+  // this used to say `x' wasn't a constant, because build_enumerator
+  // was getting the value of x wrapped around a NOP_EXPR.  It now
+  // strips them off before working on it, so we shouldn't get any
+  // errors  for this.
+  y = (x + 0x0000)
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum4.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum4.C
new file mode 100755
index 0000000..826ccd3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum4.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed enums
+class X {
+public:
+  enum { a };
+};
+
+enum { b = 1 };
+enum ok {  y = b };
+enum notok { z = X::a };
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum5.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum5.C
new file mode 100755
index 0000000..32134ef
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum5.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed enums
+enum Thing { FIRST, SECOND } ;
+
+int main()
+{
+    Thing x = FIRST ;
+    x = 27 ;          // this line should be a type error.// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum6.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum6.C
new file mode 100755
index 0000000..de82148
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum6.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed enums
+class X {
+  private:
+    enum E1 {a1, b1};
+  public:
+    enum E2 {a2, b2};
+    };
+
+void h(X* p) {
+    X::E2 e2;
+    int x2 = X::a2;
+
+    X::E1 e1;
+    int x1 = X::a1;		// Should be rejected, and is.// ERROR - .*
+    }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum7.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum7.C
new file mode 100755
index 0000000..5a397d7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum7.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed enums
+enum color { red, green, blue, orange, brown };
+
+struct s {
+      enum color      field:2; // ERROR - too small
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum8.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum8.C
new file mode 100755
index 0000000..d9380ad
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum8.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// GROUPS passed enums
+class foo1
+{
+ public:
+   enum foo1_enum
+   {
+      ENUM1,
+      ENUM2,
+   }; // ERROR - comma
+};
+
+   
+class foo2 
+{
+ private:
+   enum foo1::foo1_enum	Enum;
+};
+
+
+class foo3
+{
+ private:
+   foo1::foo1_enum Enum;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum9.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum9.C
new file mode 100755
index 0000000..f04deb1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum9.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed enums
+enum fig {
+    figgy,
+    pudding,
+}; // ERROR - comma
+
+class X {
+public:
+    static fig (*open)(void *thing, const char *filename);
+    static fig (*parse)(void *thing);
+};
+
+enum fig (*X::open)(void *thing, const char *filename) = 0;
+fig (*X::parse)(void *thing) = 0;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg1.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg1.C
new file mode 100755
index 0000000..9450d76
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg1.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class A { };
+
+int i = A::_ter;// ERROR -  ._ter.*
+int j = A::term;// ERROR -  .term.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg10.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg10.C
new file mode 100755
index 0000000..24ddcaa
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg10.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class foo {
+public:
+  virtual static int f () = 0;// ERROR -  member `f' cannot be declared both virtual and static.*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg11.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg11.C
new file mode 100755
index 0000000..de5ed8a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg11.C
@@ -0,0 +1,3 @@
+// Build don't link: 
+// GROUPS passed error-messages
+void foo (mutable int x);// ERROR -  non-member `x' cannot be declared `mutable'.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg12.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg12.C
new file mode 100755
index 0000000..0b59ba0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg12.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class foo {
+public:
+  friend mutable int x ();// ERROR -  non-object member `x' cannot be declared `mutable'
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg2.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg2.C
new file mode 100755
index 0000000..0bfb4c2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg2.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed error-messages
+typedef void (*pfv)(double, double);
+extern "C" typedef void (*pfv)(double, double);// ERROR -  multiple.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg3.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg3.C
new file mode 100755
index 0000000..1d115e6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg3.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed error-messages
+#include <fstream.h>
+#include <iomanip.h>
+
+// This error should not appear:
+// bug.C: In method `test::test(const class test &)':
+// bug.C:8: field `' not in immediate context
+
+class test{
+public:
+	int	flags;
+	test()	{};
+	};
+
+int main()
+
+{
+return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg4.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg4.C
new file mode 100755
index 0000000..72f6150
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg4.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class X {
+public:
+    static int x;// ERROR -  previous.*
+    static int y;// ERROR -  previous.*
+};
+
+unsigned X::x;// ERROR -  conflict.*
+unsigned X::y;// ERROR -  conflict.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg5.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg5.C
new file mode 100755
index 0000000..37b956c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg5.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class foo {};
+~foo () {}// ERROR -  destructors must be member functions.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg6.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg6.C
new file mode 100755
index 0000000..ce60f0d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg6.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class foo {
+public:
+  ~bar () {}// ERROR -  destructor `bar' must match class name `foo'.*
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg7.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg7.C
new file mode 100755
index 0000000..5971806
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg7.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class foo {
+public:
+  volatile int () {}// ERROR - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg8.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg8.C
new file mode 100755
index 0000000..a2ad4df
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg8.C
@@ -0,0 +1,3 @@
+// Build don't link: 
+// GROUPS passed error-messages
+operator int ;// ERROR -  declaration of `operator int' as non-function.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg9.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg9.C
new file mode 100755
index 0000000..0714de6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg9.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class foo {
+public:
+  int ~foo ();// ERROR -  return type specification for destructor invalid.*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/explicit1.C b/gcc/testsuite/g++.old-deja/g++.brendan/explicit1.C
new file mode 100755
index 0000000..148155e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/explicit1.C
@@ -0,0 +1,4 @@
+// $7.1.2 disallows explicit on anything but declarations of
+// constructors ... including friends.
+class foo { public: foo(); };
+class bar { public: friend explicit foo::foo(); }; // ERROR - explicit friend
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/friend1.C b/gcc/testsuite/g++.old-deja/g++.brendan/friend1.C
new file mode 100755
index 0000000..9aea460
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/friend1.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed friends
+class A
+{
+private:
+  A () {}
+
+friend struct B;
+};
+
+class B
+{
+public:
+  A a;
+};
+
+B b;
+
+int main () {}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/friend2.C b/gcc/testsuite/g++.old-deja/g++.brendan/friend2.C
new file mode 100755
index 0000000..5b1333f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/friend2.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed friends
+class X {
+  int a;
+friend void friend_set (X*, int);
+};
+
+void friend_set (X *p, int i) { p->a = i; }
+
+void f()
+{
+  X obj;
+  friend_set (&obj, 10);
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/friend3.C b/gcc/testsuite/g++.old-deja/g++.brendan/friend3.C
new file mode 100755
index 0000000..1fa48a8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/friend3.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// GROUPS passed friends
+class B {
+
+   friend class A;
+
+   enum {
+      bEnum = 1,
+   }; // ERROR - comma
+
+   int bArray[ bEnum ];
+
+public:
+   void bFunction(int arg[ bEnum ]);
+};
+
+
+class A {
+   int aMember;
+
+public:
+   void aFunction(int a[B::bEnum])
+   {
+      B b;
+      b.bArray[ B::bEnum ] = aMember;
+   }
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/friend4.C b/gcc/testsuite/g++.old-deja/g++.brendan/friend4.C
new file mode 100755
index 0000000..f19d81a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/friend4.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed friends
+// do_friend should complain that foo was declared as a friend of
+// A before A was defined
+struct A;
+struct B { friend A::foo (); };// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/groff1.C b/gcc/testsuite/g++.old-deja/g++.brendan/groff1.C
new file mode 100755
index 0000000..179ef30
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/groff1.C
@@ -0,0 +1,33 @@
+// GROUPS passed groff
+/* This should compile properly with the new overloading scheme.  */
+
+extern "C" void printf (const char *, ...);
+extern "C" void exit (int);
+
+int win = 0;
+
+class symbol
+{
+public:
+  symbol(const char *p, int how = 0) {}
+  symbol() {}
+};
+
+class dictionary
+{
+public:
+  void *lookup(symbol s, void *v=0) { win = 1; }
+  void *lookup(const char *) {}
+};
+
+int main()
+{
+  char buf[2048];
+  dictionary exceptions;
+  unsigned char *tem = new unsigned char[19 + 1];
+
+  exceptions.lookup (symbol (buf), tem);
+
+  printf (win ? "PASS\n" : "FAIL\n");
+  exit (! win);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init1.C b/gcc/testsuite/g++.old-deja/g++.brendan/init1.C
new file mode 100755
index 0000000..4396906
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init1.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed initialization
+  class Thing{
+  private:
+	  int x,y;
+  public:
+	  Thing (int v, int q) { x = v; q = y; }
+	  void doit(int);
+  };
+
+  Thing t(18,19);
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init10.C b/gcc/testsuite/g++.old-deja/g++.brendan/init10.C
new file mode 100755
index 0000000..45b2985
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init10.C
@@ -0,0 +1,3 @@
+// Build don't link: 
+// GROUPS passed initialization
+struct { int :0; } a;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init11.C b/gcc/testsuite/g++.old-deja/g++.brendan/init11.C
new file mode 100755
index 0000000..69fd77c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init11.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed initialization
+struct String {
+  char * string;
+  String(const char* st);  
+};
+
+extern char array [];
+static String sub = array;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init12.C b/gcc/testsuite/g++.old-deja/g++.brendan/init12.C
new file mode 100755
index 0000000..7d7c13a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init12.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed array-bindings
+char * bob();
+
+int main()
+{
+    char a[1][2];
+    a[0] = bob();// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init13.C b/gcc/testsuite/g++.old-deja/g++.brendan/init13.C
new file mode 100755
index 0000000..41f0fcf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init13.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed initialization
+struct A {
+  operator int ();
+};
+ 
+int i = A();
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init2.C b/gcc/testsuite/g++.old-deja/g++.brendan/init2.C
new file mode 100755
index 0000000..a9ec6f3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init2.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed initialization
+// this should give an error in require_instantiated_type about not
+// being allowed to have an initializer list in an argument list.
+int f(int a = {1});// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init3.C b/gcc/testsuite/g++.old-deja/g++.brendan/init3.C
new file mode 100755
index 0000000..b86c2c7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init3.C
@@ -0,0 +1,38 @@
+// GROUPS passed initialization
+// p2766: Make sure that members are initialized in order of declaration
+// in the class, not in order of specification in the mem-initializer list.
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int count = 0;
+
+void die () { printf ("FAIL\n"); exit (1); }
+
+class bar1 {
+public:
+  bar1 (int) { if (count != 0) die (); count = 1; }
+};
+
+class bar2
+{
+public:
+  bar2 (int) { if (count != 1) die (); count = 2; }
+};
+
+class foo
+{
+public:
+  bar1 a;
+  bar2 b;
+  foo (int, int);
+};
+
+// bar1 should get built before bar2
+foo::foo (int x, int y) : b(x), a(y) {}
+
+int main()
+{
+  foo f (1, 2);
+  printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init4.C b/gcc/testsuite/g++.old-deja/g++.brendan/init4.C
new file mode 100755
index 0000000..c1d3592
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init4.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed initialization
+struct CharList { int i; };
+
+const CharList& terminals = { 1 };// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init5.C b/gcc/testsuite/g++.old-deja/g++.brendan/init5.C
new file mode 100755
index 0000000..112dcac
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init5.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed initialization
+int main( int argc, char**argv, char** envp ){
+    char* domain = argv[1];
+    domain = domain? (char*)"component" : domain;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init6.C b/gcc/testsuite/g++.old-deja/g++.brendan/init6.C
new file mode 100755
index 0000000..e49758a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init6.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed initialization
+class Tag {
+public:
+	Tag(int i):value(i){}
+	int value;
+};
+
+extern const Tag myTag;
+extern const Tag myTag=9;
+
+// The compiler should not issue an error on this line; expand_static_init
+// should be checking that there's no initializer for this line, and thus
+// doesn't need to produce an error.
+extern const Tag myTag;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init7.C b/gcc/testsuite/g++.old-deja/g++.brendan/init7.C
new file mode 100755
index 0000000..033da8f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init7.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed initialization
+struct myChoiceList
+{
+	int bla;
+	int blubb;
+	int brummbrumm;
+};
+
+extern const myChoiceList foo;
+
+extern const myChoiceList foo = {1,1,1};
+
+// finish_decl should have an exclusion so an error is not produced
+// for this line.
+extern const myChoiceList foo;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init8.C b/gcc/testsuite/g++.old-deja/g++.brendan/init8.C
new file mode 100755
index 0000000..4818a41
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init8.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed initialization
+class A
+{
+public:
+    A(const A & a) : i_member(a.i_member)
+    {
+    }
+    A(const int & i) : i_member(i)
+    {
+    }
+    union
+    {
+        int i_member;
+    };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init9.C b/gcc/testsuite/g++.old-deja/g++.brendan/init9.C
new file mode 100755
index 0000000..bad6416
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init9.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed initialization
+int FALSE = 0;
+class X {
+public:
+  static int FALSE;
+};
+
+// The compiler should NOT complain about redeclaration of the global
+// `FALSE' with this declaration...grokvardecl shouldn't be doing that.
+int X::FALSE = 0;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/label1.C b/gcc/testsuite/g++.old-deja/g++.brendan/label1.C
new file mode 100755
index 0000000..ff0b87c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/label1.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed labels
+// it should only give 1 error, about using an undefined label
+int main(void) { goto dummy; }// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/label2.C b/gcc/testsuite/g++.old-deja/g++.brendan/label2.C
new file mode 100755
index 0000000..bce2112
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/label2.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed labels
+class X {
+public:
+    X();
+};
+void foo ()
+{
+X:  ::abort();
+    goto X;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/line1.C b/gcc/testsuite/g++.old-deja/g++.brendan/line1.C
new file mode 100755
index 0000000..d76832e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/line1.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed error-messages
+typedef struct s S;// ERROR -  previous.*
+struct S { int member:1; };  // the lineno for this should be 2, not 0// ERROR -  conflicting types.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc1.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc1.C
new file mode 100755
index 0000000..666ec25
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc1.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+int main( int argc, char**argv, char** envp ){
+    char* domain = argv[1];
+    domain = domain? (char*)"component" : domain;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc10.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc10.C
new file mode 100755
index 0000000..4d96926
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc10.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed miscellaneous
+// The compiler shouldn't give a `invalid operands to binary +' for this
+// case.
+enum flag { OFF, ON };
+enum BOOL { FALSE = (enum flag) 0, TRUE };
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc11.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc11.C
new file mode 100755
index 0000000..043f6a5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc11.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed miscellaneous
+// This should not complain about A::f being abstract.
+struct	A
+{
+	virtual int f() = 0;
+};
+
+struct	B : virtual A
+{
+	virtual int f()		{	return 1;	}
+	virtual int g() = 0;
+};
+
+struct	C: B
+{
+	int g()			{	return 2;	}
+};
+
+C	c;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc12.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc12.C
new file mode 100755
index 0000000..73db9bf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc12.C
@@ -0,0 +1,16 @@
+// GROUPS passed miscellaneous
+extern "C" void exit (int);
+extern "C" int printf (char *, ...);
+
+/* Make sure cp-lex.c handles these properly--if this links, that means
+   it emitted the strings instead of __FUNCTION__.0, etc.  */
+
+int
+main()
+{
+  char *a = __FUNCTION__;
+  char *b = __PRETTY_FUNCTION__;
+
+  printf ("PASS\n");
+  exit (0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc13.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc13.C
new file mode 100755
index 0000000..57292a2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc13.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+// This should only give warnings from duplicate_decls; it should not get
+// errors from push_overloaded_decl as well.
+
+extern "C"
+{
+  long unsigned int strlen(char*);// ERROR -  warning// ERROR -  warning.*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc14.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc14.C
new file mode 100755
index 0000000..024566f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc14.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+class X {
+public:
+    enum e {
+	New,// ERROR -  conflicts with other.*
+    }; // ERROR - comma
+
+    static int New(int);// ERROR -  declaration.*
+};
+
+int main() {}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc15.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc15.C
new file mode 100755
index 0000000..e4dd53e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc15.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+// we shouldn't get any warnings or errors for this code
+struct A {
+        int     aa;
+};
+struct B : public A {
+};
+struct C : public A {
+};
+struct D : public C, public B {
+        void fun() { C::aa = 10; }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc16.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc16.C
new file mode 100755
index 0000000..15e3946
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc16.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+// Using a typedef causes a compiler error
+typedef unsigned int Uint32;
+
+// Using a define so that there isn't a typedef works OK.
+//#define Uint32 unsigned int
+
+Uint32 func0(Uint32, Uint32)
+{
+   return 0;
+}
+
+Uint32 func1(Uint32, Uint32)
+{
+   return 1;
+}
+
+Uint32 (*mf[])(Uint32, Uint32) = {func0, func1};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc17.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc17.C
new file mode 100755
index 0000000..987618f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc17.C
@@ -0,0 +1,36 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+typedef int va_list;
+class ostream;
+class String {
+public:
+operator const char *() const;
+};
+class FwtErrorManager {
+public:
+    FwtErrorManager(ostream& err, const char *program);
+public:
+    void form(const char *format, ...);
+protected:
+    const String _program;	 
+private:
+    FwtErrorManager(const FwtErrorManager&);
+    void operator=(const FwtErrorManager&);
+};
+class FwtProgram: public FwtErrorManager {
+public:
+    FwtProgram();	 
+};
+class FwtArgOptions { };
+class FwtStdProgram: public FwtProgram, public FwtArgOptions {
+public:
+    FwtStdProgram();	 
+    void usage_if_not_complete();
+};
+void
+FwtStdProgram::usage_if_not_complete()
+{
+	FwtStdProgram& thisp = *this;
+	thisp.form("%s: error, there were unrecognized options",
+		   (char *) FwtErrorManager::_program);// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc2.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc2.C
new file mode 100755
index 0000000..d9aa99b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc2.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+// Should be fixed by:
+// Sun Jun 13 12:55:22 1993  Brendan Kehoe  (brendan@lisa.cygnus.com)
+//
+//	* cp-decl.c (grokvardecl): Don't complain about duplicate
+//	definitions of `extern "C"' declarations (parallelize it with how
+//	regular `extern' decls are handled).
+
+extern "C" double  _MaXdOuB, _MiNdOuB;
+extern "C" double  _MaXdOuB, _MiNdOuB;	// no error should be emitted for this
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc3.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc3.C
new file mode 100755
index 0000000..d632cb7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc3.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+// The compiler should not error about taking the addr of main in this example.
+class fred {
+private:
+  void main () {
+  }
+public:
+  fred ( ) {
+    &fred::main;
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc4.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc4.C
new file mode 100755
index 0000000..93aea92
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc4.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed miscellaneous
+// This should not emit an error about A::~A() being redefined; we
+// should check that it is a pure virtual.
+class A {
+public:
+    virtual ~A() = 0;
+};
+
+A::~A() {}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc5.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc5.C
new file mode 100755
index 0000000..05eeed6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc5.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed miscellaneous
+class A {
+    static A aa[2];
+};
+
+A A::aa[2]; // should be completely legal
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc6.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc6.C
new file mode 100755
index 0000000..b05c1f1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc6.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed miscellaneous
+// test that use of `inline' is forbidden when it should be
+inline int i;// ERROR - .*
+struct c { inline int i; };// ERROR - .*
+int foo (inline int i);// ERROR - .*
+inline class c; // ERROR - inline
+inline typedef int t; // ERROR - inline
+class d { inline friend class c; }; // ERROR - inline
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc7.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc7.C
new file mode 100755
index 0000000..af07d6f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc7.C
@@ -0,0 +1,15 @@
+// GROUPS passed miscellaneous
+extern "C" void printf (char *, ...);
+
+int main()
+{
+  int i = 0;
+  // Make sure build_unary_op correctly computes this.
+  int *pi = &(++i);
+  *pi = 4;
+
+  if (i != 4)
+    printf ("FAIL\n");
+  else
+    printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc8.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc8.C
new file mode 100755
index 0000000..b2aa92f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc8.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed miscellaneous
+// used to say invalid lvalue in `&\'
+class foo {
+        int     a;
+    public:
+        foo(int a);
+};
+
+foo::foo(int a)
+{
+    foo::a=a;
+}
+
+int main()
+{
+foo     obj(4);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc9.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc9.C
new file mode 100755
index 0000000..88071c6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc9.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// GROUPS passed miscellaneous
+//The program listed below produces the following error during compilation:
+//   % g++ bug17.cc
+//   bug17.cc: In method `class Y& Y::operator = (const class Y&)':
+//   bug17.cc:18: invalid use of non-lvalue array
+
+class X {
+public:
+   X& operator=(const X&) { return *this; }
+};
+
+struct S {
+   char c[10];
+   X x;
+};
+
+class Y {
+   S s;
+public:
+   const S& f() const { return s; }
+
+   Y& operator=(const Y& _Y) {
+      s = _Y.s;    // this line compiles
+      s = _Y.f();  // this line does not compile
+      return *this;
+   }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/mutable1.C b/gcc/testsuite/g++.old-deja/g++.brendan/mutable1.C
new file mode 100755
index 0000000..79157b7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/mutable1.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed mutable
+class foo;
+class bar {
+  mutable foo const *foobar;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest1.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest1.C
new file mode 100755
index 0000000..32aab3e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest1.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+int x;
+class enclose {
+public:
+  int x;
+
+  class inner {
+  public:
+    void f (int i) {
+      x = i;// ERROR - .*
+    }
+  };
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest10.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest10.C
new file mode 100755
index 0000000..d22e307
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest10.C
@@ -0,0 +1,30 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class A
+	{
+	public:
+		class B
+			{
+			public:
+				int f ();
+				void g (int);
+			private:
+				int b;
+			};
+	};
+
+int A::B::f ()
+	{
+	int val=b;
+	return val;
+	}
+
+void A::B::g (int val)
+	{
+	b = val;
+	}
+
+
+int main ()
+	{
+	}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest11.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest11.C
new file mode 100755
index 0000000..4a57b38
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest11.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class A {
+  int x;
+
+  struct B {
+    int x;
+  };
+  struct C {
+    int bug (A::B &y);
+  };
+};
+
+int
+A::C::bug (A::B &y)
+{
+  return y.x;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest12.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest12.C
new file mode 100755
index 0000000..19286db
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest12.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+struct enclose {
+  class nested;
+  nested *nptr;
+  class nested {
+    int x;
+  };
+  void f();
+};
+
+void enclose::f()
+{
+  nptr = new enclose::nested;  
+}
+
+void g()
+{
+  enclose obj;
+  obj.nptr = new enclose::nested;  
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest13.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest13.C
new file mode 100755
index 0000000..354e7bc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest13.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+// The bug here is that wer'e getting a message about inner not
+// being a basetype itself.  I think it's because it's being
+// compared as the "inner" we knew about when it was forward-declared,
+// versus the "inner" we know about when it *has* been defined.
+
+class temp
+{
+public:
+        struct inner;
+        inner *trump()
+        {
+                return (tt);
+        }
+        struct inner
+        {
+                int ll;
+        }*tt;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest15.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest15.C
new file mode 100755
index 0000000..4a696af
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest15.C
@@ -0,0 +1,37 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class BDDHeap {
+public:
+    BDDHeap();
+    BDDHeap(const BDDHeap&);
+
+    class Page {
+    public:
+	int i;
+    };
+    struct Pointer {
+	Page *page;
+	unsigned index;
+
+	Pointer();
+	Pointer(const BDDHeap& heap);
+    };
+
+    struct Half {
+	struct {
+	    Page *top;
+	    Page **tail;
+	} inuse;
+
+	Half();
+    };
+
+    Half half[2];
+    unsigned halfspace;
+};
+
+inline
+BDDHeap::Pointer::Pointer(const BDDHeap& heap):
+page(heap.half[heap.halfspace].inuse.top),
+index(0)
+{ }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest16.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest16.C
new file mode 100755
index 0000000..920ea0b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest16.C
@@ -0,0 +1,41 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class BDDHeap {
+public:
+    BDDHeap();
+    BDDHeap(const BDDHeap&);
+
+    class Page {
+    public:
+	int i;
+    };
+    struct Pointer {
+	Page *page;
+	unsigned index;
+
+	Pointer();
+	Pointer(const BDDHeap& heap);
+    };
+
+    struct Half {
+	struct {
+	    Page *top;
+	    Page **tail;
+	} inuse;
+
+	Half();
+    };
+
+    Half half[2];
+    unsigned halfspace;
+};
+
+inline
+BDDHeap::Pointer::Pointer(const BDDHeap& heap):
+page(0),
+index(0)
+{
+    Page *x = heap.half[heap.halfspace].inuse.top;
+    page = x;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest17.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest17.C
new file mode 100755
index 0000000..f61c49e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest17.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class T {
+public:
+    typedef int I;
+    class Y {int y;};
+    typedef Y Z;
+};
+
+T::I i;
+T::Y y;
+T::Z z;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest18.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest18.C
new file mode 100755
index 0000000..e41def4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest18.C
@@ -0,0 +1,31 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+// This is the first line of file ||t2.C||.
+
+// This code demonstrates what appears to be a bug with nested types.
+// In C++, nested typedefs are not supposed to be visible outside
+// their class scopes but they apparently are in gcc 2.4.5.  This code
+// compiles fine in AT&T cfront 3.0.1, but will not compile with gcc.
+
+// If this class does not precede String, then the code will compile.
+
+class Another {
+public:
+    typedef int Length;
+};
+
+// If String does not define typedef int Length, then the code will
+// compile.
+
+class String {
+public:
+    typedef int Length;		// remove this and it will compile fine
+
+    int foo(Length length) const;
+};
+
+int String::foo(Length length) const {
+    return length;
+}
+
+// File ||t2.C|| ends here.
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest19.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest19.C
new file mode 100755
index 0000000..efa7ac5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest19.C
@@ -0,0 +1,40 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+// This is the first line of file ||t3.C||.
+
+// This code demonstrates a variation of the same problem with nested
+// types.  In C++, nested typedefs are not supposed to be visible
+// outside their class scopes but they apparently are in gcc 2.4.5.
+// This code compiles fine in AT&T cfront 3.0.1, but gcc rejects it
+// with the messages given below.
+
+// If this class does not precede Expr, then the code will compile.
+
+class Another {
+public:
+    typedef int Boolean;
+    enum { FALSE, TRUE };
+};
+
+// If Expr does not define typedef int Boolean, then the code will
+// compile.
+
+class Expr {
+public:
+    typedef int Boolean;
+    enum { FALSE, TRUE };
+    void foo();
+    void call_something_with(Boolean);
+};
+
+// t3.C: In method `void  Expr::foo ()':
+//   t3.C:36: uninitialized const `Boolean'
+//   t3.C:36: parse error before `='
+//   t3.C:37: `argument' undeclared (first use this function)
+//   t3.C:37: (Each undeclared identifier is reported only once
+//   t3.C:37: for each function it appears in.)
+
+void Expr::foo() {
+    const Boolean argument = TRUE;
+    call_something_with(argument);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest2.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest2.C
new file mode 100755
index 0000000..4b55245
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest2.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class A {
+protected:
+  class B {
+  public:
+    ~B();
+  private:
+    float _datum;
+  };
+private:
+  B *_b;
+};
+
+A::B::~B()
+{
+  _datum = 8.0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest20.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest20.C
new file mode 100755
index 0000000..297b08a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest20.C
@@ -0,0 +1,30 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+// This is the first line of file ||t5.C||.
+
+// This code initializing an unnamed union inside a class appears to
+// be legal C++ input and compiles fine with AT&T cfront 3.0.1, but
+// gcc 2.4.5 complains about multiple initializations of the same
+// member.
+
+class Expr {
+public:
+    enum Type { undefined, slong, ulong, ldouble };
+    Expr();
+    Expr(Type type, const Expr* initializer);
+private:
+    Type type_;
+    union {
+	long slong_;
+	unsigned long ulong_;
+	long double ldouble_;
+    };
+};
+
+// Construct an undefined expression.
+
+Expr::Expr()
+    :
+    type_(undefined),
+    slong_(-1)
+{}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest21.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest21.C
new file mode 100755
index 0000000..f32166d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest21.C
@@ -0,0 +1,95 @@
+// GROUPS passed nested-classes
+#include <iostream.h>
+#include <stdio.h>
+
+static char output[1024];
+
+class BDDRetrace {
+public:
+    class Dump {
+    public:
+	virtual Dump& operator<<(char c) = 0;
+	virtual Dump& operator<<(int i) = 0;
+	virtual Dump& operator<<(double r) = 0;
+    };
+
+    class Dump1: public Dump {
+    public:
+	Dump& operator<<(char c);
+	Dump& operator<<(int i);
+	Dump& operator<<(double r);
+    };
+};
+
+class Dump2: public BDDRetrace::Dump {
+public:
+    BDDRetrace::Dump& operator<<(char c);
+    BDDRetrace::Dump& operator<<(int i);
+    BDDRetrace::Dump& operator<<(double r);
+};
+
+BDDRetrace::Dump&
+BDDRetrace::Dump1::operator<<(char c)
+{ char tempout[1024];
+  sprintf (tempout, "%s%s%c", output, "1-", c);
+  strcpy (output, tempout);
+  return *this;
+}
+
+BDDRetrace::Dump&
+BDDRetrace::Dump1::operator<<(int i)
+{ char tempout[1024];
+  sprintf (tempout, "%s%s%d", output, "1-", i);
+  strcpy (output, tempout);
+  return *this; }
+
+BDDRetrace::Dump&
+BDDRetrace::Dump1::operator<<(double r)
+{ char tempout[1024];
+  sprintf (tempout, "%s%s%1.0f", output, "1-", r);
+  strcpy (output, tempout);
+  return *this; }
+
+BDDRetrace::Dump&
+Dump2::operator<<(char c)
+{ char tempout[1024];
+  sprintf (tempout, "%s%s%c", output, "2-", c);
+  strcpy (output, tempout);
+  return *this; }
+
+BDDRetrace::Dump&
+Dump2::operator<<(int i)
+{ char tempout[1024];
+  sprintf (tempout, "%s%s%d", output, "2-", i);
+  strcpy (output, tempout);
+  return *this; }
+
+BDDRetrace::Dump&
+Dump2::operator<<(double r)
+{ char tempout[1024];
+  sprintf (tempout, "%s%s%1.0f", output, "2-", r);
+  strcpy (output, tempout);
+  return *this; }
+
+int main()
+{
+    BDDRetrace::Dump1 d1;
+    Dump2 d2;
+
+    sprintf (output, " ");
+
+    d1 << 'a';
+    d1 << 1;
+    d1 << 1.0;
+
+    d2 << 'a';
+    d2 << 1;
+    d2 << 1.0;
+
+    if (strcmp (output, " 1-a1-11-12-a2-12-1") == 0)
+      printf ("PASS\n");
+    else
+      printf ("FAIL\n");
+
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest22.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest22.C
new file mode 100755
index 0000000..cd26c34
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest22.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class foo {
+public:
+   typedef int bar;
+   foo::bar    fb; // this line causes a syntax error!
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest23.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest23.C
new file mode 100755
index 0000000..e18398b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest23.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class CS {
+public:
+    class PS {
+    };
+};
+
+class NCS: public CS {
+public:
+    class S: public PS {
+    };
+};
+
+int i;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest24.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest24.C
new file mode 100755
index 0000000..4fcc02c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest24.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+struct A {
+  A (){}
+};
+
+void foo ()
+{
+ struct B {};
+
+ struct S : B {
+   A a;
+ };
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest3.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest3.C
new file mode 100755
index 0000000..bedd519
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest3.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class X {
+public:
+  struct M2 { int m; };
+  M2 g(int);
+};
+
+
+X::M2 X::g(int i) { X::M2 m2; return m2; }
+
+int main() { }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest4.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest4.C
new file mode 100755
index 0000000..34631f4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest4.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed nested-classes
+class vec {
+    class blah { };
+
+    ::vec::blah	satan( 0);// ERROR - .*
+    blah	herman( 0);// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/new-array.C b/gcc/testsuite/g++.old-deja/g++.brendan/new-array.C
new file mode 100755
index 0000000..3080a58
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/new-array.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed operator-new
+typedef struct {
+	int a;
+} AStruct;
+
+void MakeBug() {
+	AStruct *job;
+
+	// This used to crash, it should now give error(s).
+	job = new AStruct[];// ERROR - .*
+
+	job = new AStruct;
+}
+
+int main () {
+	MakeBug();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/new1.C b/gcc/testsuite/g++.old-deja/g++.brendan/new1.C
new file mode 100755
index 0000000..09326d2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/new1.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed operator-new
+typedef __SIZE_TYPE__ size_t;
+struct x { int a; void * operator new (size_t, void *); };
+struct x * f(void *p) { return new (p) x; }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/new2.C b/gcc/testsuite/g++.old-deja/g++.brendan/new2.C
new file mode 100755
index 0000000..64b3d51
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/new2.C
@@ -0,0 +1,67 @@
+// GROUPS passed operator-new
+// Check that if there is a user defined class-specific operator
+// new for a given class, that operator is invoked when a new
+// object of the class is requested, regardless of whether or not
+// there is also a constructor for the given class, and regardless
+// of whether or not the constructor for the given class is defined
+// before or after the new operator is even declared.
+
+extern "C" void printf (char *, ...); 
+
+typedef __SIZE_TYPE__ size_t;
+
+struct base {
+	int i;
+
+	base ()
+	{
+		i = 7;
+	}
+
+	void * operator new (size_t size);
+	void operator delete (void*);
+};
+
+class derived : public base {
+	int j;
+};
+
+int new_call_count = 0;
+int expected_size = 0;
+int errors = 0;
+
+int main ()
+{
+	base*		base_ptr;
+	derived*	derived_ptr;
+
+	expected_size = 4;
+	base_ptr = new base;
+	expected_size = 8;
+	derived_ptr = new derived ();
+
+	if ((new_call_count != 2) || (errors != 0))
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
+
+char allocation_space[1000];
+char* allocation_ptr = allocation_space;
+
+void base::operator delete (void* p)
+{
+}
+
+void *base::operator new (size_t size)
+{
+	char* return_value = allocation_ptr;
+
+	new_call_count++;
+	if (size != expected_size)
+		errors++;
+	allocation_ptr = allocation_ptr + size;
+	return (void*) return_value;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/new3.C b/gcc/testsuite/g++.old-deja/g++.brendan/new3.C
new file mode 100755
index 0000000..5f5c988
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/new3.C
@@ -0,0 +1,36 @@
+// GROUPS passed operator-new
+#include <stdio.h>
+#include <stdlib.h>
+#include <new>
+
+int pass = 0;
+
+void *operator new(size_t sz) throw (std::bad_alloc) {
+
+  void *p;
+
+  pass = 1;
+  p = malloc(sz);
+  return p;
+}
+
+class A {
+public:
+  A() {}
+  ~A() {}
+
+  int a;
+  int b;
+};
+
+
+int main()
+{
+  A *bb = new A[10];
+  delete [] bb;
+
+  if (pass)
+    printf ("PASS\n");
+  else
+    printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ns1.C b/gcc/testsuite/g++.old-deja/g++.brendan/ns1.C
new file mode 100755
index 0000000..d20a9d9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ns1.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed old-abort
+struct B 
+{
+      void f(char); 
+      void g(char);
+};
+  
+class C 
+{
+  int g();
+};// ERROR -  warning
+
+class D2 : public B 
+{
+  using B::f;  // ok: B is a base of D
+  using C::g;  // error: C isn't a base of D2
+}; // ERROR - type C is not a base type for type D2
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators1.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators1.C
new file mode 100755
index 0000000..89453f9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators1.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed operators
+struct A {
+	int x;
+};
+
+int operator()(A x,float y) { // MUST be a member function// ERROR - .*
+	return 1;
+}
+
+int main() {
+	A x;
+	x(1.0); // ERROR - no match for call
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators2.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators2.C
new file mode 100755
index 0000000..ece06ef
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators2.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed operators
+class X { };
+void operator[](X& a, X& b) {} // MUST be a member function// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators3.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators3.C
new file mode 100755
index 0000000..e068de3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators3.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed operators
+class X { };
+void operator->(X& a, X& b) {} // MUST be a member function// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators4.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators4.C
new file mode 100755
index 0000000..b56d26c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators4.C
@@ -0,0 +1,121 @@
+// GROUPS passed operators
+// Check that the & operator, when applied to a global function
+// or member function returns a proper value as long as the context
+// in which the result of & is used requires a pointer to a specific
+// unambigous (function-pointer) type.
+//
+// This test fails (in test5()) when compiled with g++ 1.34.1.
+
+extern "C" void printf (char *, ...); 
+
+int function (char c);
+int function (float f);
+
+class base {
+	int filler;
+public:
+	int method (char);
+	int method (float);
+};
+
+void* vp;
+
+typedef int (*ptr_to_func_of_char)(char);
+typedef int (*ptr_to_func_of_float)(float);
+typedef int (base::*ptr_to_method_of_char)(char);
+typedef int (base::*ptr_to_method_of_float)(float);
+
+int test2 (void*);
+int test3 (void*);
+int test4 (void*);
+int test5 (void*);
+
+base* base_ptr;
+
+int fail ()
+{
+  printf ("FAIL\n");
+  return 1;
+}
+
+int main ()
+{
+	base_ptr = new base;
+
+	ptr_to_func_of_char p0 = &function;
+	vp = (void*) p0;
+	if (test2 (vp))
+		return fail ();
+	ptr_to_func_of_float p1 = &function;
+	vp = (void*) p1;
+	if (test3 (vp))
+		return fail ();
+	ptr_to_method_of_char p2 = &base::method;
+	vp = (void*) p2; // ERROR - 
+	if (test4 (vp))
+		return fail ();
+	ptr_to_method_of_float p3 = &base::method;
+	vp = (void*) p3; // ERROR - 
+	if (test5 (vp))
+		return fail ();
+
+	printf ("PASS\n");
+	return 0;
+}
+
+int test2 (void* vp)
+{
+	char ch = 'x';
+
+	return (((ptr_to_func_of_char)vp)(ch) !=  9901);
+}
+
+int test3 (void* vp)
+{
+	float flt = 9.9;
+
+	return (((ptr_to_func_of_float)vp)(flt) !=  9902);
+}
+
+int test4 (void* vp)
+{
+	char ch = 'x';
+	ptr_to_method_of_char p = (ptr_to_method_of_char) vp; // ERROR - bad type conversion
+
+	return ((base_ptr->*p)(ch) !=  9904);
+}
+
+int test5 (void* vp)
+{
+	float flt = 9.9;
+	ptr_to_method_of_float p = (ptr_to_method_of_float) vp; // ERROR - bad type conversion
+
+	if ((base_ptr->*p)(flt) !=  9905) {
+		return 1;
+	} else
+		return 0;
+}
+
+int function (char c)
+{
+	c = c;
+	return 9901;
+}
+
+int function (float f)
+{
+	f = f;
+	return 9902;
+}
+
+int base::method (char c)
+{
+	c = c;
+	return 9904;
+}
+
+int base::method (float f)
+{
+	f = f;
+	return 9905;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators5.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators5.C
new file mode 100755
index 0000000..84c09a2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators5.C
@@ -0,0 +1,52 @@
+// GROUPS passed operators
+// Check that operators may be (directly) recursive.
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	int i;
+};
+
+base base_variable;
+
+base operator+ (const base& left, const base& right)
+{
+	base ret_val;
+
+	ret_val.i = left.i + right.i;
+	return ret_val;
+}
+
+base operator- (const base& left, int right)
+{
+	base ret_val;
+
+	ret_val.i = left.i - right;
+	return ret_val;
+}
+
+// Define the unary ! operator for class base to be the fibonachi
+// operator.
+
+base operator! (const base& right)
+{
+	if (right.i < 2)
+		return right;
+	else
+		return ((!(right-1)) + (!(right-2)));
+}
+
+int main ()
+{
+	base k;
+
+	k.i = 15;
+	k = !k;		// fib it!
+
+	if (k.i != 610)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators6.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators6.C
new file mode 100755
index 0000000..c0c2318
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators6.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed operators
+class a {
+public:
+    a* operator->() { return this; }
+    void p();
+};
+
+void a::p() {
+  operator->();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators7.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators7.C
new file mode 100755
index 0000000..7a95221
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators7.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed operators
+class A {
+  char *p;
+public:
+  operator const char *() const { return p; }
+};
+
+int foo(const A &a)
+{
+  return (a != 0);
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators8.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators8.C
new file mode 100755
index 0000000..390f749
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators8.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed operators
+struct A {
+  char *p;
+  operator char *();
+};
+
+char foo(A a)
+{
+  return a[0];
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload1.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload1.C
new file mode 100755
index 0000000..e5040fd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload1.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed overloading
+class Foo
+{
+public:
+  int f (void);
+};
+
+class Bar : public Foo
+{
+public:
+      int f (int); // ERROR - candidates are
+};
+
+int main ()
+{
+  Bar b;
+
+  b.f ();// ERROR - 
+  b.f (10);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload10.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload10.C
new file mode 100755
index 0000000..e28d6ea
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload10.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// GROUPS passed overloading
+class Bed {
+   public:
+   static void bed_func(
+      int        (*f)(int &, int, int));
+};
+class g_func {
+public:
+	static int save_status;
+
+	// in compute_harshness, we should be using comptypes, not ==, to
+	// check if this is equivalent to the previous decl; the only
+	// difference is the default arg
+	static int rpt_func(int &status, int expand, 
+		int restore_cursor=1 );
+};
+
+int  main (int argc, 
+           char **argv,
+           char  **envp)
+{
+   Bed::bed_func(g_func::rpt_func);
+   return(1);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload11.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload11.C
new file mode 100755
index 0000000..cbced94
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload11.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed overloading
+class foo_int
+{
+public:
+  int & i;
+
+  foo_int (int &j) : i(j) {};
+  void inc () { i++; }
+
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload2.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload2.C
new file mode 100755
index 0000000..75068da
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload2.C
@@ -0,0 +1,43 @@
+// GROUPS passed overloading
+// Check that calls to the correct overloaded virtual
+// functions are generated even where the type of the formal
+// arguments for the overloadings are similar or related.
+
+extern "C" void printf (char *, ...); 
+
+int proper_method_called = 0;
+
+struct base {
+	int member;
+	virtual void method (char)
+	{
+	}
+	virtual void method (char *)
+	{
+	}
+};
+
+struct derived : public base {
+	int member;
+	virtual void method (char)
+	{
+	}
+	virtual void method (char *)
+	{
+		proper_method_called++;
+	}
+};
+
+char *message;
+
+int main ()
+{
+	derived derived_object;
+
+	derived_object.method (message);
+
+	if (proper_method_called != 1)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload3.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload3.C
new file mode 100755
index 0000000..baa90fb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload3.C
@@ -0,0 +1,27 @@
+// Build don't link: 
+// GROUPS passed overloading
+typedef int rutBoolean;
+
+class rutBigIntRep
+{
+public:
+  friend rutBoolean operator>(const rutBigIntRep& a, const rutBigIntRep& b);
+  operator rutBoolean() const;  
+protected:
+  enum Kluge {kluge};
+  rutBigIntRep(Kluge) {}
+  rutBigIntRep();
+  rutBigIntRep(const rutBigIntRep& value);
+  rutBigIntRep& operator=(const rutBigIntRep& value);
+};
+
+rutBoolean operator>(const rutBigIntRep& a, const rutBigIntRep& b) {
+  // This should not result in a warning.  It used to warn about the
+  // conversion from int to enum while exploring the possibility of
+  // converting `a' via `operator rutBoolean', then using the
+  // rutBigIntRep(Kluge) constructor.  It later realizes it shouldn't
+  // do this, but the call to build_type_conversion was ending up with
+  // a warning in convert.
+  rutBigIntRep diff(a);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload4.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload4.C
new file mode 100755
index 0000000..21c3dc8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload4.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed overloading
+  typedef void *		(*NewObject) (void);
+  
+  class B
+  {
+  public:
+	static void WantsNew (NewObject creator); // ERROR - candidates are
+  };
+  
+  class A
+  {
+  public:
+      static A * NewOne (void);
+  
+      static void InitClass (void)
+      {
+	  B::WantsNew ( (NewObject) A::NewOne );
+	  // This used to die in convert_harshness_{ansi,old} cuz it
+	  // didn't know what to do about a void type.
+	  B::WantsNew ( A::NewOne );// ERROR - 
+      }
+  };
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload5.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload5.C
new file mode 100755
index 0000000..d71f0c0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload5.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed overloading
+class Foo
+{
+public:
+  int operator << (const signed char&);
+  int operator << (const unsigned char&);
+  int operator << (const short&);
+  int operator << (const unsigned short&);
+  int operator << (const long&);
+  int operator << (const unsigned long&);
+};
+
+int main ()
+{
+  Foo fd;
+
+  // We fixed convert_harshness_ansi so it considers the call to
+  // <<(const signed char&) to be a trivial conversion.  It used
+  // to always make it a standard conversion, which made it conflict
+  // with <<(const unsigned char &), which is really a std conv.
+  fd << (signed char) 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload6.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload6.C
new file mode 100755
index 0000000..84903c1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload6.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed overloading
+struct temp_string {
+  temp_string (const unsigned char);
+};
+  
+class String {
+ public:
+  String& operator = (temp_string);
+  String& operator = (const String&);
+}; 
+class S {
+ public:
+  operator temp_string & () const;
+}; 
+
+S lbuf;
+
+static void e_r ()
+{
+  String a;
+  a = lbuf;
+ return;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload7.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload7.C
new file mode 100755
index 0000000..ec2685c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload7.C
@@ -0,0 +1,41 @@
+// GROUPS passed overloading
+extern "C" void printf (char *, ...);
+
+struct NoName {
+        
+        int first;
+        int second;
+};
+
+class Casted {
+
+  public:
+
+        NoName  x;
+        double  y;
+
+        Casted ( int _x , double _y ): y(_y) 
+        { 
+                x.first = _x;
+                x.second = _x*2;
+        }
+        
+        operator NoName() const { return x; }
+        operator double() const { return y; }
+};
+
+int main()
+{
+        Casted c(10,12.34);
+
+        NoName x;
+        double y;
+
+        x = c;
+        y = c;
+
+	if (x.first == 10 && x.second == 20 && y == 12.34)
+	  printf ("PASS\n");
+	else
+	  printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload8.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload8.C
new file mode 100755
index 0000000..71d1689
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload8.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed overloading
+typedef struct{double re,im;} complex;
+class Complex{public:double re,im;
+    inline void operator=(Complex&X){re=X.re; im=X.im;};};
+void zxcvbnm(int n,...){n=1;}
+int main(){complex c; Complex C;
+zxcvbnm(1,c);
+zxcvbnm(1,C);}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload9.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload9.C
new file mode 100755
index 0000000..93a0cbf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload9.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed overloading
+class CLogger
+{
+public:
+      void operator() (int,const char *) {}; // ERROR - candidates
+      void operator() (int,const char *, ...) {}; // ERROR - candidates
+} Log;
+
+class CGLogger : public CLogger
+{
+} GLog;
+
+int main()
+{
+        Log(1,"Test");// ERROR -  call of.*
+        Log(1,"Test %d",3);
+        GLog(1,"Test");// ERROR -  call of.*
+        GLog(1,"Test %d",3);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/parse1.C b/gcc/testsuite/g++.old-deja/g++.brendan/parse1.C
new file mode 100755
index 0000000..0c62c03
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/parse1.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed parsing
+class Try {
+private:
+  char s;
+public:
+  // an escaped double-quote should not call consume_string inside
+  // reinit_parse_for_block
+  void  mf() { s='\"'; }
+};
+
+int main()
+{
+  Try x;
+  x.mf();
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/parse2.C b/gcc/testsuite/g++.old-deja/g++.brendan/parse2.C
new file mode 100755
index 0000000..cd588e1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/parse2.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed parsing
+class BitString {
+public:
+    int i;
+};
+
+
+typedef BitString BS;
+typedef ::BitString cBS;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/parse3.C b/gcc/testsuite/g++.old-deja/g++.brendan/parse3.C
new file mode 100755
index 0000000..8be64a3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/parse3.C
@@ -0,0 +1,22 @@
+// Build don't link: 
+
+// these are marked as expected errors because they evidence an
+// ambiguity in the grammar between expressions and declarations.
+// when the parser's been cleaned up or rewritten, these two error
+// markers can go away, since they'll no longer occur.
+
+class A
+{
+  public:
+    int high;
+    unsigned int low;
+    A operator+(const A in);
+};
+
+A A::operator+(const A in)
+{
+    if (high==0)
+      return A();    // this works
+    else
+      return (A());  // this works not // gets bogus error - XFAIL *-*-* 
+} // gets bogus error - XFAIL *-*-* 
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/parse4.C b/gcc/testsuite/g++.old-deja/g++.brendan/parse4.C
new file mode 100755
index 0000000..6526c60
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/parse4.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+
+// this is marked as an expected error because it evidences an
+// ambiguity in the grammar between expressions and declarations.
+// when the parser's been cleaned up or rewritten, the error
+// marker can go away, since it'll no longer occur.
+
+class B
+{
+public:
+    B( int t ) {}
+    void f() {}
+};
+
+int g() { return 0; } // gets bogus error - referenced below XFAIL *-*-*
+
+int main()
+{
+    int try1;
+    B( try1 ).f();   // no syntax error
+    B b( g() );      // no syntax error
+    B( ::g() ).f();  // no syntax error 
+    B( g() ).f();    // gets bogus error - treated as decl XFAIL *-*-*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/parse5.C b/gcc/testsuite/g++.old-deja/g++.brendan/parse5.C
new file mode 100755
index 0000000..81a5fe6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/parse5.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+
+// this is marked as an expected error because it evidences an
+// ambiguity in the grammar between expressions and declarations.
+// when the parser's been cleaned up or rewritten, the error
+// marker can go away, since it'll no longer occur.
+
+class ptr8
+   {
+public:
+   ptr8(unsigned char *string,int len);
+   };
+
+template <unsigned int S>
+class buf
+   {
+public:
+   buf(const ptr8& aRef);
+   };
+
+int main()
+   {
+   unsigned  char b[3];
+   buf<3> b2(ptr8(&b[0],3)); // gets bogus error - XFAIL *-*-*
+   }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/parse6.C b/gcc/testsuite/g++.old-deja/g++.brendan/parse6.C
new file mode 100755
index 0000000..d5ece06
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/parse6.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+
+// this is marked as an expected error because it evidences an
+// ambiguity in the grammar between expressions and declarations.
+// when the parser's been cleaned up or rewritten, the error
+// marker can go away, since it'll no longer occur.
+
+class A { };
+
+int main()  {
+  A a = a;
+  A b(b); // gets bogus error - XFAIL *-*-*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/prepost1.C b/gcc/testsuite/g++.old-deja/g++.brendan/prepost1.C
new file mode 100755
index 0000000..e1b18bc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/prepost1.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed prefix-postfix
+class foo {
+public:
+      operator ++ (); // ERROR - no type or storage class
+};
+
+int main()
+{
+  foo x;
+
+  // This should fall back to calling operator++(), and be an error with
+  // the -pedantic flag.
+  x++;// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/prepost2.C b/gcc/testsuite/g++.old-deja/g++.brendan/prepost2.C
new file mode 100755
index 0000000..1e34433
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/prepost2.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed initialization
+class foo {
+public:
+      operator ++ (); // ERROR - no type or storage class
+      operator ++ (int); // ERROR - no type or storage class
+      operator ++ (char);		// illegal// ERROR - .*
+      operator ++ (short);		// illegal// ERROR - .*
+      operator ++ (long);		// illegal// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/prepost3.C b/gcc/testsuite/g++.old-deja/g++.brendan/prepost3.C
new file mode 100755
index 0000000..4244e4f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/prepost3.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed prefix-postfix
+class Y {
+public:
+   friend Y operator++ (Y&);
+   friend Y operator++ (Y&, char);	// illegal// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/prepost4.C b/gcc/testsuite/g++.old-deja/g++.brendan/prepost4.C
new file mode 100755
index 0000000..ac31f91
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/prepost4.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed prefix-postfix
+class Y {
+public:
+   friend Y operator++ (Y&);
+
+   // This is legal---it's a good test to make sure that grokfndecl's
+   // checking of the arguments is sane.
+   friend Y operator++ (Y&, int);
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ptolemy1.C b/gcc/testsuite/g++.old-deja/g++.brendan/ptolemy1.C
new file mode 100755
index 0000000..3e3b2df
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ptolemy1.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed ptolemy-bugs
+class Tcl_Interp;
+
+class PTcl {
+public:
+	PTcl(Tcl_Interp* interp = 0);
+	~PTcl();
+	int alias(int argc,char** argv);
+};
+
+typedef int (PTcl::*InterpFuncP)(int,char**);
+
+struct InterpTableEntry {
+	char* name;
+	InterpFuncP func;
+};
+
+ 
+static InterpTableEntry funcTable[] = {
+	{ "alias" , &PTcl::alias  } ,
+	0, 0
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ptolemy2.C b/gcc/testsuite/g++.old-deja/g++.brendan/ptolemy2.C
new file mode 100755
index 0000000..58a10dc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ptolemy2.C
@@ -0,0 +1,69 @@
+// GROUPS passed ptolemy-bugs
+#include <iostream.h>
+
+class PTcl {
+public:
+	int dispatcher(int which,int argc,char** argv);
+	// fns in the table
+	int one(int argc, char** argv);
+	int two(int argc, char** argv);
+	int three(int argc, char** argv);
+};
+
+// An InterpFuncP is a pointer to an PTcl function that takes an argc-argv
+// argument list and returns TCL_OK or TCL_ERROR.
+
+typedef int (PTcl::*InterpFuncP)(int,char**);
+
+struct InterpTableEntry {
+	char* name;
+	InterpFuncP func;
+};
+
+// Here is the function table and dispatcher function.
+// These macros define entries for the table
+
+#define quote(x) #x
+#define ENTRY(verb) { quote(verb), &PTcl::verb }
+
+static InterpTableEntry funcTable[] = {
+	ENTRY(one),
+	ENTRY(two),
+	ENTRY(three),
+	{0, 0}
+};
+
+int PTcl::dispatcher(int which, int argc, char** argv) {
+	return (this->*(funcTable[which].func))(argc, argv);
+}
+
+void printargs(char** argv) {
+//	while (*argv) {
+//		cout << " " << *argv++;
+//	}
+//	cout << "\n";
+}
+
+int PTcl::one(int, char** argv) {
+  cout << "FAIL\n";
+	printargs(argv);
+	return 0;
+}
+
+int PTcl::two(int, char** argv) {
+  cout << "PASS\n";
+	printargs(argv);
+	return 0;
+}
+
+int PTcl::three(int, char** argv) {
+  cout << "FAIL\n";
+	printargs(argv);
+	return 0;
+}
+
+int main (int argc, char** argv) {
+	PTcl obj;
+	obj.dispatcher(1,argc,argv);
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem1.C b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem1.C
new file mode 100755
index 0000000..49c9f75
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem1.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed pointers-to-members
+class my_class 
+{
+public:
+  typedef void func_type (int num);
+  my_class (int num, func_type* proc);
+  void dispatch (void);
+private:
+  int _num;
+  func_type *_proc;
+};
+
+my_class::my_class (int num, func_type* proc) : _num(num), _proc(proc) 
+{
+}
+
+void my_class::dispatch (void)
+{
+  _proc(_num);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem2.C b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem2.C
new file mode 100755
index 0000000..2af19e0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem2.C
@@ -0,0 +1,26 @@
+// Build don't link: 
+// GROUPS passed pointers-to-members
+struct C {
+  struct N {
+    int g1(int);
+    int g2(int);
+  };
+
+  typedef int (N::*pmfn)(int);
+  
+  int f1(int);
+  int f2(int);
+};
+
+int (C::*f)(int) = &C::f1;		
+
+/*
+   The compiler should not crash on the line below; this change fixes it:
+        * cp-tree.c (list_hash_lookup_or_cons): Make sure the type doesn't
+        have TYPE_PTRMEMFUNC_P set before we try to build its
+        CLASSTYPE_ID_AS_LIST.
+*/
+
+C::pmfn h = &C::N::g1;			
+
+int (C::N::*g)(int) = &C::N::g2;	
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem3.C b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem3.C
new file mode 100755
index 0000000..0f6bf0b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem3.C
@@ -0,0 +1,32 @@
+// Build don't link: 
+// GROUPS passed pointers-to-members
+template<class T> class TemplA {
+    T t;
+};
+
+
+template<class T> class TemplB {
+public:    
+    typedef void (T::*TClassMethod)();
+
+private:
+/*
+   This line should not crash cuz of the get_decl_list change in this:
+	* cp-tree.c (list_hash_lookup_or_cons): Make sure the type doesn't
+	have TYPE_PTRMEMFUNC_P set before we try to build its
+	CLASSTYPE_ID_AS_LIST.
+	(get_decl_list): Likewise, when trying to read it.
+*/
+    TemplA<TClassMethod> Tmethod;  
+};
+
+
+class C {
+    int a;
+};
+
+int main(int, char**) {
+
+    TemplB<C> test;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem4.C b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem4.C
new file mode 100755
index 0000000..a4f792e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem4.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed pointers-to-members
+class X   {
+ private:
+  int i;
+ public:
+  X(int k)			{ i=k; }
+  int operator=(X &a)		{ return i = a.i; }
+  int operator=(int ii)	{ return i = ii; }
+};
+int main(void)
+{
+  int (X::*op1_ptr)(X&);
+  op1_ptr = &X::operator=;    // g++ gives error 
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/recurse.C b/gcc/testsuite/g++.old-deja/g++.brendan/recurse.C
new file mode 100755
index 0000000..639dfb3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/recurse.C
@@ -0,0 +1,80 @@
+// Build don't link: 
+// GROUPS passed recursive-aborts
+// types
+typedef unsigned int DBflag;   // for storing user flag value
+typedef unsigned long DBoffset; // 32-bit unsigned integer
+typedef DBoffset DBsize;  // type for storing sizes of objects
+typedef unsigned char DBbyte;   // 8-bit unsigned char
+
+class DBlink
+{
+protected:
+  DBbyte link[4];       // hold link in portable MSB first format
+public:
+  DBlink(DBoffset = 0, DBflag = 0);
+  DBlink &operator=(const DBlink &);
+  DBlink &operator=(DBoffset);
+  operator DBoffset();
+  operator const DBbyte *() { return link; }
+  void set_flag() { link[0] |= 0x80; }
+  void reset_flag() { link[0] &= 0x7f; }
+  int test_flag() const { return (link[0] & 0x80) != 0; }
+};
+
+typedef DBlink DBsizerec;       // hold data record size in portable format
+
+// constants
+const DBoffset DB_NULL = 0;
+
+class DBlinkrec
+{
+protected:
+  // offsets are stored with MSB in link[0]
+  DBlink l;  // offset into link file of right child - MSB = red bit
+  DBlink r;  // offset into link file of left child - MSB = delete
+  DBlink d;  // offset into parallel data file - MSB = user flag
+public:
+  DBlinkrec():l(DB_NULL), r(DB_NULL), d(DB_NULL) {}
+  void make_red() // set link to red
+  { l.set_flag(); }
+  void make_black() // set link to black
+  { l.reset_flag(); }
+  int is_red() const // indicates whether this is a red link
+  { return l.test_flag(); }
+  void set_discard() // set discard flag
+  { r.set_flag(); }
+  void reset_discard() // reset discard flag
+  { r.reset_flag(); }
+  int is_discarded() const // check discard flag
+  { return r.test_flag(); }
+  void set_flag() // set user flag
+  { d.set_flag(); }
+  void reset_flag() // reset user flag
+  { d.reset_flag(); }
+  int is_flag() const // check user flag
+  { return d.test_flag(); }
+
+  friend class DataBase;
+};
+
+class DBpathrec : public DBlinkrec
+{
+  DBoffset offset;    // offset of link record in LNK file
+public:
+  DBpathrec():offset(DB_NULL) { }
+  DBpathrec(DBoffset off, const DBlinkrec &lr):offset(off), DBlinkrec(lr) {}
+  operator DBoffset() { return offset; }
+  DBpathrec &operator=(DBoffset off) { offset = off; return *this; }
+  DBpathrec &operator=(const DBpathrec &pr)
+  { offset = pr.offset; (DBlinkrec)*this = (DBlinkrec)pr; return *this; }
+
+  friend class DataBase;
+};
+
+int main()
+{
+  DBpathrec a(), b();
+
+  a = b;// ERROR -  non-lvalue in assignment.*
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/redecl1.C b/gcc/testsuite/g++.old-deja/g++.brendan/redecl1.C
new file mode 100755
index 0000000..39a432c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/redecl1.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed redeclaration
+inline int min(int x, int y) {return x < y ? x : y;}		/* 235 */// ERROR - .*
+int min(int a, int b);
+inline int min(int a, int b) {return (a < b)?a:b;}// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/redecl2.C b/gcc/testsuite/g++.old-deja/g++.brendan/redecl2.C
new file mode 100755
index 0000000..5894219
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/redecl2.C
@@ -0,0 +1,51 @@
+// GROUPS passed redeclaration
+// Check that if multiple declarations of the same single
+// function are present in different places in the same file,
+// and if these declarations differ (as allowed) in the number
+// of argument defaults provided, that correct values are
+// passed at all call points anyway.
+
+extern "C" void printf (char *, ...); 
+
+void receiver (int ii, int jj);
+
+void sender_1 ()
+{
+	receiver (3,7);
+}
+
+void receiver (int ii, int jj = 9);
+
+void sender_2 ()
+{
+	receiver (5);
+}
+
+int ii_sum = 0;
+int jj_sum = 0;
+
+void sender_3 ();
+
+int main ()
+{
+	sender_1 ();
+	sender_2 ();
+	sender_3 ();
+	if (ii_sum != 13 || jj_sum != 25)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
+
+void receiver (int ii, int jj)
+{
+	ii_sum += ii;
+	jj_sum += jj;
+}
+
+void sender_3 ()
+{
+	receiver (5);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/redecl3.C b/gcc/testsuite/g++.old-deja/g++.brendan/redecl3.C
new file mode 100755
index 0000000..5987e0e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/redecl3.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed redeclaration
+class foo
+{
+public:
+    int bar(int a);
+};
+
+
+void bar(int &a);
+
+int foo::bar(int a)  {
+    int a = 0;			// Should this be an error ?// ERROR -  declaration.*
+
+    bar(a);
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/reference1.C b/gcc/testsuite/g++.old-deja/g++.brendan/reference1.C
new file mode 100755
index 0000000..84ad6f4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/reference1.C
@@ -0,0 +1,53 @@
+// Special g++ Options: -w
+// GROUPS passed references
+// Check that if a reference is initialized to refer to a value
+// which is returned from a function call, the actual call to
+// the function is only invoked for the original initialization
+// of the reference, and not for each subsequent use of the
+// reference.
+//
+// This test fails with G++ 1.35.0- (pre-release).
+// Reported 4/4/89 by Kim Smith
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	mutable int data_member;
+
+	base () {}
+	void function_member () const;
+};
+
+base base_object;
+
+base base_returning_function ();
+
+int call_count = 0;
+
+int main ()
+{
+	const base& base_ref = base_returning_function ();
+
+	base_ref.function_member ();
+	base_ref.function_member ();
+	base_ref.data_member  = 99;
+
+	if (call_count == 1)
+	  printf ("PASS\n");
+	else
+	  printf ("FAIL\n");
+
+	return 0;
+}
+
+base base_returning_function ()
+{
+	base local_base_object;
+
+	call_count++;
+	return local_base_object;
+}
+
+void base::function_member () const
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/rtti1.C b/gcc/testsuite/g++.old-deja/g++.brendan/rtti1.C
new file mode 100755
index 0000000..6dcdff3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/rtti1.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+// GROUPS passed RTTI
+#include <typeinfo>
+
+struct B                                { virtual ~B(){}  };
+struct D0 : public virtual B            { virtual ~D0(){}  };
+struct D1 : public virtual D0           { virtual ~D1(){}  };
+struct C : public virtual B, public D1  { virtual ~C() { } };
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/scope1.C b/gcc/testsuite/g++.old-deja/g++.brendan/scope1.C
new file mode 100755
index 0000000..babbb01
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/scope1.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+// GROUPS passed scoping
+int f (int i) {
+  if (i)
+    for (int j = i; j; j--)
+      ;
+  return j;	// error: j should only be in scope inside the body of `for'// ERROR - .*
+} // ERROR - non-void
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/scope2.C b/gcc/testsuite/g++.old-deja/g++.brendan/scope2.C
new file mode 100755
index 0000000..fccd1d6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/scope2.C
@@ -0,0 +1,29 @@
+// Build don't link: 
+// GROUPS passed scoping
+class A
+{
+ public:
+  A() {}
+  ~A() {}
+  virtual void f() {}
+};
+
+class B : public A
+{
+ public:
+  B() {}
+  ~B() {}
+  virtual void f() {}
+};
+
+
+B GLOBAL_B;
+
+B& foo() {return GLOBAL_B;}
+
+int main()
+{
+  // build_scoped_method_call and build_scoped_ref should know how
+  // to deal with a reference for this
+  foo().A::f(); 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/scope3.C b/gcc/testsuite/g++.old-deja/g++.brendan/scope3.C
new file mode 100755
index 0000000..cf78430
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/scope3.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// GROUPS passed scoping
+// This is fixed when NEW_CLASS_SCOPING is on.
+
+template<class T>
+class ArrayG {
+public:
+    ArrayG();
+protected:
+    const unsigned INITIAL;
+    T* array;			 
+};
+
+template<class T>
+ArrayG<T>::ArrayG():
+array(new T[INITIAL])
+{ }
+
+struct X {
+    struct Correspondence {
+	int i;
+    };
+
+    void fill(ArrayG<Correspondence>& a);
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/scope4.C b/gcc/testsuite/g++.old-deja/g++.brendan/scope4.C
new file mode 100755
index 0000000..a6781ab
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/scope4.C
@@ -0,0 +1,31 @@
+// Build don't link: 
+// GROUPS passed scoping
+class BitString {
+public:
+    int i;
+    int length() const;
+};
+
+typedef BitString BS;
+
+class V {
+public:
+    class BitString {
+    public:
+        static int x(const ::BitString& value);
+      static int y(const class ::BitString& value); // should be parsed ok
+        static int z(const BS& value);
+    };
+};
+
+int
+V::BitString::x(const ::BitString& value)
+{ return value.length(); }
+
+int
+V::BitString::y(const class ::BitString& value) // should be parsed ok
+{ return value.length(); }
+
+int
+V::BitString::z(const BS& value)
+{ return value.length(); }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/scope5.C b/gcc/testsuite/g++.old-deja/g++.brendan/scope5.C
new file mode 100755
index 0000000..7532369
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/scope5.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed scoping
+class Integer {
+public:
+    int i;
+};
+
+class Type {
+    enum Class { ENUM, INTEGER };
+
+    class Description {
+    public:
+        
+    };
+
+    class Integer: public Description {
+    public:
+        ::Integer low;
+        ::Integer high;
+    };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/shadow1.C b/gcc/testsuite/g++.old-deja/g++.brendan/shadow1.C
new file mode 100755
index 0000000..6a1d9d1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/shadow1.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+// GROUPS passed errors
+void f( int a) {
+  int a;	// this should be an error now// ERROR - .*
+	{
+		int a;
+	}
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/sizeof1.C b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof1.C
new file mode 100755
index 0000000..c8242eb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof1.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed sizeof
+// ARM $5.3.2
+
+void f() { }
+
+int
+main()
+{
+  // sizeof may not be applied to a function
+  int i = sizeof( f);// ERROR - .*
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/sizeof2.C b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof2.C
new file mode 100755
index 0000000..ddac679
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof2.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed sizeof
+// ARM $5.3.2
+
+void f() { }
+
+struct foo { int bit : 1; };
+
+int
+main()
+{
+  // sizeof may not be applied to a bit-field
+  foo f;
+  int i = sizeof (f.bit);// ERROR - .*
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/sizeof3.C b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof3.C
new file mode 100755
index 0000000..e6972ca
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof3.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed sizeof
+// ARM $5.3.2
+
+class bar;
+
+int
+main()
+{
+  // sizeof may not be applied to an undefined class
+  int k = sizeof (bar);// ERROR - .*
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/sizeof4.C b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof4.C
new file mode 100755
index 0000000..62d76c0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof4.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed sizeof
+// ARM $5.3.2
+
+int
+main()
+{
+  // sizeof may not be applied to the type void
+  int l = sizeof (void);// ERROR - .*
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/sizeof5.C b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof5.C
new file mode 100755
index 0000000..0ef9d9c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof5.C
@@ -0,0 +1,17 @@
+// GROUPS passed sizeof
+// ARM $5.3.2
+
+extern "C" void printf (char *, ...);
+
+class foo {};
+
+int
+main ()
+{
+  // The size of any class or class object is larger than zero.
+  int i = sizeof (foo);
+  if (i > 0)
+    printf ("PASS\n");
+  else
+    printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/sorry1.C b/gcc/testsuite/g++.old-deja/g++.brendan/sorry1.C
new file mode 100755
index 0000000..caa9276
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/sorry1.C
@@ -0,0 +1,36 @@
+// Build don't link: 
+// GROUPS passed old-sorry
+class a {
+public:
+	int*	foo();
+};
+
+a aa;
+a* ap;
+
+class b {
+public:
+	int	ok(int* p =aa.foo());	
+
+  // dump_init should know what to do with this NON_LVALUE_EXPR
+	int	f(int* p =ap->foo());		
+};
+
+	int
+b::ok(int *p) 
+{
+	return 0;
+}
+
+	int
+b::f(int *p) 
+{			
+	return 0;
+}
+	void
+bar()
+{
+	b b;
+	b.ok();
+	b.f();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/static1.C b/gcc/testsuite/g++.old-deja/g++.brendan/static1.C
new file mode 100755
index 0000000..b30c796
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/static1.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed static
+class A { public: int a; };// ERROR - .*
+void foo7 () { A::a = 3; }// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/static2.C b/gcc/testsuite/g++.old-deja/g++.brendan/static2.C
new file mode 100755
index 0000000..8fd5ffc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/static2.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed static
+class A
+{
+        public:
+        void    member(void)
+        {
+        }
+
+        static void staticMember()
+        {
+	  member (); // illegal, no object for calling non-static method// ERROR - .*
+        }
+};
+
+int main()
+{
+        A::staticMember();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/static3.C b/gcc/testsuite/g++.old-deja/g++.brendan/static3.C
new file mode 100755
index 0000000..5c52f0e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/static3.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed static
+class foo{
+public:
+  static void  bar( int i ){ value = i; }
+  static int  value;// ERROR - .*
+};
+
+const int  foo::value = 0; // should be an error.// ERROR - .*
+
+int main(){
+  foo::bar( 1 );
+  return 0;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/synth1.C b/gcc/testsuite/g++.old-deja/g++.brendan/synth1.C
new file mode 100755
index 0000000..5356796
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/synth1.C
@@ -0,0 +1,33 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors -g -Wall
+// GROUPS passed synthetics
+// excess errors test - XFAIL sparc64-*-elf
+// Check to make sure that g++ doesn't get freaked out about the use
+// of generated methods that it supposedly "can't see".
+
+class Char {
+public:
+    Char();
+    Char(char v);
+    
+    // synthetic copy-constructor and operator=
+private:
+    char value;
+};
+
+class XChar: public Char {
+public:
+    XChar();
+    XChar(char v, int serial);
+    
+    void operator=(const XChar& other);
+private:
+    int serial;
+};
+
+void
+XChar::operator=(const XChar& other)
+{
+    Char::operator=(other);
+    // serial stays the same
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template1.C b/gcc/testsuite/g++.old-deja/g++.brendan/template1.C
new file mode 100755
index 0000000..e6609fd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template1.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed templates
+// g++-2.2.1: member functions returning a template type 
+
+
+template <class T> struct list { };
+
+struct A
+{
+  list<int> L;
+
+  list<int>  get_list();
+
+};
+
+
+list<int> A::get_list() { return L; }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template11.C b/gcc/testsuite/g++.old-deja/g++.brendan/template11.C
new file mode 100755
index 0000000..4a953a3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template11.C
@@ -0,0 +1,47 @@
+// Build don't link: 
+// GROUPS passed templates
+template <class Called>
+class aCallback
+{
+public:
+  aCallback(Called& obj, int (Called::*met)());
+
+  int callback();
+  
+protected:
+
+private:
+  // the object to call
+  Called&       object;
+  
+  // the method to apply
+  int (Called::*method)();
+  
+};
+
+template <class Called>
+aCallback<Called>::aCallback(Called& obj,
+                             int (Called::*met)()) :
+object(obj),
+method(met)
+{};
+
+template <class Called>
+int aCallback<Called>::callback()
+{
+  return (object.*method)();
+}
+
+struct myStruct
+{
+  int action() {return 24;};
+};
+
+int main()
+{
+  myStruct toto;
+
+  aCallback<myStruct>   cb(toto, &myStruct::action);
+
+  return cb.callback();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template12.C b/gcc/testsuite/g++.old-deja/g++.brendan/template12.C
new file mode 100755
index 0000000..2165ae2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template12.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+// GROUPS passed templates
+inline void foo (const int &x) {}
+
+template <class type>
+inline void foo (const type &x) {x.eat_this_and_die();}
+
+int main (int argc, char **argv) {foo (argc);}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template13.C b/gcc/testsuite/g++.old-deja/g++.brendan/template13.C
new file mode 100755
index 0000000..653ef21
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template13.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed templates
+template<class T>
+class ListS {
+public:
+    class Vix {
+    public:
+	Vix();
+    };
+};
+
+template<class T>
+ListS<T>::Vix::Vix()
+{ }
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template15.C b/gcc/testsuite/g++.old-deja/g++.brendan/template15.C
new file mode 100755
index 0000000..b830505
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template15.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed templates
+template<class T> class Stack {
+  public:
+    Stack (int s = 10);         //Comment out "= 10" and it will compile
+    ~Stack(void);               //Omitting "void" doesn't help
+}; 
+
+template<class T> Stack<T>::~Stack(void) 
+{ }
+
+//If this definition comes before the one for ~Stack, the error message
+//about redeclaration of `void Stack<int>::~Stack()' will not occur.
+template<class T> Stack<T>::Stack(int s)
+{ }
+
+int main () {
+    Stack<int> stk(10);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template16.C b/gcc/testsuite/g++.old-deja/g++.brendan/template16.C
new file mode 100755
index 0000000..ec13a24
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template16.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed templates
+template<class T> class TList {
+   typedef void (T::*TVOIDFUNT)();
+   typedef T*   (T::*TTPFUNT)(T*);
+};
+
+class A;
+class B : TList<A> { };
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template17.C b/gcc/testsuite/g++.old-deja/g++.brendan/template17.C
new file mode 100755
index 0000000..e6c2652
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template17.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed templates
+struct Regex { int i; Regex(char *, int); };
+template<class KEY>
+class NDAMName {
+public:
+    static const Regex pattern;
+    static unsigned sequence_number;
+};
+
+const Regex NDAMName<'L'>::pattern("^[Ll](.*)$",   1);// ERROR -  type/value.*
+unsigned NDAMName<'L'>::sequence_number = 0;// ERROR -  type/value
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template18.C b/gcc/testsuite/g++.old-deja/g++.brendan/template18.C
new file mode 100755
index 0000000..5c6479c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template18.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed templates
+template<class T> class X;
+typedef X<int> IX;
+
+template<class T>
+class X {
+public:
+  T x;
+};
+
+struct A {
+  IX c;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template19.C b/gcc/testsuite/g++.old-deja/g++.brendan/template19.C
new file mode 100755
index 0000000..a8b33c1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template19.C
@@ -0,0 +1,26 @@
+// Build don't link: 
+// GROUPS passed templates
+template <class T>
+class Base
+{
+public:
+    Base() { }
+};
+
+template <class memberType, class keyType>
+class Middle : public Base<memberType>
+{
+public:
+    Middle (keyType const & (*ko) (memberType const &))
+    {
+    }
+};
+
+// EXCHANGE the following lines for this code to work.
+//template <class memberType, class keyType> class Middle;
+template <class T, class keyType> class Middle;
+
+struct Test : public Middle <int, int>
+{
+    Test();
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template2.C b/gcc/testsuite/g++.old-deja/g++.brendan/template2.C
new file mode 100755
index 0000000..ca60fa7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template2.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed templates
+template <class Q>
+class Conc {
+public:
+	static int body();
+};
+
+template <class Q>
+int Conc<Q>::body() {return 0;}
+
+int main () {
+	Conc<int> s2;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template20.C b/gcc/testsuite/g++.old-deja/g++.brendan/template20.C
new file mode 100755
index 0000000..da26f9a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template20.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed templates
+template <class A, class B> class Map;
+
+class Foo
+{
+public:
+    static Map<int,int> bar;
+};
+
+template <class A, class B>
+class Map
+{
+public :
+    int find();
+};
+
+int main()
+{
+    int z = Foo::bar.find();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template21.C b/gcc/testsuite/g++.old-deja/g++.brendan/template21.C
new file mode 100755
index 0000000..9d61391
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template21.C
@@ -0,0 +1,43 @@
+// Build don't link: 
+// GROUPS passed templates
+template<class T>
+class L {
+public:
+    L();
+
+    T x[30];
+    int doit(int i) const;
+};
+
+#ifdef BUG
+template<class T>
+int
+L<T>::doit(int i) const
+{
+    return x[i].z;
+}
+#endif
+
+class X {
+public:
+    class Y {
+    public:
+        Y();
+        Y(int);
+
+        int z;
+    };
+    
+    L<Y> ly;
+};
+
+#ifndef BUG
+template<class T>
+int
+L<T>::doit(int i) const
+{
+    return x[i].z;
+}
+#endif
+
+static X x;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template22.C b/gcc/testsuite/g++.old-deja/g++.brendan/template22.C
new file mode 100755
index 0000000..28c70b3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template22.C
@@ -0,0 +1,22 @@
+// GROUPS passed templates
+extern "C" int printf (const char *, ...);
+
+template <class T>
+class Foo
+{
+public:
+  void func (int const& i);
+};
+
+template <class T>
+void Foo<T>::
+func (int const& i)
+{}
+
+
+int main ()
+{ 
+  Foo<int const> foo;
+  printf ("PASS\n");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template23.C b/gcc/testsuite/g++.old-deja/g++.brendan/template23.C
new file mode 100755
index 0000000..f38d420
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template23.C
@@ -0,0 +1,34 @@
+// Build don't link: 
+// GROUPS passed templates
+template <class T>
+class T_Base
+{};
+
+template <class T>
+class T_Derived
+: public T_Base<T>
+{};
+
+
+class Base
+{
+public:
+  Base (float name);
+};
+
+class Derived
+: public Base
+{
+private:
+  T_Base<int>*	data_;	// Fix (1): Change date_ from T_Base<int>* to T_Derived<int>*
+  
+public:
+  Derived (float name); 
+};
+
+
+Derived::
+Derived (float name)
+:  Base(name),
+   data_(new T_Derived<int>()) 
+{}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template24.C b/gcc/testsuite/g++.old-deja/g++.brendan/template24.C
new file mode 100755
index 0000000..34549a0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template24.C
@@ -0,0 +1,20 @@
+// GROUPS passed templates
+extern "C" void printf (char *, ...);
+
+template <class F>
+class Temp
+{
+  F  func_;
+public:
+  Temp (F f) :func_(f) {}
+};
+
+int func (int h = 1, int z = 2) { return h+z; }
+
+int main ()
+{
+  Temp<int(*)(int, int)> temp (func);
+
+  printf ("PASS\n");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template25.C b/gcc/testsuite/g++.old-deja/g++.brendan/template25.C
new file mode 100755
index 0000000..5939fed
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template25.C
@@ -0,0 +1,36 @@
+// Build don't link: 
+// GROUPS passed templates
+template <class T>
+class Temp_Base
+{};
+
+template <class T>
+class Temp_Derived
+: public Temp_Base<T>
+{
+public:
+  Temp_Derived (int i = 10) {}
+};
+
+
+class Base
+{
+  float r_;
+public:
+  Base (float r) : r_(r) {}
+};
+
+class Derived
+: public Base
+{
+private:
+  Temp_Base<int>*  boo_;	   
+public:
+  Derived (float);
+};
+
+Derived::
+Derived (float form)
+: Base(form),
+  boo_(new Temp_Derived<int>)
+{}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template26.C b/gcc/testsuite/g++.old-deja/g++.brendan/template26.C
new file mode 100755
index 0000000..6dc1555
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template26.C
@@ -0,0 +1,31 @@
+// Build don't link: 
+// GROUPS passed templates
+class V {
+ public:
+  V();
+  V(int);
+  };
+
+template <int I> class AA: public virtual V {
+ public:
+  AA();
+  AA(int);
+  };
+
+template <int I> class BB : public virtual V {
+ public:
+  BB();
+  BB(int);
+  };
+
+template <int I> AA<I>::AA() {};
+template <int I> AA<I>::AA(int i): V(i) {};
+template <int I> BB<I>::BB() {};
+template <int I> BB<I>::BB(int i) {};
+
+class CC : public AA<1>, public BB<2> {
+ public:
+  CC();
+  CC(int);
+  };
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template27.C b/gcc/testsuite/g++.old-deja/g++.brendan/template27.C
new file mode 100755
index 0000000..a2649d4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template27.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed templates
+        template<class K, class V> class MapLS { };
+        class String {};
+        class X1 { };
+        class RefProto { };
+        template<class REP> class Ref { };
+        
+        class MapLS<String, Ref<X1> >: public MapLS<String, RefProto> {
+        public:
+            ~MapLS();
+        };
+        
+        MapLS<String, Ref<X1> >::~MapLS() { }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template28.C b/gcc/testsuite/g++.old-deja/g++.brendan/template28.C
new file mode 100755
index 0000000..48ae7fb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template28.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed templates
+class X {
+        const char *fptr;
+public:
+        X(const char *ptr) { fptr = ptr; }
+        operator const char*() { return fptr; }
+};
+
+int main(){
+        X x1("1234");
+        X x2(x1+1);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template29.C b/gcc/testsuite/g++.old-deja/g++.brendan/template29.C
new file mode 100755
index 0000000..2c427d9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template29.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed templates
+   template <class ElementType> class A
+    { public:
+       A(ElementType) {}
+       ElementType get() const ;
+    };
+
+    template <class ElementType> ElementType A<ElementType>::get() const
+    { return ElementType(0); }
+
+int main() { const A<short> a(3); }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template3.C b/gcc/testsuite/g++.old-deja/g++.brendan/template3.C
new file mode 100755
index 0000000..3900421
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template3.C
@@ -0,0 +1,49 @@
+// GROUPS passed templates
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int count = 0;
+
+void
+die (int x)
+{
+  if (x != ++count)
+    {
+      printf ("FAIL\n");
+      exit (1);
+    }
+}
+
+class A {
+  public:
+    void   f() const { die (-1); }
+};
+
+
+template <class Item>
+class B : public A {
+  public:
+  void f() const;
+};
+
+template <class Item>
+inline void B<Item>::f() const { die (1); }
+
+template <class Item>
+class C : public A {
+  public:
+    void f() const { die (2); }
+};
+
+
+int main()
+{
+    B<int> b;
+    C<int> c;
+
+    b.f(); //- bugged, (A::f() called instead of B::f())
+    c.f(); //- works fine (C::f() called)
+
+    printf ("PASS\n");
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template30.C b/gcc/testsuite/g++.old-deja/g++.brendan/template30.C
new file mode 100755
index 0000000..97357d6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template30.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed templates
+
+        template<class K, class V> class MapLS { };
+        class String {};
+        class X1 { };
+        class RefProto { };
+        template<class REP> class Ref { };
+        
+        class MapLS<String, Ref<X1> >: public MapLS<String, RefProto> {
+        public:
+            ~MapLS();
+        };
+        
+        MapLS<String, Ref<X1> >::~MapLS() { }
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template31.C b/gcc/testsuite/g++.old-deja/g++.brendan/template31.C
new file mode 100755
index 0000000..3a1b149
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template31.C
@@ -0,0 +1,38 @@
+// Build don't link: 
+// GROUPS passed templates
+// PRMS Id: 13218
+
+struct C {
+        int x;
+        char y;
+        double z;
+};
+C c02;
+
+template <int* ip> struct A {
+        int* p;
+        A() : p(ip) {}
+};
+
+template <C* cp> struct B {
+        C* p;
+        B() : p(cp) {}
+};
+
+int i00;
+
+int main(void)
+{
+        A<&i00> a00;
+
+        extern int i01;
+        A<&i01> a01;
+
+        B<&c02> b02;
+
+        extern C c03;
+        B<&c03> b03;
+}
+
+int i01;
+C c03;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template4.C b/gcc/testsuite/g++.old-deja/g++.brendan/template4.C
new file mode 100755
index 0000000..318cd2e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template4.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed templates
+// This used to be a circularity in chainon.
+template <class ARG> struct TMPL {
+    typedef int ARG::*ARG_data_member_ptr;
+    typedef void (ARG::*ARG_func_member_ptr) ();
+};
+
+struct S { };
+
+TMPL<S> object;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template5.C b/gcc/testsuite/g++.old-deja/g++.brendan/template5.C
new file mode 100755
index 0000000..39b74d6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template5.C
@@ -0,0 +1,48 @@
+// Build don't link: 
+// GROUPS passed templates
+template<class T>
+class Vector
+{
+public:
+    Vector(int x);
+    ~Vector();
+    T& operator [] (int i);
+
+private:
+    T* v;
+    int sz;
+} ;
+
+template<class T>
+Vector<T>::Vector(int x)
+{
+    sz = x;
+    v = new T (sz);
+} ;
+
+template<class T>
+Vector<T>::~Vector()
+    { delete [] v; } ;
+
+template<class T>
+T &
+Vector<T>::operator [] (int i)
+    { return v[i]; } ;
+
+int
+main(int, char **)
+{
+    Vector<int> intvec(3);
+
+    intvec[0] = 1;
+    intvec[1] = 2;
+    intvec[2] = 3;
+
+    for (int i = 0; i < 3; i++)
+	intvec[i];
+
+    return 0;
+}
+
+
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template6.C b/gcc/testsuite/g++.old-deja/g++.brendan/template6.C
new file mode 100755
index 0000000..96459ca
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template6.C
@@ -0,0 +1,30 @@
+// Build don't link: 
+// GROUPS passed templates
+struct B {
+};
+
+struct X : B {
+  ~X ();
+};
+
+struct Request {
+  X s;
+};
+
+template <class ET> class TC {
+  ET data;
+};
+
+struct TMem {
+
+  ~TMem() {}
+
+  TC<Request> *req;
+};
+
+struct FIO {
+
+  void init ();
+
+  FIO () { init(); }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template7.C b/gcc/testsuite/g++.old-deja/g++.brendan/template7.C
new file mode 100755
index 0000000..59dc483
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template7.C
@@ -0,0 +1,48 @@
+// Build don't link: 
+// GROUPS passed templates
+template <class ET>
+class ChainElem {
+public:
+  
+  ET data;
+};
+
+template <class ET>
+class Chain {
+public:
+
+  ChainElem<ET> *first;
+
+  virtual ~Chain() {}
+
+};
+
+struct B {
+};
+
+struct X : B {
+  ~X ();
+};
+
+struct TBNFexpression {
+};
+
+struct TCaseLabelPair {
+};
+
+struct TVariant {  
+  Chain<TCaseLabelPair> CaseLabelList;
+};
+
+struct TCaseConstruct {
+  Chain<TBNFexpression> TagFieldPrefixes;
+  Chain<TVariant> Variants;
+};
+
+struct Production {
+  X TypeName;
+};
+
+struct SimpleSyntax {
+  Chain<Production> Productions;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template8.C b/gcc/testsuite/g++.old-deja/g++.brendan/template8.C
new file mode 100755
index 0000000..80adbe1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template8.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed templates
+#include <stdio.h>
+
+// make sure we accept unions for templates
+template<int n>
+union Double_alignt{
+	double for_alignt;
+	char array[n];
+
+};
+
+int main(){
+
+	
+	Double_alignt<20000> heap;
+
+	printf(" &heap.array[0] = %d, &heap.for_alignt = %d\n", &heap.array[0], &heap.for_alignt);
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template9.C b/gcc/testsuite/g++.old-deja/g++.brendan/template9.C
new file mode 100755
index 0000000..c4c9c83
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template9.C
@@ -0,0 +1,20 @@
+// GROUPS passed templates
+// Test that the compiler will emit the definition of min given just
+// the declaration.  At one point in the past, it did not.
+// Special g++ Options: -fguiding-decls
+#include <iostream.h>
+
+template <class T> inline T min(T a, T b) { return (a < b) ? a : b;};
+
+double min(double,double);	// this should expand the template
+
+main () {
+    int a = 1, b = 2;
+    double aa = 2.0, bb = 1.2;
+    cout << min(a,b) << ", " << min(aa,bb) << "\n";
+    if (min (a, aa) == a)
+      cout << "PASS" << endl;
+    else
+      cout << "FAIL" << endl;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/temporary1.C b/gcc/testsuite/g++.old-deja/g++.brendan/temporary1.C
new file mode 100755
index 0000000..8c6d4c3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/temporary1.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed temporaries
+#include <stdio.h>
+
+int main ()
+{
+        int a = 2;
+
+        if (----a == 0)
+                printf ("a = 0\n");
+
+        printf ("a = %d\n", a);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/typedef1.C b/gcc/testsuite/g++.old-deja/g++.brendan/typedef1.C
new file mode 100755
index 0000000..2f7aa87
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/typedef1.C
@@ -0,0 +1,29 @@
+// Build don't link: 
+
+class baseClassA
+{
+public:
+private:
+	class internalClassA
+	{
+	public:
+	private:
+		typedef int privateType;
+
+		privateType memberA;
+	};
+};
+
+class baseClassB
+{
+public:
+private:
+	class internalClassA
+	{
+	public:
+	private:
+		typedef unsigned int privateType;
+
+		privateType memberB;
+	};
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/union1.C b/gcc/testsuite/g++.old-deja/g++.brendan/union1.C
new file mode 100755
index 0000000..7a4df26
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/union1.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed unions
+// This is fixed by finish_anon_union doing a string_cst_equal check on
+// the DECL_SIZE of the decls, instead of comparing the DECL_SIZE nodes.
+     unsigned
+     hash(const double d)
+     {
+        static union {
+           unsigned asint[2];
+           double asdouble;
+        };
+        asdouble = d;
+        return asint[0] ^ asint[1];
+     }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/union2.C b/gcc/testsuite/g++.old-deja/g++.brendan/union2.C
new file mode 100755
index 0000000..d913ae8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/union2.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed unions
+class B;
+ 
+struct A {
+    A(B* x) : i(x) {}
+    A() : i(0) {}
+ 
+    union {
+        B* i;
+        B* c;
+    };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/union3.C b/gcc/testsuite/g++.old-deja/g++.brendan/union3.C
new file mode 100755
index 0000000..ad8b840
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/union3.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed unions
+union alan {
+int a;
+char *b;
+alan();
+};
+ 
+alan mary;
+ 
+alan::alan()
+{
+        a=0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility1.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility1.C
new file mode 100755
index 0000000..7d11f87
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility1.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed visibility
+class foo {
+protected:
+  int i;
+};
+
+class bar : public foo {
+public:
+  friend void baz (foo *);
+};
+
+void baz (foo *f)
+{
+  f->i = 1;	// error: i is protected// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility10.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility10.C
new file mode 100755
index 0000000..4eb3cae
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility10.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed visibility
+struct base
+{
+    protected:
+        void base_func() {}// ERROR - .*is protected.*
+};
+
+struct derived : public base
+{
+    protected:
+        void derived_func(base *ptr) { ptr->base_func(); }// ERROR -  within this context
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility2.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility2.C
new file mode 100755
index 0000000..09e0f65
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility2.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed visibility
+class X {
+      void g (int); // ERROR - private
+public:
+  void g (double);
+};
+	
+class Y : public X { void f() { g (1); } }; // ERROR - private
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility3.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility3.C
new file mode 100755
index 0000000..6e84da5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility3.C
@@ -0,0 +1,38 @@
+// Build don't link: 
+// GROUPS passed visibility
+// Used to say:
+// manip.cc:17: member `_f' is a private member of class `B<int>'
+// manip.cc:17: member `_a' is a private member of class `B<int>'
+
+class A {};
+
+template <class TP>
+class B
+{
+  A &(*_f) (A &, TP);
+  TP _a;
+public:
+  B (A &(*f) (A &, TP), TP a) : _f (f), _a (a) {}
+  friend A &operator<< <>(A &o, const B<TP> &m);
+};
+
+template <class TP>
+inline A &
+operator<< (A &o, const B<TP> &m)
+{
+  (*m._f) (o, m._a);
+  return o;
+}
+
+A &setw (A &, int);
+B<int> setw (int n)
+{
+  return B<int> (setw, n);
+}
+
+A x;
+
+void f ()
+{
+  x << setw (2);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility4.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility4.C
new file mode 100755
index 0000000..1e7aea1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility4.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed visibility
+template <class T> 
+class Feld {
+public:
+  Feld(const Feld&) {}
+};
+
+class Polynom : private Feld<double> {
+  Polynom();
+  friend Polynom f(const Polynom&);
+};
+
+Polynom f(const Polynom& p) { return p; }    
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility5.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility5.C
new file mode 100755
index 0000000..a53881a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility5.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+// GROUPS passed visibility
+template<int K> class B;
+template<int K> class A {int n; friend class B<K>;};
+template<int K> class B {public: void method(A<K>) const;};
+template<int K> void B<K>::method(A<K> X) const {X.n=0;}
+typedef B<2> B2;
+ 
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility6.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility6.C
new file mode 100755
index 0000000..5ca62c0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility6.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed visibility
+class bottom
+{
+public:
+  int b;
+};
+class middle : private bottom
+{
+public:
+  void foo () { b; }
+};
+class top : public middle
+{
+public:
+  void bar () { b; }// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility7.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility7.C
new file mode 100755
index 0000000..670547d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility7.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed visibility
+class X
+{
+public:
+  void fn ();// ERROR - .*
+};
+class Y : private X
+{};
+
+class Unrelated
+{
+public:
+  void foo () { Y y; y.fn (); }// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility8.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility8.C
new file mode 100755
index 0000000..a3bb856
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility8.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed visibility
+// Make sure private inheritance affects the visibility of
+// static members used in an inherited context.
+class foo
+{
+public:
+  static int y;
+};
+class foo1 : private foo
+{ };
+class foo2 : public foo1
+{ public:
+  void bar () { y; }// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility9.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility9.C
new file mode 100755
index 0000000..c259929
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility9.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed visibility
+class A {
+public:
+        void aMethod(void) {};// ERROR - .*
+};
+
+class AA : A { };
+
+class B {
+public:
+        void thisMethod() {
+                AA ana;
+                ana.aMethod();// ERROR - .*
+        }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/vtables1.C b/gcc/testsuite/g++.old-deja/g++.brendan/vtables1.C
new file mode 100755
index 0000000..984ce18
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/vtables1.C
@@ -0,0 +1,42 @@
+// GROUPS passed virtual-tables
+// Check that virtual function tables are generated and used
+// even for struct's/classes which have no explicit constructors.
+
+extern "C" void printf (char *, ...); 
+
+int base_func_member_1_called = 0;
+int derived_func_member_1_called = 0;
+
+struct base {
+	virtual void func_member_1 ()
+	{
+		base_func_member_1_called++;
+	}
+};
+
+struct derived : public base {
+	virtual void func_member_1 ()
+	{
+		derived_func_member_1_called++;
+	}
+
+	virtual void func_member_2 ()
+	{
+	}
+};
+
+base* bp1;
+base* bp2;
+
+int main ()
+{
+	bp1 = new base;
+	bp2 = new derived;
+
+	bp1->func_member_1 ();
+	bp2->func_member_1 ();
+
+	printf ("PASS\n");
+
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings1.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings1.C
new file mode 100755
index 0000000..0296362
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings1.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed warnings
+// there should be a warning about foo only defining private methods
+class foo {
+  int bar();
+};// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings10.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings10.C
new file mode 100755
index 0000000..78ddf77
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings10.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed warnings
+void foo()
+{
+  int i;
+  if (1) {
+    for (int i = 0; i < 10; i++)
+      ;
+  }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings2.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings2.C
new file mode 100755
index 0000000..49971d5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings2.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed warnings
+class K {
+public:
+        void f() {
+        }; // there should be no warning about this semicolon
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings3.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings3.C
new file mode 100755
index 0000000..14fe997
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings3.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// Special g++ Options: -O2 -Wall
+// GROUPS passed warnings
+class A {
+int i;
+public:
+        void funcA(void) { 
+                funcB(); 
+        }
+
+	// The compiler should not emit a warning about not being
+	// able to inline this function.
+        void funcB(void) { 
+                i++; 
+        }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings4.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings4.C
new file mode 100755
index 0000000..d733522
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings4.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed warnings
+int
+main ()
+{
+  register int x;
+  int * foo = &x; // in C++ it's perfectly legal to do this
+
+  return 0;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings5.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings5.C
new file mode 100755
index 0000000..5a953fd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings5.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed warnings
+enum TypeKind { ATK, BTK } ;
+
+struct Type {
+  enum TypeKind kind : 8;
+  void setBTK();
+};
+
+void Type::setBTK() { kind = BTK; }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings6.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings6.C
new file mode 100755
index 0000000..785c083
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings6.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// Special g++ Options: -O2 -Wall -ansi -pedantic
+// GROUPS passed warnings
+// should not emit this warning about func:
+// 	x.C:2: warning: invalid storage class for function `func'
+//
+template <class T> inline void func(T)
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings7.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings7.C
new file mode 100755
index 0000000..24e7a2c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings7.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// Special g++ Options: -O2 -Wall
+// GROUPS passed warnings
+template<class T>
+class X {
+public:
+    void kill(unsigned i)
+	{ vec[i].~T(); }
+    T *vec;
+};
+
+class Y { };
+
+void
+x()
+{
+    X<int> x;
+    x.kill(0);
+    X<Y> y;
+    y.kill(0);
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings8.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings8.C
new file mode 100755
index 0000000..5599918
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings8.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// Special g++ Options: -Wall
+// GROUPS passed warnings
+bool foo(unsigned char c)
+{
+  return (c & 17) != 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings9.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings9.C
new file mode 100755
index 0000000..c46f2a1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings9.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// Special g++ Options: -Wall
+// GROUPS passed warnings
+inline int foo()
+{
+  return 3;
+}