[Bug c++/19919] New: [regression 3.3/3.4.4.0]

[kent at sas dot com]

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& BePlusTree<Value, 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 = DefaultKeyValue<Value>,
  typename Cmp = DefaultComparator<Key> >
  class SortedVector : public Vector<Value, Capacity>
  {
  public:
    SortedVector() : Vector<Value, 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 = DefaultKeyValue<Value>,
    typename Cmp = DefaultComparator<Key>,
    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 SortedVector<Value,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 SortedVector<void*,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