🚀 go-pugleaf

Hi,

  The following program gets a fatal signal on the sun4.  ( Sorry it's
so long ).  Here's the diagnostic:

----------------------------------------
g++ version 1.27.0
 /usr/public/lib/g++/gcc-cpp+ -v -I/cd/ua/schmidt/include/ -undef
-D__GNU__ -D__GNUG__ -Dsparc -Dsun -Dunix foo.cc /tmp/cca15290.cpp GNU
CPP version 1.27.0
 /usr/public/lib/g++/gcc-c++ /tmp/cca15290.cpp -quiet -dumpbase foo.cc
-finline-functions -fmemoize-lookups -fsave-memoized -fchar-charconst
-noreg -version -o /tmp/cca15290.s

In function listSLList::remove_front ():
foo.cc:624: initializer unused
foo.cc:630: initializer unused

In function void listSLList::del_front ():
foo.cc:642: Segmentation violation
/usr/public/g++: Program c++ got fatal signal 11.

----------------------------------------

Doug

----------------------------------------
#include <stddef.h>
struct intSLListNode
{
  intSLListNode*         tl;
  int                    hd;
                         intSLListNode();
                         intSLListNode(int& h, intSLListNode* t = 0);
                         ~intSLListNode();
};
inline intSLListNode::intSLListNode() {}
inline intSLListNode::intSLListNode(int& h, intSLListNode* t = 0)
{
  hd = h;
  tl = t;
}
inline intSLListNode::~intSLListNode() {}
typedef intSLListNode* intSLListNodePtr;
class intSLListTrav;
class intSLList
{
  friend class          intSLListTrav;
protected:
  intSLListNode*        last;
public:
                        intSLList();
                        intSLList(intSLList& a);
                        ~intSLList();
  intSLList&            operator = (intSLList& a);
  int                   null();
  int                   empty();
  int                   valid();
  const void*           operator void* ();
  int                   operator ! ();
  int                   length();
  void                  clear();
  void                  prepend(int& item);
  void                  append(int& item);
  int&                  front();
  int&                  rear();
  int                   remove_front();
  void                  del_front();
  void                  error(const char* msg);
};
class intSLListTrav
{
  friend class          intSLList;
protected:
  intSLList*            L;
  intSLListNode*        current;
public:
                        intSLListTrav(intSLList& l);
                        ~intSLListTrav();
  int                   null();
  int                   valid();
  const void*           operator void* ();
  int                   operator ! ();
  void                  advance();
  int&                  get();
  void                  reset();
  void                  reset(intSLList& l);
  void                  insert_after(int&item);
};
class intSLStack : private intSLList
{
public:
  intSLList::null();
  intSLList::empty();
  intSLList::clear();
  intSLList::length();
  intSLList::operator ! ();
  intSLList::operator void*();
  intSLList::error(const char* msg);
                        intSLStack();
                        intSLStack(intSLStack& a);
                        ~intSLStack();
  intSLStack&           operator = (intSLStack& a);
  void                  push(int& item);
  int                   pop();
  int&                  top();
  void                  del_top();
};
class intSLQueue: private intSLList
{
public:
  intSLList::null();
  intSLList::empty();
  intSLList::clear();
  intSLList::length();
  intSLList::operator ! ();
  intSLList::operator void*();
  intSLList::error(const char* msg);
  intSLList::front();
  intSLList::rear();
  intSLList::del_front();
                        intSLQueue();
                        intSLQueue(intSLQueue& a);
                        ~intSLQueue();
  intSLQueue&           operator = (intSLQueue& a);
  void                  enq(int& item);
  int                   deq();
};
extern void default_intSLList_error_handler(char*);
extern one_arg_error_handler_t intSLList_error_handler;
extern one_arg_error_handler_t 
        set_intSLList_error_handler(one_arg_error_handler_t f);
