this snippet from firebird vulcan project. it compiles with gcc 3.2
sorry, i'm still learning what i can cut out of the sample and still have it be
valid C++
GNU C++ version 3.4.2 20041017 (Red Hat 3.4.2-6.fc3) (i386-redhat-linux)
compiled by GNU C version 3.4.2 20041017 (Red Hat 3.4.2-6.fc3).
host g++ a.cpp
a.cpp: In static member function `static const Key BePlusTreeValue, Key,
Allocator, KeyOfValue, Cmp, LeafCount, NodeCount::NodeList::generate(void*,
void*)':a.cpp:114: error: expected primary-expression before ')' token
a.cpp:114: error: expected `)' before item
a.cpp:115: error: expected `)' before ';' token
a.cpp -
#define NULL ((void*)0)
typedef long long size_t;
// Very fast static array of simple types
template typename T, int Capacity
class Vector
{
public:
Vector() : count(0) {}
T operator[](int index) { return data[index]; }
T* begin() { return data; }
T* end() { return data + count; }
protected:
int count;
T data[Capacity];
};
// Template to convert value to index directly
template typename T
class DefaultKeyValue
{
public:
static const T generate(void* sender, const T Item) { return Item; }
};
// Template for default value comparsion
template typename T
class DefaultComparator
{
public:
static bool greaterThan(const T i1, const T i2) { return i1 i2; }
};
// Fast sorted array of simple objects
// It is used for B+ tree nodes lower, but can still be used by itself
template typename Value, int Capacity, typename Key = Value,
typename KeyOfValue = DefaultKeyValueValue,
typename Cmp = DefaultComparatorKey
class SortedVector : public VectorValue, Capacity
{
public:
SortedVector() : VectorValue, Capacity() {}
};
class MallocAllocator {
public:
void *allocate(size_t size) {return NULL;}
void deallocate(void *p) { }
};
template typename Value,
typename Key = Value, typename Allocator = MallocAllocator,
typename KeyOfValue = DefaultKeyValueValue,
typename Cmp = DefaultComparatorKey,
int LeafCount = 100,
int NodeCount = 100
class BePlusTree {
public:
BePlusTree(Allocator *_pool) : pool(_pool), level(0),
defaultAccessor(this)
{
root = new (_pool-allocate(sizeof(ItemList))) ItemList();
};
~BePlusTree() { }
bool add(const Value item) { return defaultAccessor.add(item); }
private:
BePlusTree(Allocator *_pool, void *rootPage) :pool(_pool), level(0),
root(new(rootPage) ItemList()), defaultAccessor(this) {}
class NodeList;
public:
class ItemList : public SortedVectorValue,LeafCount,Key,KeyOfValue,Cmp
{
public:
NodeList *parent;
ItemList *next, *prev;
// Adds newly created item to doubly-linked list
ItemList(ItemList *items) : parent(NULL) { }
ItemList() : parent(NULL), next(NULL), prev(NULL) {};
friend class BePlusTree;
friend class BePlusTree::NodeList;
};
private:
class NodeList : public SortedVectorvoid*,NodeCount,Key,NodeList,Cmp
{
public:
NodeList(NodeList *items) : parent(NULL) {}
NodeList() : parent(NULL), next(NULL), prev(NULL) {}
int level;
NodeList *parent;
NodeList *next, *prev;
static const Key generate(void *sender, void *item)
{
for (int lev = ((NodeList *)sender)-level; lev 0; lev--)
item = *((NodeList *)item)-begin();
return KeyOfValue::generate(item,
*((BePlusTree::ItemList *)item)-begin()
);
}
};
public:
class Accessor
{
public:
Accessor(BePlusTree* _tree) : tree(_tree), curr(NULL), curPos(0) {}
Value current() const { return (*curr)[curPos]; }
public:
BePlusTree* tree;
ItemList *curr;
int curPos;
};
public:
Allocator *pool;
int level;
void *root;
Accessor defaultAccessor;
friend class MemoryPool;
friend class NodeList;
friend class Accessor;
};
--
Summary: [regression 3.3/3.4.4.0]
Product: gcc
Version: 3.3
Status: UNCONFIRMED
Severity: normal
Priority: P2
Component: c++
AssignedTo: unassigned at gcc dot gnu dot org
ReportedBy: kent at sas dot com
CC: gcc-bugs at gcc dot gnu dot org
GCC host triplet: i386-redhat-linux
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19919
