Release-1.4.7-20060716

1 files changed, 575 insertions, 12 deletions

diff --git a/src/entry.cpp b/src/entry.cpp
index 66d6d9f..61de661 100644
--- a/src/entry.cpp
+++ b/src/entry.cpp
@@ -15,6 +15,7 @@
  *
  */
 
+#include <qfile.h>
 #include "entry.h"
 #include "util.h"
 #include "section.h"
@@ -24,10 +25,10 @@ int Entry::num=0;
 Entry::Entry()
 {
   num++;
-  parent=0;
+  m_parent=0;
   section = EMPTY_SEC;
-  sublist = new QList<Entry>;
-  sublist->setAutoDelete(TRUE);
+  m_sublist = new QList<Entry>;
+  m_sublist->setAutoDelete(TRUE);
   extends = new QList<BaseInfo>;
   extends->setAutoDelete(TRUE);
   groups = new QList<Grouping>;
@@ -55,7 +56,7 @@ Entry::Entry(const Entry &e)
   stat        = e.stat;
   explicitExternal = e.explicitExternal;
   virt        = e.virt;
-  parent      = e.parent;
+  m_parent    = e.m_parent;
   type        = e.type.copy();
   name        = e.name.copy();
   args        = e.args.copy();
@@ -91,8 +92,8 @@ Entry::Entry(const Entry &e)
   objc        = e.objc;
   tagInfo     = e.tagInfo;
   hidden      = e.hidden;
-  sublist     = new QList<Entry>;
-  sublist->setAutoDelete(TRUE);
+  m_sublist   = new QList<Entry>;
+  m_sublist->setAutoDelete(TRUE);
   extends     = new QList<BaseInfo>;
   extends->setAutoDelete(TRUE);
   groups      = new QList<Grouping>;
@@ -104,11 +105,11 @@ Entry::Entry(const Entry &e)
   groupDocType = e.groupDocType;
 
   // deep copy of the child entry list
-  QListIterator<Entry> eli(*e.sublist);
+  QListIterator<Entry> eli(*e.m_sublist);
   Entry *cur;
   for (;(cur=eli.current());++eli)
   {
-    sublist->append(new Entry(*cur));
+    m_sublist->append(new Entry(*cur));
   }
   
   // deep copy base class list
@@ -172,7 +173,9 @@ Entry::~Entry()
 {
   //printf("Deleting entry %d name %s type %x children %d\n",
   //       num,name.data(),section,sublist->count());
-  delete sublist;
+  
+  //delete sublist; // each element is now own by a EntryNav so we do no longer own
+                    // our children.
   delete extends;
   delete groups;
   delete anchors;
@@ -191,8 +194,8 @@ void Entry::addSubEntry(Entry *current)
   //    name.data(),section);
   //printf("Entry::addSubEntry(%s:%p) to %s\n",current->name.data(),
   //    current,name.data());
-  current->parent=this;
-  sublist->append(current);  
+  current->m_parent=this;
+  m_sublist->append(current);  
 }
 
 void Entry::reset()
@@ -238,7 +241,7 @@ void Entry::reset()
   subGrouping = TRUE;
   protection = Public;
   groupDocType = GROUPDOC_NORMAL;
-  sublist->clear();
+  m_sublist->clear();
   extends->clear();
   groups->clear();
   anchors->clear();
@@ -255,6 +258,45 @@ int Entry::getSize()
   return sizeof(Entry);
 }
 
