main.cpp

Doxygen的词根来源于Document（文档）和Oxygen（氧气）

      break;
    case IDoc::Section:
      {
        IDocSection *sec = dynamic_cast<IDocSection*>(doc);
        ASSERT(sec!=0);
        InPrint(("<section id=`%s' level=%d>\n",
            sec->id()->latin1(),sec->level()));
        DumpDoc(sec->title(),level+1);
        IDocIterator *di = sec->paragraphs();
        IDoc *pdoc;
        for (di->toFirst();(pdoc=di->current());di->toNext())
        {
          DumpDoc(pdoc,level+1);
        }
        di=sec->subSections();
        for (di->toFirst();(pdoc=di->current());di->toNext())
        {
          DumpDoc(pdoc,level+1);
        }
        IDocInternal *intern = sec->internal();
        if (intern)
        {
          DumpDoc(intern,level+1);
        }
        InPrint(("</section>\n"));
      }
      break;
    case IDoc::Internal:
      {
        IDocInternal *intern = dynamic_cast<IDocInternal*>(doc);
        ASSERT(intern!=0);
        InPrint(("<internal>\n"));
        IDocIterator *di = intern->paragraphs();
        IDoc *pdoc;
        for (di->toFirst();(pdoc=di->current());di->toNext())
        {
          DumpDoc(pdoc,level+1);
        }
        di=intern->subSections();
        for (di->toFirst();(pdoc=di->current());di->toNext())
        {
          DumpDoc(pdoc,level+1);
        }
        InPrint(("</internal>\n"));
      }
      break;
    case IDoc::Copy:
      {
        IDocCopy *cpy = dynamic_cast<IDocCopy*>(doc);
        ASSERT(cpy!=0);
        InPrint(("<copydoc>\n"));
        IDocIterator *di = cpy->contents();
        IDoc *pdoc;
        for (di->toFirst();(pdoc=di->current());di->toNext())
        {
          DumpDoc(pdoc,level+1);
        }
        di->release();
        InPrint(("<copydoc/>\n"));
      }
      break;
    case IDoc::TocItem:
      {
        IDocTocItem *ti = dynamic_cast<IDocTocItem*>(doc);
        ASSERT(ti!=0);
        InPrint(("<tocitem id=\"%s\" title=\"%s\"/>\n",
                 ti->id()->latin1(),ti->title()->latin1()));
      }
      break;
    case IDoc::TocList:
      {
        IDocTocList *tl = dynamic_cast<IDocTocList*>(doc);
        ASSERT(tl!=0);
        InPrint(("<toclist>\n"));
        IDocIterator *di = tl->elements();
        IDoc *pdoc;
        for (di->toFirst();(pdoc=di->current());di->toNext())
        {
          DumpDoc(pdoc,level+1);
        }
        di->release();
        InPrint(("<toclist/>\n"));
      }
      break;
    case IDoc::Verbatim:
      {
        IDocVerbatim *vt = dynamic_cast<IDocVerbatim*>(doc);
        ASSERT(vt!=0);
        const char *s=0;
        switch (vt->type())
        {
          case IDocVerbatim::Verbatim:  s="verbatim"; break;
          case IDocVerbatim::HtmlOnly:  s="htmlonly"; break;
          case IDocVerbatim::LatexOnly: s="latexonly"; break;
          default:
            printf("Invalid verbatim type!\n");
        }
        InPrint(("<verbatim %s>\n",s));
        InPrint(("%s",vt->text()->latin1()));
        InPrint(("</verbatim>\n"));
      }
      break;
    case IDoc::Anchor:
      {
        IDocAnchor *anc = dynamic_cast<IDocAnchor*>(doc);
        ASSERT(anc!=0);
        InPrint(("<anchor id='%s'/>\n",anc->id()->latin1()));
      }
      break;
    case IDoc::Symbol:
      {
        IDocSymbol *sym = dynamic_cast<IDocSymbol*>(doc);
        ASSERT(sym!=0);
        InPrint(("<symbol type=%s letter=%c/>\n",
              sym->typeString()->latin1(),sym->letter()));
      }
      break;
    case IDoc::Root:
      {
        InPrint(("<root>\n"));
        IDocRoot *root = dynamic_cast<IDocRoot*>(doc);
        ASSERT(root!=0);
        IDocIterator *di = root->contents();
        IDoc *pdoc;
        for (di->toFirst();(pdoc=di->current());di->toNext())
        {
          DumpDoc(pdoc,level+1);
        }
        di->release();
        InPrint(("</root>\n"));
      }
      break;

    default:
      printf("Found unsupported node type %d!\n",doc->kind());
      break;
  }
}

