aboutsummaryrefslogtreecommitdiff
path: root/gcc/testsuite/g++.old-deja/g++.mike/p1989.C
diff options
context:
space:
mode:
Diffstat (limited to 'gcc/testsuite/g++.old-deja/g++.mike/p1989.C')
-rw-r--r--gcc/testsuite/g++.old-deja/g++.mike/p1989.C494
1 files changed, 494 insertions, 0 deletions
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p1989.C b/gcc/testsuite/g++.old-deja/g++.mike/p1989.C
new file mode 100644
index 00000000000..a145b1ecbce
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p1989.C
@@ -0,0 +1,494 @@
+// Build don't link:
+// prms-id: 1989
+
+#define TRUE true
+#define FALSE false
+typedef void *Pix;
+
+template<class T>
+struct link {
+ T item;
+ link *next;
+ link *prev;
+
+ link(const T& t): item(t), prev(0), next(0)
+ { };
+ link(const T& t, link<T> *p, link<T> *n): item(t), prev(p), next(n)
+ { };
+};
+
+template<class T>
+class List_DL {
+public:
+ List_DL();
+ List_DL(const List_DL&);
+ ~List_DL();
+
+ void append(const T& item);
+ void prepend(const T& item);
+ void insert(const T& item, Pix x, bool before);
+
+ void remove(Pix& x)
+ { T tmp; remove(x, tmp); }
+ void remove(Pix& x, T& item);
+
+ void clear();
+
+ unsigned length() const
+ { return count; }
+
+private:
+
+ unsigned count;
+ link<T> *head;
+ link<T> *tail;
+
+public:
+ Pix first() const
+ { return Pix(head); }
+ Pix last() const
+ { return Pix(tail); }
+ void next(Pix& x) const
+ { if (0 != x) x = ((link<T> *) x)->next; }
+ void prev(Pix& x) const
+ { if (0 != x) x = ((link<T> *) x)->prev; }
+ T& operator()(Pix x) const
+ { return ((link<T> *) x)->item; }
+};
+
+template<class T>
+List_DL<T>::List_DL():
+count(0),
+head(0)
+{ }
+
+template<class T>
+List_DL<T>::List_DL(const List_DL& other):
+count(0),
+head(0)
+{
+ for (Pix x=other.first(); 0 != x; other.next(x))
+ append(other(x));
+}
+
+template<class T>
+List_DL<T>::~List_DL()
+{
+ clear();
+}
+
+template<class T>
+void
+List_DL<T>::append(const T& item)
+{
+ count++;
+ if (0 == head) {
+ head = new link<T>(item);
+ tail = head;
+ } else {
+ tail->next = new link<T>(item, tail, 0);
+ tail = tail->next;
+ }
+}
+
+template<class T>
+void
+List_DL<T>::prepend(const T& item)
+{
+ count++;
+ if (0 == head) {
+ head = new link<T>(item);
+ tail = head;
+ } else {
+ head = new link<T>(item, 0, head);
+ if (tail == head)
+ tail = tail->next;
+ }
+}
+
+template<class T>
+void
+List_DL<T>::insert(const T& item, Pix x, bool before = TRUE)
+{
+ link<T> *l = (link<T> *) x;
+
+ if (before) {
+ if (0 == l || l == head) {
+ prepend(item);
+ } else {
+ link<T> *n = new link<T>(item, l->prev, l);
+ l->prev->next = n;
+ l->prev = n;
+ }
+ } else {
+ if (0 == l || l == tail) {
+ append(item);
+ } else {
+ link<T> *n = new link<T>(item, l, l->next);
+ l->next->prev = n;
+ l->prev = n;
+ }
+ }
+}
+
+template<class T>
+void
+List_DL<T>::remove(Pix& x, T& item)
+{
+ link<T> *l = (link<T> *) x;
+
+ if (0 == l)
+ return;
+
+ item = l->item;
+ if (1 == count) {
+ delete head;
+ head = 0;
+ tail = 0;
+ } else {
+ // more than one item in the list
+ if (l == head) {
+ link<T> *old = head;
+ head = head->next;
+ head->prev = 0;
+ delete old;
+ } else if (l == tail) {
+ link<T> *old = tail;
+ tail = tail->prev;
+ tail->next = 0;
+ delete old;
+ } else {
+ l->next->prev = l->prev;
+ l->prev->next = l->next;
+ delete l;
+ }
+ }
+}
+
+template<class T>
+void
+List_DL<T>::clear()
+{
+ link<T> *l, *succ;
+ for (l=head; 0 != l; l=succ) {
+ succ = l->next;
+ delete l;
+ }
+ head = 0;
+ tail = 0;
+}
+
+template<class T>
+class List_DLS: public List_DL<T> {
+public:
+ List_DLS(): List_DL<T>()
+ { };
+ List_DLS(const List_DLS& other): List_DL<T>(other)
+ { };
+
+ bool contains(const T& item) const
+ { return search(item) != 0 ? TRUE: FALSE; }
+ Pix search(const T&) const;
+};
+
+template<class T>
+Pix
+List_DLS<T>::search(const T& item) const
+{
+ for (Pix x=first(); 0 != x; next(x)) {
+ if (item == operator()(x)) // ERROR - const subversion
+ return x;
+ }
+ return 0;
+}
+
+template<class T>
+class List_DLSp: public List_DL<T> {
+public:
+ List_DLSp(): List_DL<T>()
+ { };
+ List_DLSp(const List_DLSp& other): List_DL<T>(other)
+ { };
+
+ bool contains(const T& item) const
+#ifndef INTERNAL_ERROR
+ ;
+#else
+ { return search(item) != 0 ? TRUE: FALSE; }
+#endif
+ Pix search(const T&) const;
+};
+
+template<class T>
+bool
+List_DLSp<T>::contains(const T& item) const
+{
+ for (Pix x=first(); 0 != x; next(x)) {
+ if (*item == *operator()(x))
+ return TRUE;
+ }
+ return FALSE;
+}
+
+template<class T>
+class Set {
+public:
+ Set();
+ Set(const Set& other);
+
+ virtual void add(const T& item);
+
+ void remove(const T& item)
+ { Pix x = search(item); remove(x); }
+ void remove(Pix& x)
+ { T tmp; remove(x, tmp); }
+ virtual void remove(Pix& x, T& item);
+
+ virtual void clear();
+
+ virtual bool contains(const T&) const;
+ virtual Pix search(const T&) const;
+
+ virtual unsigned length() const;
+
+ virtual Pix first() const;
+ virtual void next(Pix& x) const;
+ virtual T& operator()(Pix x) const;
+};
+
+template<class T>
+Set<T>::Set()
+{ }
+
+template<class T>
+Set<T>::Set(const Set& other)
+{ }
+
+
+template<class T>
+class Set_DL: public List_DLS<T> {
+public:
+ Set_DL();
+ Set_DL(const Set_DL& other);
+
+ void add(const T& item)
+ { list.append(item); }
+ void remove(Pix& x, T& item)
+ { list.remove(x, item); }
+
+ void clear()
+ { list.clear(); }
+
+ bool contains(const T& item) const
+ { return list.contains(item); }
+ Pix search(const T& item) const
+ { return list.search(item); }
+
+ unsigned length() const
+ { return list.length(); }
+
+ Pix first() const
+ { return list.first(); }
+ void next(Pix& x) const
+ { list.next(x); }
+ T& operator()(Pix x) const
+ { return list(x); }
+private:
+ List_DLS<T> list;
+};
+
+template<class T>
+class Set_DLp: public List_DLSp<T> {
+public:
+ Set_DLp();
+ Set_DLp(const Set_DLp& other);
+
+ void add(const T& item)
+ { list.append(item); }
+ void remove(Pix& x, T& item)
+ { list.remove(x, item); }
+
+ void clear()
+ { list.clear(); }
+
+ bool contains(const T& item) const
+ { return list.contains(item); }
+ Pix search(const T& item) const
+ { return list.search(item); }
+
+ unsigned length() const
+ { return list.length(); }
+
+ Pix first() const
+ { return list.first(); }
+ void next(Pix& x) const
+ { list.next(x); }
+ T& operator()(Pix x) const
+ { return list(x); }
+private:
+ List_DLSp<T> list;
+};
+
+template<class T>
+struct vertex {
+ T item;
+ List_DL<vertex<T> *> fanout;
+
+ vertex(): item(), fanout() // gets bogus error
+ { };
+ vertex(const T& i): item(), fanout() // gets bogus error - XFAIL *-*-*
+ { };
+};
+
+template<class T>
+class Graph {
+public:
+ Graph();
+ Graph(const Graph&);
+ ~Graph();
+
+ void add(const T& from, const T& to);
+ bool contains(const T& from, const T& to) const;
+
+ void clear()
+ { vertices.clear(); }
+
+ unsigned lengthV() const
+ { return vertices.length(); }
+
+ Pix firstV() const
+ { return vertices.first(); }
+ void nextV(Pix& x) const
+ { vertices.next(x); }
+ T& V(Pix x) const
+ { return vertices(x).item; }
+
+ Pix firstV1(Pix vx) const;
+ void nextV1(Pix vx, Pix& x) const;
+ T& V1(Pix vx, Pix x) const;
+private:
+ vertex<T> *lookup(const T& from) const;
+ vertex<T> *lookup_new(const T& from);
+
+ List_DLS<vertex<T> > vertices;
+};
+
+template<class T>
+Graph<T>::Graph():
+vertices()
+{ }
+
+template<class T>
+Graph<T>::Graph(const Graph& other):
+vertices()
+{
+ for (Pix vx=firstV(); 0 != vx; nextV(vx)) {
+ for (Pix vx1=firstV1(vx); 0 != vx1; nextV1(vx, vx1)) {
+ add(V(vx), V1(vx, vx1));
+ }
+ }
+}
+
+template<class T>
+Graph<T>::~Graph()
+{
+ clear();
+}
+
+template<class T>
+void
+Graph<T>::add(const T& from, const T& to)
+{
+ vertex<T> *fromv = lookup_new(from);
+ if (from == to)
+ return;
+ vertex<T> *tov = lookup_new(to);
+ fromv->fanout.append(tov);
+}
+
+template<class T>
+bool
+Graph<T>::contains(const T& from, const T& to) const
+{
+ vertex<T> *fromv = lookup(from);
+ if (0 == fromv)
+ return FALSE;
+
+ for (Pix x=fromv->fanout.first(); 0 != x; fromv->fanout.next(x)) {
+ if (fromv->fanout(x)->item == to)
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+template<class T>
+vertex<T> *
+Graph<T>::lookup(const T& from) const
+{
+ for (Pix x=vertices.first(); 0 != x; vertices.next(x)) {
+ if (vertices(x).item == from)
+ return &vertices(x);
+ }
+ return 0;
+}
+
+template<class T>
+vertex<T> *
+Graph<T>::lookup_new(const T& from)
+{
+ vertex<T> *v = lookup(from);
+ if (0 == v) {
+ vertices.append(from); // gets bogus error
+ return &vertices(vertices.last());
+ }
+ return v;
+}
+
+template<class T>
+Pix
+Graph<T>::firstV1(Pix vx) const
+{
+ vertex<T> *v = (vertex<T> *) vx;
+ return v->fanout.first();
+}
+
+template<class T>
+void
+Graph<T>::nextV1(Pix vx, Pix& x) const
+{
+ vertex<T> *v = (vertex<T> *) vx;
+ return v->fanout.next(x); // ERROR - return from void method
+}
+
+template<class T>
+T&
+Graph<T>::V1(Pix vx, Pix x) const
+{
+ vertex<T> *v = (vertex<T> *) vx;
+ static T x1;
+ return x1;
+}
+
+class STRLIdentifier;
+
+extern x(List_DL<STRLIdentifier *>);
+extern x(List_DLS<STRLIdentifier *>);
+
+extern x(Set<STRLIdentifier *>);
+extern x(Set_DL<STRLIdentifier *>);
+extern x(Set_DLp<STRLIdentifier *>);
+
+extern x(Graph<STRLIdentifier *>);
+
+class STRLIdentifier {
+ char buf[10];
+};
+
+extern int operator==(vertex<STRLIdentifier*>&, vertex<STRLIdentifier*>&); // ERROR - const subversion
+extern int operator==(STRLIdentifier&, STRLIdentifier&); // ERROR - fn ref in err msg
+
+extern x(List_DLSp<STRLIdentifier *>);
+
+template class Graph<STRLIdentifier *>;
+template class List_DLS<vertex<STRLIdentifier *> >;
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-22 18:34:17 +0000