[comp.sys.amiga] The following C++ program keep me stumped... HELP! :)

jonasf@kuling.UUCP (Jonas "flax" Flygare) (02/22/90)

I am using lattice C++ version 1.0 and lattice C version 5.04.
compiles w/o warnings/errors, when run it bombs (stack set to 200000)
if I insert a char variable and cin >> `variable`; to 'step' through
the program it runs fine... So, if anyone out there know what's wrong
with it, please tell me..

------------------------------------test.cc-----------------

#include <stream.h>
#include "derlist.h"


main()
{
  derlist f(1), g(2), h(3), i(4), *p;
  cout << "append\n";
  f.append(g);
  cout << "append\n";
  f.append(h);
  cout << "append\n";
  f.append(i);
  cout << "append\n";
  p=&f;
  cout << "assign\n";
  do
  {
   cout << "value = " << p->getvalue() << "\n";
   p=(derlist*)p->next();
  }
  while (p->next()!=p);

  cout << "loop\n";
  g.unlink(); 
  cout << "unlink\n";  
  
  p=&f;
  cout << "assign\n";

  do
  {
   cout << "value = " << p->getvalue() << "\n";
   p=(derlist*)p->next();
  }
  while (p->next()!=p);
}

------------------------------------linkage.h-----------------

// File linkage: linkage specs for my list objects.
// Linkage: Doubly linked. Beginning and end signalled with self ref.

#ifndef LINKAGE_DEFINED
class linkage
{
  protected: 
   linkage *prev_node;
   linkage *next_node;
  public:
   linkage(linkage* p=NULL, linkage* n=NULL); // bombed here!
   virtual ~linkage();
    linkage* next();
    linkage* prev();
    linkage& getnext();
    linkage& getprev();
    virtual void append(linkage& nod);
    virtual void insert(linkage& nod);
    virtual void append(linkage* nod);
    virtual void insert(linkage* nod);
    void unlink();
    linkage& first();
    linkage& last();
   virtual linkage* find(linkage* node, int (*fun)(linkage*, linkage*)=NULL);  
};
#define LINKAGE_DEFINED
#endif LINKAGE_DEFINED

------------------------------------linkage.cc-----------------

#include <stream.h>
#include "linkage.h"


linkage::linkage(linkage* a, linkage* b)
{
  prev_node=(a) ? a : this;
  next_node=(b) ? b : this;
}

linkage* linkage::next() 
{
  return next_node;
}

linkage* linkage::prev() 
{
  return prev_node;
}

linkage& linkage::getnext() 
{
  return *next_node;
}

linkage& linkage::getprev() 
{
  return *prev_node;
}

void linkage::append(linkage& nod)
{
  if (next_node==this)  // have end of list, insert node
  {
    next_node=&nod;
    nod.prev_node=this;
  }
  else
   next_node->append(nod);
}

void linkage::insert(linkage& nod)
{
  if (prev_node==this)
  {
    prev_node=&(nod.last());
    (nod.last()).next_node=this;
  }
  else
  {
    prev_node->next_node=&(nod.first());
    (nod.first()).prev_node=prev_node;
    prev_node=&(nod.last());
    (nod.last()).next_node=this;
  }
}

void linkage::append(linkage* nod)
{
  if (next_node==this)  // have end of list, insert node
  {
    next_node=nod;
    nod->prev_node=this;
  }
  else
   next_node->append(nod);
}

void linkage::insert(linkage* nod)
{
  if (prev_node==this)
  {
    prev_node=&(nod->last());
    (nod->last()).next_node=this;
  }
  else
  {
    prev_node->next_node=&(nod->first());
    (nod->first()).prev_node=prev_node;
    prev_node=&(nod->last());
    (nod->last()).next_node=this;
  }
}

void linkage::unlink()
{
  next_node->prev_node=prev_node;
  prev_node->next_node=next_node;
  next_node=prev_node=this;
  delete this;
}

linkage::~linkage()
{
  if (prev_node!=this)
  {
   prev_node->next_node=prev_node;
  }
  if (next_node!=this) delete next_node;
}

linkage& linkage::first()
{
  if (prev_node==this) return *this;
  else return prev_node->first();
}

linkage& linkage::last()
{
  if (next_node==this) return *this;
  else return next_node->last();
}

linkage* linkage::find(linkage* node, int (*fun)(linkage*, linkage*))
{
  if (fun)
  {
   if ((*fun)(node, this)) return this;
    else if (next_node!=this)
     return next_node->find(node, fun);
     else return NULL;
  }
  else // generic comparison!
  if (node==this) return this;
  else return next_node->find(node,fun);
}

------------------------------------derlist.h-----------------

#include "linkage.h"

#ifndef DERLIST_DEFINED
class derlist : public linkage
{
  private:
   int value;
  public:
   derlist(int a=0);
   int getvalue() {return value;}
   void append(linkage&);
   void insert(linkage&);
   void append(linkage*);
   void insert(linkage*);
   void append(derlist&);
   void insert(derlist&);
   linkage* find(linkage*, int (*fun)(linkage*, linkage*) = NULL);
};
#define DERLIST_DEFINED
#endif DERLIST_DEFINED

------------------------------------derlist.cc-----------------

#include <stream.h>
#include "derlist.h"

derlist::derlist(int a) : (NULL, NULL)
{
  value=a;
}

linkage* derlist::find(linkage* nod, int (*fun)(linkage*, linkage*))
{
  if (fun)
  {
   if ((*fun)(nod, (linkage*)this)) return (linkage*)this;
    else if (next_node!=(linkage*)this)
     return next_node->find(nod, fun);
     else return NULL;
  }
  else // generic comparison!
  if (((derlist*)nod)->value==this->value) return (linkage*)this;
  else return next_node->find(nod,fun);
}

void derlist::append(linkage& l)
{
  linkage::append(l);
}
void derlist::append(linkage* l)
{
  linkage::append(l);
}

void derlist::append(derlist& l)
{
  linkage::append((linkage*) &l);
}

void derlist::insert(linkage& l)
{
  linkage::insert(l);
}
void derlist::insert(linkage* l)
{
  linkage::insert(l);
}

void derlist::insert(derlist& l)
{
  linkage::insert((linkage*) &l);
}
-- 
jonasf@kuling.docs.uu.se : "Doedth eddydthig dthrike you adth dthrayge 
Jonas (flax) Flygare     :  aboud dthidth houdth?" -- Dirk Gently