void DumpGraph(IGraph *graph)
{
  if (graph==0) { printf(" --- no graph ---\n"); return; }
  printf(" --- graph ----\n");
  INodeIterator *ni = graph->nodes();
  INode *node;
  for (ni->toFirst();(node=ni->current());ni->toNext())
  {
    printf("   --- node id=%s label=%s linkId=%s\n",
           node->id()->latin1(),
           node->label()->latin1(),
           node->linkId()->latin1()
          );
    IChildNodeIterator *cni = node->children();
    IChildNode *cn;
    for (cni->toFirst();(cn=cni->current());cni->toNext())
    {
      printf("    + child id=%s label=%s relation=%s\n",
          cn->node()->id()->latin1(),
          cn->node()->label()->latin1(),
          cn->relationString()->latin1()
      );
      IEdgeLabelIterator *eli = cn->edgeLabels();
      IEdgeLabel *el;
      for (eli->toFirst();(el=eli->current());eli->toNext())
      {
        printf("      edgeLabel=%s\n",el->label()->latin1());
      }
      eli->release();
    }
    cni->release();
  }
  ni->release();
  printf(" --- end graph ----\n");

}

void DumpParamList(IParamIterator *pli,int indent)
{
  QString indentStr;
  indentStr.fill(' ',indent);
  IParam *par;
  for (pli->toFirst();(par=pli->current());pli->toNext())
  {
    ILinkedTextIterator *lti = par->type();
    QString parType = linkedTextToString(lti);
    lti->release();
    lti = par->defaultValue();
    QString defVal =  linkedTextToString(lti);
    lti->release();
    printf("%sParam type=%s decl_name=%s def_name=%s defvalue=%s\n",
        indentStr.data(), parType.latin1(), 
        par->declarationName()->latin1(),
        par->definitionName()->latin1(),
        defVal.latin1());
  }
}

