Release-1.4.7-20060910

INSTALL

-DOXYGEN Version 1.4.7-20060810
+DOXYGEN Version 1.4.7-20060910
 
 Please read the installation section of the manual 
 (http://www.doxygen.org/install.html) for instructions.
 
 --------
-Dimitri van Heesch (10 August 2006)
+Dimitri van Heesch (10 September 2006)

README

-DOXYGEN Version 1.4.7_20060810
+DOXYGEN Version 1.4.7_20060910
 
 Please read INSTALL for compilation instructions.
 
@@ -17,4 +17,4 @@ to subscribe to the lists or to visit the archives.
 
 Enjoy,
 
-Dimitri van Heesch (dimitri@stack.nl) (10 August 2006)
+Dimitri van Heesch (dimitri@stack.nl) (10 September 2006)

addon/doxyapp/doxyapp.cpp

@@ -26,6 +26,7 @@
  */
 
 #include </usr/include/unistd.h> // ugly hack to get the right unistd.h (doxygen has one too)
+#include <stdlib.h>
 #include "doxygen.h"
 #include "outputgen.h"
 #include "parserintf.h"
@@ -274,7 +275,7 @@ int main(int argc,char **argv)
   parseInput();
 
   // iterate over the input files
-  FileNameListIterator fnli(Doxygen::inputNameList); 
+  FileNameListIterator fnli(*Doxygen::inputNameList); 
   FileName *fn;
   // foreach file with a certain name
   for (fnli.toFirst();(fn=fnli.current());++fnli)
@@ -289,6 +290,8 @@ int main(int argc,char **argv)
     }
   }
 
+  // remove temporary files
+  unlink("/tmp/doxygen/doxygen_objdb.tmp");
   // clean up after us
   rmdir("/tmp/doxygen");
 

configure

@@ -20,7 +20,7 @@ doxygen_version_minor=4
 doxygen_version_revision=7
 
 #NOTE: Setting version_mmn to "NO" will omit mmn info from the package.
-doxygen_version_mmn=20060810
+doxygen_version_mmn=20060910
 
 bin_dirs=`echo $PATH | sed -e "s/:/ /g"`
 

qtools/Doxyfile

@@ -829,7 +829,7 @@ MAN_LINKS              = NO
 # generate an XML file that captures the structure of 
 # the code including all documentation.
 
-GENERATE_XML           = YES
+GENERATE_XML           = NO
 
 # The XML_OUTPUT tag is used to specify where the XML pages will be put. 
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be 

qtools/qcstring.h

@@ -43,14 +43,14 @@
 #include "qarray.h"
 #endif // QT_H
 
+#include <stdlib.h>
 #include <string.h>
 
 #if defined(_OS_SUN_) && defined(_CC_GNU_)
 #include <strings.h>
 #endif
 
-//#undef SMALLSTRING
-#define SMALLSTRING
+class QGString;
 
 /*****************************************************************************
   Fixes and workarounds for some platforms
@@ -143,7 +143,6 @@ Q_EXPORT int qstrnicmp( const char *, const char *, uint len );
 
 #endif
 
-
 // qChecksum: Internet checksum
 
 Q_EXPORT Q_UINT16 qChecksum( const char *s, uint len );
@@ -166,34 +165,35 @@ Q_EXPORT QDataStream &operator<<( QDataStream &, const QByteArray & );
 Q_EXPORT QDataStream &operator>>( QDataStream &, QByteArray & );
 #endif
 
-
-
-#ifdef SMALLSTRING
-#define SCString QCString
-#include "scstring.h"
-#else
-
-/*****************************************************************************
-  QCString class
- *****************************************************************************/
-
 class QRegExp;
 
