Internal compiler error in egcs-1.1b

[Carlo Wood <carlo at runaway dot xs4all dot nl>]

I ran into an ICE.

>g++ -ggdb -c bug.cc
bug.cc:36: previous declaration `template <class CLIENT, class METHOD> FooEventServer::EventRequest<CLIENT,METHOD>'
bug.cc:45: used 2 template parameters instead of 3
bug.cc:45: redefinition of `class FooEventServer::EventRequest<CLIENT,METHOD>'
bug.cc:42: previous definition here
bug.cc:52: duplicate nested type `template <class CLIENT, class METHOD, class BUSYINTERFACE> FooEventServer::EventRequest<CLIENT,METHOD><CLIENT,METHOD,BUSYINTERFACE>'
../../egcs-1.1b/gcc/dwarf2out.c:9055: Internal compiler error in function gen_type_die

Carlo Wood  <carlo@runaway.xs4all.nl>

bug.cc:
-------------------------------------------------------------------------------
#include <list>

class event_server_ct {
};

template<class EVENTDATA>
class event_request_tct {
public:
  virtual void triggered(const EVENTDATA &eventdata) = 0;
};

class busy_interface_ct {
};

//=============================================================================
//
// Start of test classes
//
// FooEventServer: An EventServer
//

class FooEventServer : public event_server_ct {
public:
  class EventData {
    int i;
  public:
    EventData(int j) : i(j) {}
  };

private:
  typedef list<event_request_tct<EventData> *> request_list_ct;
  request_list_ct clients;

public:
  template<class CLIENT, typename METHOD>
  class EventRequest : public event_request_tct<EventData> {
    CLIENT ptr;
    METHOD func;
  public:
    EventRequest(CLIENT c, METHOD m) : ptr(c), func(m) {}
    virtual void triggered(const EventData &d);
  };

  template<class CLIENT, typename METHOD, class BUSYINTERFACE>
  class EventRequest : public event_request_tct<EventData> {
    CLIENT ptr;
    METHOD func;
    BUSYINTERFACE bi;
  public:
    EventRequest(CLIENT c, METHOD m, BUSYINTERFACE b) : ptr(c), func(m), bi(b) {}
    virtual void triggered(const EventData &d);
  };

  template<class CLIENT, typename METHOD>
  void fooRequest(CLIENT c, METHOD m);
  template<class CLIENT, typename METHOD, class BUSYINTERFACE>
  void fooRequest(CLIENT c, METHOD m, BUSYINTERFACE bi);
  void fooTrigger(const EventData &d);
};

template<class CLIENT, typename METHOD>
void FooEventServer::fooRequest(CLIENT c, METHOD m)
{
  clients.push_back(new EventRequest<CLIENT, METHOD>(c, m));
}

template<class CLIENT, typename METHOD, class BUSYINTERFACE>
void FooEventServer::fooRequest(CLIENT c, METHOD m, BUSYINTERFACE b)
{
  clients.push_back(new EventRequest<CLIENT, METHOD, BUSYINTERFACE>(c, m, b));
}

void FooEventServer::fooTrigger(const EventData &d)
{
  for (request_list_ct::iterator i = clients.begin(); i != clients.end(); ++i)
    (*i)->triggered(d);
}

template<class CLIENT, typename METHOD>
void FooEventServer::EventRequest::triggered(const EventData &d)
{
  (ptr.*func)(d);
}

template<class CLIENT, typename METHOD, class BUSYINTERFACE>
void FooEventServer::EventRequest::triggered(const EventData &d)
{
  (ptr.*func)(d);
}

//-----------------------------------------------------------------------------
//
// BarEventServer: Another EventServer
//

class BarEventServer : public event_server_ct {
public:
  class EventData {
    string i;
  public:
    EventData(const string &s) : i(s) {}
    friend ostream &operator<<(ostream &os, const EventData& d) { return os << d.i; }
  };

private:
  typedef list<event_request_tct<EventData> *> request_list_ct;
  request_list_ct clients;

public:
  template<class CLIENT, typename METHOD>
  class EventRequest : public event_request_tct<EventData> {
    CLIENT ptr;
    METHOD func;
  public:
    EventRequest(CLIENT c, METHOD m) : ptr(c), func(m) {}
    virtual void triggered(const EventData &d);
  };

  template<class CLIENT, typename METHOD> void barRequest(CLIENT c, METHOD m);
  template<class CLIENT, typename METHOD, class BUSYINTERFACE>
  void fooRequest(CLIENT c, METHOD m, BUSYINTERFACE bi);
  void barTrigger(const EventData &d);
};

template<class CLIENT, typename METHOD>
void BarEventServer::barRequest(CLIENT c, METHOD m)
{
  clients.push_back(new EventRequest<CLIENT, METHOD>(c, m));
}

template<class CLIENT, typename METHOD, class BUSYINTERFACE>
void BarEventServer::barRequest(CLIENT c, METHOD m, BUSYINTERFACE b)
{
  clients.push_back(new EventRequest<CLIENT, METHOD, BUSYINTERFACE>(c, m, b));
}

void BarEventServer::barTrigger(const EventData &d)
{
  for (request_list_ct::iterator i = clients.begin(); i != clients.end(); ++i)
    (*i)->triggered(d);
}

template<class CLIENT, typename METHOD>
void BarEventServer::EventRequest::triggered(const EventData &d)
{
  (ptr.*func)(d);
}

//-----------------------------------------------------------------------------
//
// An event client
//

class MyEventClient1 {
public:
  busy_interface_ct bi1, bi2;
  void handle_foo(const typename FooEventServer::EventData &)
  {
  }
  void handle_bar(const typename BarEventServer::EventData &)
  {
  }
};

class MyEventClient2 {
public:
  void handle_foo(const typename FooEventServer::EventData &)
  {
  }
};

//=============================================================================
//
// start
//
// Application initialisation.
//

int main(void)
{
  FooEventServer foo;
  BarEventServer bar;
  MyEventClient1 x;
  MyEventClient2 y;

  // Request event:
  foo.fooRequest(x, &MyEventClient1::handle_foo, x.bi1);
  bar.barRequest(x, &MyEventClient1::handle_bar, x.bi2);
  foo.fooRequest(y, &MyEventClient2::handle_foo);

  FooEventServer::EventData foodata(3);
  BarEventServer::EventData bardata("bar event");

  // Trigger events:
  foo.fooTrigger(foodata);
  bar.barTrigger(bardata);
}