1 /******************************************************************************

     2  *

     3  * Copyright (C) 1997-2008 by Dimitri van Heesch.

     4  *

     5  * Permission to use, copy, modify, and distribute this software and its

     6  * documentation under the terms of the GNU General Public License is hereby 

     7  * granted. No representations are made about the suitability of this software 

     8  * for any purpose. It is provided "as is" without express or implied warranty.

     9  * See the GNU General Public License for more details.

    10  *

    11  * Documents produced by Doxygen are derivative works derived from the

    12  * input used in their production; they are not affected by this license.

    13  *

    14  */

    15 

    16 #include "qtbc.h"

    17 #include <qfileinfo.h>

    18 #include <qfile.h>

    19 #include <qdir.h>

    20 #include <qdict.h>

    21 #include <qregexp.h>

    22 #include <qstrlist.h>

    23 #include <stdio.h>

    24 #include <stdlib.h>

    25 #include <sys/stat.h>

    26 #include <qtextcodec.h>

    27 #include <unistd.h>

    28 #include <errno.h>

    29 

    30 #include "version.h"

    31 #include "doxygen.h"

    32 #include "scanner.h"

    33 #include "entry.h"

    34 #include "index.h"

    35 #include "logos.h"

    36 #include "instdox.h"

    37 #include "message.h"

    38 #include "config.h"

    39 #include "util.h"

    40 #include "pre.h"

    41 #include "tagreader.h"

    42 #include "dot.h"

    43 #include "docparser.h"

    44 #include "dirdef.h"

    45 #include "outputlist.h"

    46 #include "declinfo.h"

    47 #include "htmlgen.h"

    48 #include "latexgen.h"

    49 #include "mangen.h"

    50 #include "language.h"

    51 #include "debug.h"

    52 #include "htmlhelp.h"

    53 #include "qhp.h"

    54 #include "indexlog.h"

    55 #include "ftvhelp.h"

    56 #include "defargs.h"

    57 #include "rtfgen.h"

    58 #include "xmlgen.h"

    59 #include "xmlditagen.h"

    60 #include "defgen.h"

    61 #include "perlmodgen.h"

    62 #include "reflist.h"

    63 #include "pagedef.h"

    64 #include "bufstr.h"

    65 #include "commentcnv.h"

    66 #include "cmdmapper.h"

    67 #include "searchindex.h"

    68 #include "parserintf.h"

    69 #include "htags.h"

    70 #include "pyscanner.h"

    71 #include "fortranscanner.h"

    72 #include "dbusxmlscanner.h"

    73 #include "code.h"

    74 #include "objcache.h"

    75 #include "store.h"

    76 #include "marshal.h"

    77 #include "portable.h"

    78 #include "vhdlscanner.h"

    79 #include "vhdldocgen.h"

    80 #include "eclipsehelp.h"

    81 

    82 #include "layout.h"

    83 

    84 #define RECURSE_ENTRYTREE(func,var) \

    85   do { if (var->children()) { \

    86     EntryNavListIterator eli(*var->children()); \

    87     for (;eli.current();++eli) func(eli.current()); \

    88   } } while(0) 

    89 

    90 

    91 #if !defined(_WIN32) || defined(__CYGWIN__)

    92 #include <signal.h>

    93 #define HAS_SIGNALS

    94 #endif

    95 

    96 // globally accessible variables

    97 ClassSDict      *Doxygen::classSDict = 0;

    98 ClassSDict      *Doxygen::hiddenClasses = 0;

    99 NamespaceSDict  *Doxygen::namespaceSDict = 0;

   100 MemberNameSDict *Doxygen::memberNameSDict = 0;

   101 MemberNameSDict *Doxygen::functionNameSDict = 0;   

   102 FileNameList    *Doxygen::inputNameList = 0;       // all input files

   103 FileNameDict    *Doxygen::inputNameDict = 0;          

   104 GroupSDict      *Doxygen::groupSDict = 0;

   105 FormulaList      Doxygen::formulaList;             // all formulas

   106 FormulaDict      Doxygen::formulaDict(1009);       // all formulas

   107 FormulaDict      Doxygen::formulaNameDict(1009);   // the label name of all formulas

   108 PageSDict       *Doxygen::pageSDict = 0;

   109 PageSDict       *Doxygen::exampleSDict = 0;

   110 SectionDict      Doxygen::sectionDict(257);        // all page sections

   111 StringDict       Doxygen::aliasDict(257);          // aliases

   112 FileNameDict    *Doxygen::includeNameDict = 0;     // include names

   113 FileNameDict    *Doxygen::exampleNameDict = 0;     // examples

   114 FileNameDict    *Doxygen::imageNameDict = 0;       // images

   115 FileNameDict    *Doxygen::dotFileNameDict = 0;     // dot files

   116 StringDict       Doxygen::namespaceAliasDict(257); // all namespace aliases

   117 StringDict       Doxygen::tagDestinationDict(257); // all tag locations

   118 QDict<void>      Doxygen::expandAsDefinedDict(257); // all macros that should be expanded

   119 QIntDict<MemberGroupInfo> Doxygen::memGrpInfoDict(1009); // dictionary of the member groups heading

   120 PageDef         *Doxygen::mainPage = 0;

   121 bool             Doxygen::insideMainPage = FALSE; // are we generating docs for the main page?

   122 QTextStream      Doxygen::tagFile;

   123 NamespaceDef    *Doxygen::globalScope = 0;

   124 QDict<RefList>  *Doxygen::xrefLists = new QDict<RefList>; // dictionary of cross-referenced item lists

   125 bool             Doxygen::parseSourcesNeeded = FALSE;

   126 QTime            Doxygen::runningTime;

   127 SearchIndex *    Doxygen::searchIndex=0;

   128 QDict<DefinitionIntf> *Doxygen::symbolMap;

   129 bool             Doxygen::outputToWizard=FALSE;

   130 QDict<int> *     Doxygen::htmlDirMap = 0;

   131 QCache<LookupInfo> Doxygen::lookupCache(50000,50000);

   132 DirSDict        *Doxygen::directories;

   133 SDict<DirRelation> Doxygen::dirRelations(257);

   134 ParserManager   *Doxygen::parserManager = 0;

   135 QCString Doxygen::htmlFileExtension;

   136 bool             Doxygen::suppressDocWarnings = FALSE;

   137 ObjCache        *Doxygen::symbolCache = 0;

   138 Store           *Doxygen::symbolStorage;

   139 QCString         Doxygen::objDBFileName;

   140 QCString         Doxygen::entryDBFileName;

   141 bool             Doxygen::gatherDefines = TRUE;

   142 IndexList        Doxygen::indexList;

   143 int              Doxygen::subpageNestingLevel = 0;

   144 bool             Doxygen::userComments = FALSE;

   145 QCString         Doxygen::spaces;

   146 

   147 // locally accessible globals

   148 static QDict<EntryNav>  g_classEntries(1009);

   149 static StringList       g_inputFiles;         

   150 static QDict<void>      g_compoundKeywordDict(7);  // keywords recognised as compounds

   151 static OutputList      *g_outputList = 0;          // list of output generating objects

   152 static QDict<FileDef>   g_usingDeclarations(1009); // used classes

   153 static FileStorage     *g_storage = 0;

   154 static bool             g_successfulRun = FALSE;

   155 static bool             g_dumpSymbolMap = FALSE;

   156 static bool             g_dumpConfigAsXML = FALSE;

   157 

   158 void clearAll()

   159 {

   160   g_inputFiles.clear();      

   161   //g_excludeNameDict.clear();  

   162   //delete g_outputList; g_outputList=0;

   163 

   164   Doxygen::classSDict->clear();       

   165   Doxygen::namespaceSDict->clear();   

   166   Doxygen::pageSDict->clear();         

   167   Doxygen::exampleSDict->clear();      

   168   Doxygen::inputNameList->clear();   

   169   Doxygen::formulaList.clear();     

   170   Doxygen::sectionDict.clear();       

   171   Doxygen::inputNameDict->clear();    

   172   Doxygen::includeNameDict->clear();  

   173   Doxygen::exampleNameDict->clear();  

   174   Doxygen::imageNameDict->clear();     

   175   Doxygen::dotFileNameDict->clear();     

   176   Doxygen::formulaDict.clear();      

   177   Doxygen::formulaNameDict.clear();  

   178   Doxygen::tagDestinationDict.clear();

   179   delete Doxygen::mainPage; Doxygen::mainPage=0;

   180 }

   181 

   182 void statistics()

   183 {

   184   fprintf(stderr,"--- inputNameDict stats ----\n");

   185   Doxygen::inputNameDict->statistics();

   186   fprintf(stderr,"--- includeNameDict stats ----\n");

   187   Doxygen::includeNameDict->statistics();

   188   fprintf(stderr,"--- exampleNameDict stats ----\n");

   189   Doxygen::exampleNameDict->statistics();

   190   fprintf(stderr,"--- imageNameDict stats ----\n");

   191   Doxygen::imageNameDict->statistics();

   192   fprintf(stderr,"--- dotFileNameDict stats ----\n");

   193   Doxygen::dotFileNameDict->statistics();

   194   //fprintf(stderr,"--- g_excludeNameDict stats ----\n");

   195   //g_excludeNameDict.statistics();

   196   fprintf(stderr,"--- aliasDict stats ----\n");

   197   Doxygen::aliasDict.statistics();

   198   fprintf(stderr,"--- typedefDict stats ----\n");

   199   fprintf(stderr,"--- namespaceAliasDict stats ----\n");

   200   Doxygen::namespaceAliasDict.statistics();

   201   fprintf(stderr,"--- formulaDict stats ----\n");

   202   Doxygen::formulaDict.statistics();

   203   fprintf(stderr,"--- formulaNameDict stats ----\n");

   204   Doxygen::formulaNameDict.statistics();

   205   fprintf(stderr,"--- tagDestinationDict stats ----\n");

   206   Doxygen::tagDestinationDict.statistics();

   207   fprintf(stderr,"--- g_compoundKeywordDict stats ----\n");

   208   g_compoundKeywordDict.statistics();

   209   fprintf(stderr,"--- expandAsDefinedDict stats ----\n");

   210   Doxygen::expandAsDefinedDict.statistics();

   211   fprintf(stderr,"--- memGrpInfoDict stats ----\n");

   212   Doxygen::memGrpInfoDict.statistics();

   213 }

   214 

   215 

   216 

   217 static void addMemberDocs(EntryNav *rootNav,MemberDef *md, const char *funcDecl,

   218                    ArgumentList *al,bool over_load,NamespaceSDict *nl=0);

   219 static void findMember(EntryNav *rootNav,

   220                        QCString funcDecl,

   221                        bool overloaded,

   222                        bool isFunc

   223                       );

   224 

   225 

   226 struct STLInfo

   227 {

   228   const char *className;

   229   const char *baseClass1;

   230   const char *baseClass2;

   231   const char *templType1;

   232   const char *templName1;

   233   const char *templType2;

   234   const char *templName2;

   235   bool virtualInheritance;

   236   bool iterators;

   237 };

   238 

   239 static STLInfo g_stlinfo[] =

   240 {

   241   // className              baseClass1                      baseClass2             templType1     templName1     templType2    templName2     virtInheritance  // iterators

   242   { "allocator",            0,                              0,                     "T",           "elements",    0,            0,             FALSE,              FALSE },

   243   { "auto_ptr",             0,                              0,                     "T",           "ptr",         0,            0,             FALSE,              FALSE },

   244   { "ios_base",             0,                              0,                     0,             0,             0,            0,             FALSE,              FALSE },

   245   { "basic_ios",            "ios_base",                     0,                     "Char",        0,             0,            0,             FALSE,              FALSE },

   246   { "basic_istream",        "basic_ios<Char>",              0,                     "Char",        0,             0,            0,             TRUE,               FALSE },

   247   { "basic_ostream",        "basic_ios<Char>",              0,                     "Char",        0,             0,            0,             TRUE,               FALSE },

   248   { "basic_iostream",       "basic_istream<Char>",          "basic_ostream<Char>", "Char",        0,             0,            0,             FALSE,              FALSE },

   249   { "basic_ifstream",       "basic_istream<Char>",          0,                     "Char",        0,             0,            0,             FALSE,              FALSE },

   250   { "basic_ofstream",       "basic_ostream<Char>",          0,                     "Char",        0,             0,            0,             FALSE,              FALSE },

   251   { "basic_fstream",        "basic_iostream<Char>",         0,                     "Char",        0,             0,            0,             FALSE,              FALSE },

   252   { "basic_istringstream",  "basic_istream<Char>",          0,                     "Char",        0,             0,            0,             FALSE,              FALSE },

   253   { "basic_ostringstream",  "basic_ostream<Char>",          0,                     "Char",        0,             0,            0,             FALSE,              FALSE },

   254   { "basic_stringstream",   "basic_iostream<Char>",         0,                     "Char",        0,             0,            0,             FALSE,              FALSE },

   255   { "ios",                  "basic_ios<char>",              0,                     0,             0,             0,            0,             FALSE,              FALSE },

   256   { "wios",                 "basic_ios<wchar_t>",           0,                     0,             0,             0,            0,             FALSE,              FALSE },

   257   { "istream",              "basic_istream<char>",          0,                     0,             0,             0,            0,             FALSE,              FALSE },

   258   { "wistream",             "basic_istream<wchar_t>",       0,                     0,             0,             0,            0,             FALSE,              FALSE },

   259   { "ostream",              "basic_ostream<char>",          0,                     0,             0,             0,            0,             FALSE,              FALSE },

   260   { "wostream",             "basic_ostream<wchar_t>",       0,                     0,             0,             0,            0,             FALSE,              FALSE },

   261   { "ifstream",             "basic_ifstream<char>",         0,                     0,             0,             0,            0,             FALSE,              FALSE },

   262   { "wifstream",            "basic_ifstream<wchar_t>",      0,                     0,             0,             0,            0,             FALSE,              FALSE },

   263   { "ofstream",             "basic_ofstream<char>",         0,                     0,             0,             0,            0,             FALSE,              FALSE },

   264   { "wofstream",            "basic_ofstream<wchar_t>",      0,                     0,             0,             0,            0,             FALSE,              FALSE },

   265   { "fstream",              "basic_fstream<char>",          0,                     0,             0,             0,            0,             FALSE,              FALSE },

   266   { "wfstream",             "basic_fstream<wchar_t>",       0,                     0,             0,             0,            0,             FALSE,              FALSE },

   267   { "istringstream",        "basic_istringstream<char>",    0,                     0,             0,             0,            0,             FALSE,              FALSE },

   268   { "wistringstream",       "basic_istringstream<wchar_t>", 0,                     0,             0,             0,            0,             FALSE,              FALSE },

   269   { "ostringstream",        "basic_ostringstream<char>",    0,                     0,             0,             0,            0,             FALSE,              FALSE },

   270   { "wostringstream",       "basic_ostringstream<wchar_t>", 0,                     0,             0,             0,            0,             FALSE,              FALSE },

   271   { "stringstream",         "basic_stringstream<char>",     0,                     0,             0,             0,            0,             FALSE,              FALSE },

   272   { "wstringstream",        "basic_stringstream<wchar_t>",  0,                     0,             0,             0,            0,             FALSE,              FALSE },

   273   { "basic_string",         0,                              0,                     "Char",        0,             0,            0,             FALSE,              TRUE  },

   274   { "string",               "basic_string<char>",           0,                     0,             0,             0,            0,             FALSE,              TRUE  },

   275   { "wstring",              "basic_string<wchar_t>",        0,                     0,             0,             0,            0,             FALSE,              TRUE  },

   276   { "complex",              0,                              0,                     0,             0,             0,            0,             FALSE,              FALSE },

   277   { "bitset",               0,                              0,                     "Bits",        0,             0,            0,             FALSE,              FALSE },

   278   { "deque",                0,                              0,                     "T",           "elements",    0,            0,             FALSE,              TRUE  },

   279   { "list",                 0,                              0,                     "T",           "elements",    0,            0,             FALSE,              TRUE  },

   280   { "map",                  0,                              0,                     "K",           "keys",        "T",          "elements",    FALSE,              TRUE  },

   281   { "multimap",             0,                              0,                     "K",           "keys",        "T",          "elements",    FALSE,              TRUE  },

   282   { "set",                  0,                              0,                     "K",           "keys",        0,            0,             FALSE,              TRUE  },

   283   { "multiset",             0,                              0,                     "K",           "keys",        0,            0,             FALSE,              TRUE  },

   284   { "vector",               0,                              0,                     "T",           "elements",    0,            0,             FALSE,              TRUE  },

   285   { "queue",                0,                              0,                     "T",           "elements",    0,            0,             FALSE,              FALSE },

   286   { "priority_queue",       0,                              0,                     "T",           "elements",    0,            0,             FALSE,              FALSE },

   287   { "stack",                0,                              0,                     "T",           "elements",    0,            0,             FALSE,              FALSE },

   288   { "valarray",             0,                              0,                     "T",           "elements",    0,            0,             FALSE,              FALSE },

   289   { "exception",            0,                              0,                     0,             0,             0,            0,             FALSE,              FALSE },

   290   { "bad_alloc",            "exception",                    0,                     0,             0,             0,            0,             FALSE,              FALSE },

   291   { "bad_cast",             "exception",                    0,                     0,             0,             0,            0,             FALSE,              FALSE },

   292   { "bad_typeid",           "exception",                    0,                     0,             0,             0,            0,             FALSE,              FALSE },

   293   { "logic_error",          "exception",                    0,                     0,             0,             0,            0,             FALSE,              FALSE },

   294   { "ios_base::failure",    "exception",                    0,                     0,             0,             0,            0,             FALSE,              FALSE },

   295   { "runtime_error",        "exception",                    0,                     0,             0,             0,            0,             FALSE,              FALSE },

   296   { "bad_exception",        "exception",                    0,                     0,             0,             0,            0,             FALSE,              FALSE },

   297   { "domain_error",         "logic_error",                  0,                     0,             0,             0,            0,             FALSE,              FALSE },

   298   { "invalid_argument",     "logic_error",                  0,                     0,             0,             0,            0,             FALSE,              FALSE },

   299   { "length_error",         "logic_error",                  0,                     0,             0,             0,            0,             FALSE,              FALSE },

   300   { "out_of_range",         "logic_error",                  0,                     0,             0,             0,            0,             FALSE,              FALSE },

   301   { "range_error",          "runtime_error",                0,                     0,             0,             0,            0,             FALSE,              FALSE },

   302   { "overflow_error",       "runtime_error",                0,                     0,             0,             0,            0,             FALSE,              FALSE },

   303   { "underflow_error",      "runtime_error",                0,                     0,             0,             0,            0,             FALSE,              FALSE },

   304   { 0,                      0,                              0,                     0,             0,             0,            0,             FALSE,              FALSE }

   305 };

   306 

   307 static void addSTLMember(EntryNav *rootNav,const char *type,const char *name)

   308 {

   309   Entry *memEntry = new Entry;

   310   memEntry->name       = name;

   311   memEntry->type       = type;

   312   memEntry->protection = Private;

   313   memEntry->section    = Entry::VARIABLE_SEC;

   314   memEntry->brief      = "STL member";

   315   memEntry->hidden     = FALSE; 

   316   memEntry->artificial = TRUE;

   317   //memEntry->parent     = root;

   318   //root->addSubEntry(memEntry);

   319   EntryNav *memEntryNav = new EntryNav(rootNav,memEntry);

   320   memEntryNav->setEntry(memEntry);

   321   rootNav->addChild(memEntryNav);

   322 }

   323 

   324 static void addSTLIterator(EntryNav *classEntryNav,const char *name)

   325 {

   326   Entry *iteratorClassEntry = new Entry;

   327   iteratorClassEntry->fileName  = "[STL]";

   328   iteratorClassEntry->startLine = 1;

   329   iteratorClassEntry->name      = name;

   330   iteratorClassEntry->section   = Entry::CLASS_SEC;

   331   iteratorClassEntry->brief     = "STL iterator class";

   332   iteratorClassEntry->hidden    = FALSE;

   333   iteratorClassEntry->artificial= TRUE;

   334   EntryNav *iteratorClassEntryNav = new EntryNav(classEntryNav,iteratorClassEntry);

   335   iteratorClassEntryNav->setEntry(iteratorClassEntry);

   336   classEntryNav->addChild(iteratorClassEntryNav);

   337 }

   338 

   339 

   340 static void addSTLClasses(EntryNav *rootNav)

   341 {

   342   Entry *namespaceEntry = new Entry;

   343   namespaceEntry->fileName  = "[STL]";

   344   namespaceEntry->startLine = 1;

   345   //namespaceEntry->parent    = rootNav->entry();

   346   namespaceEntry->name      = "std";

   347   namespaceEntry->section   = Entry::NAMESPACE_SEC;

   348   namespaceEntry->brief     = "STL namespace";

   349   namespaceEntry->hidden    = FALSE;

   350   namespaceEntry->artificial= TRUE;

   351   //root->addSubEntry(namespaceEntry);

   352   EntryNav *namespaceEntryNav = new EntryNav(rootNav,namespaceEntry);

   353   namespaceEntryNav->setEntry(namespaceEntry);

   354   rootNav->addChild(namespaceEntryNav);

   355   

   356   STLInfo *info = g_stlinfo;

   357   while (info->className)

   358   {

   359     //printf("Adding STL class %s\n",info->className);

   360     QCString fullName = info->className;

   361     fullName.prepend("std::");

   362 

   363     // add fake Entry for the class

   364     Entry *classEntry = new Entry;

   365     classEntry->fileName  = "[STL]";

   366     classEntry->startLine = 1;

   367     classEntry->name      = fullName;

   368     //classEntry->parent    = namespaceEntry;

   369     classEntry->section   = Entry::CLASS_SEC;

   370     classEntry->brief     = "STL class";

   371     classEntry->hidden    = FALSE;

   372     classEntry->artificial= TRUE;

   373     //namespaceEntry->addSubEntry(classEntry);

   374     EntryNav *classEntryNav = new EntryNav(namespaceEntryNav,classEntry);

   375     classEntryNav->setEntry(classEntry);

   376     namespaceEntryNav->addChild(classEntryNav);

   377 

   378     // add template arguments to class

   379     if (info->templType1)

   380     {

   381       ArgumentList *al = new ArgumentList;

   382       Argument *a=new Argument;

   383       a->type="typename";

   384       a->name=info->templType1;

   385       al->append(a);

   386       if (info->templType2) // another template argument

   387       {

   388         a=new Argument;

   389         a->type="typename";

   390         a->name=info->templType2;

   391         al->append(a);

   392       }

   393       classEntry->tArgLists = new QList<ArgumentList>;

   394       classEntry->tArgLists->setAutoDelete(TRUE);

   395       classEntry->tArgLists->append(al);

   396     }

   397     // add member variables

   398     if (info->templName1)

   399     {

   400       addSTLMember(classEntryNav,info->templType1,info->templName1);

   401     }

   402     if (info->templName2)

   403     {

   404       addSTLMember(classEntryNav,info->templType2,info->templName2);

   405     }

   406     if (info->baseClass1)

   407     {

   408       classEntry->extends->append(new BaseInfo(info->baseClass1,Public,info->virtualInheritance?Virtual:Normal));

   409     }

   410     if (info->baseClass2)

   411     {

   412       classEntry->extends->append(new BaseInfo(info->baseClass2,Public,info->virtualInheritance?Virtual:Normal));

   413     }

   414     if (info->iterators)

   415     {

   416       // add iterator class

   417       addSTLIterator(classEntryNav,fullName+"::iterator");

   418       addSTLIterator(classEntryNav,fullName+"::const_iterator");

   419       addSTLIterator(classEntryNav,fullName+"::reverse_iterator");

   420       addSTLIterator(classEntryNav,fullName+"::const_reverse_iterator");

   421     }

   422     info++;

   423   }

   424 }

   425 

   426 //----------------------------------------------------------------------------

   427 

   428 static Definition *findScopeFromQualifiedName(Definition *startScope,const QCString &n,

   429                                               FileDef *fileScope=0);

   430 

   431 static void addPageToContext(PageDef *pd,EntryNav *rootNav)

   432 {

   433   if (rootNav->parent()) // add the page to it's scope

   434   {

   435     QCString scope = rootNav->parent()->name();

   436     if (rootNav->parent()->section()==Entry::PACKAGEDOC_SEC)

   437     {

   438       scope=substitute(scope,".","::");

   439     }

   440     scope = stripAnonymousNamespaceScope(scope);

   441     scope+="::"+pd->name();

   442     Definition *d = findScopeFromQualifiedName(Doxygen::globalScope,scope);

   443     if (d) 

   444     {

   445       pd->setPageScope(d);

   446     }

   447   }

   448 }

   449 

   450 static void addRelatedPage(EntryNav *rootNav)

   451 {

   452   Entry *root = rootNav->entry();

   453   GroupDef *gd=0;

   454   QListIterator<Grouping> gli(*root->groups);

   455   Grouping *g;

   456   for (;(g=gli.current());++gli)

   457   {

   458     if (!g->groupname.isEmpty() && (gd=Doxygen::groupSDict->find(g->groupname))) break;

   459   }

   460   //printf("---> addRelatedPage() %s gd=%p\n",root->name.data(),gd);

   461   QCString doc;

   462   if (root->brief.isEmpty())

   463   {

   464     doc=root->doc+root->inbodyDocs;

   465   }

   466   else

   467   {

   468     doc=root->brief+"\n\n"+root->doc+root->inbodyDocs;

   469   }

   470   PageDef *pd = addRelatedPage(root->name,root->args,doc,root->anchors,

   471       root->fileName,root->startLine,

   472       root->sli,

   473       gd,rootNav->tagInfo()

   474      );

   475   if (pd)

   476   {

   477     pd->addSectionsToDefinition(root->anchors);

   478     addPageToContext(pd,rootNav);

   479   }

   480 }

   481 

   482 static void buildGroupListFiltered(EntryNav *rootNav,bool additional)

   483 {

   484   if (rootNav->section()==Entry::GROUPDOC_SEC && !rootNav->name().isEmpty())

   485   {

   486     //printf("Found group %s title=`%s type=%d'\n",

   487     //    root->name.data(),root->type.data(),root->groupDocType);

   488 

   489     rootNav->loadEntry(g_storage);

   490     Entry *root = rootNav->entry();

   491     

   492     if ((root->groupDocType==Entry::GROUPDOC_NORMAL && !additional) ||

   493         (root->groupDocType!=Entry::GROUPDOC_NORMAL && additional))

   494     {

   495       GroupDef *gd;

   496 

   497       if ((gd=Doxygen::groupSDict->find(root->name)))

   498       {

   499         if ( !gd->hasGroupTitle() )

   500         {

   501           gd->setGroupTitle( root->type );

   502         }

   503         else if ( root->type.length() > 0 && root->name != root->type && gd->groupTitle() != root->type )

   504         {

   505           warn( root->fileName,root->startLine,

   506               "group %s: ignoring title \"%s\" that does not match old title \"%s\"\n",

   507               root->name.data(), root->type.data(), gd->groupTitle() );

   508         }

   509         gd->setBriefDescription(root->brief,root->briefFile,root->briefLine);

   510         gd->setDocumentation( root->doc, root->docFile, root->docLine );

   511         gd->setInbodyDocumentation( root->inbodyDocs, root->inbodyFile, root->inbodyLine );

   512         gd->addSectionsToDefinition(root->anchors);

   513         gd->setRefItems(root->sli);

   514       }

   515       else

   516       {

   517         if (rootNav->tagInfo())

   518         {

   519           gd = new GroupDef(root->fileName,root->startLine,root->name,root->type,rootNav->tagInfo()->fileName);

   520           gd->setReference(rootNav->tagInfo()->tagName);

   521         }

   522         else

   523         {

   524           gd = new GroupDef(root->fileName,root->startLine,root->name,root->type);

   525         }

   526         gd->setBriefDescription(root->brief,root->briefFile,root->briefLine);

   527         gd->setDocumentation(root->doc,root->docFile,root->docLine);

   528         gd->setInbodyDocumentation( root->inbodyDocs, root->inbodyFile, root->inbodyLine );

   529         gd->addSectionsToDefinition(root->anchors);

   530         Doxygen::groupSDict->append(root->name,gd);

   531         gd->setRefItems(root->sli);

   532       }

   533     }

   534 

   535     rootNav->releaseEntry();

   536   }

   537   if (rootNav->children())

   538   {

   539     EntryNavListIterator eli(*rootNav->children());

   540     EntryNav *e;

   541     for (;(e=eli.current());++eli)

   542     {

   543       buildGroupListFiltered(e,additional);

   544     }

   545   }

   546 }

   547 

   548 static void buildGroupList(EntryNav *rootNav)

   549 {

   550   // first process the @defgroups blocks

   551   buildGroupListFiltered(rootNav,FALSE);

   552   // then process the @addtogroup, @weakgroup blocks

   553   buildGroupListFiltered(rootNav,TRUE);

   554 }

   555 

   556 static void findGroupScope(EntryNav *rootNav)

   557 {

   558   if (rootNav->section()==Entry::GROUPDOC_SEC && !rootNav->name().isEmpty() && 

   559       rootNav->parent() && !rootNav->parent()->name().isEmpty())

   560   {

   561     GroupDef *gd;

   562     if ((gd=Doxygen::groupSDict->find(rootNav->name())))

   563     {

   564       QCString scope = rootNav->parent()->name();

   565       if (rootNav->parent()->section()==Entry::PACKAGEDOC_SEC)

   566       {

   567         scope=substitute(scope,".","::");

   568       }

   569       scope = stripAnonymousNamespaceScope(scope);

   570       scope+="::"+gd->name();

   571       Definition *d = findScopeFromQualifiedName(Doxygen::globalScope,scope);

   572       if (d) 

   573       {

   574         gd->setGroupScope(d);

   575       }

   576     }

   577   }

   578   RECURSE_ENTRYTREE(findGroupScope,rootNav);

   579 }

   580 

   581 static void organizeSubGroupsFiltered(EntryNav *rootNav,bool additional)

   582 {

   583   if (rootNav->section()==Entry::GROUPDOC_SEC && !rootNav->name().isEmpty())

   584   {

   585     rootNav->loadEntry(g_storage);

   586     Entry *root = rootNav->entry();

   587 

   588     if ((root->groupDocType==Entry::GROUPDOC_NORMAL && !additional) ||

   589         (root->groupDocType!=Entry::GROUPDOC_NORMAL && additional))

   590     {

   591       GroupDef *gd;

   592       if ((gd=Doxygen::groupSDict->find(root->name)))

   593       {

   594         //printf("adding %s to group %s\n",root->name.data(),gd->name().data());

   595         addGroupToGroups(root,gd);

   596       }

   597     }

   598 

   599     rootNav->releaseEntry();

   600   }

   601   if (rootNav->children())

   602   {

   603     EntryNavListIterator eli(*rootNav->children());

   604     EntryNav *e;

   605     for (;(e=eli.current());++eli)

   606     {

   607       organizeSubGroupsFiltered(e,additional);

   608     }

   609   }

   610 }

   611 

   612 static void organizeSubGroups(EntryNav *rootNav)

   613 {

   614   //printf("Defining groups\n");

   615   // first process the @defgroups blocks

   616   organizeSubGroupsFiltered(rootNav,FALSE);

   617   //printf("Additional groups\n");

   618   // then process the @addtogroup, @weakgroup blocks

   619   organizeSubGroupsFiltered(rootNav,TRUE);

   620 }

   621 

   622 //----------------------------------------------------------------------

   623 

   624 static void buildFileList(EntryNav *rootNav)

   625 {

   626   if (((rootNav->section()==Entry::FILEDOC_SEC) ||

   627         ((rootNav->section() & Entry::FILE_MASK) && Config_getBool("EXTRACT_ALL"))) &&

   628       !rootNav->name().isEmpty() && !rootNav->tagInfo() // skip any file coming from tag files

   629      )

   630   {

   631     rootNav->loadEntry(g_storage);

   632     Entry *root = rootNav->entry();

   633 

   634     bool ambig;

   635     FileDef *fd=findFileDef(Doxygen::inputNameDict,root->name,ambig);

   636     //printf("**************** root->name=%s fd=%p\n",root->name.data(),fd);

   637     if (fd && !ambig)

   638     {

   639 #if 0

   640       if ((!root->doc.isEmpty() && !fd->documentation().isEmpty()) ||

   641           (!root->brief.isEmpty() && !fd->briefDescription().isEmpty()))

   642       {

   643         warn(

   644             root->fileName,root->startLine,

   645             "Warning: file %s already documented. "

   646             "Skipping documentation.",

   647             root->name.data()

   648             );

   649       }

   650       else

   651 #endif

   652       {

   653         //printf("Adding documentation!\n");

   654         // using FALSE in setDocumentation is small hack to make sure a file 

   655         // is documented even if a \file command is used without further 

   656         // documentation

   657         fd->setDocumentation(root->doc,root->docFile,root->docLine,FALSE);

   658         fd->setBriefDescription(root->brief,root->briefFile,root->briefLine); 

   659         fd->addSectionsToDefinition(root->anchors);

   660         fd->setRefItems(root->sli);

   661         QListIterator<Grouping> gli(*root->groups);

   662         Grouping *g;

   663         for (;(g=gli.current());++gli)

   664         {

   665           GroupDef *gd=0;

   666           if (!g->groupname.isEmpty() && (gd=Doxygen::groupSDict->find(g->groupname)))

   667           {

   668             gd->addFile(fd);

   669             //printf("File %s: in group %s\n",fd->name().data(),s->data());

   670           }

   671         }

   672       }

   673     }

   674 	// NOTE: if OUTPUT_INCLUDES is true then we will see files that are not in

   675 	// the INPUT list

   676     else if (!Config_getBool("OUTPUT_INCLUDES"))

   677     {

   678       const char *fn = root->fileName.data();

   679       QCString text;

   680       text.sprintf("Warning: the name `%s' supplied as "

   681           "the second argument in the \\file statement ",

   682           root->name.data()

   683                   );

   684       if (ambig) // name is ambigious

   685       {

   686         text+="matches the following input files:\n";

   687         text+=showFileDefMatches(Doxygen::inputNameDict,root->name);

   688         text+="Please use a more specific name by "

   689           "including a (larger) part of the path!";

   690       }

   691       else // name is not an input file

   692       {

   693         text+="is not an input file";

   694       }

   695       warn(fn,root->startLine,text);

   696     }

   697 

   698     rootNav->releaseEntry();

   699   }

   700   RECURSE_ENTRYTREE(buildFileList,rootNav);

   701 }

   702 

   703 static void addIncludeFile(ClassDef *cd,FileDef *ifd,Entry *root)

   704 {

   705   if ( 

   706       (!root->doc.stripWhiteSpace().isEmpty() || 

   707        !root->brief.stripWhiteSpace().isEmpty() || 

   708        Config_getBool("EXTRACT_ALL")

   709       ) && root->protection!=Private

   710      )

   711   { 

   712     //printf(">>>>>> includeFile=%s\n",root->includeFile.data());

   713 

   714     bool local=Config_getBool("FORCE_LOCAL_INCLUDES");

   715     QCString includeFile = root->includeFile;

   716     if (!includeFile.isEmpty() && includeFile.at(0)=='"')

   717     {

   718       local = TRUE;

   719       includeFile=includeFile.mid(1,includeFile.length()-2);

   720     }

   721     else if (!includeFile.isEmpty() && includeFile.at(0)=='<')

   722     {

   723       local = FALSE;

   724       includeFile=includeFile.mid(1,includeFile.length()-2);

   725     }

   726 

   727     bool ambig;

   728     FileDef *fd=0;

   729     // see if we need to include a verbatim copy of the header file

   730     //printf("root->includeFile=%s\n",root->includeFile.data());

   731     if (!includeFile.isEmpty() && 

   732         (fd=findFileDef(Doxygen::inputNameDict,includeFile,ambig))==0

   733        )

   734     { // explicit request

   735       QCString text;

   736       text.sprintf("Warning: the name `%s' supplied as "

   737                   "the argument of the \\class, \\struct, \\union, or \\include command ",

   738                   includeFile.data()

   739                  );

   740       if (ambig) // name is ambigious

   741       {

   742         text+="matches the following input files:\n";

   743         text+=showFileDefMatches(Doxygen::inputNameDict,root->includeFile);

   744         text+="Please use a more specific name by "

   745             "including a (larger) part of the path!";

   746       }

   747       else // name is not an input file

   748       {

   749         text+="is not an input file";

   750       }

   751       warn(root->fileName,root->startLine,text);

   752     }

   753     else if (includeFile.isEmpty() && ifd &&

   754         // see if the file extension makes sense

   755         guessSection(ifd->name())==Entry::HEADER_SEC)

   756     { // implicit assumption

   757       fd=ifd;

   758     }

   759 

   760     // if a file is found, we mark it as a source file.

   761     if (fd)

   762     {

   763       QCString iName = !root->includeName.isEmpty() ? 

   764                        root->includeName : includeFile;

   765       if (!iName.isEmpty()) // user specified include file

   766       {

   767         if (iName.at(0)=='<') local=FALSE; // explicit override

   768         if (iName.at(0)=='"' || iName.at(0)=='<')

   769         {

   770           iName=iName.mid(1,iName.length()-2); // strip quotes or brackets

   771         }

   772         if (iName.isEmpty())

   773         {

   774           iName=fd->name();

   775         }

   776       }

   777       else if (!Config_getList("STRIP_FROM_INC_PATH").isEmpty()) 

   778       {

   779         iName=stripFromIncludePath(fd->absFilePath());

   780       }

   781       else // use name of the file containing the class definition

   782       {

   783         iName=fd->name();

   784       }

   785       if (fd->generateSourceFile()) // generate code for header

   786       {

   787         cd->setIncludeFile(fd,iName,local,!root->includeName.isEmpty());

   788       }

   789       else // put #include in the class documentation without link

   790       {

   791         cd->setIncludeFile(0,iName,local,TRUE);

   792       }

   793     }

   794   }

   795 }

   796 

   797 #if 0

   798 static bool addNamespace(Entry *root,ClassDef *cd)

   799 {

   800   // see if this class is defined inside a namespace

   801   if (root->section & Entry::COMPOUND_MASK)

   802   {

   803     Entry *e = root->parent;

   804     while (e)

   805     {

   806       if (e->section==Entry::NAMESPACE_SEC)

   807       {

   808         NamespaceDef *nd=0;

   809         QCString nsName = stripAnonymousNamespaceScope(e->name);

   810         //printf("addNameSpace() trying: %s\n",nsName.data());

   811         if (!nsName.isEmpty() && nsName.at(0)!='@' &&

   812             (nd=getResolvedNamespace(nsName))

   813            )

   814         {

   815           cd->setNamespace(nd);

   816           cd->setOuterScope(nd);

   817           nd->insertClass(cd);

   818           return TRUE;

   819         }

   820       }

   821       e=e->parent;

   822     } 

   823   }

   824   return FALSE;

   825 }

   826 #endif

   827 

   828 #if 0

   829 static Definition *findScope(Entry *root,int level=0)

   830 {

   831   if (root==0) return 0;

   832   //printf("start findScope name=%s\n",root->name.data());

   833   Definition *result=0;

   834   if (root->section&Entry::SCOPE_MASK)

   835   {

   836     result = findScope(root->parent,level+1); // traverse to the root of the tree

   837     if (result)

   838     {

   839       //printf("Found %s inside %s at level %d\n",root->name.data(),result->name().data(),level);

   840       // TODO: look at template arguments

   841       result = result->findInnerCompound(root->name);

   842     }

   843     else // reached the global scope

   844     {

   845       // TODO: look at template arguments

   846       result = Doxygen::globalScope->findInnerCompound(root->name);

   847       //printf("Found in globalScope %s at level %d\n",result->name().data(),level);

   848     }

   849   }

   850   //printf("end findScope(%s,%d)=%s\n",root->name.data(),

   851   //       level,result==0 ? "<none>" : result->name().data());

   852   return result;

   853 }

   854 #endif

   855 

   856 /*! returns the Definition object belonging to the first \a level levels of 

   857  *  full qualified name \a name. Creates an artificial scope if the scope is

   858  *  not found and set the parent/child scope relation if the scope is found.

   859  */

   860 static Definition *buildScopeFromQualifiedName(const QCString name,int level)

   861 {

   862   int i=0;

   863   int p=0,l;

   864   Definition *prevScope=Doxygen::globalScope;

   865   QCString fullScope;

   866   while (i<level)

   867   {

   868     int idx=getScopeFragment(name,p,&l);

   869     QCString nsName = name.mid(idx,l);

   870     if (nsName.isEmpty()) return prevScope;

   871     if (!fullScope.isEmpty()) fullScope+="::";

   872     fullScope+=nsName;

   873     NamespaceDef *nd=Doxygen::namespaceSDict->find(fullScope);

   874     Definition *innerScope = nd;

   875     ClassDef *cd=0; 

   876     if (nd==0) cd = getClass(fullScope);

   877     if (nd==0 && cd) // scope is a class

   878     {

   879       innerScope = cd;

   880     }

   881     else if (nd==0 && cd==0) // scope is not known!

   882     {

   883       // introduce bogus namespace

   884       //printf("++ adding dummy namespace %s to %s\n",nsName.data(),prevScope->name().data());

   885       nd=new NamespaceDef(

   886         "[generated]",1,fullScope);

   887 

   888       // add namespace to the list

   889       Doxygen::namespaceSDict->inSort(fullScope,nd);

   890       innerScope = nd;

   891     }

   892     else // scope is a namespace

   893     {

   894     }

   895     // make the parent/child scope relation

   896     prevScope->addInnerCompound(innerScope);

   897     innerScope->setOuterScope(prevScope);

   898     // proceed to the next scope fragment

   899     p=idx+l+2;

   900     prevScope=innerScope;

   901     i++;

   902   }

   903   return prevScope;

   904 }

   905 

   906 static Definition *findScopeFromQualifiedName(Definition *startScope,const QCString &n,

   907                                               FileDef *fileScope)

   908 {

   909   //printf("<findScopeFromQualifiedName(%s,%s)\n",startScope ? startScope->name().data() : 0, n.data());

   910   Definition *resultScope=startScope;

   911   if (resultScope==0) resultScope=Doxygen::globalScope;

   912   QCString scope=stripTemplateSpecifiersFromScope(n,FALSE);

   913   int l1=0,i1;

   914   i1=getScopeFragment(scope,0,&l1);

   915   if (i1==-1) 

   916   {

   917     //printf(">no fragments!\n");

   918     return resultScope;

   919   }

   920   int p=i1+l1,l2=0,i2;

   921   while ((i2=getScopeFragment(scope,p,&l2))!=-1)

   922   {

   923     QCString nestedNameSpecifier = scope.mid(i1,l1);

   924     Definition *orgScope = resultScope;

   925     //printf("  nestedNameSpecifier=%s\n",nestedNameSpecifier.data());

   926     resultScope = resultScope->findInnerCompound(nestedNameSpecifier);

   927     //printf("  resultScope=%p\n",resultScope);

   928     if (resultScope==0) 

   929     {

   930       NamespaceSDict *usedNamespaces;

   931       if (orgScope==Doxygen::globalScope && fileScope &&

   932           (usedNamespaces = fileScope->getUsedNamespaces())) 

   933         // also search for used namespaces 

   934       {

   935         NamespaceSDict::Iterator ni(*usedNamespaces);

   936         NamespaceDef *nd;

   937         for (ni.toFirst();((nd=ni.current()) && resultScope==0);++ni)

   938         {

   939           // restart search within the used namespace

   940           resultScope = findScopeFromQualifiedName(nd,n,fileScope);

   941         }

   942         if (resultScope) 

   943         {

   944           // for a nested class A::I in used namespace N, we get

   945           // N::A::I while looking for A, so we should compare

   946           // resultScope->name() against scope.left(i2+l2)

   947           //printf("  -> result=%s scope=%s\n",resultScope->name().data(),scope.data());

   948           if (rightScopeMatch(resultScope->name(),scope.left(i2+l2)))

   949           {

   950             break;

   951           }

   952           goto nextFragment;

   953         }

   954       }

   955 

   956       // also search for used classes. Complication: we haven't been able 

   957       // to put them in the right scope yet, because we are still resolving

   958       // the scope relations!

   959       // Therefore loop through all used classes and see if there is a right 

   960       // scope match between the used class and nestedNameSpecifier.

   961       QDictIterator<FileDef> ui(g_usingDeclarations);

   962       FileDef *usedFd;

   963       for (ui.toFirst();(usedFd=ui.current());++ui)

   964       {

   965         //printf("Checking using class %s\n",ui.currentKey());

   966         if (rightScopeMatch(ui.currentKey(),nestedNameSpecifier))

   967         {

   968           // ui.currentKey() is the fully qualified name of nestedNameSpecifier

   969           // so use this instead.

   970           QCString fqn = QCString(ui.currentKey())+

   971                          scope.right(scope.length()-p);

   972           resultScope = buildScopeFromQualifiedName(fqn,fqn.contains("::"));

   973           //printf("Creating scope from fqn=%s result %p\n",fqn.data(),resultScope);

   974           if (resultScope) 

   975           {

   976             //printf("> Match! resultScope=%s\n",resultScope->name().data());

   977             return resultScope;

   978           }

   979         }

   980       }

   981       

   982       //printf("> name %s not found in scope %s\n",nestedNameSpecifier.data(),orgScope->name().data());

   983       return 0;

   984     }

   985  nextFragment:

   986     i1=i2;

   987     l1=l2;

   988     p=i2+l2;

   989   }

   990   //printf(">findScopeFromQualifiedName scope %s\n",resultScope->name().data());

   991   return resultScope;

   992 }

   993 

   994 ArgumentList *getTemplateArgumentsFromName(

   995                   const QCString &name,

   996                   const QList<ArgumentList> *tArgLists)

   997 {

   998   if (tArgLists==0) return 0;

   999   

  1000   QListIterator<ArgumentList> ali(*tArgLists);

  1001   // for each scope fragment, check if it is a template and advance through

  1002   // the list if so.

  1003   int i,p=0;

  1004   while ((i=name.find("::",p))!=-1)

  1005   {

  1006     NamespaceDef *nd = Doxygen::namespaceSDict->find(name.left(i));

  1007     if (nd==0)

  1008     {

  1009       ClassDef *cd = getClass(name.left(i));

  1010       if (cd)

  1011       {

  1012         if (cd->templateArguments())

  1013         {

  1014           ++ali;

  1015         }

  1016       }

  1017     }

  1018     p=i+2;

  1019   }

  1020   return ali.current();

  1021 }

  1022 

  1023 static ClassDef::CompoundType convertToCompoundType(int section,int specifier)

  1024 {

  1025     ClassDef::CompoundType sec=ClassDef::Class; 

  1026     if (specifier&Entry::Struct) 

  1027       sec=ClassDef::Struct;

  1028     else if (specifier&Entry::Union) 

  1029       sec=ClassDef::Union;

  1030     else if (specifier&Entry::Interface) 

  1031       sec=ClassDef::Interface;

  1032     else if (specifier&Entry::Protocol) 

  1033       sec=ClassDef::Protocol;

  1034     else if (specifier&Entry::Category) 

  1035       sec=ClassDef::Category;

  1036     else if (specifier&Entry::Exception) 

  1037       sec=ClassDef::Exception;

  1038 

  1039     switch(section)

  1040     {

  1041       //case Entry::UNION_SEC: 

  1042       case Entry::UNIONDOC_SEC: 

  1043         sec=ClassDef::Union; 

  1044         break;

  1045       //case Entry::STRUCT_SEC:

  1046       case Entry::STRUCTDOC_SEC: 

  1047         sec=ClassDef::Struct; 

  1048         break;

  1049       //case Entry::INTERFACE_SEC:

  1050       case Entry::INTERFACEDOC_SEC:

  1051         sec=ClassDef::Interface; 

  1052         break;

  1053       //case Entry::PROTOCOL_SEC:

  1054       case Entry::PROTOCOLDOC_SEC:

  1055         sec=ClassDef::Protocol; 

  1056         break;

  1057       //case Entry::CATEGORY_SEC:

  1058       case Entry::CATEGORYDOC_SEC:

  1059         sec=ClassDef::Category; 

  1060         break;

  1061       //case Entry::EXCEPTION_SEC:

  1062       case Entry::EXCEPTIONDOC_SEC:

  1063         sec=ClassDef::Exception; 

  1064         break;

  1065     }

  1066     return sec;

  1067 }

  1068 

  1069 

  1070 static void addClassToContext(EntryNav *rootNav)

  1071 {

  1072   //printf("Loading entry for rootNav=%p name=%s\n",rootNav,rootNav->name().data());

  1073   rootNav->loadEntry(g_storage);

  1074   Entry *root = rootNav->entry();

  1075 

  1076   //NamespaceDef *nd = 0;

  1077   FileDef *fd = rootNav->fileDef();

  1078 

  1079   QCString scName;

  1080   if (rootNav->parent()->section()&Entry::SCOPE_MASK)

  1081   {

  1082      scName=rootNav->parent()->name();

  1083   }

  1084   // name without parent's scope

  1085   QCString fullName = root->name;

  1086 

  1087   // strip off any template parameters (but not those for specializations)

  1088   fullName=stripTemplateSpecifiersFromScope(fullName);

  1089 

  1090   // name with scope (if not present already)

  1091   QCString qualifiedName = fullName;

  1092   if (!scName.isEmpty() && !leftScopeMatch(fullName,scName))

  1093   {

  1094     qualifiedName.prepend(scName+"::");

  1095   }

  1096 

  1097   // see if we already found the class before

  1098   ClassDef *cd = getClass(qualifiedName);

  1099 

  1100   Debug::print(Debug::Classes,0, "  Found class with name %s (qualifiedName=%s -> cd=%p)\n",

  1101       cd ? cd->name().data() : root->name.data(), qualifiedName.data(),cd);

  1102   

  1103   if (cd) 

  1104   {

  1105     fullName=cd->name();

  1106     Debug::print(Debug::Classes,0,"  Existing class %s!\n",cd->name().data());

  1107     //if (cd->templateArguments()==0)

  1108     //{

  1109     //  //printf("existing ClassDef tempArgList=%p specScope=%s\n",root->tArgList,root->scopeSpec.data());

  1110     //  cd->setTemplateArguments(tArgList);

  1111     //}

  1112 

  1113     cd->setDocumentation(root->doc,root->docFile,root->docLine);

  1114     cd->setBriefDescription(root->brief,root->briefFile,root->briefLine);

  1115 

  1116     if (root->bodyLine!=-1 && cd->getStartBodyLine()==-1)

  1117     {

  1118       cd->setBodySegment(root->bodyLine,root->endBodyLine);

  1119       cd->setBodyDef(fd);

  1120     }

  1121     //cd->setName(fullName); // change name to match docs

  1122 

  1123     if (cd->templateArguments()==0) 

  1124     {

  1125       // this happens if a template class declared with @class is found

  1126       // before the actual definition.

  1127       ArgumentList *tArgList = 

  1128         getTemplateArgumentsFromName(cd->name(),root->tArgLists);

  1129       cd->setTemplateArguments(tArgList);

  1130     }

  1131 

  1132     cd->setCompoundType(convertToCompoundType(root->section,root->spec));

  1133   }

  1134   else // new class