From mboxrd@z Thu Jan  1 00:00:00 1970
From: Tom.Lake@glossa.co.uk (Tom.Lake)
To: egcs-bugs@cygnus.com
Subject: Bug Report
Date: Mon, 25 Jan 1999 06:49:00 -0000
Message-id: <199901251303.NAA07338@glossa.co.uk>
X-SW-Source: 1999-01/msg00684.html
List-Id: <gcc-bugs.sourceware.org>

The following self-contained c++ file give compiler error 980715 under release
egcs-1.1.1 on ultrasparc solaris 2.6

Cheers,
Tom Lake
-------------------------------------------------------------------------------
Language, concurrency, software engineering  | InterGlossa Ltd  
Email:  Tom.Lake@glossa.co.uk                | 31A, Chain Street
Tel: +44 118 956 1919  Fax: +44 118 956 1920 | Reading   RG1 2HX
Web Home Pages:   http://www.glossa.co.uk    | UK
-------------------------------------------------------------------------------

#include<string>
#include<iostream>

#define SEQTYPE 9

int fail(string x){}

template <class Type>
class Pred{
  public:
 virtual int Test(Type)=0;
};


template <class X, class Y>
class Pair
#ifdef GCENABLED
   : public gc
#endif
{
public:
  X first;
  Y second;
  Pair() {};
  Pair(X a, Y b) { first = a; second = b; };
};
 
template <class X, class Y>
inline Pair<X,Y> fetch(Pair<X,Y> p) { return p;}
//template <class X, class Y>
//inline Pair<X,Y>& fetch(Pair<X,Y>& p) { return p;}
template <class X, class Y>
inline Pair<X,Y> fetch(Pair<X,Y> *p) { return *p;}
 
template <class X, class Y>
inline int operator==(const Pair<X,Y>& q1, const Pair<X,Y>& q2)
{return (fetch(q1.first) == fetch(q2.first)  &&
         fetch(q1.second) == fetch(q2.second)); }


template <class Type>
class Sequence
{ public:
     virtual Sequence<Type>* AddFront(Type v)=0;
     virtual Sequence<Type>* AddRear(Type v)=0;
     virtual Sequence<Type>* Concatenate(Sequence<Type>* s)=0;
     virtual Sequence<Type>* Reverse()=0;
     virtual Sequence<Type>* SeqFilter(Pred<Type>*)=0;
     virtual Type* Head()=0;
     virtual Type* Last()=0;
     virtual Sequence<Type>* Tail()=0;
     virtual Sequence<Type>* Front()=0;
     virtual Type* Extract(int i)=0;
     virtual int Length()=0;
     virtual int Empty()=0;
     virtual void Fold2(void (*)(Type,void*), void*)=0;
     virtual int operator==(const Sequence<Type> &)=0;
     virtual int GetType()=0;

};
template <class A, class B>
void Fold(Sequence<A>* s, void (*f)(A,B*), B* b)
{ s->Fold2( (void (*)(A,void*))f, (void*) b);}

template <class Type>
class ListNode
#ifdef GCENABLED
   : public gc
#endif
{
public:
  ListNode(){};
  ListNode<Type>* next;
  ListNode(Type t, ListNode<Type>* n){data = t; next = n;}
  Type data;
};

template <class Type>
class Seq : public Sequence<Type>
#ifdef GCENABLED
   , public gc
#endif
{
public:
  /* DESTRUCTIVE METHODS  */
     void Append(Type v);
     void Cons(Type v);

  /* FUNCTIONAL METHODS */
     ListNode<Type> *first;
     ListNode<Type> *last;
     Seq(){first = (ListNode<Type>*)NULL; last = (ListNode<Type>*)NULL;}
     Seq(ListNode<Type>* f, ListNode<Type>* l){first = f; last = l;}
     //Seq(const Seq<Type>& s) {first = s.first; last = s.last};
     virtual Sequence<Type>* AddFront(Type v);
     virtual Sequence<Type>* AddRear(Type v);
     virtual Sequence<Type>* Concatenate(Sequence<Type>* s);
     virtual Sequence<Type>* Reverse();
     virtual Sequence<Type>* SeqFilter(Pred<Type>*);
     virtual Type* Head(){return (first != (ListNode<Type>*)NULL)?&(first->data)
:
                             (fail("Head of empty list"),(Type*)NULL);
                         }
     virtual Type* Last(){return (last != (ListNode<Type>*)NULL)?&(last->data):
                           (fail("Last of empty list"),(Type*)NULL);
                         }
     virtual Sequence<Type>* Tail();
     virtual Sequence<Type>* Front();
     virtual Type* Extract(int i);
     virtual int Length();
     virtual int Empty();
     virtual void Fold2(void (*)(Type,void*), void*);
     void consistency_check()
       {
#ifdef AFA_DEBUG
         /* should fail if list not consistent */
          ListNode<Type> *cursor = first;
          if (first)
           while (cursor != last) cursor = cursor->next;
          else if (last) cursor = first->next;
#endif
       }
     int operator==(const Sequence<Type> &);
     Seq<Type>(Type t)
     {first=(ListNode<Type>*)NULL; 
      last=(ListNode<Type>*)NULL;Append(t);
     };
     virtual int GetType(){return SEQTYPE;}
};

template<class Type>
void equal_aux(Type t, Pair<int, ListNode<Type>* >* p)
{ if(p->first == 0) return;
  if(p->second == (ListNode<Type>*)NULL || !(fetch(t) == fetch(p->second->data)) )       p->first = 0;
  else p->second = p->second->next;
}



template<class Type>
int Seq<Type>::operator==(const Sequence<Type> &s)
{
  Pair<int, ListNode<Type>* > p(1, first);
  Fold((Sequence<Type>*)&s, /*(void (Type, Pair<int, ListNode<Type>* >*))*/(equal_aux<Type> ), &p);   
  return (p.first && p.second == (ListNode<Type>*)NULL);
}



typedef int PAAligned_Shape;

class PASize : public Seq<PAAligned_Shape>{
public:
 PASize(){first=(ListNode<PAAligned_Shape> *)NULL;
          last= (ListNode<PAAligned_Shape>*)NULL;} /* Should not be needed */
 PASize(PAAligned_Shape as){first=(ListNode<PAAligned_Shape>*)NULL;
                            last=(ListNode<PAAligned_Shape>*)NULL;
                            Append(as);
                           }
 int operator==(const PASize & s1)
{return ((Seq<PAAligned_Shape>&)*this) == ((Seq<PAAligned_Shape>&)s1); }
};

inline PASize fetch(PASize s){return s;}

PASize a,b;

int main(void){
   return a==b;
}

/*    T H E     E N D    */