inline intSLList::~intSLList()
{
  clear();
}
inline intSLList::intSLList()
{
  last = 0;
}
inline int intSLList::null()
{
  return last == 0;
}
inline int intSLList::empty()
{
  return last == 0;
}
inline int intSLList::valid()
{
  return last != 0;
}
inline const void* intSLList::operator void* ()
{
  return (last == 0)? 0 : this;
}
inline int intSLList::operator ! ()
{
  return last == 0;
}
inline int intSLList::length()
{
  if (last == 0)
    return 0;
  else
  {
    int l = 1;
    for (intSLListNode* p = last->tl; p != last; p = p->tl) ++l;
    return l;
  }
}
inline intSLListTrav::intSLListTrav(intSLList& a)
{
  L = &a; 
  if (a.last == 0)
    current =  0;
  else
    current = a.last->tl;
}
inline void intSLListTrav::reset()
{
  if (L->last == 0) current = 0; else current = L->last->tl;
}
inline void intSLListTrav::reset(intSLList& a)
{
  L = &a; 
  if (a.last == 0)
    current =  0;
  else
    current = a.last->tl;
}
inline intSLListTrav::~intSLListTrav() {}
inline int intSLListTrav::null()
{
  return current == 0;
}
inline int intSLListTrav::valid()
{
  return current != 0;
}
inline const void* intSLListTrav::operator void* ()
{
  return (current == 0)? 0 : this;
}
inline int intSLListTrav::operator ! ()
{
  return (current == 0);
}
inline void intSLListTrav::advance()
{
  if (current != 0) 
  {
    current = (current == L->last)? 0 : current->tl;
  }
}
inline int& intSLListTrav::get()
{
  if (current == 0)
    (*intSLList_error_handler)("get from null traverser");
  return current->hd;
}
inline int& intSLList::front()
{
  if (last == 0)
    error("front: empty list");
  return last->tl->hd;
}
inline int& intSLList::rear()
{
  if (last == 0)
    error("rear: empty list");
  return last->hd;
}
inline intSLStack::intSLStack() {}
inline intSLStack::intSLStack(intSLStack& a) : (a) {}
inline intSLStack::~intSLStack() {}
inline intSLStack&  intSLStack::operator = (intSLStack& a)
{
  intSLList::operator = (a); return *this;
}
inline void  intSLStack::push(int& item)
{
  intSLList::prepend(item);
}
inline void intSLStack::del_top()
{
  intSLList::del_front();
}
inline int& intSLStack::top()
{
  return intSLList::front();
}
inline int intSLStack::pop()
{
  return intSLList::remove_front();
}
inline intSLQueue::intSLQueue() {}
inline intSLQueue::intSLQueue(intSLQueue& a) : (a) {}
inline intSLQueue::~intSLQueue() {}
inline intSLQueue&  intSLQueue::operator = (intSLQueue& a)
{
  intSLList::operator = (a); return *this;
}
inline void  intSLQueue::enq(int& item)
{
  intSLList::append(item);
}
inline int intSLQueue::deq()
{
  return intSLList::remove_front();
}
struct list {
	int   		project;
	intSLList 	component_list;
};
struct listSLListNode
{
  listSLListNode*         tl;
  list                    hd;
                         listSLListNode();
                         listSLListNode(list& h, listSLListNode* t = 0);
                         ~listSLListNode();
};
inline listSLListNode::listSLListNode() {}
inline listSLListNode::listSLListNode(list& h, listSLListNode* t = 0)
{
  hd = h;
  tl = t;
}
inline listSLListNode::~listSLListNode() {}
typedef listSLListNode* listSLListNodePtr;
class listSLListTrav;
class listSLList
{
  friend class          listSLListTrav;
protected:
  listSLListNode*        last;
public:
                        listSLList();
                        listSLList(listSLList& a);
                        ~listSLList();
  listSLList&            operator = (listSLList& a);
  int                   null();
  int                   empty();
  int                   valid();
  const void*           operator void* ();
  int                   operator ! ();
  int                   length();
  void                  clear();
  void                  prepend(list& item);
  void                  append(list& item);
  list&                  front();
  list&                  rear();
  list                   remove_front();
  void                  del_front();
  void                  error(const char* msg);
};
class listSLListTrav
{
  friend class          listSLList;
protected:
  listSLList*            L;
  listSLListNode*        current;
public:
                        listSLListTrav(listSLList& l);
                        ~listSLListTrav();
  int                   null();
  int                   valid();
  const void*           operator void* ();
  int                   operator ! ();
  void                  advance();
  list&                  get();
  void                  reset();
  void                  reset(listSLList& l);
  void                  insert_after(list&item);
};
class listSLStack : private listSLList
{
public:
  listSLList::null();
  listSLList::empty();
  listSLList::clear();
  listSLList::length();
  listSLList::operator ! ();
  listSLList::operator void*();
  listSLList::error(const char* msg);
                        listSLStack();
                        listSLStack(listSLStack& a);
                        ~listSLStack();
  listSLStack&           operator = (listSLStack& a);
  void                  push(list& item);
  list                   pop();
  list&                  top();
  void                  del_top();
};
class listSLQueue: private listSLList
{
public:
  listSLList::null();
  listSLList::empty();
  listSLList::clear();
  listSLList::length();
  listSLList::operator ! ();
  listSLList::operator void*();
  listSLList::error(const char* msg);
  listSLList::front();
  listSLList::rear();
  listSLList::del_front();
                        listSLQueue();
                        listSLQueue(listSLQueue& a);
                        ~listSLQueue();
  listSLQueue&           operator = (listSLQueue& a);
  void                  enq(list& item);
  list                   deq();
};
extern void default_listSLList_error_handler(char*);
extern one_arg_error_handler_t listSLList_error_handler;
extern one_arg_error_handler_t 
        set_listSLList_error_handler(one_arg_error_handler_t f);