+void Entry::createSubtreeIndex(EntryNav *nav,QFile &storage,FileDef *fd)
+{
+  EntryNav *childNav = new EntryNav(nav,this);
+  nav->addChild(childNav);
+  childNav->setFileDef(fd);
+  childNav->saveEntry(this,storage);
+  if (m_sublist)
+  {
+    //printf("saveEntry: %d children\n",node->sublist->count());
+    QListIterator<Entry> eli(*m_sublist);
+    Entry *childNode;
+    for (eli.toFirst();(childNode=eli.current());++eli)
+    {
+      childNode->createSubtreeIndex(childNav,storage,fd);
+    }
+    m_sublist->clear();
+  }
+}
+
+void Entry::createNavigationIndex(EntryNav *rootNav,QFile &storage,FileDef *fd)
+{
+  if (m_sublist)
+  {
+    //printf("saveEntries: %d children\n",root->sublist->count());
+    // store all child entries of root, but keep the navigation info (=index)
+    QListIterator<Entry> eli(*m_sublist);
+    Entry *e;
+    for (eli.toFirst();(e=eli.current());++eli)
+    {
+      createSubtreeIndex(rootNav,storage,fd);
+    }
+    // remove all entries from root
+    m_sublist->clear();
+  }
+}
+
+
+
+
 /*! the argument list is documented if one of its
  *  arguments is documented 
  */
@@ -283,3 +325,524 @@ void Entry::addSpecialListItem(const char *listName,int itemId)
   sli->append(ili);
 }
 