-class Q_EXPORT QCString : public QByteArray	// C string class
+/** This is an alternative implementation of QCString. It provides basically
+ *  the same functions but uses less memory for administration. This class
+ *  is just a wrapper around a plain C string requiring only 4 bytes "overhead".
+ *  QCString features sharing of data and stores the string length, but 
+ *  requires 4 + 12 bytes for this (even for the empty string). As doxygen 
+ *  uses a LOT of string during a run it saves a lot of memory to use a 
+ *  more memory efficient implementation at the cost of relatively low
+ *  runtime overhead.
+ */
+class QCString 
 {
 public:
-    QCString() {}				// make null string
-    QCString( int size );			// allocate size incl. \0
-    QCString( const QCString &s ) : QByteArray( s ) {}
-    QCString( const char *str );		// deep copy
-    QCString( const char *str, uint maxlen );	// deep copy, max length
-
-    QCString    &operator=( const QCString &s );// shallow copy
+    QCString() : m_data(0) {}		// make null string
+    QCString( const QCString &s );
+    QCString( int size );
+    QCString( const char *str );
+    QCString( const char *str, uint maxlen );
+    ~QCString();
+
+    QCString    &operator=( const QCString &s );// deep copy
     QCString    &operator=( const char *str );	// deep copy
 
     bool        isNull()        const;
     bool	isEmpty()	const;
     uint	length()	const;
+    uint        size()          const { return m_data ? length()+1 : 0; }
+    char *      data()          const { return m_data; }
     bool	resize( uint newlen );
     bool	truncate( uint pos );
     bool	fill( char c, int len = -1 );
@@ -211,24 +211,23 @@ public:
     int		contains( char c, bool cs=TRUE ) const;
     int		contains( const char *str, bool cs=TRUE ) const;
     int		contains( const QRegExp & ) const;
+    bool        stripPrefix(const char *prefix);
 
     QCString	left( uint len )  const;
     QCString	right( uint len ) const;
     QCString	mid( uint index, uint len=0xffffffff) const;
 
-    QCString	leftJustify( uint width, char fill=' ', bool trunc=FALSE)const;
-    QCString	rightJustify( uint width, char fill=' ',bool trunc=FALSE)const;
-
     QCString	lower() const;
     QCString	upper() const;
 
     QCString	stripWhiteSpace()	const;
     QCString	simplifyWhiteSpace()	const;
 
+    QCString    &assign( const char *str );
     QCString    &insert( uint index, const char * );
     QCString    &insert( uint index, char );
-    QCString    &append( const char * );
-    QCString    &prepend( const char * );
+    QCString    &append( const char *s );
+    QCString    &prepend( const char *s );
     QCString    &remove( uint index, uint len );
     QCString    &replace( uint index, uint len, const char * );
     QCString    &replace( const QRegExp &, const char * );
@@ -239,10 +238,7 @@ public:
     uint	toUInt( bool *ok=0 )	const;
     long	toLong( bool *ok=0 )	const;
     ulong	toULong( bool *ok=0 )	const;
-    float	toFloat( bool *ok=0 )	const;
-    double	toDouble( bool *ok=0 )	const;
 
-    QCString    &setStr( const char *s );
     QCString    &setNum( short );
     QCString    &setNum( ushort );
     QCString    &setNum( int );
@@ -252,14 +248,56 @@ public:
     QCString    &setNum( float, char f='g', int prec=6 );
     QCString    &setNum( double, char f='g', int prec=6 );
 
-    bool	setExpand( uint index, char c );
-
 		operator const char *() const;
     QCString    &operator+=( const char *str );
     QCString    &operator+=( char c );
+    char &at( uint index ) const;
+    char &operator[]( int i ) const { return at(i); }
+    
+  private:
+    static void msg_index( uint );
+    void duplicate( const QCString &s );
+    void duplicate( const char *str);
+    QCString &duplicate( const char *str, int);
+
+    char *      m_data;
 };
 
