This is the mail archive of the
gcc-bugs@gcc.gnu.org
mailing list for the GCC project.
egcs-1.0.2-8 Templates
- To: egcs-bugs at cygnus dot com
- Subject: egcs-1.0.2-8 Templates
- From: Russell Duke <rduke at migaux dot cgg dot com>
- Date: Wed, 17 Jun 1998 10:47:34 +0100
- Organization: CGG - London R&D
Hi,
I've just upgraded my laptop from Red Hat 5.0 to 5.1 and am having
trouble getting my C+ software to recompile/link.
Under linux I have been using '-fno-implicit-template' to disable
implicit generation of template instances, and explicitly instantiating
all the ones required in a single file. This worked fine under the old
GNU g++, but always generates an 'Internal compiler error' now that egcs
is used.
It gives an error every time it sees one of these template lines -
class GuiKeypadButton;
template class GuiList<GuiKeypadButton*>;
Saying :
GuiList.C: In method `GuiList<GuiKeypadButton*>::
GuiList(class GuiList<GuiKeypadButton*>&) :
GuiList.C:95: Internal compiler error
GuiList.C:95: Please submit a full bug report to ....
How should I instantiate templates using egcs ?
Note relevant files are attached.
Cheers,
Russ Duke.
________________________________________________________________________
Russell Duke
Senior Graphical Programmer
________________________________________________________________________
Compagnie Generale de Geophysique direct : +44 (0)181-899-2830
CGG House main : +44 (0)181-899-2400
4 Dukes Green Avenue fax : +44 (0)181-899-2500
Feltham
Middlesex TW14 0LR email : rduke@cgg.com
United Kingdom
________________________________________________________________________
Please note : The information contained in this message is strictly
confidential and for the use of the addressee only.
________________________________________________________________________
/*
********************************************************************************
* *
* Compagnie Generale de Geophysique *
* *
******************************* Copyright CGG **********************************
Creation Date : 21th February 1998
Author : Russell Duke
Language : C++
Module(s) : GuiTemplates
Parent Class : -
Purpose : Instigates all the template classes for the gcc compiler...
RCS Details
-----------
$Id: GuiTemplates.C,v 1.3 1998/06/04 11:55:35 duke Exp duke $
$Log: GuiTemplates.C,v $
Revision 1.3 1998/06/04 11:55:35 duke
Added new GuiList<GuiScratchPadMgr*> template class
Revision 1.2 1998/06/03 07:25:32 duke
Subsitute tabs for four spaces
Revision 1.1 1998/04/26 16:32:21 duke
Initial revision
*/
#if defined( LINUX )
#include "GuiMath.h"
#include "GuiIterator.h"
#include "GuiListIterator.C"
#include "GuiList.C"
#include "GuiLookupList.C"
#include "GuiLookupListIterator.C"
#include "MotifTabbedFolder.h"
#include "GuiLinkParameter.h"
#include "GuiString.h"
#include "GuiWidgetDefs.h"
class GuiKeypadButton;
class GuiKeypadParameters;
class GuiParameter;
class GuiProcess;
class Folder;
class GuiWindow;
class GuiMessage;
class GuiData;
class GuiDataLister;
class GuiDataIcon;
class GuiWidget;
class GuiDragSite;
class GuiDropSite;
class GuiDrawData;
class GuiScratchPad;
class GuiScratchPadMgr;
class GuiScales;
class GuiDisplay;
//
// Math functions ...
//
//template int max<int> ( int, int );
//template int min<int> ( int, int );
//template float max<float> ( float, float );
//template float min<float> ( float, float );
//
// listNode ...
//
//template class listNode<GuiString>;
template class listNode<GuiKeypadButton*>;
template class listNode<GuiKeypadParameters*>;
template class listNode<GuiParameter*>;
template class listNode<int>;
template class listNode<float>;
template class listNode<GuiData*>;
template class listNode<GuiLinkParameter::LinkData*>;
template class listNode<MotifTabbedFolder::Folder*>;
template class listNode<GuiWindow*>;
template class listNode<GuiMessage*>;
template class listNode<GuiDataLister*>;
template class listNode<GuiWidget*>;
template class listNode<GuiDragSite*>;
template class listNode<GuiDropSite*>;
template class listNode<GuiDrawData*>;
template class listNode<GuiScratchPad*>;
template class listNode<GuiScratchPadMgr*>;
template class listNode<GuiScales*>;
template class listNode<GuiDisplay*>;
//
// GuiList ...
//
template class GuiList<GuiKeypadButton*>;
template class GuiList<GuiKeypadParameters*>;
template class GuiList<GuiParameter*>;
template class GuiList<int>;
template class GuiList<float>;
template class GuiList<GuiData*>;
template class GuiList<GuiLinkParameter::LinkData*>;
template class GuiList<MotifTabbedFolder::Folder*>;
template class GuiList<GuiWindow*>;
template class GuiList<GuiMessage*>;
template class GuiList<GuiDataLister*>;
template class GuiList<GuiWidget*>;
template class GuiList<GuiDragSite*>;
template class GuiList<GuiDropSite*>;
template class GuiList<GuiDrawData*>;
template class GuiList<GuiScratchPad*>;
template class GuiList<GuiScratchPadMgr*>;
template class GuiList<GuiScales*>;
template class GuiList<GuiDisplay*>;
//
// ListIterators ...
//
template class GuiIterator<int>;
template class GuiIterator<float>;
template class GuiIterator<GuiKeypadParameters*>;
template class GuiIterator<GuiKeypadButton*>;
template class GuiIterator<GuiParameter*>;
template class GuiIterator<GuiLinkParameter::LinkData*>;
template class GuiIterator<GuiData*>;
template class GuiIterator<MotifTabbedFolder::Folder*>;
template class GuiIterator<GuiWindow*>;
template class GuiIterator<GuiMessage*>;
template class GuiIterator<GuiDataLister*>;
template class GuiIterator<GuiWidget*>;
template class GuiIterator<GuiDragSite*>;
template class GuiIterator<GuiDropSite*>;
template class GuiIterator<GuiDrawData*>;
template class GuiIterator<GuiScratchPad*>;
template class GuiIterator<GuiScratchPadMgr*>;
template class GuiIterator<GuiScales*>;
template class GuiIterator<GuiDisplay*>;
template class GuiListIterator<int>;
template class GuiListIterator<float>;
template class GuiListIterator<GuiKeypadParameters*>;
template class GuiListIterator<GuiKeypadButton*>;
template class GuiListIterator<GuiParameter*>;
template class GuiListIterator<GuiLinkParameter::LinkData*>;
template class GuiListIterator<GuiData*>;
template class GuiListIterator<MotifTabbedFolder::Folder*>;
template class GuiListIterator<GuiWindow*>;
template class GuiListIterator<GuiMessage*>;
template class GuiListIterator<GuiDataLister*>;
template class GuiListIterator<GuiWidget*>;
template class GuiListIterator<GuiDragSite*>;
template class GuiListIterator<GuiDropSite*>;
template class GuiListIterator<GuiDrawData*>;
template class GuiListIterator<GuiScratchPad*>;
template class GuiListIterator<GuiScratchPadMgr*>;
template class GuiListIterator<GuiScales*>;
template class GuiListIterator<GuiDisplay*>;
//
// lookupNode ...
//
template class lookupNode<GuiString,GuiProcess*>;
template class lookupNode<GuiString,GuiParameter*>;
template class lookupNode<GuiString,GuiString>;
template class lookupNode<GuiString,unsigned long>;
template class lookupNode<GuiData*,GuiDataIcon*>;
template class lookupNode<GuiCallbackProc,GuiPointer>;
template class lookupNode<GuiDrawData*,GuiScales*>;
template class lookupNode<GuiData*,GuiString*>;
template class lookupNode<GuiCallbackProc, GuiPointer>;
//
// LookupList ...
//
template class GuiLookupList<GuiString,GuiParameter*>;
template class GuiLookupList<GuiString,GuiProcess*>;
template class GuiLookupList<GuiString,GuiString>;
template class GuiLookupList<GuiString,unsigned long>;
template class GuiLookupList<GuiData*,GuiDataIcon*>;
template class GuiLookupList<GuiCallbackProc,GuiPointer>;
template class GuiLookupList<GuiDrawData*,GuiScales*>;
template class GuiLookupList<GuiData*,GuiString*>;
template class GuiLookupList<GuiCallbackProc, GuiPointer>;
template class GuiLookupListIterator<GuiString,GuiParameter*>;
template class GuiLookupListIterator<GuiString,GuiProcess*>;
template class GuiLookupListIterator<GuiString,GuiString>;
template class GuiLookupListIterator<GuiString,unsigned long>;
template class GuiLookupListIterator<GuiData*,GuiDataIcon*>;
template class GuiLookupListIterator<GuiCallbackProc,GuiPointer>;
template class GuiLookupListIterator<GuiDrawData*,GuiScales*>;
template class GuiLookupListIterator<GuiData*,GuiString*>;
template class GuiLookupListIterator<GuiCallbackProc, GuiPointer>;
template class GuiList< lookupNode<GuiString,GuiParameter*>* >;
template class GuiList< lookupNode<GuiString,GuiProcess*>* >;
template class GuiList< lookupNode<GuiString,GuiString>* >;
template class GuiList< lookupNode<GuiString,unsigned long>* >;
template class GuiList< lookupNode<GuiData*,GuiDataIcon*>* >;
template class GuiList< lookupNode<GuiCallbackProc,GuiPointer>* >;
template class GuiList< lookupNode<GuiDrawData*,GuiScales*>* >;
template class GuiList< lookupNode<GuiData*,GuiString*>* >;
template class GuiList< lookupNode<GuiCallbackProc, GuiPointer>* >;
template class listNode< lookupNode<GuiString,GuiParameter*>* >;
template class listNode< lookupNode<GuiString,GuiProcess*>* >;
template class listNode< lookupNode<GuiString,GuiString>* >;
template class listNode< lookupNode<GuiString,unsigned long>* >;
template class listNode< lookupNode<GuiData*,GuiDataIcon*>* >;
template class listNode< lookupNode<GuiCallbackProc,GuiPointer>* >;
template class listNode< lookupNode<GuiDrawData*,GuiScales*>* >;
template class listNode< lookupNode<GuiData*, GuiString*>* >;
template class listNode< lookupNode<GuiCallbackProc, GuiPointer>* >;
template class GuiIterator< lookupNode<GuiString,GuiParameter*>* >;
template class GuiIterator< lookupNode<GuiString,GuiProcess*>* >;
template class GuiIterator< lookupNode<GuiString,GuiString>* >;
template class GuiIterator< lookupNode<GuiString,unsigned long>* >;
template class GuiIterator< lookupNode<GuiData*,GuiDataIcon*>* >;
template class GuiIterator< lookupNode<GuiCallbackProc,GuiPointer>* >;
template class GuiIterator< lookupNode<GuiDrawData*,GuiScales*>* >;
template class GuiIterator< lookupNode<GuiData*,GuiString*>* >;
template class GuiIterator< lookupNode<GuiCallbackProc, GuiPointer>*>;
template class GuiListIterator< lookupNode<GuiString,GuiParameter*>* >;
template class GuiListIterator< lookupNode<GuiString,GuiProcess*>* >;
template class GuiListIterator< lookupNode<GuiString,GuiString>* >;
template class GuiListIterator< lookupNode<GuiString,unsigned long>* >;
template class GuiListIterator< lookupNode<GuiData*,GuiDataIcon*>* >;
template class GuiListIterator< lookupNode<GuiCallbackProc,GuiPointer>* >;
template class GuiListIterator< lookupNode<GuiDrawData*,GuiScales*>* >;
template class GuiListIterator< lookupNode<GuiData*,GuiString*>* >;
template class GuiListIterator< lookupNode<GuiCallbackProc, GuiPointer>* >;
#endif // _linux_
#ifndef _GuiList_h_
#define _GuiList_h_
/*
********************************************************************************
* *
* Compagnie Generale de Geophysique *
* *
******************************* Copyright CGG **********************************
Creation Date : 28th November 1997
Author : Russell Duke
Language : C++
Module(s) : List.h
Purpose : Header file GuiList class
RCS Details
-----------
$Id: GuiList.h,v 1.2 1998/06/03 07:25:32 duke Exp $
$Log: GuiList.h,v $
Revision 1.2 1998/06/03 07:25:32 duke
Subsitute tabs for four spaces
Revision 1.1 1998/04/26 16:19:55 duke
Initial revision
*/
#include "GuiDefs.h"
#include "GuiListIterator.h"
template <class T>
class listNode
{
public:
listNode();
~listNode();
listNode<T>& operator=( const listNode<T>& node );
T item;
listNode<T>* next;
listNode<T>* last;
};
template <class T>
class GuiList
{
public:
// Constructors
GuiList();
GuiList( GuiList<T> &list );
// Destructor
~GuiList();
// Interator creation
GuiListIterator<T>* createIterator();
// List management routines
GuiList<T>& operator=( GuiList<T>& );
long count() const;
T get( const long ) const;
T firstItem() const;
T lastItem() const;
bool includes( const T& ) const;
bool append( const T& );
bool prepend( const T& );
bool insert( const long, const T& );
void remove( const T& );
void remove( const long );
void removeLast();
void removeFirst();
void removeAll();
// Stack use
T top() const;
void push( const T& );
T pop();
private:
long count_;
listNode<T>* first_;
listNode<T>* last_;
};
#endif // _GuiList_h_
/*
********************************************************************************
* *
* Compagnie Generale de Geophysique *
* *
******************************* Copyright CGG **********************************
Creation Date : 24th November 1997
Author : Russell Duke
Language : C++
Module(s) : GuiList
Parent Class : -
Purpose : Class for the GuiList
RCS Details
-----------
$Id: GuiList.C,v 1.2 1998/06/03 07:25:32 duke Exp $
$Log: GuiList.C,v $
Revision 1.2 1998/06/03 07:25:32 duke
Subsitute tabs for four spaces
Revision 1.1 1998/04/26 16:33:59 duke
Initial revision
*/
#include "GuiList.h"
//
// List Node ...
//
template <class T>
listNode<T>::listNode()
: item( NULL ),
next( NULL ),
last( NULL )
{
}
template <class T>
listNode<T>::~listNode()
{
// Delete the item ...
/* Leave it to the calling routine ...
if ( item )
delete item;
*/
}
template <class T>
listNode<T>& listNode<T>::operator=( const listNode<T>& node )
{
// Copy item
if ( &node != this )
{
item = node.item;
next = node.next;
last = node.last;
}
return ( *this );
}
//
// List ...
//
// Constructors
template <class T>
GuiList<T>::GuiList()
:count_( 0 ),
first_( NULL ),
last_( NULL )
{
}
template <class T>
GuiList<T>::GuiList( GuiList<T> &list )
:count_( 0 ),
first_( NULL ),
last_( NULL )
{
GuiListIterator<T>* step = list.createIterator();
for ( step->firstItem(); !step->isDone; step->next() )
if ( !append( step->currentItem() ) )
break;
delete step;
}
// Destructor
template <class T>
GuiList<T>::~GuiList()
{
removeAll();
}
// Interator creation
template <class T>
GuiListIterator<T>* GuiList<T>::createIterator()
{
return ( new GuiListIterator<T>( this ) );
}
// List management routines
template <class T>
GuiList<T>& GuiList<T>::operator=( GuiList &list )
{
if ( &list != this )
{
removeAll();
GuiListIterator<T>* step = list.createIterator();
for ( step->firstItem(); !step->isDone; step->next() )
if ( !append( step->currentItem() ) )
break;
delete step;
}
return ( *this );
}
template <class T>
long GuiList<T>::count() const
{
return( count_ );
}
template <class T>
T GuiList<T>::get( const long index ) const
{
T item = 0;
long count = index;
listNode<T>* node;
if ( first_ )
{
for ( node=first_, count=0; node; node=node->next, count++ )
{
if (count == index)
{
item = node->item;
break;
}
}
}
return( item );
}
template <class T>
T GuiList<T>::firstItem() const
{
T item = 0;
if ( first_ )
item = first_->item;
return( item );
}
template <class T>
T GuiList<T>::lastItem() const
{
T item = 0;
if ( last_ )
item = last_->item;
return( item );
}
template <class T>
bool GuiList<T>::includes( const T& item ) const
{
listNode<T>* node;
for ( node=first_; node; node=node->next )
if ( node->item == item )
return ( true );
return( false );
}
template <class T>
bool GuiList<T>::append( const T& item )
{
listNode<T>* extra = new listNode<T>;
if ( extra )
{
extra->item = item;
extra->last = last_;
extra->next = NULL;
if ( !first_ )
first_ = extra;
if ( last_ )
last_->next = extra;
last_ = extra;
count_++;
return( true );
}
return( false );
}
template <class T>
bool GuiList<T>::prepend( const T& item )
{
listNode<T>* extra = new listNode<T>;
if ( extra )
{
extra->item = item;
extra->next = first_;
extra->last = NULL;
if ( first_ )
first_->last = extra;
if ( !last_ )
last_ = extra;
first_ = extra;
count_++;
return( true );
}
return( false );
}
template <class T>
bool GuiList<T>::insert( const long index,
const T& item )
{
if ( count_ == 0 || index > count_ )
{
// New last in list
return( append( item ) );
}
else if ( index == 0 )
{
// New first in list
return( prepend( item ) );
}
else
{
// Insert into the middle of the list
long count = index;
listNode<T>* node;
listNode<T>* extra = new listNode<T>;
if ( extra )
{
for ( node=first_, count=0; node; node=node->next, count++ )
{
if ( count == index )
{
extra->item = item;
extra->last = node->last;
extra->next = node;
node->last->next = extra;
node->last = extra;
count_++;
return( true );
}
}
}
}
return( false );
}
template <class T>
void GuiList<T>::remove( const T& item )
{
listNode<T> *node, *next;
for ( node=first_; node; node=next )
{
next = node->next;
if ( node->item == item )
{
if ( node == first_ )
{
first_ = first_->next;
if ( first_ )
first_->last = NULL;
}
if ( node == last_ )
{
last_ = last_->last;
if ( last_ )
last_->next = NULL;
}
if ( node != first_ && node != last_ )
{
if ( node->next )
node->next->last = node->last;
if ( node->last )
node->last->next = node->next;
}
delete node;
count_--;
}
}
}
template <class T>
void GuiList<T>::remove( const long index )
{
listNode<T> *node, *next;
int count;
for ( node=first_, count=0; node; node=next, count++ )
{
next = node->next;
if ( count == index )
{
if ( node == first_ )
{
first_ = first_->next;
if ( first_ )
first_->last = NULL;
}
if ( node == last_ )
{
last_ = last_->last;
if ( last_ )
last_->next = NULL;
}
if ( node != first_ && node != last_ )
{
if ( node->next )
node->next->last = node->last;
if ( node->last )
node->last->next = node->next;
}
delete node;
count_--;
}
}
}
template <class T>
void GuiList<T>::removeLast()
{
if ( last_ )
{
// Get node before last one
listNode<T>* node = last_->last;
// If it exists set its next node to NULL
if ( node )
node->next = NULL;
// If this is the last one, point last node to NULL, stops double deletion
if ( first_ == last_ )
first_ = NULL;
// Delete last item in the list
delete last_;
// Assign new last item
last_ = node;
// Decrement counter
count_--;
}
}
template <class T>
void GuiList<T>::removeFirst()
{
if ( first_ )
{
// Get node after first one
listNode<T>* node = first_->next;
// If it exists set its last node to NULL
if ( node )
node->last = NULL;
// If this is the last one, point last node to NULL, stops double deletion
if ( first_ == last_ )
last_ = NULL;
// Delete first item in the list
delete first_;
// Assign new first item
first_ = node;
// Decrement counter
count_--;
}
}
template <class T>
void GuiList<T>::removeAll()
{
listNode<T> *node, *next;
for ( node=first_; node; node=next )
{
next = node->next;
delete node;
}
first_ = NULL;
last_ = NULL;
count_ = 0;
}
// Stack use
template <class T>
T GuiList<T>::top() const
{
return( lastItem() );
}
template <class T>
void GuiList<T>::push( const T& item )
{
append( item );
}
template <class T>
T GuiList<T>::pop()
{
T item = lastItem();
removeLast();
return( item );
}