+//------------------------------------------------------------------
+
+#define NULL_LIST 0xffffffff
+
+void marshalInt(QFile &f,int v)
+{
+  uchar b[4];
+  b[0]=((uint)v)>>24;
+  b[1]=(((uint)v)>>16)&0xff;
+  b[2]=(((uint)v)>>8)&0xff;
+  b[3]=v&0xff;
+  f.writeBlock((const char *)b,4);
+}
+
+void marshalUInt(QFile &f,uint v)
+{
+  uchar b[4];
+  b[0]=v>>24;
+  b[1]=(v>>16)&0xff;
+  b[2]=(v>>8)&0xff;
+  b[3]=v&0xff;
+  f.writeBlock((const char *)b,4);
+}
+
+void marshalBool(QFile &f,bool b)
+{
+  char c = b;
+  f.writeBlock(&c,sizeof(char));
+}
+
+void marshalQCString(QFile &f,const QCString &s)
+{
+  uint l=s.length();
+  marshalUInt(f,l);
+  if (l>0) f.writeBlock(s.data(),l);
+}
+
+void marshalArgumentList(QFile &f,ArgumentList *argList)
+{
+  if (argList==0)
+  {
+    marshalUInt(f,NULL_LIST); // null pointer representation
+  }
+  else
+  {
+    marshalUInt(f,argList->count());
+    ArgumentListIterator ali(*argList);
+    Argument *a;
+    for (ali.toFirst();(a=ali.current());++ali)
+    {
+      marshalQCString(f,a->attrib);    
+      marshalQCString(f,a->type);    
+      marshalQCString(f,a->canType);    
+      marshalQCString(f,a->name);    
+      marshalQCString(f,a->array);    
+      marshalQCString(f,a->defval);    
+      marshalQCString(f,a->docs);    
+    }
+    marshalBool(f,argList->constSpecifier);
+    marshalBool(f,argList->volatileSpecifier);
+    marshalBool(f,argList->pureSpecifier);
+  }
+}
+
+void marshalArgumentLists(QFile &f,QList<ArgumentList> *argLists)
+{
+  if (argLists==0)
+  {
+    marshalUInt(f,NULL_LIST); // null pointer representation
+  }
+  else
+  {
+    marshalUInt(f,argLists->count());
+    QListIterator<ArgumentList> ali(*argLists);
+    ArgumentList *al;
+    for (ali.toFirst();(al=ali.current());++ali)
+    {
+      marshalArgumentList(f,al);
+    }
+  }
+}
+
+void marshalBaseInfoList(QFile &f, QList<BaseInfo> *baseList)
+{
+  if (baseList==0)
+  {
+    marshalUInt(f,NULL_LIST); // null pointer representation
+  }
+  else
+  {
+    marshalUInt(f,baseList->count());
+    QListIterator<BaseInfo> bli(*baseList);
+    BaseInfo *bi;
+    for (bli.toFirst();(bi=bli.current());++bli)
+    {
+      marshalQCString(f,bi->name);
+      marshalInt(f,(int)bi->prot);
+      marshalInt(f,(int)bi->virt);
+    }
+  }
+}
+
+void marshalGroupingList(QFile &f, QList<Grouping> *groups)
+{
+  if (groups==0)
+  {
+    marshalUInt(f,NULL_LIST); // null pointer representation
+  }
+  else
+  {
+    marshalUInt(f,groups->count());
+    QListIterator<Grouping> gli(*groups);
+    Grouping *g;
+    for (gli.toFirst();(g=gli.current());++gli)
+    {
+      marshalQCString(f,g->groupname);
+      marshalInt(f,(int)g->pri);
+    }
+  }
+}
+
+void marshalSectionInfoList(QFile &f, QList<SectionInfo> *anchors)
+{
+  if (anchors==0)
+  {
+    marshalUInt(f,NULL_LIST); // null pointer representation
+  }
+  else
+  {
+    marshalUInt(f,anchors->count());
+    QListIterator<SectionInfo> sli(*anchors);
+    SectionInfo *si;
+    for (sli.toFirst();(si=sli.current());++sli)
+    {
+      marshalQCString(f,si->label);
+      marshalQCString(f,si->title);
+      marshalQCString(f,si->ref);
+      marshalInt(f,(int)si->type);
+      marshalQCString(f,si->fileName);
+    }
+  }
+}
+
+void marshalItemInfoList(QFile &f, QList<ListItemInfo> *sli)
+{
+  if (sli==0)
+  {
+    marshalUInt(f,NULL_LIST); // null pointer representation
+  }
+  else
+  {
+    marshalUInt(f,sli->count());
+    QListIterator<ListItemInfo> liii(*sli);
+    ListItemInfo *lii;
+    for (liii.toFirst();(lii=liii.current());++liii)
+    {
+      marshalQCString(f,lii->type);
+      marshalInt(f,lii->itemId);
+    }
+  }
+}
+
+//------------------------------------------------------------------
+
+int unmarshalInt(QFile &f)
+{
+  uchar b[4];
+  f.readBlock((char *)b,4);
+  int result=(int)((((uint)b[0])<<24)+((uint)b[1]<<16)+((uint)b[2]<<8)+(uint)b[3]);
+  //printf("unmarshalInt: %x %x %x %x: %x offset=%llx\n",b[0],b[1],b[2],b[3],result,f.pos());
+  return result;
+}
+
+uint unmarshalUInt(QFile &f)
+{
+  uchar b[4];
+  f.readBlock((char *)b,4);
+  uint result=(((uint)b[0])<<24)+((uint)b[1]<<16)+((uint)b[2]<<8)+(uint)b[3];
+  //printf("unmarshalUInt: %x %x %x %x: %x offset=%llx\n",b[0],b[1],b[2],b[3],result,f.pos());
+  return result;
+}
+
+bool unmarshalBool(QFile &f)
+{
+  char result;
+  f.readBlock(&result,sizeof(result));
+  //printf("unmarshalBool: %x offset=%llx\n",result,f.pos());
+  return result;
+}
+
+QCString unmarshalQCString(QFile &f)
+{
+  uint len = unmarshalUInt(f);
+  //printf("unmarshalQCString: len=%d offset=%llx\n",len,f.pos());
+  QCString result(len+1);
+  result.at(len)='\0';
+  if (len>0)
+  {
+    f.readBlock(result.data(),len);
+  }
+  //printf("unmarshalQCString: result=%s\n",result.data());
+  return result;
+}
+
+ArgumentList *unmarshalArgumentList(QFile &f)
+{
+  uint i;
+  uint count = unmarshalUInt(f);
+  if (count==NULL_LIST) return 0; // null list
+  ArgumentList *result = new ArgumentList;
+  //printf("unmarshalArgumentList: %d\n",count);
+  for (i=0;i<count;i++)
+  {
+    Argument *a = new Argument;
+    a->attrib  = unmarshalQCString(f);
+    a->type    = unmarshalQCString(f);
+    a->canType = unmarshalQCString(f);
+    a->name    = unmarshalQCString(f);
+    a->array   = unmarshalQCString(f);
+    a->defval  = unmarshalQCString(f);
+    a->docs    = unmarshalQCString(f);
+    result->append(a);
+  }
+  result->constSpecifier    = unmarshalBool(f);
+  result->volatileSpecifier = unmarshalBool(f);
+  result->pureSpecifier     = unmarshalBool(f);
+  return result;
+}
+
+QList<ArgumentList> *unmarshalArgumentLists(QFile &f)
+{
+  uint i;
+  uint count = unmarshalUInt(f);
+  if (count==NULL_LIST) return 0; // null list
+  QList<ArgumentList> *result = new QList<ArgumentList>;
+  //printf("unmarshalArgumentLists: %d\n",count);
+  for (i=0;i<count;i++)
+  {
+    result->append(unmarshalArgumentList(f));
+  }
+  return result;
+}
+
+QList<BaseInfo> *unmarshalBaseInfoList(QFile &f)
+{
+  uint i;
+  uint count = unmarshalUInt(f);
+  if (count==NULL_LIST) return 0; // null list
+  QList<BaseInfo> *result = new QList<BaseInfo>;
+  for (i=0;i<count;i++)
+  {
+    QCString name   = unmarshalQCString(f);
+    Protection prot = (Protection)unmarshalInt(f);
+    Specifier virt  = (Specifier)unmarshalInt(f);
+    result->append(new BaseInfo(name,prot,virt));
+  }
+  return result;
+}
+
+QList<Grouping> *unmarshalGroupingList(QFile &f)
+{
+  uint i;
+  uint count = unmarshalUInt(f);
+  if (count==NULL_LIST) return 0; // null list
+  QList<Grouping> *result = new QList<Grouping>;
+  for (i=0;i<count;i++)
+  {
+    QCString name = unmarshalQCString(f);
+    Grouping::GroupPri_t prio = (Grouping::GroupPri_t)unmarshalInt(f);
+    result->append(new Grouping(name,prio));
+  }
+  return result;
+}
+
+QList<SectionInfo> *unmarshalSectionInfoList(QFile &f)
+{
+  uint i;
+  uint count = unmarshalUInt(f);
+  if (count==NULL_LIST) return 0; // null list
+  QList<SectionInfo> *result = new QList<SectionInfo>;
+  for (i=0;i<count;i++)
+  { 
+    QCString label = unmarshalQCString(f);
+    QCString title = unmarshalQCString(f);
+    QCString ref   = unmarshalQCString(f);
+    SectionInfo::SectionType type = (SectionInfo::SectionType)unmarshalInt(f);
+    QCString fileName = unmarshalQCString(f);
+    result->append(new SectionInfo(fileName,label,title,type,ref));
+  }
+  return result;
+}
+
+QList<ListItemInfo> *unmarshalItemInfoList(QFile &f)
+{
+  uint i;
+  uint count = unmarshalUInt(f);
+  if (count==NULL_LIST) return 0; // null list
+  QList<ListItemInfo> *result = new QList<ListItemInfo>;
+  for (i=0;i<count;i++)
+  { 
+    ListItemInfo *lii = new ListItemInfo;
+    lii->type   = unmarshalQCString(f);
+    lii->itemId = unmarshalInt(f);
+    result->append(lii);
+  }
+  return result;
+}
+
+//------------------------------------------------------------------
+
+#define HEADER ('D'<<24)+('O'<<16)+('X'<<8)+'!'
+
+bool saveEntry(Entry *e,QFile &f)
+{
+  marshalUInt(f,HEADER);
+  marshalInt(f,(int)e->protection);
+  marshalInt(f,(int)e->mtype);
+  marshalInt(f,e->memSpec);
+  marshalInt(f,e->initLines);
+  marshalBool(f,e->stat);
+  marshalBool(f,e->explicitExternal);
+  marshalBool(f,e->proto);
+  marshalBool(f,e->subGrouping);
+  marshalBool(f,e->callGraph);
+  marshalBool(f,e->callerGraph);
+  marshalInt(f,(int)e->virt);
+  marshalQCString(f,e->args);
+  marshalQCString(f,e->bitfields);
+  marshalArgumentList(f,e->argList);
+  marshalArgumentLists(f,e->tArgLists);
+  marshalQCString(f,e->program);
+  marshalQCString(f,e->initializer);
+  marshalQCString(f,e->includeFile);
+  marshalQCString(f,e->includeName);
+  marshalQCString(f,e->doc);
+  marshalInt(f,e->docLine);
+  marshalQCString(f,e->docFile);
+  marshalQCString(f,e->brief);
+  marshalInt(f,e->briefLine);
+  marshalQCString(f,e->briefFile);
+  marshalQCString(f,e->inbodyDocs);
+  marshalInt(f,e->inbodyLine);
+  marshalQCString(f,e->inbodyFile);
+  marshalQCString(f,e->relates);
+  marshalBool(f,e->relatesDup);
+  marshalQCString(f,e->read);
+  marshalQCString(f,e->write);
+  marshalQCString(f,e->inside);
+  marshalQCString(f,e->exception);
+  marshalInt(f,e->bodyLine);
+  marshalInt(f,e->endBodyLine);
+  marshalInt(f,e->mGrpId);
+  marshalBaseInfoList(f,e->extends);
+  marshalGroupingList(f,e->groups);
+  marshalSectionInfoList(f,e->anchors);
+  marshalQCString(f,e->fileName);
+  marshalInt(f,e->startLine);
+  marshalItemInfoList(f,e->sli);
+  marshalBool(f,e->objc);
+  marshalBool(f,e->hidden);
+  marshalInt(f,(int)e->groupDocType);
+  return TRUE;
+}
+
+bool loadEntry(Entry *e,QFile &f)
+{
+  uint header=unmarshalUInt(f);
+  if (header!=HEADER)
+  {
+    printf("Internal error: Invalid header for entry in storage file: %x. Disk full?\n",header);
+    exit(1);
+  }
+  e->protection       = (Protection)unmarshalInt(f);
+  e->mtype            = (MethodTypes)unmarshalInt(f);
+  e->memSpec          = unmarshalInt(f);
+  e->initLines        = unmarshalInt(f);
+  e->stat             = unmarshalBool(f);
+  e->explicitExternal = unmarshalBool(f);
+  e->proto            = unmarshalBool(f);
+  e->subGrouping      = unmarshalBool(f);
+  e->callGraph        = unmarshalBool(f);
+  e->callerGraph      = unmarshalBool(f);
+  e->virt             = (Specifier)unmarshalInt(f);
+  e->args             = unmarshalQCString(f);
+  e->bitfields        = unmarshalQCString(f);
+  e->argList          = unmarshalArgumentList(f);
+  e->tArgLists        = unmarshalArgumentLists(f);
+  e->program          = unmarshalQCString(f);
+  e->initializer      = unmarshalQCString(f);
+  e->includeFile      = unmarshalQCString(f);
+  e->includeName      = unmarshalQCString(f);
+  e->doc              = unmarshalQCString(f);
+  e->docLine          = unmarshalInt(f);
+  e->docFile          = unmarshalQCString(f);
+  e->brief            = unmarshalQCString(f);
+  e->briefLine        = unmarshalInt(f);
+  e->briefFile        = unmarshalQCString(f);
+  e->inbodyDocs       = unmarshalQCString(f);
+  e->inbodyLine       = unmarshalInt(f);
+  e->inbodyFile       = unmarshalQCString(f);
+  e->relates          = unmarshalQCString(f);
+  e->relatesDup       = unmarshalBool(f);
+  e->read             = unmarshalQCString(f);
+  e->write            = unmarshalQCString(f);
+  e->inside           = unmarshalQCString(f);
+  e->exception        = unmarshalQCString(f);
+  e->bodyLine         = unmarshalInt(f);
+  e->endBodyLine      = unmarshalInt(f);
+  e->mGrpId           = unmarshalInt(f);
+  e->extends          = unmarshalBaseInfoList(f);
+  e->groups           = unmarshalGroupingList(f);
+  e->anchors          = unmarshalSectionInfoList(f);
+  e->fileName         = unmarshalQCString(f);
+  e->startLine        = unmarshalInt(f);
+  e->sli              = unmarshalItemInfoList(f);
+  e->objc             = unmarshalBool(f);
+  e->hidden           = unmarshalBool(f);
+  e->groupDocType     = (Entry::GroupDocType)unmarshalInt(f);
+  return TRUE;
+}
+
+EntryNav::EntryNav(EntryNav *parent, Entry *e)
+             : m_parent(parent), m_subList(0), m_section(e->section), m_type(e->type),
+              m_name(e->name), m_fileDef(0), m_info(0), m_offset(-1), 
+              m_noLoad(FALSE)
+{
+  if (e->tagInfo)
+  {
+    m_tagInfo = new TagInfo;
+    m_tagInfo->tagName  = e->tagInfo->tagName;
+    m_tagInfo->fileName = e->tagInfo->fileName;
+    m_tagInfo->anchor   = e->tagInfo->anchor;
+    if (e->tagInfo)
+    {
+      //printf("tagInfo %p: tagName=%s fileName=%s anchor=%s\n",
+      //    e->tagInfo,
+      //    e->tagInfo->tagName.data(),
+      //    e->tagInfo->fileName.data(),
+      //    e->tagInfo->anchor.data());
+    }
+  }
+  else
+  {
+    m_tagInfo = 0;
+  }
+}
+
+EntryNav::~EntryNav()
+{
+  delete m_subList;
+  delete m_info;
+  delete m_tagInfo;
+}
+
+void EntryNav::addChild(EntryNav *e)
+{
+  if (m_subList==0) 
+  {
+    m_subList = new QList<EntryNav>;
+    m_subList->setAutoDelete(TRUE);
+  }
+  m_subList->append(e);
+}
+
+bool EntryNav::loadEntry(QFile &storage)
+{
+  if (m_noLoad)
+  {
+    return TRUE;
+  }
+  if (m_offset==-1) 
+  {
+    //printf("offset not set!\n");
+    return FALSE;
+  }
+  //delete m_info;
+  if (m_info==0)  m_info = new Entry;
+  //printf("EntryNav::loadEntry: new entry %p: %s\n",m_info,m_name.data());
+  m_info->name = m_name;
+  m_info->type = m_type;
+  m_info->section = m_section;
+  //m_info->tagInfo = m_tagInfo;
+  //if (m_parent)
+  //{
+  //  m_info->parent = m_parent->m_info;
+  //}
+  //m_info->parent = 0;
+  //printf("load entry: seek to %llx\n",m_offset);
+  if (!storage.seek(m_offset)) 
+  {
+    //printf("seek failed!\n");
+    return FALSE;
+  }
+  return ::loadEntry(m_info,storage);
+}
+
+bool EntryNav::saveEntry(Entry *e,QFile &storage)
+{
+  m_offset = storage.pos();
+  //printf("EntryNav::saveEntry offset=%llx\n",m_offset);
+  return ::saveEntry(e,storage);
+}
+
+void EntryNav::releaseEntry()
+{
+  if (!m_noLoad) 
+  { 
+    delete m_info; 
+    //printf("EntryNav::releaseEntry %p\n",m_info);
+    m_info=0; 
+  }
+}
+
+void EntryNav::setEntry(Entry *e) 
+{ 
+  delete m_info;
+  m_info = e; 
+  //printf("EntryNav::setEntry %p\n",e);
+  m_noLoad=TRUE; 
+}
+