-#endif
+inline char &QCString::at( uint index ) const
+{
+  return m_data[index];
+}
+
+inline void QCString::duplicate( const QCString &s )
+{
+  if (!s.isEmpty()) 
+  {
+    uint l = strlen(s.data());
+    m_data = (char *)malloc(l+1);
+    if (m_data) memcpy(m_data,s.data(),l+1);
+  }
+  else 
+    m_data=0; 
+}
+
+inline void QCString::duplicate( const char *str)
+{
+  if (str && str[0]!='\0') 
+  {
+    uint l = strlen(str);
+    m_data = (char *)malloc(l+1);
+    if (m_data) memcpy(m_data,str,l+1);
+  }
+  else 
+    m_data=0;
+}
+
+inline QCString &QCString::duplicate( const char *str, int)
+{
+  if (m_data) free(m_data);
+  duplicate(str);
+  return *this;
+}
 
 /*****************************************************************************
   QCString stream functions
@@ -370,21 +408,26 @@ Q_EXPORT inline bool operator>=( const char *s1, const QCString &s2 )
 
 Q_EXPORT inline QCString operator+( const QCString &s1, const QCString &s2 )
 {
-    QCString tmp( s1.data() );
+    QCString tmp(s1);
     tmp += s2;
     return tmp;
 }
 
+
+inline QCString operator+( const QCString &s1, const QGString &s2 );
+inline QCString operator+( const QGString &s1, const QCString &s2 );
+
+
 Q_EXPORT inline QCString operator+( const QCString &s1, const char *s2 )
 {
-    QCString tmp( s1.data() );
+    QCString tmp(s1);
     tmp += s2;
     return tmp;
 }
 
 Q_EXPORT inline QCString operator+( const char *s1, const QCString &s2 )
 {
-    QCString tmp( s1 );
+    QCString tmp(s1);
     tmp += s2;
     return tmp;
 }
@@ -404,4 +447,5 @@ Q_EXPORT inline QCString operator+( char c1, const QCString &s2 )
     return tmp;
 }
 
+
 #endif // QCSTRING_H

qtools/qfile.h

@@ -52,7 +52,7 @@ class Q_EXPORT QFile : public QIODevice			// file I/O device class
 public:
     QFile();
     QFile( const QString &name );
-   ~QFile();
+    virtual ~QFile();
 
     QString	name()	const;
     void	setName( const QString &name );
@@ -95,6 +95,7 @@ public:
     int		handle() const;
 
     int64       pos() const;
+    int64       toEnd();
     bool        seek(int64 pos);
 
 protected:

qtools/qfile_unix.cpp

@@ -643,6 +643,19 @@ int64 QFile::pos() const
   return -1;
 }
 
+int64 QFile::toEnd() 
+{
+  if (isOpen())
+  {
+     // TODO: support 64 bit size
+     if (fseek( fh, 0, SEEK_END )!=-1)
+     {
+       return ftell( fh );
+     }
+  }
+  return -1;
+}
+
 bool QFile::seek( int64 pos )
 {
   if (isOpen())

qtools/qfile_win32.cpp

@@ -602,6 +602,19 @@ int64 QFile::pos() const
   return -1;
 }
 
+int64 QFile::toEnd() 
+{
+  if (isOpen())
+  {
+     // TODO: support 64 bit size
+     if (fseek( fh, 0, SEEK_END )!=-1)
+     {
+       return ftell( fh );
+     }
+  }
+  return -1;
+}
+
 bool QFile::seek( int64 pos )
 {
   if (isOpen())

qtools/qgstring.cpp

+/******************************************************************************
+ *
+ * Copyright (C) 1997-2004 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby 
+ * granted. No representations are made about the suitability of this software 
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * Documents produced by Doxygen are derivative works derived from the
+ * input used in their production; they are not affected by this license.
+ *
+ */
+
+#include "qgstring.h"
+
+#include <assert.h>
+
+#define BLOCK_SIZE 64
+#define ROUND_SIZE(x) ((x)+BLOCK_SIZE-1)&~(BLOCK_SIZE-1)
+
+QGString::QGString() // make null string
+  : m_data(0), m_len(0), m_memSize(0) 
+{
+} 
+
+QGString::QGString(uint size)
+{
+  m_memSize = ROUND_SIZE(size);
+  if (m_memSize==0)
+  {
+    m_data=0;
+    m_len=0;
+  }
+  else
+  {
+    m_data = (char*)malloc(m_memSize);
+    m_data[0]='\0';
+    m_len=0;
+  }
+}
+
+QGString::QGString( const QGString &s ) 
+{ 
+  if (s.m_memSize==0)
+  {
+    m_data    = 0;
+    m_len     = 0;
+    m_memSize = 0;
+  }
+  else
+  {
+    m_data    = (char *)malloc(s.m_memSize); 
+    m_len     = s.m_len;
+    m_memSize = s.m_memSize;
+    qstrcpy(m_data,s.m_data);
+  }
+} 
+
+QGString::QGString( const char *str )
+{
+  if (str==0)
+  {
+    m_data=0;
+    m_len=0;
+    m_memSize=0;
+  }
+  else
+  {
+    m_len = qstrlen(str);
+    m_memSize = ROUND_SIZE(m_len+1);
+    assert(m_memSize>=m_len+1);
+    m_data = (char *)malloc(m_memSize);
+    qstrcpy(m_data,str);
+  }
+}
+
+QGString::~QGString() 
+{ 
+  free(m_data); 
+  m_data=0; 
+}
+
+bool QGString::resize( uint newlen )
+{
+  m_len = 0;
+  if (newlen==0)
+  {
+    if (m_data) { free(m_data); m_data=0; }
+    m_memSize=0;
+    return TRUE;
+  }
+  m_memSize = ROUND_SIZE(newlen+1);
+  assert(m_memSize>=newlen+1);
+  if (m_data==0)
+  {
+    m_data = (char *)malloc(m_memSize);
+  }
+  else
+  {
+    m_data = (char *)realloc(m_data,m_memSize);
+  }
+  if (m_data==0) return FALSE;
+  m_data[newlen-1]='\0';
+  m_len = qstrlen(m_data);
+  return TRUE;
+}
+
+QGString &QGString::operator=( const QGString &s ) 
+{
+  if (m_data) free(m_data);
+  if (s.m_memSize==0) // null string
+  {
+    m_data    = 0;
+    m_len     = 0;
+    m_memSize = 0;
+  }
+  else
+  {
+    m_len     = s.m_len;
+    m_memSize = s.m_memSize;
+    m_data    = (char*)malloc(m_memSize);
+    qstrcpy(m_data,s.m_data);
+  }
+  return *this;
+}
+
+QGString &QGString::operator=( const char *str ) 
+{ 
+  if (m_data) free(m_data);
+  if (str==0) // null string
+  {
+    m_data    = 0;
+    m_len     = 0;
+    m_memSize = 0;
+  }
+  else
+  {
+    m_len     = qstrlen(str);
+    m_memSize = ROUND_SIZE(m_len+1);
+    assert(m_memSize>=m_len+1);
+    m_data    = (char*)malloc(m_memSize);
+    qstrcpy(m_data,str);
+  }
+  return *this;
+}
+
+QGString &QGString::operator+=( const QGString &s )
+{
+  if (s.m_memSize==0) return *this;
+  uint len1 = length();
+  uint len2 = s.length();
+  uint memSize = ROUND_SIZE(len1 + len2 + 1);
+  assert(memSize>=len1+len2+1);
+  char *newData = memSize!=m_memSize ? (char*)realloc( m_data, memSize ) : m_data;
+  m_memSize = memSize;
+  if (m_data)
+  {
+    m_data = newData;
+    memcpy( m_data + len1, s, len2 + 1 );
+  }
+  return *this;
+}
+
+QGString &QGString::operator+=( const char *str )
+{
+  if (!str) return *this;
+  uint len1 = length();
+  uint len2 = qstrlen(str);
+  uint memSize = ROUND_SIZE(len1 + len2 + 1);
+  assert(memSize>=len1+len2+1);
+  char *newData = memSize!=m_memSize ? (char *)realloc( m_data, memSize ) : m_data;
+  m_memSize = memSize;
+  if (newData)
+  {
+    m_data = newData;
+    memcpy( m_data + len1, str, len2 + 1 );
+  }
+  m_len+=len2;
+  return *this;
+}
+
+QGString &QGString::operator+=( char c )
+{
+  uint len = m_len;
+  uint memSize = ROUND_SIZE(len+2);
+  assert(memSize>=len+2);
+  char *newData = memSize!=m_memSize ? (char *)realloc( m_data, memSize ) : m_data;
+  m_memSize = memSize;
+  if (newData)
+  {
+    m_data = newData;
+    m_data[len] = c;
+    m_data[len+1] = '\0';
+  }
+  m_len++;
+  return *this;
+}
+

