Inheritance diagram for TagFileParser:

Classes
class	EndElementHandler

class	StartElementHandler

Public Member Functions
	TagFileParser (const char *tagName)

void	setDocumentLocator (QXmlLocator *locator)

void	setFileName (const QString &fileName)

void	warn (const char *fmt)

void	warn (const char fmt, const char s)

void	startCompound (const QXmlAttributes &attrib)

void	endCompound ()

void	startMember (const QXmlAttributes &attrib)

void	endMember ()

void	startEnumValue (const QXmlAttributes &attrib)

void	endEnumValue ()

void	endDocAnchor ()

void	endClass ()

void	endNamespace ()

void	endFile ()

void	endPage ()

void	endDir ()

void	startStringValue (const QXmlAttributes &)

void	startDocAnchor (const QXmlAttributes &attrib)

void	endType ()

void	endName ()

void	startBase (const QXmlAttributes &attrib)

void	endBase ()

void	startIncludes (const QXmlAttributes &attrib)

void	endIncludes ()

void	endTemplateArg ()

void	endFilename ()

void	endPath ()

void	endAnchor ()

void	endClangId ()

void	endAnchorFile ()

void	endArglist ()

void	endTitle ()

void	endSubgroup ()

void	startIgnoreElement (const QXmlAttributes &)

void	endIgnoreElement ()

bool	startDocument ()

bool	startElement (const QString &, const QString &, const QString &name, const QXmlAttributes &attrib)

bool	endElement (const QString &, const QString &, const QString &name)

bool	characters (const QString &ch)

void	dump ()

void	buildLists (Entry *root)

void	addIncludes ()

Public Member Functions inherited from QXmlDefaultHandler
	QXmlDefaultHandler ()

virtual	~QXmlDefaultHandler ()

bool	endDocument ()

bool	startPrefixMapping (const QString &prefix, const QString &uri)

bool	endPrefixMapping (const QString &prefix)

bool	ignorableWhitespace (const QString &ch)

bool	processingInstruction (const QString &target, const QString &data)

bool	skippedEntity (const QString &name)

bool	warning (const QXmlParseException &exception)

bool	error (const QXmlParseException &exception)

bool	fatalError (const QXmlParseException &exception)

bool	notationDecl (const QString &name, const QString &publicId, const QString &systemId)

bool	unparsedEntityDecl (const QString &name, const QString &publicId, const QString &systemId, const QString &notationName)

bool	resolveEntity (const QString &publicId, const QString &systemId, QXmlInputSource *&ret)

bool	startDTD (const QString &name, const QString &publicId, const QString &systemId)

bool	endDTD ()

bool	startCDATA ()

bool	endCDATA ()

bool	comment (const QString &ch)

bool	attributeDecl (const QString &eName, const QString &aName, const QString &type, const QString &valueDefault, const QString &value)

bool	internalEntityDecl (const QString &name, const QString &value)

bool	externalEntityDecl (const QString &name, const QString &publicId, const QString &systemId)

QString	errorString ()

Public Member Functions inherited from QXmlContentHandler
virtual	~QXmlContentHandler ()

Public Member Functions inherited from QXmlErrorHandler
virtual	~QXmlErrorHandler ()

Public Member Functions inherited from QXmlDTDHandler
virtual	~QXmlDTDHandler ()

Public Member Functions inherited from QXmlEntityResolver
virtual	~QXmlEntityResolver ()

Public Member Functions inherited from QXmlLexicalHandler
virtual	~QXmlLexicalHandler ()

Public Member Functions inherited from QXmlDeclHandler
virtual	~QXmlDeclHandler ()

Private Types
enum	State { Invalid, InClass, InFile, InNamespace, InGroup, InPage, InMember, InEnumValue, InPackage, InDir, InTempArgList }

Private Member Functions
void	buildMemberList (Entry *ce, QList< TagMemberInfo > &members)

void	addDocAnchors (Entry *e, const TagAnchorInfoList &l)

Private Attributes
QList< TagClassInfo >	m_tagFileClasses

QList< TagFileInfo >	m_tagFileFiles

QList< TagNamespaceInfo >	m_tagFileNamespaces

QList< TagGroupInfo >	m_tagFileGroups

QList< TagPageInfo >	m_tagFilePages

QList< TagPackageInfo >	m_tagFilePackages

QList< TagDirInfo >	m_tagFileDirs

QDict< StartElementHandler >	m_startElementHandlers

QDict< EndElementHandler >	m_endElementHandlers

TagClassInfo *	m_curClass

TagFileInfo *	m_curFile

TagNamespaceInfo *	m_curNamespace

TagPackageInfo *	m_curPackage

TagGroupInfo *	m_curGroup

TagPageInfo *	m_curPage

TagDirInfo *	m_curDir

TagMemberInfo *	m_curMember

TagEnumValueInfo *	m_curEnumValue

TagIncludeInfo *	m_curIncludes

QCString	m_curString

QCString	m_tagName

QCString	m_fileName

QCString	m_title

State	m_state

QStack< State >	m_stateStack

QXmlLocator *	m_locator

QCString	m_inputFileName

Detailed Description

Tag file parser.

Reads an XML-structured tagfile and builds up the structure in memory. The method buildLists() is used to transfer/translate the structures to the doxygen engine.

Definition at line 211 of file tagreader.cpp.

Member Enumeration Documentation

enum TagFileParser::State

private

Enumerator
Invalid
InClass
InFile
InNamespace
InGroup
InPage
InMember
InEnumValue
InPackage
InDir
InTempArgList

Definition at line 213 of file tagreader.cpp.

                { Invalid,
                  InClass,
                  InFile,
                  InNamespace,
                  InGroup,
                  InPage,
                  InMember,
                  InEnumValue,
                  InPackage,
                  InDir,
                  InTempArgList
                };

Constructor & Destructor Documentation

TagFileParser::TagFileParser ( const char * tagName )

inline

Definition at line 248 of file tagreader.cpp.

                                        : m_startElementHandlers(17),
                                          m_endElementHandlers(17),
                                          m_tagName(tagName)
     {
       m_startElementHandlers.setAutoDelete(TRUE);
       m_endElementHandlers.setAutoDelete(TRUE);
       m_curClass=0;
       m_curFile=0;
       m_curNamespace=0;
       m_curPackage=0;
       m_curGroup=0;
       m_curPage=0;
       m_curDir=0;
       m_curMember=0;
       m_curEnumValue=0;
       m_curIncludes=0;
       m_state = Invalid;
       m_locator = 0;
     }

Member Function Documentation

void TagFileParser::addDocAnchors	(	Entry *	e,
		const TagAnchorInfoList &	l
	)

