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

     2  *

     3  * 

     4  *

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

     6  *

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

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

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

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

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

    12  *

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

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

    15  *

    16  */

    17 

    18 #include <stdio.h>

    19 #include <qfile.h>

    20 #include <qregexp.h>

    21 #include "classdef.h"

    22 #include "classlist.h"

    23 #include "entry.h"

    24 #include "doxygen.h"

    25 #include "membername.h"

    26 #include "message.h"

    27 #include "config.h"

    28 #include "util.h"

    29 #include "diagram.h"

    30 #include "language.h"

    31 #include "htmlhelp.h"

    32 #include "example.h"

    33 #include "outputlist.h"

    34 #include "dot.h"

    35 #include "defargs.h"

    36 #include "debug.h"

    37 #include "docparser.h"

    38 #include "searchindex.h"

    39 #include "vhdldocgen.h"

    40 #include "layout.h"

    41 

    42 //-----------------------------------------------------------------------------

    43 

    44 //static inline MemberList *createNewMemberList(MemberList::ListType lt)

    45 //{

    46 //  MemberList *result = new MemberList(lt);

    47 //  return result;

    48 //}

    49 

    50 class ClassDefImpl

    51 {

    52   public:

    53     ClassDefImpl();

    54    ~ClassDefImpl();

    55     void init(const char *defFileName, const char *name,

    56               const QCString &ctStr, const char *fName);

    57 

    58     /*! file name that forms the base for the output file containing the

    59      *  class documentation. For compatibility with Qt (e.g. links via tag 

    60      *  files) this name cannot be derived from the class name directly.

    61      */

    62     QCString fileName;                   

    63 

    64     /*! Include information about the header file should be included

    65      *  in the documentation. 0 by default, set by setIncludeFile().

    66      */

    67     IncludeInfo *incInfo;                

    68 

    69     /*! List of base class (or super-classes) from which this class derives

    70      *  directly. 

    71      */

    72     BaseClassList *inherits;

    73 

    74     /*! List of sub-classes that directly derive from this class 

    75      */

    76     BaseClassList *inheritedBy;

    77 

    78     /*! Namespace this class is part of 

    79      *  (this is the inner most namespace in case of nested namespaces)

    80      */

    81     NamespaceDef  *nspace;              

    82 

    83     /*! File this class is defined in */

    84     FileDef *fileDef;

    85 

    86     /*! List of all members (including inherited members) */

    87     MemberNameInfoSDict *allMemberNameInfoSDict;

    88 

    89     /*! Template arguments of this class */

    90     ArgumentList *tempArgs;

    91 

    92     /*! Type constraints for template parameters */

    93     ArgumentList *typeConstraints;

    94 

    95     /*! Files that were used for generating the class documentation. */

    96     QStrList files;

    97 

    98     /*! Examples that use this class */

    99     ExampleSDict *exampleSDict;

   100 

   101     /*! Holds the kind of "class" this is. */

   102     ClassDef::CompoundType compType;

   103 

   104     /*! The protection level in which this class was found. 

   105      *  Typically Public, but for nested classes this can also be Protected

   106      *  or Private.

   107      */ 

   108     Protection prot;

   109 

   110     /*! The inner classes contained in this class. Will be 0 if there are

   111      *  no inner classes.

   112      */

   113     ClassSDict *innerClasses;

   114 

   115     /* classes for the collaboration diagram */

   116     UsesClassDict *usesImplClassDict;

   117     UsesClassDict *usedByImplClassDict;

   118     UsesClassDict *usesIntfClassDict;

   119 

   120     /*! Template instances that exists of this class, the key in the

   121      *  dictionary is the template argument list.

   122      */ 

   123     QDict<ClassDef> *templateInstances;

   124 

   125     /*! Template instances that exists of this class, as defined by variables.

   126      *  We do NOT want to document these individually. The key in the

   127      *  dictionary is the template argument list.

   128      */ 

   129     QDict<ClassDef> *variableInstances;

   130 

   131     QDict<int> *templBaseClassNames;

   132 

   133     /*! The class this class is an instance of. */

   134     ClassDef *templateMaster;

   135 

   136     /*! local class name which could be a typedef'ed alias name. */

   137     QCString className;

   138 

   139     /*! If this class is a Objective-C category, then this points to the

   140      *  class which is extended.

   141      */

   142     ClassDef *categoryOf;

   143 

   144     QList<MemberList> memberLists;

   145 

   146     /* user defined member groups */

   147     MemberGroupSDict *memberGroupSDict;

   148 

   149     /*! Is this an abstact class? */

   150     bool isAbstract;

   151 

   152     /*! Is the class part of an unnamed namespace? */

   153     bool isStatic;

   154 

   155     /*! Is the class part implemented in Objective C? */

   156     bool isObjC;

   157 

   158     /*! TRUE if classes members are merged with those of the base classes. */

   159     bool membersMerged;

   160 

   161     /*! TRUE if the class is defined in a source file rather than a header file. */

   162     bool isLocal;

   163 

   164     bool isTemplArg;

   165 

   166     /*! Does this class group its user-grouped members

   167      *  as a sub-section of the normal (public/protected/..) 

   168      *  groups?

   169      */

   170     bool subGrouping; 

   171 

   172     bool usedOnly;

   173 };

   174 

   175 void ClassDefImpl::init(const char *defFileName, const char *name,

   176                         const QCString &ctStr, const char *fName)

   177 {

   178   if (fName)

   179   {

   180     fileName=stripExtension(fName);

   181   }

   182   else

   183   {

   184     fileName=ctStr+name;

   185   }

   186   exampleSDict = 0;

   187   inherits    = 0;

   188   inheritedBy = 0;

   189   allMemberNameInfoSDict = 0;

   190   incInfo=0;

   191   tempArgs=0;

   192   typeConstraints=0;

   193   prot=Public;

   194   nspace=0;

   195   fileDef=0;

   196   usesImplClassDict=0;

   197   usedByImplClassDict=0;

   198   usesIntfClassDict=0;

   199   memberGroupSDict = 0;

   200   innerClasses = 0;

   201   subGrouping=Config_getBool("SUBGROUPING");

   202   templateInstances = 0;

   203   variableInstances = 0;

   204   templateMaster =0;

   205   templBaseClassNames = 0;

   206   isAbstract = FALSE;

   207   isStatic = FALSE;

   208   isTemplArg = FALSE;

   209   membersMerged = FALSE;

   210   categoryOf = 0;

   211   usedOnly = FALSE;

   212   //QCString ns;

   213   //extractNamespaceName(name,className,ns);

   214   //printf("m_name=%s m_className=%s ns=%s\n",m_name.data(),m_className.data(),ns.data());

   215 

   216   if (((QCString)defFileName).right(5)!=".java" && 

   217       guessSection(defFileName)==Entry::SOURCE_SEC)

   218   {

   219     isLocal=TRUE;

   220   }

   221   else

   222   {

   223     isLocal=FALSE;

   224   }

   225 }

   226 

   227 ClassDefImpl::ClassDefImpl()

   228 {

   229 }

   230 

   231 ClassDefImpl::~ClassDefImpl()

   232 {

   233   delete inherits;

   234   delete inheritedBy;

   235   delete allMemberNameInfoSDict;

   236   delete exampleSDict;

   237   delete usesImplClassDict;

   238   delete usedByImplClassDict;

   239   delete usesIntfClassDict;

   240   delete incInfo;

   241   delete memberGroupSDict;

   242   delete innerClasses;

   243   delete templateInstances;

   244   delete variableInstances;

   245   delete templBaseClassNames;

   246   delete tempArgs;

   247   delete typeConstraints;

   248 }

   249 

   250 // constructs a new class definition

   251 ClassDef::ClassDef(

   252     const char *defFileName,int defLine,

   253     const char *nm,CompoundType ct,

   254     const char *lref,const char *fName,

   255     bool isSymbol) 

   256  : Definition(defFileName,defLine,removeRedundantWhiteSpace(nm),0,0,isSymbol) 

   257 {

   258   visited=FALSE;

   259   setReference(lref);

   260   m_impl = new ClassDefImpl;

   261   m_impl->compType = ct;

   262   m_impl->isObjC   = FALSE;

   263   m_impl->init(defFileName,name(),compoundTypeString(),fName);

   264 

   265 }

   266 

   267 // destroy the class definition

   268 ClassDef::~ClassDef()

   269 {

   270   delete m_impl;

   271 }

   272 

   273 QCString ClassDef::getMemberListFileName() const

   274 {

   275   return convertNameToFile(compoundTypeString()+name()+"-members");

   276 }

   277 

   278 QCString ClassDef::displayName() const

   279 {

   280   static bool optimizeOutputForJava = Config_getBool("OPTIMIZE_OUTPUT_JAVA");

   281   static bool vhdlOpt = Config_getBool("OPTIMIZE_OUTPUT_VHDL");

   282   QCString n;

   283   if (vhdlOpt)

   284   {

   285     n = VhdlDocGen::getClassName(this);

   286   }

   287   else 

   288   {

   289     n=qualifiedNameWithTemplateParameters();

   290   }

   291   if (optimizeOutputForJava)

   292   {

   293     n=substitute(n,"::",".");

   294   }

   295   if (m_impl->compType==ClassDef::Protocol && n.right(2)=="-p")

   296   {

   297     n="<"+n.left(n.length()-2)+">";

   298   }

   299   return n;

   300 }

   301 

   302 // inserts a base class in the inheritance list

   303 void ClassDef::insertBaseClass(ClassDef *cd,const char *n,Protection p,

   304                                Specifier s,const char *t)

   305 {

   306   //printf("*** insert base class %s into %s\n",cd->name().data(),name().data());

   307   //inherits->inSort(new BaseClassDef(cd,p,s,t));

   308   if (m_impl->inherits==0)

   309   {

   310     m_impl->inherits = new BaseClassList;

   311     m_impl->inherits->setAutoDelete(TRUE);

   312   }

   313   if (Config_getBool("PREPROCESS_INCLUDES")) {

   314     // If we are preprocessing the #included files we might have seen

   315     // this class declaration, and inheritance more than once so we

   316     // only add a relationship where one did not exist before

   317     bool hasAlready = false;

   318 	BaseClassListIterator bcli(*baseClasses());

   319 	BaseClassDef *bcd;

   320 	for (bcli.toFirst();(bcd=bcli.current());++bcli) {

   321 	  if (bcd->usedName == n) {

   322 		hasAlready = true;

   323 		//printf("*** Seen it...\n");

   324 		break;

   325 	  }

   326 	}

   327 	if (!hasAlready) {

   328 	  m_impl->inherits->append(new BaseClassDef(cd,n,p,s,t));

   329 	}

   330   } else {

   331 	m_impl->inherits->append(new BaseClassDef(cd,n,p,s,t));

   332   }

   333 }

   334 

   335 // inserts a sub class in the inherited list

   336 void ClassDef::insertSubClass(ClassDef *cd,Protection p,

   337                                 Specifier s,const char *t)

   338 {

   339   //printf("*** insert sub class %s into %s\n",cd->name().data(),name().data());

   340   if (m_impl->inheritedBy==0)

   341   {

   342     m_impl->inheritedBy   = new BaseClassList;

   343     m_impl->inheritedBy->setAutoDelete(TRUE);

   344   }

   345   m_impl->inheritedBy->inSort(new BaseClassDef(cd,0,p,s,t));

   346 }

   347 

   348 void ClassDef::addMembersToMemberGroup()

   349 {

   350   QListIterator<MemberList> mli(m_impl->memberLists);

   351   MemberList *ml;

   352   for (mli.toFirst();(ml=mli.current());++mli)

   353   {

   354     if ((ml->listType()&MemberList::detailedLists)==0)

   355     {

   356       ::addMembersToMemberGroup(ml,&m_impl->memberGroupSDict,this);

   357     }

   358   }

   359 

   360   // add members inside sections to their groups

   361   if (m_impl->memberGroupSDict)

   362   {

   363     MemberGroupSDict::Iterator mgli(*m_impl->memberGroupSDict);

   364     MemberGroup *mg;

   365     for (;(mg=mgli.current());++mgli)

   366     {

   367       if (mg->allMembersInSameSection() && m_impl->subGrouping) 

   368       {

   369         //printf("addToDeclarationSection(%s)\n",mg->header().data());

   370         mg->addToDeclarationSection();

   371       }

   372     }

   373   }

   374 }

   375 

   376 // adds new member definition to the class

   377 void ClassDef::internalInsertMember(MemberDef *md,

   378                                     Protection prot,

   379                                     bool addToAllList

   380                                    )

   381 {

   382   //printf("%p:insertInternalMember(%s) isHidden()=%d\n", this, md->name().data(),md->isHidden());

   383   if (md->isHidden()) return;

   384 

   385   if (!isReference())

   386   {

   387     static bool extractPrivate = Config_getBool("EXTRACT_PRIVATE");

   388 

   389     /********************************************/

   390     /* insert member in the declaration section */

   391     /********************************************/

   392     if (md->isRelated() && (extractPrivate || prot!=Private))

   393     {

   394       addMemberToList(MemberList::related,md,true);

   395     }

   396     else if (md->isFriend())

   397     {

   398       addMemberToList(MemberList::friends,md,true);

   399     }

   400     else

   401     {

   402       switch (md->memberType())

   403       {

   404         case MemberDef::Signal: // Qt specific

   405           addMemberToList(MemberList::signals,md,true);

   406           break;

   407         case MemberDef::DCOP:   // KDE2 specific

   408           addMemberToList(MemberList::dcopMethods,md,true);

   409           break;

   410         case MemberDef::Property:

   411           addMemberToList(MemberList::properties,md,true);

   412           break;

   413         case MemberDef::Event:

   414           addMemberToList(MemberList::events,md,true);

   415           break;

   416         case MemberDef::Slot:   // Qt specific

   417           switch (prot)

   418           {

   419             case Protected: 

   420             case Package: // slots in packages are not possible!

   421               addMemberToList(MemberList::proSlots,md,true);

   422               break;

   423             case Public:    

   424               addMemberToList(MemberList::pubSlots,md,true);

   425               break;

   426             case Private:   

   427               addMemberToList(MemberList::priSlots,md,true);

   428               break;

   429           }

   430           break;

   431         default: // any of the other members

   432           if (md->isStatic())

   433           {

   434             if (md->isVariable())

   435             {

   436               switch (prot)

   437               {

   438                 case Protected: 

   439                   addMemberToList(MemberList::proStaticAttribs,md,true);

   440                   break;

   441                 case Package: 

   442                   addMemberToList(MemberList::pacStaticAttribs,md,true);

   443                   break;

   444                 case Public:    

   445                   addMemberToList(MemberList::pubStaticAttribs,md,true);

   446                   break;

   447                 case Private:   

   448                   addMemberToList(MemberList::priStaticAttribs,md,true);

   449                   break;

   450               }

   451             }

   452             else // function

   453             {

   454               switch (prot)

   455               {

   456                 case Protected: 

   457                   addMemberToList(MemberList::proStaticMethods,md,true);

   458                   break;

   459                 case Package: 

   460                   addMemberToList(MemberList::pacStaticMethods,md,true);

   461                   break;

   462                 case Public:    

   463                   addMemberToList(MemberList::pubStaticMethods,md,true);

   464                   break;

   465                 case Private:   

   466                   addMemberToList(MemberList::priStaticMethods,md,true);

   467                   break;

   468               }

   469             }

   470           }

   471           else // not static

   472           {

   473             if (md->isVariable())

   474             {

   475               switch (prot)

   476               {

   477                 case Protected: 

   478                   addMemberToList(MemberList::proAttribs,md,true);

   479                   break;

   480                 case Package:

   481                   addMemberToList(MemberList::pacAttribs,md,true);

   482                   break;

   483                 case Public:    

   484                   addMemberToList(MemberList::pubAttribs,md,true);

   485                   break;

   486                 case Private:   

   487                   addMemberToList(MemberList::priAttribs,md,true);

   488                   break;

   489               }

   490             }

   491             else if (md->isTypedef() || md->isEnumerate() || md->isEnumValue())

   492             {

   493               switch (prot)

   494               {

   495                 case Protected: 

   496                   addMemberToList(MemberList::proTypes,md,true);

   497                   break;

   498                 case Package: 

   499                   addMemberToList(MemberList::pacTypes,md,true);

   500                   break;

   501                 case Public:    

   502                   addMemberToList(MemberList::pubTypes,md,true);

   503                   break;

   504                 case Private:   

   505                   addMemberToList(MemberList::priTypes,md,true);

   506                   break;

   507               }

   508             }

   509             else // member function

   510             {

   511               switch (prot)

   512               {

   513                 case Protected: 

   514                   addMemberToList(MemberList::proMethods,md,true);

   515                   break;

   516                 case Package: 

   517                   addMemberToList(MemberList::pacMethods,md,true);

   518                   break;

   519                 case Public:    

   520                   addMemberToList(MemberList::pubMethods,md,true);

   521                   break;

   522                 case Private:   

   523                   addMemberToList(MemberList::priMethods,md,true);

   524                   break;

   525               }

   526             }

   527           }

   528           break; 

   529       }

   530     }

   531 

   532     /*******************************************************/

   533     /* insert member in the detailed documentation section */

   534     /*******************************************************/

   535     if ((md->isRelated() && (extractPrivate || prot!=Private)) || md->isFriend())

   536     {

   537       addMemberToList(MemberList::relatedMembers,md,false);

   538     }

   539     else

   540     {

   541       switch (md->memberType())

   542       {

   543         case MemberDef::Property:

   544           addMemberToList(MemberList::propertyMembers,md,false);

   545           break;

   546         case MemberDef::Event:

   547           addMemberToList(MemberList::eventMembers,md,false);

   548           break;

   549         case MemberDef::Signal: // fall through

   550         case MemberDef::DCOP:

   551           addMemberToList(MemberList::functionMembers,md,false);

   552           break;

   553         case MemberDef::Slot:

   554           switch (prot)

   555           {

   556             case Protected: 

   557             case Package: 

   558             case Public:    

   559               addMemberToList(MemberList::functionMembers,md,false);

   560               break;

   561             case Private:   

   562               if (extractPrivate)

   563               {

   564                 addMemberToList(MemberList::functionMembers,md,false);

   565               }

   566               break;

   567           }

   568           break;

   569         default: // any of the other members

   570           if (prot!=Private || extractPrivate)

   571           {

   572             switch (md->memberType())

   573             {

   574               case MemberDef::Typedef:

   575                 addMemberToList(MemberList::typedefMembers,md,false);

   576                 break;

   577               case MemberDef::Enumeration:

   578                 addMemberToList(MemberList::enumMembers,md,false);

   579                 break;

   580               case MemberDef::EnumValue:

   581                 addMemberToList(MemberList::enumValMembers,md,false);

   582                 break;

   583               case MemberDef::Function:

   584                 if (md->isConstructor() || md->isDestructor())

   585                 {

   586                   MemberList *ml = createMemberList(MemberList::constructors);

   587                   ml->append(md);

   588                 }

   589                 else

   590                 {

   591                   addMemberToList(MemberList::functionMembers,md,false);

   592                 }

   593                 break;

   594               case MemberDef::Variable:

   595                 addMemberToList(MemberList::variableMembers,md,false);

   596                 break;

   597               default:

   598                 err("Unexpected member type %d found!\n",md->memberType());

   599             }

   600           }

   601           break; 

   602       }

   603     }

   604 

   605     /*************************************************/

   606     /* insert member in the appropriate member group */

   607     /*************************************************/

   608     // Note: this must be done AFTER inserting the member in the 

   609     // regular groups

   610     //addMemberToGroup(md,groupId);

   611     

   612   }

   613 

   614   if (md->virtualness()==Pure)

   615   {

   616     m_impl->isAbstract=TRUE;

   617   }

   618 

   619   //::addClassMemberNameToIndex(md);

   620   if (addToAllList && 

   621       !(Config_getBool("HIDE_FRIEND_COMPOUNDS") &&

   622         md->isFriend() &&

   623         (QCString(md->typeString())=="friend class" || 

   624          QCString(md->typeString())=="friend struct" ||

   625          QCString(md->typeString())=="friend union")))

   626   {

   627     //printf("=======> adding member %s to class %s\n",md->name().data(),name().data());

   628     MemberInfo *mi = new MemberInfo((MemberDef *)md,

   629                                      prot,md->virtualness(),FALSE);

   630     MemberNameInfo *mni=0;

   631     if (m_impl->allMemberNameInfoSDict==0)

   632     {

   633       m_impl->allMemberNameInfoSDict = new MemberNameInfoSDict(17);

   634       m_impl->allMemberNameInfoSDict->setAutoDelete(TRUE);

   635     }

   636     if ((mni=m_impl->allMemberNameInfoSDict->find(md->name())))

   637     {

   638       mni->append(mi);

   639     }

   640     else

   641     {

   642       mni = new MemberNameInfo(md->name());

   643       mni->append(mi);

   644       m_impl->allMemberNameInfoSDict->append(mni->memberName(),mni);

   645     }

   646   }

   647 }

   648 

   649 void ClassDef::insertMember(MemberDef *md)

   650 {

   651   internalInsertMember(md,md->protection(),TRUE);

   652 }

   653 

   654 // compute the anchors for all members

   655 void ClassDef::computeAnchors()

   656 {

   657   ClassDef *context = Config_getBool("INLINE_INHERITED_MEMB") ? this : 0;

   658   const char *letters = "abcdefghijklmnopqrstuvwxyz0123456789";

   659   QListIterator<MemberList> mli(m_impl->memberLists);

   660   MemberList *ml;

   661   int index = 0;

   662   for (mli.toFirst();(ml=mli.current());++mli)

   663   {

   664     if ((ml->listType()&MemberList::detailedLists)==0)

   665     {

   666       setAnchors(context,letters[index++],ml);

   667     }

   668   }

   669 

   670   if (m_impl->memberGroupSDict)

   671   {

   672     MemberGroupSDict::Iterator mgli(*m_impl->memberGroupSDict);

   673     MemberGroup *mg;

   674     for (;(mg=mgli.current());++mgli)

   675     {

   676       mg->setAnchors(context);

   677     }

   678   }

   679 }

   680 

   681 void ClassDef::distributeMemberGroupDocumentation()

   682 {

   683   if (m_impl->memberGroupSDict)

   684   {

   685     MemberGroupSDict::Iterator mgli(*m_impl->memberGroupSDict);

   686     MemberGroup *mg;

   687     for (;(mg=mgli.current());++mgli)

   688     {

   689       mg->distributeMemberGroupDocumentation();

   690     }

   691   }

   692 }

   693 

   694 void ClassDef::findSectionsInDocumentation()

   695 {

   696   docFindSections(documentation(),this,0,docFile());

   697   if (m_impl->memberGroupSDict)

   698   {

   699     MemberGroupSDict::Iterator mgli(*m_impl->memberGroupSDict);

   700     MemberGroup *mg;

   701     for (;(mg=mgli.current());++mgli)

   702     {

   703       mg->findSectionsInDocumentation();

   704     }

   705   }

   706   QListIterator<MemberList> mli(m_impl->memberLists);

   707   MemberList *ml;

   708   for (mli.toFirst();(ml=mli.current());++mli)

   709   {

   710     if ((ml->listType()&MemberList::detailedLists)==0)

   711     {

   712       ml->findSectionsInDocumentation();

   713     }

   714   }

   715 }

   716 

   717 

   718 // add a file name to the used files set

   719 void ClassDef::insertUsedFile(const char *f)

   720 {

   721   if (m_impl->files.find(f)==-1) m_impl->files.append(f);

   722   if (m_impl->templateInstances)

   723   {

   724     QDictIterator<ClassDef> qdi(*m_impl->templateInstances);

   725     ClassDef *cd;

   726     for (qdi.toFirst();(cd=qdi.current());++qdi)

   727     {

   728       cd->insertUsedFile(f);

   729     }

   730   }

   731 }

   732 

   733 static void writeInheritanceSpecifier(OutputList &ol,BaseClassDef *bcd)

   734 {

   735   if (bcd->prot!=Public || bcd->virt!=Normal)

   736   {

   737     ol.startTypewriter();

   738     ol.docify(" [");

   739     QStrList sl;

   740     if (bcd->prot==Protected)    sl.append("protected");

   741     else if (bcd->prot==Private) sl.append("private");

   742     if (bcd->virt==Virtual)      sl.append("virtual");

   743     const char *s=sl.first();

   744     while (s)

   745     {

   746       ol.docify(s);

   747       s=sl.next();

   748       if (s) ol.docify(", ");

   749     }

   750     ol.docify("]");

   751     ol.endTypewriter();

   752   }

   753 }

   754 

   755 void ClassDef::setIncludeFile(FileDef *fd,

   756              const char *includeName,bool local, bool force)

   757 {

   758   //printf("ClassDef::setIncludeFile(%p,%s,%d,%d)\n",fd,includeName,local,force);

   759   if (!m_impl->incInfo) m_impl->incInfo=new IncludeInfo;

   760   if ((includeName && m_impl->incInfo->includeName.isEmpty()) ||

   761       (fd!=0 && m_impl->incInfo->fileDef==0)

   762      )

   763   {

   764     //printf("Setting file info\n");

   765     m_impl->incInfo->fileDef     = fd;

   766     m_impl->incInfo->includeName = includeName;

   767     m_impl->incInfo->local       = local;

   768   }

   769   if (force && includeName) m_impl->incInfo->includeName = includeName;

   770 }

   771 

   772 // TODO: fix this: a nested template class can have multiple outer templates

   773 //ArgumentList *ClassDef::outerTemplateArguments() const

   774 //{

   775 //  int ti;

   776 //  ClassDef *pcd=0;

   777 //  int pi=0;

   778 //  if (m_impl->tempArgs) return m_impl->tempArgs;

   779 //  // find the outer most class scope

   780 //  while ((ti=name().find("::",pi))!=-1 && 

   781 //      (pcd=getClass(name().left(ti)))==0

   782 //        ) pi=ti+2;

   783 //  if (pcd)

   784 //  {

   785 //    return pcd->templateArguments();

   786 //  }

   787 //  return 0;

   788 //}

   789 

   790 static void searchTemplateSpecs(/*in*/  Definition *d,

   791                                 /*out*/ QList<ArgumentList> &result,

   792                                 /*out*/ QCString &name)

   793 {

   794   if (d->definitionType()==Definition::TypeClass)

   795   {

   796     if (d->getOuterScope())

   797     {

   798       searchTemplateSpecs(d->getOuterScope(),result,name);

   799     }

   800     ClassDef *cd=(ClassDef *)d;

   801     if (!name.isEmpty()) name+="::";

   802     name+=d->localName();

   803     bool isSpecialization = d->localName().find('<')!=-1;

   804     if (cd->templateArguments()) 

   805     {

   806       result.append(cd->templateArguments());

   807       if (!isSpecialization)

   808       {

   809         name+=tempArgListToString(cd->templateArguments());

   810       }

   811     }

   812   }

   813   else

   814   {

   815     name+=d->qualifiedName();

   816   }

   817 }

   818 

   819 static void writeTemplateSpec(OutputList &ol,Definition *d,

   820             const QCString &type)

   821 {

   822   QList<ArgumentList> specs;

   823   QCString name;

   824   searchTemplateSpecs(d,specs,name);

   825   if (specs.count()>0) // class has template scope specifiers

   826   {

   827     ol.startSubsubsection(); 

   828     QListIterator<ArgumentList> spi(specs);

   829     ArgumentList *al;

   830     for (spi.toFirst();(al=spi.current());++spi)

   831     {

   832       ol.docify("template<");

   833       Argument *a=al->first();

   834       while (a)

   835       {

   836         ol.docify(a->type);

   837         if (!a->name.isEmpty())

   838         {

   839           ol.docify(" ");

   840           ol.docify(a->name);

   841         }

   842         if (a->defval.length()!=0)

   843         {

   844           ol.docify(" = ");

   845           ol.docify(a->defval);

   846         } 

   847         a=al->next();

   848         if (a) ol.docify(", ");

   849       }

   850       ol.docify(">");

   851       ol.pushGeneratorState();

   852       ol.disableAllBut(OutputGenerator::Html);

   853       ol.lineBreak();

   854       ol.popGeneratorState();

   855     }

   856     ol.docify(type.lower()+" "+name);

   857     ol.endSubsubsection();

   858     ol.writeString("\n");

   859   }

   860 }

   861 

   862 void ClassDef::writeBriefDescription(OutputList &ol,bool exampleFlag)

   863 {

   864   if (!briefDescription().isEmpty())

   865   {

   866     ol.startParagraph();

   867     ol.parseDoc(briefFile(),briefLine(),this,0,

   868                 briefDescription(),TRUE,FALSE,0,TRUE,FALSE);

   869     ol.pushGeneratorState();

   870     ol.disable(OutputGenerator::RTF);

   871     ol.writeString(" \n");

   872     ol.enable(OutputGenerator::RTF);

   873 

   874     if (Config_getBool("REPEAT_BRIEF") || 

   875         !documentation().isEmpty() || 

   876         exampleFlag

   877        )

   878     {

   879       ol.disableAllBut(OutputGenerator::Html);

   880       ol.startTextLink(0,"_details");

   881       ol.parseText(theTranslator->trMore());

   882       ol.endTextLink();

   883     }

   884     ol.popGeneratorState();

   885 

   886     //ol.pushGeneratorState();

   887     //ol.disable(OutputGenerator::RTF);

   888     //ol.newParagraph(); // FIXME:PARA

   889     //ol.popGeneratorState();

   890     ol.endParagraph();

   891   }

   892   ol.writeSynopsis();

   893 }

   894 

   895 // write the detailed description for this class

   896 void ClassDef::writeDetailedDescription(OutputList &ol, const QCString &pageType, bool exampleFlag, 

   897                                         const QCString &title)

   898 {

   899   if ((!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF")) || 

   900       !documentation().isEmpty() || 

   901       (Config_getBool("SOURCE_BROWSER") && getStartBodyLine()!=-1 && getBodyDef()) ||

   902       exampleFlag)

   903   {

   904     ol.writeRuler();

   905     ol.pushGeneratorState();

   906       ol.disableAllBut(OutputGenerator::Html);

   907       ol.writeAnchor(0,"_details");

   908     ol.popGeneratorState();

   909     ol.startGroupHeader();

   910     ol.parseText(title);

   911     ol.endGroupHeader();

   912 

   913     ol.startTextBlock();

   914     

   915     writeTemplateSpec(ol,this,pageType);

   916     

   917     // repeat brief description

   918     if (!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF"))

   919     {

   920       ol.parseDoc(briefFile(),briefLine(),this,0,briefDescription(),FALSE,FALSE);

   921     }

   922     if (!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF") &&

   923         !documentation().isEmpty())

   924     {

   925       ol.pushGeneratorState();

   926         ol.disable(OutputGenerator::Man);

   927         ol.disable(OutputGenerator::RTF);

   928         //ol.newParagraph(); // FIXME:PARA

   929         ol.enableAll();

   930         ol.disableAllBut(OutputGenerator::Man);

   931         ol.writeString("\n\n");

   932       ol.popGeneratorState();

   933     }

   934     // write documentation

   935     if (!documentation().isEmpty())

   936     {

   937       ol.parseDoc(docFile(),docLine(),this,0,documentation(),TRUE,FALSE);

   938     }

   939     // write type constraints

   940     writeTypeConstraints(ol,this,m_impl->typeConstraints);

   941 

   942     // write examples

   943     if (exampleFlag && m_impl->exampleSDict)

   944     {

   945       ol.startSimpleSect(BaseOutputDocInterface::Examples,0,0,theTranslator->trExamples()+": ");

   946       ol.startDescForItem();

   947       ol.startParagraph();

   948       writeExample(ol,m_impl->exampleSDict);

   949       ol.endParagraph();

   950       ol.endDescForItem();

   951       ol.endSimpleSect();

   952     }

   953     //ol.newParagraph();

   954     writeSourceDef(ol,name());

   955     ol.endTextBlock();

   956   }

   957   else

   958   {

   959     writeTemplateSpec(ol,this,pageType);

   960   }

   961 }

   962     

   963 void ClassDef::showUsedFiles(OutputList &ol)

   964 {

   965   ol.pushGeneratorState();

   966   ol.disable(OutputGenerator::Man);

   967   bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");

   968 

   969   ol.writeRuler();

   970   if (fortranOpt)

   971   {

   972     ol.parseText(theTranslator->trGeneratedFromFilesFortran(

   973           m_impl->isObjC && m_impl->compType==Interface ? Class : m_impl->compType,

   974           m_impl->files.count()==1));

   975   }

   976   else

   977   {

   978     ol.parseText(theTranslator->trGeneratedFromFiles(

   979           m_impl->isObjC && m_impl->compType==Interface ? Class : m_impl->compType,

   980           m_impl->files.count()==1));  

   981   }

   982 

   983 

   984   bool first=TRUE;

   985   const char *file = m_impl->files.first();

   986   while (file)

   987   {

   988     bool ambig;

   989     FileDef *fd=findFileDef(Doxygen::inputNameDict,file,ambig);

   990     if (fd)

   991     {

   992       if (first)

   993       {

   994         first=FALSE;   

   995         ol.startItemList();

   996       }

   997 

   998       ol.startItemListItem();

   999       QCString path=fd->getPath();

  1000       if (Config_getBool("FULL_PATH_NAMES"))

  1001       {

  1002         ol.docify(stripFromPath(path));

  1003       }

  1004 

  1005       QCString fname = fd->name();

  1006       if (!fd->getVersion().isEmpty()) // append version if available

  1007       {

  1008         fname += " (" + fd->getVersion() + ")";

  1009       }

  1010 

  1011       // for HTML 

  1012       ol.pushGeneratorState();

  1013       ol.disableAllBut(OutputGenerator::Html);

  1014       if (fd->generateSourceFile())

  1015       {

  1016         ol.writeObjectLink(0,fd->getSourceFileBase(),0,fname);

  1017       }

  1018       else if (fd->isLinkable())

  1019       {

  1020         ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),0,

  1021             fname);

  1022       }

  1023       else

  1024       {

  1025         ol.docify(fname);

  1026       }

  1027       ol.popGeneratorState();

  1028 

  1029       // for other output formats

  1030       ol.pushGeneratorState();

  1031       ol.disable(OutputGenerator::Html);

  1032       if (fd->isLinkable())

  1033       {

  1034         ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),0,

  1035             fname);

  1036       }

  1037       else

  1038       {

  1039         ol.docify(fname);

  1040       }

  1041       ol.popGeneratorState();

  1042 

  1043       ol.endItemListItem();

  1044     }

  1045     file=m_impl->files.next();

  1046   }

  1047   if (!first) ol.endItemList();

  1048 

  1049   ol.popGeneratorState();

  1050 }

  1051 

  1052 

  1053 void ClassDef::writeInheritanceGraph(OutputList &ol)

  1054 {

  1055   // count direct inheritance relations

  1056   int count=0;

  1057   BaseClassDef *ibcd;

  1058   if (m_impl->inheritedBy)

  1059   {

  1060     ibcd=m_impl->inheritedBy->first();

  1061     while (ibcd)

  1062     {

  1063       ClassDef *icd=ibcd->classDef;

  1064       if ( icd->isVisibleInHierarchy()) count++;

  1065       ibcd=m_impl->inheritedBy->next();

  1066     }

  1067   }

  1068   if (m_impl->inherits)

  1069   {

  1070     ibcd=m_impl->inherits->first();

  1071     while (ibcd)

  1072     {

  1073       ClassDef *icd=ibcd->classDef;

  1074       if ( icd->isVisibleInHierarchy()) count++;

  1075       ibcd=m_impl->inherits->next();

  1076     }

  1077   }

  1078 

  1079   

  1080   bool renderDiagram = FALSE;

  1081   if (Config_getBool("HAVE_DOT") && Config_getBool("CLASS_DIAGRAMS"))

  1082     // write class diagram using dot

  1083   {

  1084     DotClassGraph inheritanceGraph(this,DotNode::Inheritance);

  1085     if (!inheritanceGraph.isTrivial() && !inheritanceGraph.isTooBig())

  1086     {

  1087       ol.pushGeneratorState();

  1088       ol.disable(OutputGenerator::Man);

  1089       ol.startDotGraph();

  1090       ol.parseText(theTranslator->trClassDiagram(displayName()));

  1091       ol.endDotGraph(inheritanceGraph);

  1092       ol.popGeneratorState();

  1093       renderDiagram = TRUE;

  1094     }

  1095   }

  1096   else if (Config_getBool("CLASS_DIAGRAMS") && count>0) 

  1097     // write class diagram using build-in generator

  1098   {

  1099     ClassDiagram diagram(this); // create a diagram of this class.

  1100     ol.startClassDiagram();

  1101     ol.disable(OutputGenerator::Man);

  1102     ol.parseText(theTranslator->trClassDiagram(displayName()));

  1103     ol.enable(OutputGenerator::Man);

  1104     ol.endClassDiagram(diagram,getOutputFileBase(),displayName());

  1105     renderDiagram = TRUE;

  1106   } 

  1107 

  1108   if (renderDiagram) // if we already show the inheritance relations graphically,

  1109                      // then hide the text version

  1110   {

  1111     ol.disableAllBut(OutputGenerator::Man);

  1112   }

  1113 

  1114   if (m_impl->inherits && (count=m_impl->inherits->count())>0)

  1115   {

  1116     ol.startParagraph();

  1117     //parseText(ol,theTranslator->trInherits()+" ");

  1118 

  1119     QCString inheritLine = theTranslator->trInheritsList(m_impl->inherits->count());

  1120     QRegExp marker("@[0-9]+");

  1121     int index=0,newIndex,matchLen;

  1122     // now replace all markers in inheritLine with links to the classes

  1123     while ((newIndex=marker.match(inheritLine,index,&matchLen))!=-1)

  1124     {

  1125       ol.parseText(inheritLine.mid(index,newIndex-index));

  1126       bool ok;

  1127       uint entryIndex = inheritLine.mid(newIndex+1,matchLen-1).toUInt(&ok);

  1128       BaseClassDef *bcd=m_impl->inherits->at(entryIndex);

  1129       if (ok && bcd)

  1130       {

  1131         ClassDef *cd=bcd->classDef;

  1132 

  1133         // use the class name but with the template arguments as given

  1134         // in the inheritance relation