qtools/qgstring.h

+#ifndef QGSTRING_H
+#define QGSTRING_H
+
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(_OS_SUN_) && defined(_CC_GNU_)
+#include <strings.h>
+#endif
+
+#include "qcstring.h"
+
+/*****************************************************************************
+  Fixes and workarounds for some platforms
+ *****************************************************************************/
+
+/** This is an alternative implementation of QCString. 
+ */
+class QGString 
+{
+  public:
+    QGString(); // make null string
+    QGString(uint size); 
+    QGString( const QGString &s );
+    QGString( const char *str );
+   ~QGString() ;
+
+    bool resize( uint newlen );
+
+    QGString    &operator=( const QGString &s );
+    QGString    &operator=( const char *str );
+    QGString    &operator+=( const QGString &s );
+    QGString    &operator+=( const char *str );
+    QGString    &operator+=( char c );
+
+    bool        isNull()        const { return m_data==0; }
+    bool	isEmpty()	const { return m_len==0; }
+    uint	length()	const { return m_len; }
+    uint        size()          const { return m_memSize; }
+    char *      data()          const { return m_data; }
+    bool	truncate( uint pos )  { return resize(pos+1); }
+        operator const char *() const { return (const char *)data(); }
+    char &at( uint index ) const      { return m_data[index]; }
+    char &operator[]( int i ) const   { return at(i); }
+    
+  private:
+    char *      m_data;
+    uint        m_len;
+    uint        m_memSize;
+};
+
+/*****************************************************************************
+  QGString non-member operators
+ *****************************************************************************/
+
+Q_EXPORT inline bool operator==( const QGString &s1, const QGString &s2 )
+{ return qstrcmp(s1.data(),s2.data()) == 0; }
+
+Q_EXPORT inline bool operator==( const QGString &s1, const char *s2 )
+{ return qstrcmp(s1.data(),s2) == 0; }
+
+Q_EXPORT inline bool operator==( const char *s1, const QGString &s2 )
+{ return qstrcmp(s1,s2.data()) == 0; }
+
+Q_EXPORT inline bool operator!=( const QGString &s1, const QGString &s2 )
+{ return qstrcmp(s1.data(),s2.data()) != 0; }
+
+Q_EXPORT inline bool operator!=( const QGString &s1, const char *s2 )
+{ return qstrcmp(s1.data(),s2) != 0; }
+
+Q_EXPORT inline bool operator!=( const char *s1, const QGString &s2 )
+{ return qstrcmp(s1,s2.data()) != 0; }
+
+Q_EXPORT inline bool operator<( const QGString &s1, const QGString& s2 )
+{ return qstrcmp(s1.data(),s2.data()) < 0; }
+
+Q_EXPORT inline bool operator<( const QGString &s1, const char *s2 )
+{ return qstrcmp(s1.data(),s2) < 0; }
+
+Q_EXPORT inline bool operator<( const char *s1, const QGString &s2 )
+{ return qstrcmp(s1,s2.data()) < 0; }
+
+Q_EXPORT inline bool operator<=( const QGString &s1, const char *s2 )
+{ return qstrcmp(s1.data(),s2) <= 0; }
+
+Q_EXPORT inline bool operator<=( const char *s1, const QGString &s2 )
+{ return qstrcmp(s1,s2.data()) <= 0; }
+
+Q_EXPORT inline bool operator>( const QGString &s1, const char *s2 )
+{ return qstrcmp(s1.data(),s2) > 0; }
+
+Q_EXPORT inline bool operator>( const char *s1, const QGString &s2 )
+{ return qstrcmp(s1,s2.data()) > 0; }
+
+Q_EXPORT inline bool operator>=( const QGString &s1, const char *s2 )
+{ return qstrcmp(s1.data(),s2) >= 0; }
+
+Q_EXPORT inline bool operator>=( const char *s1, const QGString &s2 )
+{ return qstrcmp(s1,s2.data()) >= 0; }
+
+Q_EXPORT inline QGString operator+( const QGString &s1, const QGString &s2 )
+{
+    QGString tmp( s1.data() );
+    tmp += s2;
+    return tmp;
+}
+
+Q_EXPORT inline QGString operator+( const QGString &s1, const char *s2 )
+{
+    QGString tmp( s1.data() );
+    tmp += s2;
+    return tmp;
+}
+
+Q_EXPORT inline QGString operator+( const char *s1, const QGString &s2 )
+{
+    QGString tmp( s1 );
+    tmp += s2;
+    return tmp;
+}
+
+Q_EXPORT inline QGString operator+( const QGString &s1, char c2 )
+{
+    QGString tmp( s1.data() );
+    tmp += c2;
+    return tmp;
+}
+
+Q_EXPORT inline QGString operator+( char c1, const QGString &s2 )
+{
+    QGString tmp;
+    tmp += c1;
+    tmp += s2;
+    return tmp;
+}
+
+#endif // QGSTRING_H