private

Definition at line 1143 of file tagreader.cpp.

 {
   QListIterator<TagAnchorInfo> tli(l);
   TagAnchorInfo *ta;
   for (tli.toFirst();(ta=tli.current());++tli)
   {
     if (Doxygen::sectionDict->find(ta->label)==0)
     {
       //printf("New sectionInfo file=%s anchor=%s\n",
       //    ta->fileName.data(),ta->label.data());
       SectionInfo *si=new SectionInfo(ta->fileName,-1,ta->label,ta->title,
           SectionInfo::Anchor,0,m_tagName);
       Doxygen::sectionDict->append(ta->label,si);
       e->anchors->append(si);
     }
     else
     {
       warn("Duplicate anchor %s found\n",ta->label.data());
     }
   }
 }

void TagFileParser::addIncludes ( )

Definition at line 1480 of file tagreader.cpp.

 {
   QListIterator<TagFileInfo> fit(m_tagFileFiles);
   TagFileInfo *tfi;
   for (fit.toFirst();(tfi=fit.current());++fit)
   {
     //printf("tag file tagName=%s path=%s name=%s\n",m_tagName.data(),tfi->path.data(),tfi->name.data());
     FileName *fn = Doxygen::inputNameDict->find(tfi->name);
     if (fn)
     {
       //printf("found\n");
       FileNameIterator fni(*fn);
       FileDef *fd;
       for (;(fd=fni.current());++fni)
       {
         //printf("input file path=%s name=%s\n",fd->getPath().data(),fd->name().data());
         if (fd->getPath()==QCString(m_tagName+":"+tfi->path))
         {
           //printf("found\n");
           QListIterator<TagIncludeInfo> mii(tfi->includes);
           TagIncludeInfo *ii;
           for (;(ii=mii.current());++mii)
           {
             //printf("ii->name=`%s'\n",ii->name.data());
             FileName *ifn = Doxygen::inputNameDict->find(ii->name);
             ASSERT(ifn!=0);
             if (ifn)
             {
               FileNameIterator ifni(*ifn);
               FileDef *ifd;
               for (;(ifd=ifni.current());++ifni)
               {
                 //printf("ifd->getOutputFileBase()=%s ii->id=%s\n",
                 //        ifd->getOutputFileBase().data(),ii->id.data());
                 if (ifd->getOutputFileBase()==QCString(ii->id))
                 {
                   fd->addIncludeDependency(ifd,ii->text,ii->isLocal,ii->isImported,FALSE);
                 }
               }
             }
           }
         }
       }
     }
   }
 }

void TagFileParser::buildLists ( Entry * root )

Injects the info gathered by the XML parser into the Entry tree. This tree contains the information extracted from the input in a "unrelated" form.

Definition at line 1304 of file tagreader.cpp.

 {
   // build class list
   QListIterator<TagClassInfo> cit(m_tagFileClasses);
   TagClassInfo *tci;
   for (cit.toFirst();(tci=cit.current());++cit)
   {
     Entry *ce = new Entry;
     ce->section = Entry::CLASS_SEC;
     switch (tci->kind)
     {
       case TagClassInfo::Class:     break;
       case TagClassInfo::Struct:    ce->spec = Entry::Struct;    break;
       case TagClassInfo::Union:     ce->spec = Entry::Union;     break;
       case TagClassInfo::Interface: ce->spec = Entry::Interface; break;
       case TagClassInfo::Enum:      ce->spec = Entry::Enum;      break;
       case TagClassInfo::Exception: ce->spec = Entry::Exception; break;
       case TagClassInfo::Protocol:  ce->spec = Entry::Protocol;  break;
       case TagClassInfo::Category:  ce->spec = Entry::Category;  break;
       case TagClassInfo::Service:   ce->spec = Entry::Service;   break;
       case TagClassInfo::Singleton: ce->spec = Entry::Singleton; break;
     }
     ce->name     = tci->name;
     if (tci->kind==TagClassInfo::Protocol)
     {
       ce->name+="-p";
     }
     addDocAnchors(ce,tci->docAnchors);
     TagInfo *ti  = new TagInfo;
     ti->tagName  = m_tagName;
     ti->fileName = tci->filename;
     ce->id       = tci->clangId;
     ce->tagInfo  = ti;
     ce->lang     = tci->isObjC ? SrcLangExt_ObjC : SrcLangExt_Unknown;
     // transfer base class list
     if (tci->bases)
     {
       delete ce->extends;
       ce->extends = tci->bases; tci->bases = 0;
     }
     if (tci->templateArguments)
     {
       if (ce->tArgLists==0)
       {
         ce->tArgLists = new QList<ArgumentList>;
         ce->tArgLists->setAutoDelete(TRUE);
       }
       ArgumentList *al = new ArgumentList;
       ce->tArgLists->append(al);
 
       QListIterator<QCString> sli(*tci->templateArguments);
       QCString *argName;
       for (;(argName=sli.current());++sli)
       {
         Argument *a = new Argument;
         a->type = "class";
         a->name = *argName;
         al->append(a);
       }
     }
 
     buildMemberList(ce,tci->members);
     root->addSubEntry(ce);
   }
 
   // build file list
   QListIterator<TagFileInfo> fit(m_tagFileFiles);
   TagFileInfo *tfi;
   for (fit.toFirst();(tfi=fit.current());++fit)
   {
     Entry *fe = new Entry;
     fe->section = guessSection(tfi->name);
     fe->name     = tfi->name;
     addDocAnchors(fe,tfi->docAnchors);
     TagInfo *ti  = new TagInfo;
     ti->tagName  = m_tagName;
     ti->fileName = tfi->filename;
     fe->tagInfo  = ti;
     
     QCString fullName = m_tagName+":"+tfi->path+stripPath(tfi->name);
     fe->fileName = fullName;
     //printf("new FileDef() filename=%s\n",tfi->filename.data());
     FileDef *fd = new FileDef(m_tagName+":"+tfi->path,
                               tfi->name,m_tagName,
                               tfi->filename
                              );
     FileName *mn;
     if ((mn=Doxygen::inputNameDict->find(tfi->name)))
     {
       mn->append(fd);
     }
     else
     {
       mn = new FileName(fullName,tfi->name);
       mn->append(fd);
       Doxygen::inputNameList->inSort(mn);
       Doxygen::inputNameDict->insert(tfi->name,mn);
     }
     buildMemberList(fe,tfi->members);
     root->addSubEntry(fe);
   }
 
   // build namespace list
   QListIterator<TagNamespaceInfo> nit(m_tagFileNamespaces);
   TagNamespaceInfo *tni;
   for (nit.toFirst();(tni=nit.current());++nit)
   {
     Entry *ne    = new Entry;
     ne->section  = Entry::NAMESPACE_SEC;
     ne->name     = tni->name;
     addDocAnchors(ne,tni->docAnchors);
     TagInfo *ti  = new TagInfo;
     ti->tagName  = m_tagName;
     ti->fileName = tni->filename;
     ne->id       = tni->clangId;
     ne->tagInfo  = ti;
 
     buildMemberList(ne,tni->members);
     root->addSubEntry(ne);
   }
 
   // build package list
   QListIterator<TagPackageInfo> pit(m_tagFilePackages);
   TagPackageInfo *tpgi;
   for (pit.toFirst();(tpgi=pit.current());++pit)
   {
     Entry *pe    = new Entry;
     pe->section  = Entry::PACKAGE_SEC;
     pe->name     = tpgi->name;
     addDocAnchors(pe,tpgi->docAnchors);
     TagInfo *ti  = new TagInfo;
     ti->tagName  = m_tagName;
     ti->fileName = tpgi->filename;
     pe->tagInfo  = ti;
 
     buildMemberList(pe,tpgi->members);
     root->addSubEntry(pe);
   }
 
   // build group list
   QListIterator<TagGroupInfo> git(m_tagFileGroups);
   TagGroupInfo *tgi;
   for (git.toFirst();(tgi=git.current());++git)
   {
     Entry *ge    = new Entry;
     ge->section  = Entry::GROUPDOC_SEC;
     ge->name     = tgi->name;
     ge->type     = tgi->title;
     addDocAnchors(ge,tgi->docAnchors);
     TagInfo *ti  = new TagInfo;
     ti->tagName  = m_tagName;
     ti->fileName = tgi->filename;
     ge->tagInfo  = ti;
 
     buildMemberList(ge,tgi->members);
     root->addSubEntry(ge);
   }
 
   // build page list
   QListIterator<TagPageInfo> pgit(m_tagFilePages);
   TagPageInfo *tpi;
   for (pgit.toFirst();(tpi=pgit.current());++pgit)
   {
     Entry *pe    = new Entry;
     pe->section  = tpi->filename=="index" ? Entry::MAINPAGEDOC_SEC : Entry::PAGEDOC_SEC;
     pe->name     = tpi->name;
     pe->args     = tpi->title;
     addDocAnchors(pe,tpi->docAnchors);
     TagInfo *ti  = new TagInfo;
     ti->tagName  = m_tagName;
     ti->fileName = tpi->filename;
     pe->tagInfo  = ti;
     root->addSubEntry(pe);
   }
 }

