schmidt%glacier.ics.uci.edu@ORION.CF.UCI.EDU ("Douglas C. Schmidt") (11/24/88)
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;
}