qtools/qtools.pro.in

@@ -22,6 +22,7 @@ HEADERS		= qarray.h \
 		  qgeneric.h \
 		  qglist.h \
 		  qglobal.h \
+		  qgstring.h \
 		  qgvector.h \
 		  qintdict.h \
 		  qiodevice.h \
@@ -57,6 +58,7 @@ SOURCES		= qbuffer.cpp \
 		  qgdict.cpp \
 		  qglist.cpp \
 		  qglobal.cpp \
+		  qgstring.cpp \
 		  qgvector.cpp \
 		  qiodevice.cpp \
 		  qregexp.cpp \

src/defgen.cpp

@@ -137,7 +137,7 @@ void generateDEFForMember(MemberDef *md,
   if (isFunc) //function
   {
     ArgumentList *declAl = new ArgumentList;
-    ArgumentList *defAl = md->argumentList();
+    LockingPtr<ArgumentList> defAl = md->argumentList();
     stringToArgumentList(md->argsString(),declAl);
     QCString fcnPrefix = "  " + memPrefix + "param-";
 
@@ -213,9 +213,10 @@ void generateDEFForMember(MemberDef *md,
   // TODO: exceptions, const volatile
   if (md->memberType()==MemberDef::Enumeration) // enum
   {
-    if (md->enumFieldList())
+    LockingPtr<MemberList> enumList = md->enumFieldList();
+    if (enumList!=0)
     {
-      MemberListIterator emli(*md->enumFieldList());
+      MemberListIterator emli(*enumList);
       MemberDef *emd;
       for (emli.toFirst();(emd=emli.current());++emli)
       {
@@ -239,9 +240,11 @@ void generateDEFForMember(MemberDef *md,
     << md->documentation() << endl << "_EnD_oF_dEf_TeXt_;" << endl;
 
   //printf("md->getReferencesMembers()=%p\n",md->getReferencesMembers());
-  if (md->getReferencesMembers())
+
+  LockingPtr<MemberSDict> mdict = md->getReferencesMembers();
+  if (!mdict.isNull())
   {
-    MemberSDict::Iterator mdi(*md->getReferencesMembers());
+    MemberSDict::Iterator mdi(*mdict);
     MemberDef *rmd;
     QCString refPrefix = "  " + memPrefix + "ref-";
 
@@ -271,9 +274,10 @@ void generateDEFForMember(MemberDef *md,
       }
     } /* for (mdi.toFirst...) */
   }
-  if (md->getReferencedByMembers())
+  mdict = md->getReferencedByMembers();
+  if (!mdict.isNull())
   {
-    MemberSDict::Iterator mdi(*md->getReferencedByMembers());
+    MemberSDict::Iterator mdi(*mdict);
     MemberDef *rmd;
     QCString refPrefix = "  " + memPrefix + "ref-";
 
@@ -602,15 +606,15 @@ void generateDEF()
   QTextStream t(&f);
   t << "AutoGen Definitions dummy;" << endl;
 
-  if (Doxygen::classSDict.count()+Doxygen::inputNameList.count()>0)
+  if (Doxygen::classSDict->count()+Doxygen::inputNameList->count()>0)
   {
-    ClassSDict::Iterator cli(Doxygen::classSDict);
+    ClassSDict::Iterator cli(*Doxygen::classSDict);
     ClassDef *cd;
     for (cli.toFirst();(cd=cli.current());++cli)
     {
       generateDEFForClass(cd,t);
     }
-    FileNameListIterator fnli(Doxygen::inputNameList);
+    FileNameListIterator fnli(*Doxygen::inputNameList);
     FileName *fn;
     for (;(fn=fnli.current());++fnli)
     {

src/diagram.cpp

@@ -928,7 +928,7 @@ void TreeDiagram::drawConnectors(QTextStream &t,Image *image,
 
 void clearVisitFlags()
 {
-  ClassSDict::Iterator cli(Doxygen::classSDict);
+  ClassSDict::Iterator cli(*Doxygen::classSDict);
   ClassDef *cd;
   for (;(cd=cli.current());++cli)
   {

src/dirdef.cpp

@@ -507,13 +507,13 @@ FilePair *UsedDir::findFilePair(const char *name)
 DirDef *DirDef::createNewDir(const char *path)
 {
   ASSERT(path!=0);
-  DirDef *dir = Doxygen::directories.find(path);
+  DirDef *dir = Doxygen::directories->find(path);
   if (dir==0) // new dir
   {
     //printf("Adding new dir %s\n",path);
     dir = new DirDef(path);
     //printf("createNewDir %s short=%s\n",path,dir->shortName().data());
-    Doxygen::directories.inSort(path,dir);
+    Doxygen::directories->inSort(path,dir);
   }
   return dir;
 }
@@ -781,7 +781,7 @@ void DirRelation::writeDocumentation(OutputList &ol)
 void buildDirectories()
 {
   // for each input file
-  FileNameListIterator fnli(Doxygen::inputNameList); 
+  FileNameListIterator fnli(*Doxygen::inputNameList); 
   FileName *fn;
   for (fnli.toFirst();(fn=fnli.current());++fnli)
   {
@@ -793,7 +793,7 @@ void buildDirectories()
       if (fd->getReference().isEmpty() && !fd->isDocumentationFile())
       {
         DirDef *dir;
-        if ((dir=Doxygen::directories.find(fd->getPath()))==0) // new directory
+        if ((dir=Doxygen::directories->find(fd->getPath()))==0) // new directory
         {
           dir = DirDef::mergeDirectoryInTree(fd->getPath());
         }
@@ -809,7 +809,7 @@ void buildDirectories()
   //DirDef *root = new DirDef("root:");
   // compute relations between directories => introduce container dirs.
   DirDef *dir;
-  DirSDict::Iterator sdi(Doxygen::directories);
+  DirSDict::Iterator sdi(*Doxygen::directories);
   for (sdi.toFirst();(dir=sdi.current());++sdi)
   {
     //printf("New dir %s\n",dir->displayName().data());
@@ -817,7 +817,7 @@ void buildDirectories()
     int i=name.findRev('/',name.length()-2);
     if (i>0)
     {
-      DirDef *parent = Doxygen::directories.find(name.left(i+1));
+      DirDef *parent = Doxygen::directories->find(name.left(i+1));
       //if (parent==0) parent=root;
       if (parent) 
       {
@@ -832,7 +832,7 @@ void buildDirectories()
 void computeDirDependencies()
 {
   DirDef *dir;
-  DirSDict::Iterator sdi(Doxygen::directories);
+  DirSDict::Iterator sdi(*Doxygen::directories);
   // compute nesting level for each directory
   for (sdi.toFirst();(dir=sdi.current());++sdi)
   {
@@ -877,7 +877,7 @@ void writeDirDependencyGraph(const char *dirName)
 {
   QString path;
   DirDef *dir;
-  DirSDict::Iterator sdi(Doxygen::directories);
+  DirSDict::Iterator sdi(*Doxygen::directories);
   QFile htmlPage(QCString(dirName)+"/dirdeps.html");
   if (htmlPage.open(IO_WriteOnly))
   {
@@ -921,7 +921,7 @@ void writeDirDependencyGraph(const char *dirName)
 void generateDirDocs(OutputList &ol)
 {
   DirDef *dir;
-  DirSDict::Iterator sdi(Doxygen::directories);
+  DirSDict::Iterator sdi(*Doxygen::directories);
   for (sdi.toFirst();(dir=sdi.current());++sdi)
   {
     dir->writeDocumentation(ol);