void TagFileParser::buildMemberList	(	Entry *	ce,
		QList< TagMemberInfo > &	members
	)

private

Definition at line 1165 of file tagreader.cpp.

 {
   QListIterator<TagMemberInfo> mii(members);
   TagMemberInfo *tmi;
   for (;(tmi=mii.current());++mii)
   {
     Entry *me      = new Entry;
     me->type       = tmi->type;
     me->name       = tmi->name;
     me->args       = tmi->arglist;
     if (!me->args.isEmpty())
     {
       delete me->argList;
       me->argList = new ArgumentList;
       stringToArgumentList(me->args,me->argList);
     }
     if (tmi->enumValues.count()>0)
     {
       me->spec |= Entry::Strong;
       QListIterator<TagEnumValueInfo> evii(tmi->enumValues);
       TagEnumValueInfo *evi;
       for (evii.toFirst();(evi=evii.current());++evii)
       {
         Entry *ev      = new Entry;
         ev->type       = "@";
         ev->name       = evi->name;
         ev->id         = evi->clangid;
         ev->section    = Entry::VARIABLE_SEC;
         TagInfo *ti    = new TagInfo;
         ti->tagName    = m_tagName;
         ti->anchor     = evi->anchor;
         ti->fileName   = evi->file;
         ev->tagInfo    = ti;
         me->addSubEntry(ev);
       }
     }
     me->protection = tmi->prot;
     me->virt       = tmi->virt;
     me->stat       = tmi->isStatic;
     me->fileName   = ce->fileName;
     me->id         = tmi->clangId;
     if (ce->section == Entry::GROUPDOC_SEC)
     {
       me->groups->append(new Grouping(ce->name,Grouping::GROUPING_INGROUP));
     }
     addDocAnchors(me,tmi->docAnchors);
     TagInfo *ti    = new TagInfo;
     ti->tagName    = m_tagName;
     ti->anchor     = tmi->anchor;
     ti->fileName   = tmi->anchorFile;
     me->tagInfo    = ti;
     if (tmi->kind=="define")
     {
       me->type="#define";
       me->section = Entry::DEFINE_SEC;
     }
     else if (tmi->kind=="enumvalue")
     {
       me->section = Entry::VARIABLE_SEC;
       me->mtype = Method;
     }
     else if (tmi->kind=="property")
     {
       me->section = Entry::VARIABLE_SEC;
       me->mtype = Property;
     }
     else if (tmi->kind=="event")
     {
       me->section = Entry::VARIABLE_SEC;
       me->mtype = Event;
     }
     else if (tmi->kind=="variable")
     {
       me->section = Entry::VARIABLE_SEC;
       me->mtype = Method;
     }
     else if (tmi->kind=="typedef")
     {
       me->section = Entry::VARIABLE_SEC; //Entry::TYPEDEF_SEC;
       me->type.prepend("typedef ");
       me->mtype = Method;
     }
     else if (tmi->kind=="enumeration")
     {
       me->section = Entry::ENUM_SEC;
       me->mtype = Method;
     }
     else if (tmi->kind=="function")
     {
       me->section = Entry::FUNCTION_SEC;
       me->mtype = Method;
     }
     else if (tmi->kind=="signal")
     {
       me->section = Entry::FUNCTION_SEC;
       me->mtype = Signal;
     }
     else if (tmi->kind=="prototype")
     {
       me->section = Entry::FUNCTION_SEC;
       me->mtype = Method;
     }
     else if (tmi->kind=="friend")
     {
       me->section = Entry::FUNCTION_SEC;
       me->type.prepend("friend ");
       me->mtype = Method;
     }
     else if (tmi->kind=="dcop")
     {
       me->section = Entry::FUNCTION_SEC;
       me->mtype = DCOP;
     }
     else if (tmi->kind=="slot")
     {
       me->section = Entry::FUNCTION_SEC;
       me->mtype = Slot;
     }
     ce->addSubEntry(me);
   }
 }

bool TagFileParser::characters ( const QString & ch )

inlinevirtual

