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 

   159 

   160 void clearAll()

   161 {

   162   g_inputFiles.clear();      

   163   //g_excludeNameDict.clear();  

   164   //delete g_outputList; g_outputList=0;

   165 

   166   Doxygen::classSDict->clear();       

   167   Doxygen::namespaceSDict->clear();   

   168   Doxygen::pageSDict->clear();         

   169   Doxygen::exampleSDict->clear();      

   170   Doxygen::inputNameList->clear();   

   171   Doxygen::formulaList.clear();     

   172   Doxygen::sectionDict.clear();       

   173   Doxygen::inputNameDict->clear();    

   174   Doxygen::includeNameDict->clear();  

   175   Doxygen::exampleNameDict->clear();  

   176   Doxygen::imageNameDict->clear();     

   177   Doxygen::dotFileNameDict->clear();     

   178   Doxygen::formulaDict.clear();      

   179   Doxygen::formulaNameDict.clear();  

   180   Doxygen::tagDestinationDict.clear();

   181   delete Doxygen::mainPage; Doxygen::mainPage=0;

   182 }

   183 

   184 void statistics()

   185 {

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

   187   Doxygen::inputNameDict->statistics();

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

   189   Doxygen::includeNameDict->statistics();

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

   191   Doxygen::exampleNameDict->statistics();

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

   193   Doxygen::imageNameDict->statistics();

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

   195   Doxygen::dotFileNameDict->statistics();

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

   197   //g_excludeNameDict.statistics();

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

   199   Doxygen::aliasDict.statistics();

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

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

   202   Doxygen::namespaceAliasDict.statistics();

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

   204   Doxygen::formulaDict.statistics();

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

   206   Doxygen::formulaNameDict.statistics();

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

   208   Doxygen::tagDestinationDict.statistics();

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

   210   g_compoundKeywordDict.statistics();

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

   212   Doxygen::expandAsDefinedDict.statistics();

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

   214   Doxygen::memGrpInfoDict.statistics();

   215 }

   216 

   217 

   218 

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

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

   221 static void findMember(EntryNav *rootNav,

   222                        QCString funcDecl,

   223                        bool overloaded,

   224                        bool isFunc

   225                       );

   226 

   227 

   228 struct STLInfo

   229 {

   230   const char *className;

   231   const char *baseClass1;

   232   const char *baseClass2;

   233   const char *templType1;

   234   const char *templName1;

   235   const char *templType2;

   236   const char *templName2;

   237   bool virtualInheritance;

   238   bool iterators;

   239 };

   240 

   241 static STLInfo g_stlinfo[] =

   242 {

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

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

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

   246   { "ios_base",             0,                              0,                     0,             0,             0,            0,             FALSE,              FALSE },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   278   { "complex",              0,                              0,                     0,             0,             0,            0,             FALSE,              FALSE },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   306   { 0,                      0,                              0,                     0,             0,             0,            0,             FALSE,              FALSE }

   307 };

   308 

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

   310 {

   311   Entry *memEntry = new Entry;

   312   memEntry->name       = name;

   313   memEntry->type       = type;

   314   memEntry->protection = Private;

   315   memEntry->section    = Entry::VARIABLE_SEC;

   316   memEntry->brief      = "STL member";

   317   memEntry->hidden     = FALSE; 

   318   memEntry->artificial = TRUE;

   319   //memEntry->parent     = root;

   320   //root->addSubEntry(memEntry);

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

   322   memEntryNav->setEntry(memEntry);

   323   rootNav->addChild(memEntryNav);

   324 }

   325 

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

   327 {

   328   Entry *iteratorClassEntry = new Entry;

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

   330   iteratorClassEntry->startLine = 1;

   331   iteratorClassEntry->name      = name;

   332   iteratorClassEntry->section   = Entry::CLASS_SEC;

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

   334   iteratorClassEntry->hidden    = FALSE;

   335   iteratorClassEntry->artificial= TRUE;

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

   337   iteratorClassEntryNav->setEntry(iteratorClassEntry);

   338   classEntryNav->addChild(iteratorClassEntryNav);

   339 }

   340 

   341 

   342 static void addSTLClasses(EntryNav *rootNav)

   343 {

   344   Entry *namespaceEntry = new Entry;

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

   346   namespaceEntry->startLine = 1;

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

   348   namespaceEntry->name      = "std";

   349   namespaceEntry->section   = Entry::NAMESPACE_SEC;

   350   namespaceEntry->brief     = "STL namespace";

   351   namespaceEntry->hidden    = FALSE;

   352   namespaceEntry->artificial= TRUE;

   353   //root->addSubEntry(namespaceEntry);

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

   355   namespaceEntryNav->setEntry(namespaceEntry);

   356   rootNav->addChild(namespaceEntryNav);

   357   

   358   STLInfo *info = g_stlinfo;

   359   while (info->className)

   360   {

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

   362     QCString fullName = info->className;

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

   364 

   365     // add fake Entry for the class

   366     Entry *classEntry = new Entry;

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

   368     classEntry->startLine = 1;

   369     classEntry->name      = fullName;

   370     //classEntry->parent    = namespaceEntry;

   371     classEntry->section   = Entry::CLASS_SEC;

   372     classEntry->brief     = "STL class";

   373     classEntry->hidden    = FALSE;

   374     classEntry->artificial= TRUE;

   375     //namespaceEntry->addSubEntry(classEntry);

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

   377     classEntryNav->setEntry(classEntry);

   378     namespaceEntryNav->addChild(classEntryNav);

   379 

   380     // add template arguments to class

   381     if (info->templType1)

   382     {

   383       ArgumentList *al = new ArgumentList;

   384       Argument *a=new Argument;

   385       a->type="typename";

   386       a->name=info->templType1;

   387       al->append(a);

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

   389       {

   390         a=new Argument;

   391         a->type="typename";

   392         a->name=info->templType2;

   393         al->append(a);

   394       }

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

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

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

   398     }

   399     // add member variables

   400     if (info->templName1)

   401     {

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

   403     }

   404     if (info->templName2)

   405     {

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

   407     }

   408     if (info->baseClass1)

   409     {

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

   411     }

   412     if (info->baseClass2)

   413     {

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

   415     }

   416     if (info->iterators)

   417     {

   418       // add iterator class

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

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

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

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

   423     }

   424     info++;

   425   }

   426 }

   427 

   428 //----------------------------------------------------------------------------

   429 

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

   431                                               FileDef *fileScope=0);

   432 

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

   434 {

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

   436   {

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

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

   439     {

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

   441     }

   442     scope = stripAnonymousNamespaceScope(scope);

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

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

   445     if (d) 

   446     {

   447       pd->setPageScope(d);

   448     }

   449   }

   450 }

   451 

   452 static void addRelatedPage(EntryNav *rootNav)

   453 {

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

   455   GroupDef *gd=0;

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

   457   Grouping *g;

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

   459   {

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

   461   }

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

   463   QCString doc;

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

   465   {

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

   467   }

   468   else

   469   {

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

   471   }

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

   473       root->fileName,root->startLine,

   474       root->sli,

   475       gd,rootNav->tagInfo()

   476      );

   477   if (pd)

   478   {

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

   480     addPageToContext(pd,rootNav);

   481   }

   482 }

   483 

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

   485 {

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

   487   {

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

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

   490 

   491     rootNav->loadEntry(g_storage);

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

   493     

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

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

   496     {

   497       GroupDef *gd;

   498 

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

   500       {

   501         if ( !gd->hasGroupTitle() )

   502         {

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

   504         }

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

   506         {

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

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

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

   510         }

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

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

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

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

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

   516       }

   517       else

   518       {

   519         if (rootNav->tagInfo())

   520         {

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

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

   523         }

   524         else

   525         {

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

   527         }

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

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

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

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

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

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

   534       }

   535     }

   536 

   537     rootNav->releaseEntry();

   538   }

   539   if (rootNav->children())

   540   {

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

   542     EntryNav *e;

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

   544     {

   545       buildGroupListFiltered(e,additional);

   546     }

   547   }

   548 }

   549 

   550 static void buildGroupList(EntryNav *rootNav)

   551 {

   552   // first process the @defgroups blocks

   553   buildGroupListFiltered(rootNav,FALSE);

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

   555   buildGroupListFiltered(rootNav,TRUE);

   556 }

   557 

   558 static void findGroupScope(EntryNav *rootNav)

   559 {

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

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

   562   {

   563     GroupDef *gd;

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

   565     {

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

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

   568       {

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

   570       }

   571       scope = stripAnonymousNamespaceScope(scope);

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

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

   574       if (d) 

   575       {

   576         gd->setGroupScope(d);

   577       }

   578     }

   579   }

   580   RECURSE_ENTRYTREE(findGroupScope,rootNav);

   581 }

   582 

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

   584 {

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

   586   {

   587     rootNav->loadEntry(g_storage);

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

   589 

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

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

   592     {

   593       GroupDef *gd;

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

   595       {

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

   597         addGroupToGroups(root,gd);

   598       }

   599     }

   600 

   601     rootNav->releaseEntry();

   602   }

   603   if (rootNav->children())

   604   {

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

   606     EntryNav *e;

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

   608     {

   609       organizeSubGroupsFiltered(e,additional);

   610     }

   611   }

   612 }

   613 

   614 static void organizeSubGroups(EntryNav *rootNav)

   615 {

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

   617   // first process the @defgroups blocks

   618   organizeSubGroupsFiltered(rootNav,FALSE);

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

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

   621   organizeSubGroupsFiltered(rootNav,TRUE);

   622 }

   623 

   624 //----------------------------------------------------------------------

   625 

   626 static void buildFileList(EntryNav *rootNav)

   627 {

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

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

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

   631      )

   632   {

   633     rootNav->loadEntry(g_storage);

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

   635 

   636     bool ambig;

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

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

   639     if (fd && !ambig)

   640     {

   641 #if 0

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

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

   644       {

   645         warn(

   646             root->fileName,root->startLine,

   647             "Warning: file %s already documented. "

   648             "Skipping documentation.",

   649             root->name.data()

   650             );

   651       }

   652       else

   653 #endif

   654       {

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

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

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

   658         // documentation

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

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

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

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

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

   664         Grouping *g;

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

   666         {

   667           GroupDef *gd=0;

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

   669           {

   670             gd->addFile(fd);

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

   672           }

   673         }

   674       }

   675     }

   676     else

   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