[Bug c++/29766] New: Template Specialization break down

["ypwangandy at gmail dot com" <gcc-bugzilla at gcc dot gnu dot org>]

$ g++ find.mytree.cpp
find.mytree.cpp:141:2: warning: no newline at end of file
find.mytree.cpp:123: internal compiler error: in output_constant, at
varasm.c:38
43
Please submit a full bug report,
with preprocessed source if appropriate.
See <URL:http://gcc.gnu.org/bugs.html> for instructions.


$ g++ -v
Reading specs from /usr/lib/gcc/i686-pc-cygwin/3.4.4/specs
Configured with: /gcc/gcc-3.4.4/gcc-3.4.4-1/configure --verbose --prefix=/usr
--
exec-prefix=/usr --sysconfdir=/etc --libdir=/usr/lib --libexecdir=/usr/lib
--man
dir=/usr/share/man --infodir=/usr/share/info
--enable-languages=c,ada,c++,d,f77,
java,objc --enable-nls --without-included-gettext
--enable-version-specific-runt
ime-libs --without-x --enable-libgcj --disable-java-awt --with-system-zlib
--ena
ble-interpreter --disable-libgcj-debug --enable-threads=posix
--enable-java-gc=b
oehm --disable-win32-registry --enable-sjlj-exceptions
--enable-hash-synchroniza
tion --enable-libstdcxx-debug : (reconfigured)
Thread model: posix
gcc version 3.4.4 (cygming special) (gdc 0.12, using dmd 0.125)

find.mytree.cpp
========================
#include <iostream>
#include <string>
#include <map>
#include <vector>
#define OUTPUT(x) std::cout << x << std::endl;

template <typename C>
class mytree {
        public:
        typedef  mytree<C> MYTREE;
        typedef  std::map<const std::string, MYTREE*> ELEMENT;
        typedef  typename ELEMENT::iterator ELEITER;
        #define GETTREE(x)  (*(x->second))
        #define VALUE(x) (make_pair(x->Name(), x)) 
        typedef  std::string NAME;

        mytree(char *nm, C& vl, MYTREE *ch=0, MYTREE *brss=0, MYTREE* pr=0)
        : name(nm), value(vl){ insert (ch, brss, pr); }
        mytree(const char* nm, const C& vl, MYTREE *ch=0, MYTREE *brss=0,
MYTREE* pr=0)
        : name(nm), value(vl){ insert (ch, brss, pr); }

        MYTREE& operator/(const char* str) 
        {
                return myfind(child, str);
        }
        MYTREE&  operator|(const char* str)
        {
                return myfind(brosis, str);
        }
        MYTREE&  operator^(const char* str)
        {
                return myfind(parents, str);
        }
        const C& Value() {
                return value;
        }
        const NAME &Name() {
                return name;
        }
        operator C () {
                return value;
        }
        /* 
          noloop: to avoid infinite loop. consider A add B as brother and at
mean time B add A as brother. 
                  then A add B as brother... that will be infinite loop.
                  solution: (a) we can find each time to see if B is already
A's brother
                             (b) add the noloop, when it should be finished,
just set noloop to 0.
        */
        MYTREE& insert(MYTREE *ch, MYTREE *brss, MYTREE* pr, bool noloop=1)
        {       counter++;
                if(ch){all.insert(VALUE(ch)); child.insert(VALUE(ch));
                        if(noloop)ch->insert(0, 0, this, 0);}
                if(brss){all.insert(VALUE(brss));brosis.insert(VALUE(brss));
                        if(noloop)brss->insert(0, this, 0, 0);}
                if(pr){all.insert(VALUE(pr));parents.insert(VALUE(pr));
                        if(noloop)pr->insert(this, 0, 0, 0);}
                return *this;
        }
        void dump(MYTREE *caller=0, std::string lv="") {
                typename ELEMENT::iterator it;
                MYTREE *tr = this;

                //dump all brosis
                it = this->brosis.begin();
                while(it != this->brosis.end()) {
                        tr = &GETTREE(it);
                        assert(tr);
                        if(tr != caller && tr != this)  {
                                tr->dump(this, lv);
                                //OUTPUT(lv << "|" << tr->Name() << ": " <<
tr->Value() );                              
                        }
                        ++it;
                }

                OUTPUT(lv<< " " << this->Name() << ": " << this->Value() );     

                //dump all child
                it = this->child.begin();
                while(it != this->child.end()) {
                        tr = &GETTREE(it);
                        assert(tr);
                        if(tr != caller && tr != this) {
                                //OUTPUT(lv << "\t\\" << tr->Name() << ": " <<
tr->Value() );                                           
                                tr->dump(tr, lv+"\t");
                        }
                        ++it;
                }
        }
        static void dumpall() {
                ELEITER it = all.begin();
                while(it!= all.end()) {
                        OUTPUT(it->first <<" " << it->second );
                        ++it;
                }
        }
        /*static ELEMENT& getall() { return all;}*/
        private:
                MYTREE& myfind(ELEMENT& el, const char* str)
                {
                        typename ELEMENT::iterator it = el.find(NAME(str));
                        if ( it != el.end() ) return GETTREE(it);
                        return *this;                   
                }
                NAME name;
                ELEMENT child;
                ELEMENT brosis;
                ELEMENT parents;
                static ELEMENT all;
                static int counter;
                C value;
};

template<int> int mytree<int>::counter = 0;
/*
template<typename C> 
std::map<const std::string, mytree<C>* > mytree<C>::all = std::map<const
std::string, mytree<C>* >();// This line OK!!
*/
// This line will failed!
template<int > 
std::map<const std::string, mytree<int>* > mytree<int>::all = std::map<const
std::string, mytree<int>* >();

int main()
{
        mytree<int> my1("temp01", 1);
        mytree<int> my2("root", 2, new
          mytree<int>("hello", 3, new
            mytree<int>("world", 4)));

        my2.insert(0, new mytree<int>("my3", 5), new mytree<int>("my4", 6));
        std::cout << my2/"hello"/"world" << std::endl;
        std::cout << (my2/"hello"/"world"^"hello") <<std::endl;
        std::cout << (my2|"my3"|"root") << std::endl;
        std::cout <<(my2^"my4")/"root" << std::endl;
        (my2/"hello").insert(0, new mytree<int>("my5", 10),0);

        OUTPUT((my2/"hello"^"root")/"hello");

        mytree<int>::dumpall();
        my2.dump(/*&my2*/);

        return 0;
}


-- 
           Summary: Template Specialization break down
           Product: gcc
           Version: 3.4.4
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: ypwangandy at gmail dot com
 GCC build triplet: i686-pc-cygwin
  GCC host triplet: i686-pc-cygwin
GCC target triplet: i686-pc-cygwin


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=29766