Does nothing.

Reimplemented from QXmlDefaultHandler.

Definition at line 901 of file tagreader.cpp.

     {
       m_curString+=ch.utf8();
       return TRUE;
     }

void TagFileParser::dump ( )

Dumps the internal structures. For debugging only!

Definition at line 973 of file tagreader.cpp.

 {
   msg("Result:\n");
   QListIterator<TagClassInfo> lci(m_tagFileClasses);
 
   //============== CLASSES
   TagClassInfo *cd;
   for (;(cd=lci.current());++lci)
   {
     msg("class `%s'\n",cd->name.data());
     msg("  filename `%s'\n",cd->filename.data());
     if (cd->bases)
     {
       QListIterator<BaseInfo> bii(*cd->bases);
       BaseInfo *bi;
       for ( bii.toFirst() ; (bi=bii.current()) ; ++bii) 
       {
         msg( "  base: %s \n", bi->name.data() );
       }
     }
 
     QListIterator<TagMemberInfo> mci(cd->members);
     TagMemberInfo *md;
     for (;(md=mci.current());++mci)
     {
       msg("  member:\n");
       msg("    kind: `%s'\n",md->kind.data());
       msg("    name: `%s'\n",md->name.data());
       msg("    anchor: `%s'\n",md->anchor.data());
       msg("    arglist: `%s'\n",md->arglist.data());
     }
   }
   //============== NAMESPACES
   QListIterator<TagNamespaceInfo> lni(m_tagFileNamespaces);
   TagNamespaceInfo *nd;
   for (;(nd=lni.current());++lni)
   {
     msg("namespace `%s'\n",nd->name.data());
     msg("  filename `%s'\n",nd->filename.data());
     QStringList::Iterator it;
     for ( it = nd->classList.begin(); 
         it != nd->classList.end(); ++it ) 
     {
       msg( "  class: %s \n", (*it).latin1() );
     }
 
     QListIterator<TagMemberInfo> mci(nd->members);
     TagMemberInfo *md;
     for (;(md=mci.current());++mci)
     {
       msg("  member:\n");
       msg("    kind: `%s'\n",md->kind.data());
       msg("    name: `%s'\n",md->name.data());
       msg("    anchor: `%s'\n",md->anchor.data());
       msg("    arglist: `%s'\n",md->arglist.data());
     }
   }
   //============== FILES
   QListIterator<TagFileInfo> lfi(m_tagFileFiles);
   TagFileInfo *fd;
   for (;(fd=lfi.current());++lfi)
   {
     msg("file `%s'\n",fd->name.data());
     msg("  filename `%s'\n",fd->filename.data());
     QStringList::Iterator it;
     for ( it = fd->namespaceList.begin(); 
         it != fd->namespaceList.end(); ++it ) 
     {
       msg( "  namespace: %s \n", (*it).latin1() );
     }
     for ( it = fd->classList.begin(); 
         it != fd->classList.end(); ++it ) 
     {
       msg( "  class: %s \n", (*it).latin1() );
     }
 
     QListIterator<TagMemberInfo> mci(fd->members);
     TagMemberInfo *md;
     for (;(md=mci.current());++mci)
     {
       msg("  member:\n");
       msg("    kind: `%s'\n",md->kind.data());
       msg("    name: `%s'\n",md->name.data());
       msg("    anchor: `%s'\n",md->anchor.data());
       msg("    arglist: `%s'\n",md->arglist.data());
     }
 
     QListIterator<TagIncludeInfo> mii(fd->includes);
     TagIncludeInfo *ii;
     for (;(ii=mii.current());++mii)
     {
       msg("  includes id: %s name: %s\n",ii->id.data(),ii->name.data());
     }
   }
 
   //============== GROUPS
   QListIterator<TagGroupInfo> lgi(m_tagFileGroups);
   TagGroupInfo *gd;
   for (;(gd=lgi.current());++lgi)
   {
     msg("group `%s'\n",gd->name.data());
     msg("  filename `%s'\n",gd->filename.data());
     QStringList::Iterator it;
     for ( it = gd->namespaceList.begin(); 
         it != gd->namespaceList.end(); ++it ) 
     {
       msg( "  namespace: %s \n", (*it).latin1() );
     }
     for ( it = gd->classList.begin(); 
         it != gd->classList.end(); ++it ) 
     {
       msg( "  class: %s \n", (*it).latin1() );
     }
     for ( it = gd->fileList.begin(); 
         it != gd->fileList.end(); ++it ) 
     {
       msg( "  file: %s \n", (*it).latin1() );
     }
     for ( it = gd->subgroupList.begin(); 
         it != gd->subgroupList.end(); ++it ) 
     {
       msg( "  subgroup: %s \n", (*it).latin1() );
     }
     for ( it = gd->pageList.begin(); 
         it != gd->pageList.end(); ++it ) 
     {
       msg( "  page: %s \n", (*it).latin1() );
     }
 
     QListIterator<TagMemberInfo> mci(gd->members);
     TagMemberInfo *md;
     for (;(md=mci.current());++mci)
     {
       msg("  member:\n");
       msg("    kind: `%s'\n",md->kind.data());
       msg("    name: `%s'\n",md->name.data());
       msg("    anchor: `%s'\n",md->anchor.data());
       msg("    arglist: `%s'\n",md->arglist.data());
     }
   }
   //============== PAGES
   QListIterator<TagPageInfo> lpi(m_tagFilePages);
   TagPageInfo *pd;
   for (;(pd=lpi.current());++lpi)
   {
     msg("page `%s'\n",pd->name.data());
     msg("  title `%s'\n",pd->title.data());
     msg("  filename `%s'\n",pd->filename.data());
   }
   //============== DIRS
   QListIterator<TagDirInfo> ldi(m_tagFileDirs);
   TagDirInfo *dd;
   for (;(dd=ldi.current());++ldi)
   {
     msg("dir `%s'\n",dd->name.data());
     msg("  path `%s'\n",dd->path.data());
     QStringList::Iterator it;
     for ( it = dd->fileList.begin(); 
         it != dd->fileList.end(); ++it ) 
     {
       msg( "  file: %s \n", (*it).latin1() );
     }
     for ( it = dd->subdirList.begin(); 
         it != dd->subdirList.end(); ++it ) 
     {
       msg( "  subdir: %s \n", (*it).latin1() );
     }
   }
 }

void TagFileParser::endAnchor ( )

inline

Definition at line 711 of file tagreader.cpp.

     {
       if (m_state==InMember)
       {
         m_curMember->anchor = m_curString; 
       }
       else
       {
         warn("Unexpected tag `anchor' found\n");
       }
     }