int main(int argc,char **argv)
{
  if (argc!=2)
  {
    printf("Usage: %s xmldir\n",argv[0]);
    exit(1);
  }

  IDoxygen *dox = createObjectModel();

  dox->setDebugLevel(4);

  if (!dox->readXMLDir(argv[1]))
  {
    printf("Error reading %s/index.xml\n",argv[1]);
    exit(1);
  }

  ICompoundIterator *cli = dox->compounds();
  ICompound *comp;
  printf("--- compound list ---------\n");
  for (cli->toFirst();(comp=cli->current());cli->toNext())
  {
    printf("Compound name=%s id=%s kind=%s\n",
        comp->name()->latin1(),comp->id()->latin1(),comp->kindString()->latin1());

    ISectionIterator *sli = comp->sections();
    ISection *sec;
    for (sli->toFirst();(sec=sli->current());sli->toNext())
    {
      printf("  Section kind=%s\n",sec->kindString()->latin1());
      IMemberIterator *mli = sec->members();
      IMember *mem;
      if( sec->kind() == ISection::UserDefined )
      {
	IUserDefined *group = dynamic_cast<IUserDefined*>(sec);
	printf("    Title=%s\n", group->header()->latin1() );
      }
      for (mli->toFirst();(mem=mli->current());mli->toNext())
      {
        ILinkedTextIterator *lti = mem->type();
        printf("    Member type=%s name=%s\n",
            linkedTextToString(lti).latin1(),mem->name()->latin1());
        lti->release();

        IParamIterator *pli = mem->parameters();
        DumpParamList(pli,6);
        pli->release();
        IMemberReferenceIterator *mri = mem->references();
        IMemberReference *mr;
        for (mri->toFirst();(mr=mri->current());mri->toNext())
        {
          IMember *memr = mr->member();
          printf("      References %s at line %d\n",
              mr->name()->latin1(),memr->bodyStart());
        }

        mri->release();
        mri = mem->referencedBy();
        for (mri->toFirst();(mr=mri->current());mri->toNext())
        {
          IMember *memr = mr->member();
          printf("      ReferencedBy %s at line %d\n",
              mr->name()->latin1(),memr->bodyStart());
        }
        mri->release();

        if (mem->kind()==IMember::Enum) // we have found an enum
        {
          IEnum *e = dynamic_cast<IEnum*>(mem);
          IMemberIterator *evi = e->enumValues(); // get the enum values
          IMember *mev;
          for (evi->toFirst();(mev=evi->current());evi->toNext())
          {
            IEnumValue *ev = dynamic_cast<IEnumValue*>(mev);
            ILinkedTextIterator *lti = ev->initializer();
            QString init = linkedTextToString(lti);
            lti->release();
            printf("      Enum value `%s' init=`%s'\n",
                ev->name()->latin1(),init.latin1());
          }
          evi->release();
        }

        pli = mem->templateParameters();
        if (pli)
        {
          printf("      Template parameters\n");
          DumpParamList(pli,8);
          pli->release();
        }

        IDoc *doc = mem->briefDescription();
        if (doc)
        {
          printf("===== brief description ==== \n");
          DumpDoc(doc,0);
        }

        doc = mem->detailedDescription();
        if (doc)
        {
          printf("===== detailed description ==== \n");
          DumpDoc(doc,0);
        }
      }
      mli->release();
    }
    sli->release();

    IDoc *doc = comp->briefDescription();
    if (doc)
    {
      printf("===== brief description ==== \n");
      DumpDoc(doc,0);
    }

    doc = comp->detailedDescription();
    if (doc)
    {
      printf("===== detailed description ==== \n");
      DumpDoc(doc,0);
    }

    if (comp->kind()==ICompound::Class)
    {
      IClass *cls = dynamic_cast<IClass*>(comp);
      ASSERT(cls!=0);

      printf("==== inheritance graph ==== \n");
      DumpGraph(cls->inheritanceGraph());

      printf("==== collabration graph ==== \n");
      DumpGraph(cls->collaborationGraph());

      printf("==== base classes ==== \n");
      IRelatedCompoundIterator *bcli = cls->baseCompounds();
      IRelatedCompound *bClass;
      for (bcli->toFirst();(bClass=bcli->current());bcli->toNext())
      {
        ICompound *bc = bClass->compound();
        printf("    + class %s\n",bc->name()->latin1());
        bc->release();
      }
      bcli->release();

      printf("==== derived classes ==== \n");
      IRelatedCompoundIterator *dcli = cls->derivedCompounds();
      IRelatedCompound *dClass;
      for (dcli->toFirst();(dClass=dcli->current());dcli->toNext())
      {
        ICompound *dc = dClass->compound();
        printf("    + class %s\n",dc->name()->latin1());
        dc->release();
      }
      dcli->release();
    }
    else if (comp->kind()==ICompound::File)
    {
      IFile *file = dynamic_cast<IFile*>(comp);
      ASSERT(file!=0);

      printf("==== include dependency graph ==== \n");
      DumpGraph(file->includeDependencyGraph());

      printf("==== included by dependency graph ==== \n");
      DumpGraph(file->includedByDependencyGraph());

      printf("==== source ====\n");
      DumpDoc(file->source(),0);
    }
    
    comp->release();
  }
  cli->release();
  printf("---------------------------\n");

  dox->release();

  return 0;
}