diff -r 000000000000 -r 42188c7ea2d9 Orb/Doxygen/src/namespacedef.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Orb/Doxygen/src/namespacedef.cpp	Thu Jan 21 17:29:01 2010 +0000
@@ -0,0 +1,909 @@
+/******************************************************************************
+ *
+ * 
+ *
+ * Copyright (C) 1997-2008 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 "qtbc.h"
+#include "namespacedef.h"
+#include "outputlist.h"
+#include "util.h"
+#include "language.h"
+#include "classdef.h"
+#include "classlist.h"
+#include "memberlist.h"
+#include "doxygen.h"
+#include "message.h"
+#include "docparser.h"
+#include "searchindex.h"
+#include "vhdldocgen.h"
+#include "layout.h"
+
+//------------------------------------------------------------------
+
+NamespaceDef::NamespaceDef(const char *df,int dl,
+                           const char *name,const char *lref,
+                           const char *fName) : 
+   Definition(df,dl,name)
+{
+  if (fName)
+  {
+    fileName = stripExtension(fName);
+  }
+  else
+  {
+    fileName="namespace";
+    fileName+=name;
+  }
+  classSDict = new ClassSDict(17);
+  namespaceSDict = new NamespaceSDict(17);
+  m_innerCompounds = new SDict<Definition>(17);
+  usingDirList = 0;
+  usingDeclList = 0;
+  m_allMembersDict = 0;
+  setReference(lref);
+  memberGroupSDict = new MemberGroupSDict;
+  memberGroupSDict->setAutoDelete(TRUE);
+  visited=FALSE;
+  m_subGrouping=Config_getBool("SUBGROUPING");
+}
+
+NamespaceDef::~NamespaceDef()
+{
+  delete classSDict;
+  delete namespaceSDict;
+  delete m_innerCompounds;
+  delete usingDirList;
+  delete usingDeclList;
+  delete memberGroupSDict;
+}
+
+void NamespaceDef::distributeMemberGroupDocumentation()
+{
+  MemberGroupSDict::Iterator mgli(*memberGroupSDict);
+  MemberGroup *mg;
+  for (;(mg=mgli.current());++mgli)
+  {
+    mg->distributeMemberGroupDocumentation();
+  }
+}
+
+void NamespaceDef::findSectionsInDocumentation()
+{
+  docFindSections(documentation(),this,0,docFile());
+  MemberGroupSDict::Iterator mgli(*memberGroupSDict);
+  MemberGroup *mg;
+  for (;(mg=mgli.current());++mgli)
+  {
+    mg->findSectionsInDocumentation();
+  }
+  QListIterator<MemberList> mli(m_memberLists);
+  MemberList *ml;
+  for (mli.toFirst();(ml=mli.current());++mli)
+  {
+    if (ml->listType()&MemberList::declarationLists)
+    {
+      ml->findSectionsInDocumentation();
+    }
+  }
+}
+
+void NamespaceDef::insertUsedFile(const char *f)
+{
+  if (files.find(f)==-1) 
+  {
+    if (Config_getBool("SORT_MEMBER_DOCS"))
+      files.inSort(f);
+    else
+      files.append(f);
+  }
+}
+
+void NamespaceDef::addInnerCompound(Definition *d)
+{
+  m_innerCompounds->append(d->localName(),d);
+  if (d->definitionType()==Definition::TypeNamespace)
+  {
+    insertNamespace((NamespaceDef *)d);
+  }
+  else if (d->definitionType()==Definition::TypeClass)
+  {
+    insertClass((ClassDef *)d);
+  }
+}
+
+void NamespaceDef::insertClass(ClassDef *cd)
+{
+  if (classSDict->find(cd->name())==0)
+  {
+    if (Config_getBool("SORT_BRIEF_DOCS"))
+      classSDict->inSort(cd->name(),cd);
+    else
+      classSDict->append(cd->name(),cd);
+  }
+}
+
+void NamespaceDef::insertNamespace(NamespaceDef *nd)
+{
+  if (namespaceSDict->find(nd->name())==0)
+  {
+    if (Config_getBool("SORT_MEMBER_DOCS"))
+      namespaceSDict->inSort(nd->name(),nd);
+    else
+      namespaceSDict->append(nd->name(),nd);
+  }
+}
+
+
+void NamespaceDef::addMembersToMemberGroup()
+{
+  QListIterator<MemberList> mli(m_memberLists);
+  MemberList *ml;
+  for (mli.toFirst();(ml=mli.current());++mli)
+  {
+    if (ml->listType()&MemberList::declarationLists)
+    {
+      ::addMembersToMemberGroup(ml,&memberGroupSDict,this);
+    }
+  }
+
+  // add members inside sections to their groups
+  if (memberGroupSDict)
+  {
+    MemberGroupSDict::Iterator mgli(*memberGroupSDict);
+    MemberGroup *mg;
+    for (;(mg=mgli.current());++mgli)
+    {
+      if (mg->allMembersInSameSection() && m_subGrouping)
+      {
+        //printf("----> addToDeclarationSection(%s)\n",mg->header().data());
+        mg->addToDeclarationSection();
+      }
+    }
+  }
+}
+
+void NamespaceDef::insertMember(MemberDef *md)
+{
+  if (md->isHidden()) return;
+  MemberList *allMemberList = getMemberList(MemberList::allMembersList);
+  if (allMemberList==0)
+  {
+    allMemberList = new MemberList(MemberList::allMembersList);
+    m_memberLists.append(allMemberList);
+  }
+  allMemberList->append(md); 
+  if (m_allMembersDict==0)
+  {
+    m_allMembersDict = new MemberSDict;
+  }
+  //printf("%s::m_allMembersDict->append(%s)\n",name().data(),md->localName().data());
+  m_allMembersDict->append(md->localName(),md); 
+  //::addNamespaceMemberNameToIndex(md);
+  //static bool sortBriefDocs=Config_getBool("SORT_BRIEF_DOCS");
+  switch(md->memberType())
+  {
+    case MemberDef::Variable:     
+      addMemberToList(MemberList::decVarMembers,md);
+      addMemberToList(MemberList::docVarMembers,md);
+      break;
+    case MemberDef::Function: 
+      addMemberToList(MemberList::decFuncMembers,md);
+      addMemberToList(MemberList::docFuncMembers,md);
+      break;
+    case MemberDef::Typedef:      
+      addMemberToList(MemberList::decTypedefMembers,md);
+      addMemberToList(MemberList::docTypedefMembers,md);
+      break;
+    case MemberDef::Enumeration:  
+      addMemberToList(MemberList::decEnumMembers,md);
+      addMemberToList(MemberList::docEnumMembers,md);
+      break;
+    case MemberDef::EnumValue:    
+      break;
+    case MemberDef::Define:       
+      addMemberToList(MemberList::decDefineMembers,md);
+      addMemberToList(MemberList::docDefineMembers,md);
+      break;
+    default:
+      err("NamespaceDef::insertMembers(): "
+           "member `%s' with class scope `%s' inserted in namespace scope `%s'!\n",
+           md->name().data(),
+           md->getClassDef() ? md->getClassDef()->name().data() : "",
+           name().data());
+  }
+}
+
+void NamespaceDef::computeAnchors()
+{
+  MemberList *allMemberList = getMemberList(MemberList::allMembersList);
+  if (allMemberList) setAnchors(0,'a',allMemberList);
+}
+
+void NamespaceDef::writeDetailedDescription(OutputList &ol,const QCString &title)
+{
+  if ((!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF")) || 
+      !documentation().isEmpty()
+     )
+  {
+    ol.writeRuler();
+    ol.pushGeneratorState();
+    ol.disableAllBut(OutputGenerator::Html);
+      ol.writeAnchor(0,"_details"); 
+    ol.popGeneratorState();
+    ol.startGroupHeader();
+    ol.parseText(title);
+    ol.endGroupHeader();
+
+    ol.startTextBlock();
+    if (!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF"))
+    {
+      ol.parseDoc(briefFile(),briefLine(),this,0,briefDescription(),FALSE,FALSE);
+    }
+    if (!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF") &&
+        !documentation().isEmpty())
+    {
+      ol.pushGeneratorState();
+        ol.disable(OutputGenerator::Man);
+        ol.disable(OutputGenerator::RTF);
+        //ol.newParagraph(); // FIXME:PARA
+        ol.enableAll();
+        ol.disableAllBut(OutputGenerator::Man);
+        ol.writeString("\n\n");
+      ol.popGeneratorState();
+    }
+    if (!documentation().isEmpty())
+    {
+      ol.parseDoc(docFile(),docLine(),this,0,documentation()+"\n",TRUE,FALSE);
+    }
+    ol.endTextBlock();
+  }
+}
+
+void NamespaceDef::writeBriefDescription(OutputList &ol)
+{
+  if (!briefDescription().isEmpty()) 
+  {
+    ol.startParagraph();
+    ol.parseDoc(briefFile(),briefLine(),this,0,
+                briefDescription(),TRUE,FALSE,0,TRUE,FALSE);
+    ol.pushGeneratorState();
+    ol.disable(OutputGenerator::RTF);
+    ol.writeString(" \n");
+    ol.enable(OutputGenerator::RTF);
+
+    if (Config_getBool("REPEAT_BRIEF") ||
+        !documentation().isEmpty()
+       )
+    {
+      ol.disableAllBut(OutputGenerator::Html);
+      ol.startTextLink(0,"_details");
+      ol.parseText(theTranslator->trMore());
+      ol.endTextLink();
+    }
+    ol.popGeneratorState();
+    ol.endParagraph();
+
+    // FIXME:PARA
+    //ol.pushGeneratorState();
+    //ol.disable(OutputGenerator::RTF);
+    //ol.newParagraph();
+    //ol.popGeneratorState();
+  }
+  ol.writeSynopsis();
+}
+
+void NamespaceDef::startMemberDeclarations(OutputList &ol)
+{
+  ol.startMemberSections();
+}
+
+void NamespaceDef::endMemberDeclarations(OutputList &ol)
+{
+  ol.endMemberSections();
+}
+
+void NamespaceDef::startMemberDocumentation(OutputList &ol)
+{
+  if (Config_getBool("SEPARATE_MEMBER_PAGES"))
+  {
+    ol.disable(OutputGenerator::Html);
+    Doxygen::suppressDocWarnings = TRUE;
+  }
+}
+
+void NamespaceDef::endMemberDocumentation(OutputList &ol)
+{
+  if (Config_getBool("SEPARATE_MEMBER_PAGES"))
+  {
+    ol.enable(OutputGenerator::Html);
+    Doxygen::suppressDocWarnings = FALSE;
+  }
+}
+
+void NamespaceDef::writeClassDeclarations(OutputList &ol,const QCString &title)
+{
+  if (classSDict) classSDict->writeDeclaration(ol,0,title,TRUE);
+}
+
+void NamespaceDef::writeNamespaceDeclarations(OutputList &ol,const QCString &title)
+{
+  if (namespaceSDict) namespaceSDict->writeDeclaration(ol,title,TRUE);
+}
+
+void NamespaceDef::writeMemberGroups(OutputList &ol)
+{
+  /* write user defined member groups */
+  if (memberGroupSDict)
+  {
+    MemberGroupSDict::Iterator mgli(*memberGroupSDict);
+    MemberGroup *mg;
+    for (;(mg=mgli.current());++mgli)
+    {
+      if ((!mg->allMembersInSameSection() || !m_subGrouping) 
+          && mg->header()!="[NOHEADER]")
+      {
+        mg->writeDeclarations(ol,0,this,0,0);
+      }
+    }
+  }
+}
+  
+void NamespaceDef::writeAuthorSection(OutputList &ol)
+{
+  // write Author section (Man only)
+  ol.pushGeneratorState();
+  ol.disableAllBut(OutputGenerator::Man);
+  ol.startGroupHeader();
+  ol.parseText(theTranslator->trAuthor(TRUE,TRUE));
+  ol.endGroupHeader();
+  ol.parseText(theTranslator->trGeneratedAutomatically(Config_getString("PROJECT_NAME")));
+  ol.popGeneratorState();
+}
+
+void NamespaceDef::writeDocumentation(OutputList &ol)
+{
+  bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+
+  QCString pageTitle;
+  if (Config_getBool("OPTIMIZE_OUTPUT_JAVA"))
+  {
+    pageTitle = theTranslator->trPackage(displayName());
+  }
+  else if (fortranOpt)
+  {
+    pageTitle = theTranslator->trModuleReference(displayName());
+  }
+  else
+  {
+    pageTitle = theTranslator->trNamespaceReference(displayName());
+  }
+  startFile(ol,getOutputFileBase(),name(),pageTitle,HLI_NamespaceVisible,TRUE);
+  if (getOuterScope()!=Doxygen::globalScope)
+  {
+    writeNavigationPath(ol);
+  }
+  ol.endQuickIndices();
+  ol.startContents();
+  startTitle(ol,getOutputFileBase());
+  ol.parseText(pageTitle);
+  addGroupListToTitle(ol,this);
+  endTitle(ol,getOutputFileBase(),displayName());
+  
+  if (Doxygen::searchIndex)
+  {
+    Doxygen::searchIndex->setCurrentDoc(pageTitle,getOutputFileBase());
+    Doxygen::searchIndex->addWord(localName(),TRUE);
+  }
+
+  bool generateTagFile = !Config_getString("GENERATE_TAGFILE").isEmpty();
+  if (generateTagFile)
+  {
+    Doxygen::tagFile << "  <compound kind=\"namespace\">" << endl;
+    Doxygen::tagFile << "    <name>" << convertToXML(name()) << "</name>" << endl;
+    Doxygen::tagFile << "    <filename>" << convertToXML(getOutputFileBase()) << Doxygen::htmlFileExtension << "</filename>" << endl;
+  }
+
+  Doxygen::indexList.addIndexItem(this,0);
+
+  //---------------------------------------- start flexible part -------------------------------
+
+  QListIterator<LayoutDocEntry> eli(
+      LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace));
+  LayoutDocEntry *lde;
+  for (eli.toFirst();(lde=eli.current());++eli)
+  {
+    switch (lde->kind())
+    {
+      case LayoutDocEntry::BriefDesc: 
+        writeBriefDescription(ol);
+        break; 
+      case LayoutDocEntry::MemberDeclStart: 
+        startMemberDeclarations(ol);
+        break; 
+      case LayoutDocEntry::NamespaceClasses: 
+        {
+          LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
+          writeClassDeclarations(ol,ls->title);
+        }
+        break; 
+      case LayoutDocEntry::NamespaceNestedNamespaces: 
+        {
+          LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
+          writeNamespaceDeclarations(ol,ls->title);
+        }
+        break; 
+      case LayoutDocEntry::MemberGroups: 
+        writeMemberGroups(ol);
+        break; 
+      case LayoutDocEntry::MemberDecl: 
+        {
+          LayoutDocEntryMemberDecl *lmd = (LayoutDocEntryMemberDecl*)lde;
+          writeMemberDeclarations(ol,lmd->type,lmd->title);
+        }
+        break; 
+      case LayoutDocEntry::MemberDeclEnd: 
+        endMemberDeclarations(ol);
+        break;
+      case LayoutDocEntry::DetailedDesc: 
+        {
+          LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
+          writeDetailedDescription(ol,ls->title);
+        }
+        break;
+      case LayoutDocEntry::MemberDefStart: 
+        startMemberDocumentation(ol);
+        break; 
+      case LayoutDocEntry::MemberDef: 
+        {
+          LayoutDocEntryMemberDef *lmd = (LayoutDocEntryMemberDef*)lde;
+          writeMemberDocumentation(ol,lmd->type,lmd->title);
+        }
+        break;
+      case LayoutDocEntry::MemberDefEnd: 
+        endMemberDocumentation(ol);
+        break;
+      case LayoutDocEntry::AuthorSection: 
+        writeAuthorSection(ol);
+        break;
+      case LayoutDocEntry::ClassIncludes:
+      case LayoutDocEntry::ClassInheritanceGraph:
+      case LayoutDocEntry::ClassNestedClasses:
+      case LayoutDocEntry::ClassCollaborationGraph:
+      case LayoutDocEntry::ClassAllMembersLink:
+      case LayoutDocEntry::ClassUsedFiles:
+      case LayoutDocEntry::FileClasses:
+      case LayoutDocEntry::FileNamespaces:
+      case LayoutDocEntry::FileIncludes:
+      case LayoutDocEntry::FileIncludeGraph:
+      case LayoutDocEntry::FileIncludedByGraph: 
+      case LayoutDocEntry::FileSourceLink:
+      case LayoutDocEntry::GroupClasses: 
+      case LayoutDocEntry::GroupNamespaces:
+      case LayoutDocEntry::GroupDirs: 
+      case LayoutDocEntry::GroupNestedGroups: 
+      case LayoutDocEntry::GroupFiles:
+      case LayoutDocEntry::GroupGraph: 
+      case LayoutDocEntry::GroupPageDocs:
+      case LayoutDocEntry::DirSubDirs:
+      case LayoutDocEntry::DirFiles:
+      case LayoutDocEntry::DirGraph:
+        err("Internal inconsistency: member %d should not be part of "
+            "LayoutDocManager::Namespace entry list\n",lde->kind());
+        break;
+    }
+  }
+
+  //---------------------------------------- end flexible part -------------------------------
+
+  endFile(ol);
+
+  if (generateTagFile)
+  {
+    writeDocAnchorsToTagFile();
+    Doxygen::tagFile << "  </compound>" << endl;
+  }
+
+  if (Config_getBool("SEPARATE_MEMBER_PAGES"))
+  {
+    MemberList *allMemberList = getMemberList(MemberList::allMembersList);
+    if (allMemberList) allMemberList->sort();
+    writeMemberPages(ol);
+  }
+}
+
+void NamespaceDef::writeMemberPages(OutputList &ol)
+{
+  ol.pushGeneratorState();
+  ol.disableAllBut(OutputGenerator::Html);
+
+  QListIterator<MemberList> mli(m_memberLists);
+  MemberList *ml;
+  for (mli.toFirst();(ml=mli.current());++mli)
+  {
+    if (ml->listType()&MemberList::documentationLists)
+    {
+      ml->writeDocumentationPage(ol,name(),this);
+    }
+  }
+  ol.popGeneratorState();
+}
+
+void NamespaceDef::writeQuickMemberLinks(OutputList &ol,MemberDef *currentMd) const
+{
+  static bool createSubDirs=Config_getBool("CREATE_SUBDIRS");
+
+  ol.writeString("      <div class=\"navtab\">\n");
+  ol.writeString("        <table>\n");
+
+  MemberList *allMemberList = getMemberList(MemberList::allMembersList);
+  if (allMemberList)
+  {
+    MemberListIterator mli(*allMemberList);
+    MemberDef *md;
+    for (mli.toFirst();(md=mli.current());++mli)
+    {
+      if (md->getNamespaceDef()==this && md->isLinkable())
+      {
+        ol.writeString("          <tr><td class=\"navtab\">");
+        if (md->isLinkableInProject())
+        {
+          if (md==currentMd) // selected item => highlight
+          {
+            ol.writeString("<a class=\"qindexHL\" ");
+          }
+          else
+          {
+            ol.writeString("<a class=\"qindex\" ");
+          }
+          ol.writeString("href=\"");
+          if (createSubDirs) ol.writeString("../../");
+          ol.writeString(md->getOutputFileBase()+Doxygen::htmlFileExtension+"#"+md->anchor());
+          ol.writeString("\">");
+          ol.writeString(md->localName());
+          ol.writeString("</a>");
+        }
+        ol.writeString("</td></tr>\n");
+      }
+    }
+  }
+
+  ol.writeString("        </table>\n");
+  ol.writeString("      </div>\n");
+}
+
+int NamespaceDef::countMembers()
+{
+  MemberList *allMemberList = getMemberList(MemberList::allMembersList);
+  if (allMemberList) allMemberList->countDocMembers();
+  return (allMemberList ? allMemberList->numDocMembers() : 0)+classSDict->count();
+}
+
+void NamespaceDef::addUsingDirective(NamespaceDef *nd)
+{
+  if (usingDirList==0)
+  {
+    usingDirList = new NamespaceSDict;
+  }
+  if (usingDirList->find(nd->qualifiedName())==0)
+  {
+    usingDirList->append(nd->qualifiedName(),nd);
+  }
+  //printf("%p: NamespaceDef::addUsingDirective: %s:%d\n",this,name().data(),usingDirList->count());
+}
+
+NamespaceSDict *NamespaceDef::getUsedNamespaces() const 
+{ 
+  //printf("%p: NamespaceDef::getUsedNamespace: %s:%d\n",this,name().data(),usingDirList?usingDirList->count():0);
+  return usingDirList; 
+}
+
+void NamespaceDef::addUsingDeclaration(Definition *d)
+{
+  if (usingDeclList==0)
+  {
+    usingDeclList = new SDict<Definition>(17);
+  }
+  if (usingDeclList->find(d->qualifiedName())==0)
+  {
+    usingDeclList->append(d->qualifiedName(),d);
+  }
+}
+
+QCString NamespaceDef::getOutputFileBase() const 
+{ 
+  if (isReference())
+  {
+    return fileName;
+  }
+  else
+  {
+    return convertNameToFile(fileName); 
+  }
+}
+
+Definition *NamespaceDef::findInnerCompound(const char *n)
+{
+  if (n==0) return 0;
+  Definition *d = m_innerCompounds->find(n);
+  if (d==0)
+  {
+    if (usingDirList)
+    {
+      d = usingDirList->find(n);
+    }
+    if (d==0 && usingDeclList)
+    {
+      d = usingDeclList->find(n);
+    }
+  }
+  return d;
+}
+
+void NamespaceDef::addListReferences()
+{
+  bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+  {
+    LockingPtr< QList<ListItemInfo> > xrefItems = xrefListItems();
+    addRefItem(xrefItems.pointer(),
+        qualifiedName(),
+        fortranOpt?theTranslator->trModule(TRUE,TRUE):theTranslator->trNamespace(TRUE,TRUE),
+        getOutputFileBase(),displayName(),
+        0
+        );
+  }
+  MemberGroupSDict::Iterator mgli(*memberGroupSDict);
+  MemberGroup *mg;
+  for (;(mg=mgli.current());++mgli)
+  {
+    mg->addListReferences(this);
+  }
+  QListIterator<MemberList> mli(m_memberLists);
+  MemberList *ml;
+  for (mli.toFirst();(ml=mli.current());++mli)
+  {
+    if (ml->listType()&MemberList::documentationLists)
+    {
+      ml->addListReferences(this);
+    }
+  }
+}
+
+QCString NamespaceDef::displayName() const
+{
+  QCString result=name();
+  if (Config_getBool("OPTIMIZE_OUTPUT_JAVA"))
+  {
+    result = substitute(result,"::",".");
+  }
+  return result; 
+}
+
+void NamespaceDef::combineUsingRelations()
+{
+  if (visited) return; // already done
+  visited=TRUE;
+  if (usingDirList)
+  {
+    NamespaceSDict::Iterator nli(*usingDirList);
+    NamespaceDef *nd;
+    for (nli.toFirst();(nd=nli.current());++nli)
+    {
+      nd->combineUsingRelations();
+    }
+    for (nli.toFirst();(nd=nli.current());++nli)
+    {
+      // add used namespaces of namespace nd to this namespace
+      if (nd->getUsedNamespaces())
+      {
+        NamespaceSDict::Iterator unli(*nd->getUsedNamespaces());
+        NamespaceDef *und;
+        for (unli.toFirst();(und=unli.current());++unli)
+        {
+          //printf("Adding namespace %s to the using list of %s\n",und->qualifiedName().data(),qualifiedName().data());
+          addUsingDirective(und);
+        }
+      }
+      // add used classes of namespace nd to this namespace
+      if (nd->getUsedClasses())
+      {
+        SDict<Definition>::Iterator cli(*nd->getUsedClasses());
+        Definition *ucd;
+        for (cli.toFirst();(ucd=cli.current());++cli)
+        {
+          //printf("Adding class %s to the using list of %s\n",cd->qualifiedName().data(),qualifiedName().data());
+          addUsingDeclaration(ucd);
+        }
+      }
+    }
+  }
+}
+
+void NamespaceSDict::writeDeclaration(OutputList &ol,const char *title,bool localName)
+{
+  if (count()==0) return; // no namespaces in the list
+
+  SDict<NamespaceDef>::Iterator ni(*this);
+  NamespaceDef *nd;
+  bool found=FALSE;
+  for (ni.toFirst();(nd=ni.current()) && !found;++ni)
+  {
+    if (nd->isLinkable()) found=TRUE;
+  }
+  if (!found) return; // no linkable namespaces in the list
+
+  // write list of namespaces
+  ol.startMemberHeader();
+  bool javaOpt    = Config_getBool("OPTIMIZE_OUTPUT_JAVA");
+  bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+#if 0
+  if (javaOpt)
+  {
+    ol.parseText(theTranslator->trPackages());
+  }
+  else if (fortranOpt)
+  {
+    ol.parseText(theTranslator->trModules());
+  }
+  else
+  {
+    ol.parseText(theTranslator->trNamespaces());
+  }
+#endif
+  ol.parseText(title);
+  ol.endMemberHeader();
+  ol.startMemberList();
+  for (ni.toFirst();(nd=ni.current());++ni)
+  {
+    if (nd->isLinkable())
+    {
+      ol.startMemberItem(0);
+      if (javaOpt)
+      {
+        ol.docify("package ");
+      }
+      else if (fortranOpt)
+      {
+        ol.docify("module ");
+      }
+      else
+      {
+        ol.docify("namespace ");
+      }
+      ol.insertMemberAlign();
+      QCString name;
+      if (localName)
+      {
+        name = nd->localName();
+      }
+      else
+      {
+        name = nd->displayName();
+      }
+      ol.writeObjectLink(nd->getReference(),nd->getOutputFileBase(),0,name);
+      if (!Config_getString("GENERATE_TAGFILE").isEmpty() && !nd->isReference()) 
+      {
+        Doxygen::tagFile << "    <namespace>" << convertToXML(nd->name()) << "</namespace>" << endl;
+      }
+      ol.endMemberItem();
+      if (!nd->briefDescription().isEmpty() && Config_getBool("BRIEF_MEMBER_DESC"))
+      {
+        ol.startParagraph();
+        ol.startMemberDescription();
+        ol.parseDoc(nd->briefFile(),nd->briefLine(),nd,0,nd->briefDescription(),FALSE,FALSE);
+        ol.endMemberDescription();
+        ol.endParagraph();
+      }
+    }
+  }
+  ol.endMemberList();
+}
+
+MemberList *NamespaceDef::createMemberList(MemberList::ListType lt)
+{
+  m_memberLists.setAutoDelete(TRUE);
+  QListIterator<MemberList> mli(m_memberLists);
+  MemberList *ml;
+  for (mli.toFirst();(ml=mli.current());++mli)
+  {
+    if (ml->listType()==lt)
+    {
+      return ml;
+    }
+  }
+  // not found, create a new member list
+  ml = new MemberList(lt);
+  m_memberLists.append(ml);
+  return ml;
+}
+
+void NamespaceDef::addMemberToList(MemberList::ListType lt,MemberDef *md)
+{
+  static bool sortBriefDocs = Config_getBool("SORT_BRIEF_DOCS");
+  static bool sortMemberDocs = Config_getBool("SORT_MEMBER_DOCS");
+  MemberList *ml = createMemberList(lt);
+  if (((ml->listType()&MemberList::declarationLists) && sortBriefDocs) ||
+      ((ml->listType()&MemberList::documentationLists) && sortMemberDocs)
+     )
+    ml->inSort(md);
+  else
+    ml->append(md);
+  if (ml->listType()&MemberList::declarationLists) md->setSectionList(this,ml);
+}
+
+MemberList *NamespaceDef::getMemberList(MemberList::ListType lt) const
+{
+  NamespaceDef *that = (NamespaceDef*)this;
+  MemberList *ml = that->m_memberLists.first();
+  while (ml)
+  {
+    if (ml->listType()==lt)
+    {
+      return ml;
+    }
+    ml = that->m_memberLists.next();
+  }
+  return 0;
+}
+
+void NamespaceDef::writeMemberDeclarations(OutputList &ol,MemberList::ListType lt,const QCString &title)
+{
+  MemberList * ml = getMemberList(lt);
+  if (ml) ml->writeDeclarations(ol,0,this,0,0,title,0);
+}
+
+void NamespaceDef::writeMemberDocumentation(OutputList &ol,MemberList::ListType lt,const QCString &title)
+{
+  MemberList * ml = getMemberList(lt);
+  if (ml) ml->writeDocumentation(ol,name(),this,title);
+}
+
+
+bool NamespaceDef::isLinkableInProject() const
+{
+  int i = name().findRev("::");
+  if (i==-1) i=0; else i+=2;
+  static bool extractAnonNs = Config_getBool("EXTRACT_ANON_NSPACES");
+  static bool showNamespaces = Config_getBool("SHOW_NAMESPACES");
+  if (extractAnonNs &&                             // extract anonymous ns
+      name().mid(i,20)=="anonymous_namespace{" &&  // correct prefix
+      showNamespaces)                              // not disabled by config
+  {
+    return TRUE;
+  }
+  return !name().isEmpty() && name().at(i)!='@' && // not anonymous
+    hasDocumentation() &&  // documented
+    !isReference() &&      // not an external reference
+    !isHidden() &&         // not hidden
+    !isArtificial() &&     // or artificial
+    showNamespaces;        // not disabled by config
+}
+
+bool NamespaceDef::isLinkable() const
+{
+  return isLinkableInProject() || isReference();
+}
+
+
+MemberDef * NamespaceDef::getMemberByName(const QCString &n) const
+{
+  MemberDef *md = 0;
+  if (m_allMembersDict && !n.isEmpty())
+  {
+    md = m_allMembersDict->find(n);
+    //printf("%s::m_allMembersDict->find(%s)=%p\n",name().data(),n.data(),md);
+  }
+  return md;
+}
+