void TagFileParser::endAnchorFile ( )

inline

Definition at line 745 of file tagreader.cpp.

     {
       if (m_state==InMember)
       {
         m_curMember->anchorFile = m_curString; 
       }
       else
       {
         warn("Unexpected tag `anchorfile' found\n");
       }
     }

void TagFileParser::endArglist ( )

inline

Definition at line 757 of file tagreader.cpp.

     {
       if (m_state==InMember)
       {
         m_curMember->arglist = m_curString; 
       }
       else
       {
         warn("Unexpected tag `arglist' found\n");
       }
     }

void TagFileParser::endBase ( )

inline

Definition at line 634 of file tagreader.cpp.

     {
       if (m_state==InClass && m_curClass)
       {
         m_curClass->bases->getLast()->name = m_curString;
       }
       else
       {
         warn("Unexpected tag `base' found\n");
       }
     }

void TagFileParser::endClangId ( )

inline

Definition at line 723 of file tagreader.cpp.

     {
       if (m_state==InMember)
       {
         m_curMember->clangId = m_curString; 
       }
       else if (m_state==InClass)
       {
         m_curClass->clangId =  m_curString;
       }
       else if (m_state==InNamespace)
       {
         m_curNamespace->clangId = m_curString;
       }
       else
       {
         warn("warning: Unexpected tag `anchor' found\n");
       }
     }

void TagFileParser::endClass ( )

inline

Definition at line 508 of file tagreader.cpp.

     {
       switch(m_state)
       {
         case InClass:     m_curClass->classList.append(m_curString); break;
         case InFile:      m_curFile->classList.append(m_curString); break;
         case InNamespace: m_curNamespace->classList.append(m_curString); break;
         case InGroup:     m_curGroup->classList.append(m_curString); break;
         case InPackage:   m_curPackage->classList.append(m_curString); break;
         default:   warn("Unexpected tag `class' found\n"); break; 
       }
     }

void TagFileParser::endCompound ( )

inline

Definition at line 393 of file tagreader.cpp.

     {
       switch (m_state)
       {
         case InClass:     m_tagFileClasses.append(m_curClass); 
                           m_curClass=0; break; 
         case InFile:      m_tagFileFiles.append(m_curFile); 
                           m_curFile=0; break; 
         case InNamespace: m_tagFileNamespaces.append(m_curNamespace); 
                           m_curNamespace=0; break; 
         case InGroup:     m_tagFileGroups.append(m_curGroup); 
                           m_curGroup=0; break; 
         case InPage:      m_tagFilePages.append(m_curPage); 
                           m_curPage=0; break; 
         case InDir:       m_tagFileDirs.append(m_curDir);
                           m_curDir=0; break;
         case InPackage:   m_tagFilePackages.append(m_curPackage); 
                           m_curPackage=0; break; 
         default:
                           warn("tag `compound' was not expected!\n");
       }
     }

void TagFileParser::endDir ( )

inline

Definition at line 551 of file tagreader.cpp.

     {
       switch(m_state)
       {
         case InDir:      m_curDir->subdirList.append(m_curString); break;
         default:   warn("Unexpected tag `page' found\n"); break; 
       }
     }

void TagFileParser::endDocAnchor ( )

inline

Definition at line 492 of file tagreader.cpp.

     {
       switch(m_state)
       {
         case InClass:     m_curClass->docAnchors.append(new TagAnchorInfo(m_fileName,m_curString)); break;
         case InFile:      m_curFile->docAnchors.append(new TagAnchorInfo(m_fileName,m_curString)); break;
         case InNamespace: m_curNamespace->docAnchors.append(new TagAnchorInfo(m_fileName,m_curString)); break;
         case InGroup:     m_curGroup->docAnchors.append(new TagAnchorInfo(m_fileName,m_curString)); break;
         case InPage:      m_curPage->docAnchors.append(new TagAnchorInfo(m_fileName,m_curString,m_title)); break;
         case InMember:    m_curMember->docAnchors.append(new TagAnchorInfo(m_fileName,m_curString)); break;
         case InPackage:   m_curPackage->docAnchors.append(new TagAnchorInfo(m_fileName,m_curString)); break;
         case InDir:       m_curDir->docAnchors.append(new TagAnchorInfo(m_fileName,m_curString)); break;
         default:   warn("Unexpected tag `member' found\n"); break; 
       }
     }

bool TagFileParser::endElement	(	const QString &	namespaceURI,
		const QString &	localName,
		const QString &	qName
	)

inlinevirtual

Does nothing.

Reimplemented from QXmlDefaultHandler.

Definition at line 886 of file tagreader.cpp.

     {
       //printf("endElement `%s'\n",name.data());
       EndElementHandler *handler = m_endElementHandlers[name.utf8()];
       if (handler)
       {
         (*handler)();
       }
       else 
       {
         warn("Unknown tag `%s' found!\n",name.data());
       }
       return TRUE;
     }

void TagFileParser::endEnumValue ( )

inline

Definition at line 480 of file tagreader.cpp.

     {
       m_curEnumValue->name = m_curString.stripWhiteSpace(); 
       m_state = *m_stateStack.top();
       m_stateStack.remove();
       if (m_state==InMember)
       {
         m_curMember->enumValues.append(m_curEnumValue);
         m_curEnumValue=0;
       }
     }

void TagFileParser::endFile ( )

inline

Definition at line 532 of file tagreader.cpp.

     {
       switch(m_state)
       {
         case InGroup:      m_curGroup->fileList.append(m_curString); break;
         case InDir:        m_curDir->fileList.append(m_curString); break;
         default:   warn("Unexpected tag `file' found\n"); break; 
       }
     }

void TagFileParser::endFilename ( )

inline

Definition at line 686 of file tagreader.cpp.

     {
       switch (m_state)
       {
         case InClass:     m_curClass->filename     = m_curString;    break;
         case InNamespace: m_curNamespace->filename = m_curString;    break;
         case InFile:      m_curFile->filename      = m_curString;    break;
         case InGroup:     m_curGroup->filename     = m_curString;    break;
         case InPage:      m_curPage->filename      = m_curString;    break;
         case InPackage:   m_curPackage->filename   = m_curString;    break;
         case InDir:       m_curDir->filename       = m_curString;    break;
         default: warn("Unexpected tag `filename' found\n"); break; 
       }
     }

void TagFileParser::endIgnoreElement ( )

inline

Definition at line 794 of file tagreader.cpp.

795 {

796 }

void TagFileParser::endIncludes ( )

inline

Definition at line 664 of file tagreader.cpp.

     {
       m_curIncludes->text = m_curString;
     }