inline listSLList::~listSLList()
{
  clear();
}
inline listSLList::listSLList()
{
  last = 0;
}
inline int listSLList::null()
{
  return last == 0;
}
inline int listSLList::empty()
{
  return last == 0;
}
inline int listSLList::valid()
{
  return last != 0;
}
inline const void* listSLList::operator void* ()
{
  return (last == 0)? 0 : this;
}
inline int listSLList::operator ! ()
{
  return last == 0;
}
inline int listSLList::length()
{
  if (last == 0)
    return 0;
  else
  {
    int l = 1;
    for (listSLListNode* p = last->tl; p != last; p = p->tl) ++l;
    return l;
  }
}
inline listSLListTrav::listSLListTrav(listSLList& a)
{
  L = &a; 
  if (a.last == 0)
    current =  0;
  else
    current = a.last->tl;
}
inline void listSLListTrav::reset()
{
  if (L->last == 0) current = 0; else current = L->last->tl;
}
inline void listSLListTrav::reset(listSLList& a)
{
  L = &a; 
  if (a.last == 0)
    current =  0;
  else
    current = a.last->tl;
}
inline listSLListTrav::~listSLListTrav() {}
inline int listSLListTrav::null()
{
  return current == 0;
}
inline int listSLListTrav::valid()
{
  return current != 0;
}
inline const void* listSLListTrav::operator void* ()
{
  return (current == 0)? 0 : this;
}
inline int listSLListTrav::operator ! ()
{
  return (current == 0);
}
inline void listSLListTrav::advance()
{
  if (current != 0) 
  {
    current = (current == L->last)? 0 : current->tl;
  }
}
inline list& listSLListTrav::get()
{
  if (current == 0)
    (*listSLList_error_handler)("get from null traverser");
  return current->hd;
}
inline list& listSLList::front()
{
  if (last == 0)
    error("front: empty list");
  return last->tl->hd;
}
inline list& listSLList::rear()
{
  if (last == 0)
    error("rear: empty list");
  return last->hd;
}
inline listSLStack::listSLStack() {}
inline listSLStack::listSLStack(listSLStack& a) : (a) {}
inline listSLStack::~listSLStack() {}
inline listSLStack&  listSLStack::operator = (listSLStack& a)
{
  listSLList::operator = (a); return *this;
}
inline void  listSLStack::push(list& item)
{
  listSLList::prepend(item);
}
inline void listSLStack::del_top()
{
  listSLList::del_front();
}
inline list& listSLStack::top()
{
  return listSLList::front();
}
inline list listSLStack::pop()
{
  return listSLList::remove_front();
}
inline listSLQueue::listSLQueue() {}
inline listSLQueue::listSLQueue(listSLQueue& a) : (a) {}
inline listSLQueue::~listSLQueue() {}
inline listSLQueue&  listSLQueue::operator = (listSLQueue& a)
{
  listSLList::operator = (a); return *this;
}
inline void  listSLQueue::enq(list& item)
{
  listSLList::append(item);
}
inline list listSLQueue::deq()
{
  return listSLList::remove_front();
}
// error handling
void default_listSLList_error_handler(char* msg)
{
  exit(1);
}
one_arg_error_handler_t listSLList_error_handler = default_listSLList_error_handler;
one_arg_error_handler_t set_listSLList_error_handler(one_arg_error_handler_t f)
{
  one_arg_error_handler_t old = listSLList_error_handler;
  listSLList_error_handler = f;
  return old;
}
void listSLList::error(const char* msg)
{
  (*listSLList_error_handler)(msg);
}
listSLList::listSLList(listSLList& a)
{
  if (a.last == 0)
    last = 0;
  else
  {
    listSLListNode* p = a.last->tl;
    listSLListNode* h = new listSLListNode(p->hd);
    last = h;
    p = p->tl;
    for (;;)
    {
      listSLListNode* n = new listSLListNode(p->hd);
      last->tl = n;
      last = n;
      if (p == a.last)
      {
        last->tl = h;
        return;
      }
      else
        p = p->tl;
    }
  }
}
listSLList& listSLList::operator = (listSLList& a)
{
  if (last == a.last)
    return *this;
  else
  {
    clear();
    if (a.last != 0)
    {
      listSLListNode* p = a.last->tl;
      listSLListNode* h = new listSLListNode(p->hd);
      last = h;
      p = p->tl;
      for (;;)
      {
        listSLListNode* n = new listSLListNode(p->hd);
        last->tl = n;
        last = n;
        if (p == a.last)
        {
          last->tl = h;
          return *this;
        }
        else
          p = p->tl;
      }
    }
  }
}
void listSLList::clear()
{
  if (last == 0)
    return;
  listSLListNode* p = last->tl;
  last->tl = 0;
  last = 0;
  while (p != 0)
  {
    listSLListNode* nxt = p->tl;
    delete(p);
    p = nxt;
  }
}
void listSLList::prepend(list& item)
{
  listSLListNode* t = new listSLListNode(item);
  if (last == 0)
    t->tl = last = t;
  else
  {
    t->tl = last->tl;
    last->tl = t;
  }
}
void listSLList::append(list& item)
{
  listSLListNode* t = new listSLListNode(item);
  if (last == 0)
    t->tl = last = t;
  else
  {
    t->tl = last->tl;
    last = last->tl = t;
  }
}
void listSLListTrav::insert_after(list& item)
{
  listSLListNode* t = new listSLListNode(item);
  if (L->last == 0)
    t->tl = L->last = current = t;
  else if (current == 0)
  {
    t->tl = L->last->tl;
    L->last = t;
  }
  else if (L->last == current)
  {
    t->tl = current->tl;
    current->tl = L->last = t;
  }
  else
  {
    t->tl = current->tl;
    current->tl = t;
  }
}
list listSLList::remove_front()
{
  if (last == 0)
    error("remove_front of empty list");
  listSLListNode* t = last->tl;
  list res = t->hd;
  if (t == last)
    last = 0;
  else
    last->tl = t->tl;
  delete t;
  return res;
}
void listSLList::del_front()
{
  if (last == 0)
    error("del_front of empty list");
  listSLListNode* t = last->tl;
  if (t == last)
    last = 0;
  else
    last->tl = t->tl;
  delete t;
}