void TagFileParser::endMember ( )

inline

Definition at line 447 of file tagreader.cpp.

     {
       m_state = *m_stateStack.top();
       m_stateStack.remove();
       switch(m_state)
       {
         case InClass:     m_curClass->members.append(m_curMember); break;
         case InFile:      m_curFile->members.append(m_curMember); break;
         case InNamespace: m_curNamespace->members.append(m_curMember); break;
         case InGroup:     m_curGroup->members.append(m_curMember); break;
         case InPackage:   m_curPackage->members.append(m_curMember); break;
         default:   warn("Unexpected tag `member' found\n"); break; 
       }
     }

void TagFileParser::endName ( )

inline

Definition at line 584 of file tagreader.cpp.

     {
       switch (m_state)
       {
         case InClass:     m_curClass->name     = m_curString; break;
         case InFile:      m_curFile->name      = m_curString; break;
         case InNamespace: m_curNamespace->name = m_curString; break;
         case InGroup:     m_curGroup->name     = m_curString; break;
         case InPage:      m_curPage->name      = m_curString; break;
         case InDir:       m_curDir->name       = m_curString; break;
         case InMember:    m_curMember->name    = m_curString; break;
         case InPackage:   m_curPackage->name   = m_curString; break;
         default: warn("Unexpected tag `name' found\n"); break; 
       }
     }

void TagFileParser::endNamespace ( )

inline

Definition at line 521 of file tagreader.cpp.

     {
       switch(m_state)
       {
         case InNamespace: m_curNamespace->classList.append(m_curString); break;
         case InFile:      m_curFile->namespaceList.append(m_curString); break;
         case InGroup:     m_curGroup->namespaceList.append(m_curString); break;
         default:   warn("Unexpected tag `namespace' found\n"); break; 
       }
     }

void TagFileParser::endPage ( )

inline

Definition at line 542 of file tagreader.cpp.

     {
       switch(m_state)
       {
         case InGroup:      m_curGroup->fileList.append(m_curString); break;
         default:   warn("Unexpected tag `page' found\n"); break; 
       }
     }

void TagFileParser::endPath ( )

inline

Definition at line 701 of file tagreader.cpp.

     {
       switch (m_state)
       {
         case InFile:      m_curFile->path          = m_curString;    break;
         case InDir:       m_curDir->path           = m_curString;    break;
         default: warn("Unexpected tag `path' found\n");     break; 
       }
     }

void TagFileParser::endSubgroup ( )

inline

Definition at line 778 of file tagreader.cpp.

     {
       if (m_state==InGroup)
       {
         m_curGroup->subgroupList.append(m_curString);
       }
       else
       {
         warn("Unexpected tag `subgroup' found\n");
       }
     }

void TagFileParser::endTemplateArg ( )

inline

Definition at line 669 of file tagreader.cpp.

     {
       if (m_state==InClass && m_curClass)
       {
         if (m_curClass->templateArguments==0) 
         {
           m_curClass->templateArguments = new QList<QCString>;
           m_curClass->templateArguments->setAutoDelete(TRUE);
         }
         m_curClass->templateArguments->append(new QCString(m_curString));
       }
       else
       {
         warn("Unexpected tag `templarg' found\n");
       }
     }

void TagFileParser::endTitle ( )

inline

Definition at line 768 of file tagreader.cpp.

     {
       switch (m_state)
       {
         case InGroup:     m_curGroup->title     = m_curString;    break;
         case InPage:      m_curPage->title      = m_curString;    break;
         default: warn("Unexpected tag `title' found\n"); break; 
       }
     }

void TagFileParser::endType ( )

inline

Definition at line 572 of file tagreader.cpp.

     {
       if (m_state==InMember)
       {
         m_curMember->type = m_curString; 
       }
       else
       {
         warn("Unexpected tag `type' found\n");
       }
     }

void TagFileParser::setDocumentLocator ( QXmlLocator * locator )

inlinevirtual

Does nothing.

Reimplemented from QXmlDefaultHandler.

Definition at line 268 of file tagreader.cpp.

     {
       m_locator = locator;
     }

void TagFileParser::setFileName ( const QString & fileName )

inline

Definition at line 273 of file tagreader.cpp.

     {
       m_inputFileName = fileName.utf8();
     }

void TagFileParser::startBase ( const QXmlAttributes & attrib )

inline

Definition at line 600 of file tagreader.cpp.

     {
       m_curString="";
       if (m_state==InClass && m_curClass)
       {
         QString protStr = attrib.value("protection");
         QString virtStr = attrib.value("virtualness");
         Protection prot = Public;
         Specifier  virt = Normal;
         if (protStr=="protected")
         {
           prot = Protected;
         }
         else if (protStr=="private")
         {
           prot = Private;
         }
         if (virtStr=="virtual")
         {
           virt = Virtual;
         }
         if (m_curClass->bases==0) 
         {
           m_curClass->bases = new QList<BaseInfo>;
           m_curClass->bases->setAutoDelete(TRUE);
         }
         m_curClass->bases->append(new BaseInfo(m_curString,prot,virt));
       }
       else
       {
         warn("Unexpected tag `base' found\n");
       }
     }

void TagFileParser::startCompound ( const QXmlAttributes & attrib )

inline

Definition at line 287 of file tagreader.cpp.

     {
       m_curString = "";
       QString kind = attrib.value("kind");
       QString isObjC = attrib.value("objc");
       if (kind=="class")
       {
         m_curClass = new TagClassInfo;
         m_curClass->kind = TagClassInfo::Class;
         m_state = InClass;
       }
       else if (kind=="struct")
       {
         m_curClass = new TagClassInfo;
         m_curClass->kind = TagClassInfo::Struct;
         m_state = InClass;
       }
       else if (kind=="union")
       {
         m_curClass = new TagClassInfo;
         m_curClass->kind = TagClassInfo::Union;
         m_state = InClass;
       }
       else if (kind=="interface")
       {
         m_curClass = new TagClassInfo;
         m_curClass->kind = TagClassInfo::Interface;
         m_state = InClass;
       }
       else if (kind=="enum")
       {
         m_curClass = new TagClassInfo;
         m_curClass->kind = TagClassInfo::Enum;
         m_state = InClass;
       }
       else if (kind=="exception")
       {
         m_curClass = new TagClassInfo;
         m_curClass->kind = TagClassInfo::Exception;
         m_state = InClass;
       }
       else if (kind=="protocol")
       {
         m_curClass = new TagClassInfo;
         m_curClass->kind = TagClassInfo::Protocol;
         m_state = InClass;
       }
       else if (kind=="category")
       {
         m_curClass = new TagClassInfo;
         m_curClass->kind = TagClassInfo::Category;
         m_state = InClass;
       }
       else if (kind=="service")
       {
         m_curClass = new TagClassInfo;
         m_curClass->kind = TagClassInfo::Service;
         m_state = InClass;
       }
       else if (kind=="singleton")
       {
         m_curClass = new TagClassInfo;
         m_curClass->kind = TagClassInfo::Singleton;
         m_state = InClass;
       }
       else if (kind=="file")
       {
         m_curFile = new TagFileInfo;
         m_state = InFile;
       }
       else if (kind=="namespace")
       {
         m_curNamespace = new TagNamespaceInfo;
         m_state = InNamespace;
       }
       else if (kind=="group")
       {
         m_curGroup = new TagGroupInfo;
         m_state = InGroup;
       }
       else if (kind=="page")
       {
         m_curPage = new TagPageInfo;
         m_state = InPage;
       }
       else if (kind=="package")
       {
         m_curPackage = new TagPackageInfo;
         m_state = InPackage;
       }
       else if (kind=="dir")
       {
         m_curDir = new TagDirInfo;
         m_state = InDir;
       }
       else
       {
         warn("Unknown compound attribute `%s' found!\n",kind.data());
         m_state = Invalid;
       }
       if (isObjC=="yes" && m_curClass)
       {
         m_curClass->isObjC = TRUE; 
       }
     }

void TagFileParser::startDocAnchor ( const QXmlAttributes & attrib )

inline

Definition at line 565 of file tagreader.cpp.

     {
       m_fileName = attrib.value("file").utf8();
       m_title = attrib.value("title").utf8();
       m_curString = "";
     }

bool TagFileParser::startDocument ( )

inlinevirtual

Does nothing.

Reimplemented from QXmlDefaultHandler.

Definition at line 798 of file tagreader.cpp.

     {
       m_state = Invalid;
 
       m_curClass=0;
       m_curNamespace=0;
       m_curFile=0;
       m_curGroup=0;
       m_curPage=0;
       m_curPackage=0;
       m_curDir=0;
 
       m_stateStack.setAutoDelete(TRUE);
       m_tagFileClasses.setAutoDelete(TRUE);
       m_tagFileFiles.setAutoDelete(TRUE);
       m_tagFileNamespaces.setAutoDelete(TRUE);
       m_tagFileGroups.setAutoDelete(TRUE);
       m_tagFilePages.setAutoDelete(TRUE);
       m_tagFilePackages.setAutoDelete(TRUE);
       m_tagFileDirs.setAutoDelete(TRUE);
 
       m_startElementHandlers.insert("compound",    new StartElementHandler(this,&TagFileParser::startCompound));
       m_startElementHandlers.insert("member",      new StartElementHandler(this,&TagFileParser::startMember));
       m_startElementHandlers.insert("enumvalue",   new StartElementHandler(this,&TagFileParser::startEnumValue));
       m_startElementHandlers.insert("name",        new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("base",        new StartElementHandler(this,&TagFileParser::startBase));
       m_startElementHandlers.insert("filename",    new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("includes",    new StartElementHandler(this,&TagFileParser::startIncludes));
       m_startElementHandlers.insert("path",        new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("anchorfile",  new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("anchor",      new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("clangid",     new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("arglist",     new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("title",       new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("subgroup",    new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("class",       new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("namespace",   new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("file",        new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("dir",         new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("page",        new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("docanchor",   new StartElementHandler(this,&TagFileParser::startDocAnchor));
       m_startElementHandlers.insert("tagfile",     new StartElementHandler(this,&TagFileParser::startIgnoreElement));
       m_startElementHandlers.insert("templarg",    new StartElementHandler(this,&TagFileParser::startStringValue));
       m_startElementHandlers.insert("type",        new StartElementHandler(this,&TagFileParser::startStringValue));
 
       m_endElementHandlers.insert("compound",    new EndElementHandler(this,&TagFileParser::endCompound));
       m_endElementHandlers.insert("member",      new EndElementHandler(this,&TagFileParser::endMember));
       m_endElementHandlers.insert("enumvalue",   new EndElementHandler(this,&TagFileParser::endEnumValue));
       m_endElementHandlers.insert("name",        new EndElementHandler(this,&TagFileParser::endName));
       m_endElementHandlers.insert("base",        new EndElementHandler(this,&TagFileParser::endBase));
       m_endElementHandlers.insert("filename",    new EndElementHandler(this,&TagFileParser::endFilename));
       m_endElementHandlers.insert("includes",    new EndElementHandler(this,&TagFileParser::endIncludes));
       m_endElementHandlers.insert("path",        new EndElementHandler(this,&TagFileParser::endPath));
       m_endElementHandlers.insert("anchorfile",  new EndElementHandler(this,&TagFileParser::endAnchorFile));
       m_endElementHandlers.insert("anchor",      new EndElementHandler(this,&TagFileParser::endAnchor));
       m_endElementHandlers.insert("clangid",     new EndElementHandler(this,&TagFileParser::endClangId));
       m_endElementHandlers.insert("arglist",     new EndElementHandler(this,&TagFileParser::endArglist));
       m_endElementHandlers.insert("title",       new EndElementHandler(this,&TagFileParser::endTitle));
       m_endElementHandlers.insert("subgroup",    new EndElementHandler(this,&TagFileParser::endSubgroup));
       m_endElementHandlers.insert("class"   ,    new EndElementHandler(this,&TagFileParser::endClass));
       m_endElementHandlers.insert("namespace",   new EndElementHandler(this,&TagFileParser::endNamespace));
       m_endElementHandlers.insert("file",        new EndElementHandler(this,&TagFileParser::endFile));
       m_endElementHandlers.insert("dir",         new EndElementHandler(this,&TagFileParser::endDir));
       m_endElementHandlers.insert("page",        new EndElementHandler(this,&TagFileParser::endPage));
       m_endElementHandlers.insert("docanchor",   new EndElementHandler(this,&TagFileParser::endDocAnchor));
       m_endElementHandlers.insert("tagfile",     new EndElementHandler(this,&TagFileParser::endIgnoreElement));
       m_endElementHandlers.insert("templarg",    new EndElementHandler(this,&TagFileParser::endTemplateArg));
       m_endElementHandlers.insert("type",        new EndElementHandler(this,&TagFileParser::endType));
 
       return TRUE;
     }

bool TagFileParser::startElement	(	const QString &	namespaceURI,
		const QString &	localName,
		const QString &	qName,
		const QXmlAttributes &	atts
	)

inlinevirtual

Does nothing.

Reimplemented from QXmlDefaultHandler.

Definition at line 870 of file tagreader.cpp.

     {
       //printf("startElement `%s'\n",name.data());
       StartElementHandler *handler = m_startElementHandlers[name.utf8()];
       if (handler)
       {
         (*handler)(attrib);
       }
       else 
       {
         warn("Unknown tag `%s' found!\n",name.data());
       }
       return TRUE;
     }

void TagFileParser::startEnumValue ( const QXmlAttributes & attrib )

inline

Definition at line 462 of file tagreader.cpp.

     {
       if (m_state==InMember)
       {
         m_curString = "";
         m_curEnumValue = new TagEnumValueInfo;
         m_curEnumValue->file = attrib.value("file").utf8();
         m_curEnumValue->anchor = attrib.value("anchor").utf8();
         m_curEnumValue->clangid = attrib.value("clangid").utf8();
         m_stateStack.push(new State(m_state));
         m_state = InEnumValue;
       }
       else
       {
         warn("Found enumvalue tag outside of member tag\n");
       }
     }

void TagFileParser::startIgnoreElement ( const QXmlAttributes & )

inline

Definition at line 790 of file tagreader.cpp.

791 {

792 }

void TagFileParser::startIncludes ( const QXmlAttributes & attrib )

inline

Definition at line 646 of file tagreader.cpp.

     {
       if (m_state==InFile && m_curFile)
       {
         m_curIncludes = new TagIncludeInfo;
         m_curIncludes->id = attrib.value("id").utf8();
         m_curIncludes->name = attrib.value("name").utf8();
         m_curIncludes->isLocal = attrib.value("local").utf8()=="yes" ? TRUE : FALSE;
         m_curIncludes->isImported = attrib.value("imported").utf8()=="yes" ? TRUE : FALSE;
         m_curFile->includes.append(m_curIncludes);
       }
       else
       {
         warn("Unexpected tag `includes' found\n");
       }
       m_curString="";
     }

void TagFileParser::startMember ( const QXmlAttributes & attrib )

inline

Definition at line 416 of file tagreader.cpp.

     {
       m_curMember = new TagMemberInfo;
       m_curMember->kind = attrib.value("kind").utf8();
       QCString protStr   = attrib.value("protection").utf8();
       QCString virtStr   = attrib.value("virtualness").utf8();
       QCString staticStr = attrib.value("static").utf8();
       if (protStr=="protected")
       {
         m_curMember->prot = Protected;
       }
       else if (protStr=="private")
       {
         m_curMember->prot = Private;
       }
       if (virtStr=="virtual")
       {
         m_curMember->virt = Virtual;
       }
       else if (virtStr=="pure")
       {
         m_curMember->virt = Pure;
       }
       if (staticStr=="yes")
       {
         m_curMember->isStatic = TRUE;
       }
       m_stateStack.push(new State(m_state));
       m_state = InMember;
     }

void TagFileParser::startStringValue ( const QXmlAttributes & )

inline

Definition at line 560 of file tagreader.cpp.

     {
       m_curString = "";
     }

void TagFileParser::warn ( const char * fmt )

inline

Definition at line 278 of file tagreader.cpp.

     {
       ::warn(m_inputFileName,m_locator->lineNumber(),fmt);
     }

void TagFileParser::warn	(	const char *	fmt,
		const char *	s
	)

inline

Definition at line 282 of file tagreader.cpp.

     {
       ::warn(m_inputFileName,m_locator->lineNumber(),fmt,s);
     }

Member Data Documentation

TagClassInfo* TagFileParser::m_curClass

private

Definition at line 923 of file tagreader.cpp.

TagDirInfo* TagFileParser::m_curDir

private

Definition at line 929 of file tagreader.cpp.

TagEnumValueInfo* TagFileParser::m_curEnumValue

private

Definition at line 931 of file tagreader.cpp.

TagFileInfo* TagFileParser::m_curFile

private

Definition at line 924 of file tagreader.cpp.

TagGroupInfo* TagFileParser::m_curGroup

private

Definition at line 927 of file tagreader.cpp.

TagIncludeInfo* TagFileParser::m_curIncludes

private

Definition at line 932 of file tagreader.cpp.

TagMemberInfo* TagFileParser::m_curMember

private

Definition at line 930 of file tagreader.cpp.

TagNamespaceInfo* TagFileParser::m_curNamespace

private

Definition at line 925 of file tagreader.cpp.

TagPackageInfo* TagFileParser::m_curPackage

private

Definition at line 926 of file tagreader.cpp.

TagPageInfo* TagFileParser::m_curPage

private

Definition at line 928 of file tagreader.cpp.

QCString TagFileParser::m_curString

private

Definition at line 933 of file tagreader.cpp.

QDict<EndElementHandler> TagFileParser::m_endElementHandlers

private

Definition at line 922 of file tagreader.cpp.

QCString TagFileParser::m_fileName

private

Definition at line 935 of file tagreader.cpp.

QCString TagFileParser::m_inputFileName

private

Definition at line 940 of file tagreader.cpp.

QXmlLocator* TagFileParser::m_locator

private

Definition at line 939 of file tagreader.cpp.

QDict<StartElementHandler> TagFileParser::m_startElementHandlers

private

Definition at line 921 of file tagreader.cpp.

State TagFileParser::m_state

private

Definition at line 937 of file tagreader.cpp.

QStack<State> TagFileParser::m_stateStack

private

Definition at line 938 of file tagreader.cpp.

QList<TagClassInfo> TagFileParser::m_tagFileClasses

private

Definition at line 914 of file tagreader.cpp.

QList<TagDirInfo> TagFileParser::m_tagFileDirs

private

Definition at line 920 of file tagreader.cpp.

QList<TagFileInfo> TagFileParser::m_tagFileFiles

private

Definition at line 915 of file tagreader.cpp.

QList<TagGroupInfo> TagFileParser::m_tagFileGroups

private

Definition at line 917 of file tagreader.cpp.

QList<TagNamespaceInfo> TagFileParser::m_tagFileNamespaces

private

Definition at line 916 of file tagreader.cpp.

QList<TagPackageInfo> TagFileParser::m_tagFilePackages

private

Definition at line 919 of file tagreader.cpp.

QList<TagPageInfo> TagFileParser::m_tagFilePages

private

Definition at line 918 of file tagreader.cpp.

QCString TagFileParser::m_tagName

private

Definition at line 934 of file tagreader.cpp.

QCString TagFileParser::m_title

private

Definition at line 936 of file tagreader.cpp.

The documentation for this class was generated from the following file:

doxygen-1.8.11/src/tagreader.cpp

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation