summaryrefslogtreecommitdiffstats
path: root/src/perlmodgen.cpp
diff options
context:
space:
mode:
authorDimitri van Heesch <dimitri@stack.nl>2002-10-06 19:08:54 (GMT)
committerDimitri van Heesch <dimitri@stack.nl>2002-10-06 19:08:54 (GMT)
commit4596b79abbfea0953c6cd7c6b294dc1727807960 (patch)
treec1062a06b0267bdf027f00efb00f1fb2b70db5c5 /src/perlmodgen.cpp
parent858708350c055a757c1e34461a06c5cf2277f2db (diff)
downloadDoxygen-4596b79abbfea0953c6cd7c6b294dc1727807960.zip
Doxygen-4596b79abbfea0953c6cd7c6b294dc1727807960.tar.gz
Doxygen-4596b79abbfea0953c6cd7c6b294dc1727807960.tar.bz2
Release-1.2.18-20021006
Diffstat (limited to 'src/perlmodgen.cpp')
-rw-r--r--src/perlmodgen.cpp1876
1 files changed, 1876 insertions, 0 deletions
diff --git a/src/perlmodgen.cpp b/src/perlmodgen.cpp
new file mode 100644
index 0000000..e322595
--- /dev/null
+++ b/src/perlmodgen.cpp
@@ -0,0 +1,1876 @@
+/******************************************************************************
+ *
+ *
+ *
+ *
+ * Copyright (C) 1997-2002 by Dimitri van Heesch.
+ * Authors: Dimitri van Heesch, Miguel Lobo.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby
+ * granted. No representations are made about the suitability of this software
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * Documents produced by Doxygen are derivative works derived from the
+ * input used in their production; they are not affected by this license.
+ *
+ */
+
+#include <stdlib.h>
+
+#include "perlmodgen.h"
+#include "docparser.h"
+#include "message.h"
+#include "doxygen.h"
+#include "page.h"
+
+#include <qdir.h>
+#include <qstack.h>
+#include <qdict.h>
+#include <qfile.h>
+#include <qtextstream.h>
+
+#define PERLOUTPUT_MAX_INDENTATION 40
+
+class PerlModOutputStream
+{
+public:
+
+ QString m_s;
+ QTextStream *m_t;
+
+ PerlModOutputStream(QTextStream *t = 0) : m_t(t) { }
+
+ void add(char c);
+ void add(const char *s);
+ void add(QCString &s);
+ void add(QString &s);
+ void add(int n);
+ void add(unsigned int n);
+};
+
+void PerlModOutputStream::add(char c)
+{
+ if (m_t != 0)
+ (*m_t) << c;
+ else
+ m_s += c;
+}
+
+void PerlModOutputStream::add(const char *s)
+{
+ if (m_t != 0)
+ (*m_t) << s;
+ else
+ m_s += s;
+}
+
+void PerlModOutputStream::add(QCString &s)
+{
+ if (m_t != 0)
+ (*m_t) << s;
+ else
+ m_s += s;
+}
+
+void PerlModOutputStream::add(QString &s)
+{
+ if (m_t != 0)
+ (*m_t) << s;
+ else
+ m_s += s;
+}
+
+void PerlModOutputStream::add(int n)
+{
+ if (m_t != 0)
+ (*m_t) << n;
+ else
+ m_s += n;
+}
+
+void PerlModOutputStream::add(unsigned int n)
+{
+ if (m_t != 0)
+ (*m_t) << n;
+ else
+ m_s += n;
+}
+
+class PerlModOutput
+{
+public:
+
+ PerlModOutput(PerlModOutputStream *os) : m_stream(os), m_indentation(0) { m_spaces[0] = 0; }
+ virtual ~PerlModOutput() { }
+
+ inline PerlModOutput &openSave() { iopenSave(); return *this; }
+ inline PerlModOutput &closeSave(QString &s) { icloseSave(s); return *this; }
+
+ inline PerlModOutput &add(char c) { m_stream->add(c); return *this; }
+ inline PerlModOutput &add(const char *s) { m_stream->add(s); return *this; }
+ inline PerlModOutput &add(QCString &s) { m_stream->add(s); return *this; }
+ inline PerlModOutput &add(QString &s) { m_stream->add(s); return *this; }
+ inline PerlModOutput &add(int n) { m_stream->add(n); return *this; }
+ inline PerlModOutput &add(unsigned int n) { m_stream->add(n); return *this; }
+
+ PerlModOutput &addQuoted(const char *s) { iaddQuoted(s); return *this; }
+ inline PerlModOutput &indent() { m_stream->add(m_spaces); return *this; }
+
+ inline PerlModOutput &open(char c, const char *s = 0) { iopen(c, s); return *this; }
+ inline PerlModOutput &close(char c = 0) { iclose(c); return *this; }
+
+ inline PerlModOutput &addField(const char *s) { iaddField(s); return *this; }
+ inline PerlModOutput &addFieldQuoted(const char *field, const char *content)
+ {
+ iaddFieldQuoted(field, content); return *this;
+ }
+ inline PerlModOutput &openList(const char *s = 0) { open('[', s); return *this; }
+ inline PerlModOutput &closeList() { close(']'); return *this; }
+ inline PerlModOutput &openHash(const char *s = 0 ) { open('{', s); return *this; }
+ inline PerlModOutput &closeHash() { close('}'); return *this; }
+
+protected:
+
+ void iopenSave();
+ void icloseSave(QString &);
+
+ void incIndent();
+ void decIndent();
+
+ void iaddQuoted(const char *);
+ void iaddFieldQuoted(const char *, const char *);
+ void iaddField(const char *);
+
+ void iopen(char, const char *);
+ void iclose(char);
+
+private:
+
+ PerlModOutputStream *m_stream;
+ int m_indentation;
+
+ QStack<PerlModOutputStream> m_saved;
+ char m_spaces[PERLOUTPUT_MAX_INDENTATION * 2 + 2];
+};
+
+void PerlModOutput::iopenSave()
+{
+ m_saved.push(m_stream);
+ m_stream = new PerlModOutputStream();
+}
+
+void PerlModOutput::icloseSave(QString &s)
+{
+ s = m_stream->m_s;
+ delete m_stream;
+ m_stream = m_saved.pop();
+}
+
+void PerlModOutput::incIndent()
+{
+ if (m_indentation < PERLOUTPUT_MAX_INDENTATION)
+ {
+ char *s = &m_spaces[m_indentation * 2];
+ *s++ = ' '; *s++ = ' '; *s = 0;
+ }
+ m_indentation++;
+}
+
+void PerlModOutput::decIndent()
+{
+ m_indentation--;
+ if (m_indentation < PERLOUTPUT_MAX_INDENTATION)
+ m_spaces[m_indentation * 2] = 0;
+}
+
+void PerlModOutput::iaddQuoted(const char *s)
+{
+ char c;
+ while ((c = *s++) != 0) {
+ if (c == '\'')
+ m_stream->add('\\');
+ m_stream->add(c);
+ }
+}
+
+inline void PerlModOutput::iaddField(const char *s)
+{
+ indent();
+ m_stream->add(s);
+ m_stream->add(" => ");
+}
+
+void PerlModOutput::iaddFieldQuoted(const char *field, const char *content)
+{
+ iaddField(field);
+ m_stream->add('\'');
+ iaddQuoted(content);
+ m_stream->add("',\n");
+}
+
+void PerlModOutput::iopen(char c, const char *s)
+{
+ if (s != 0)
+ iaddField(s);
+ else
+ indent();
+ m_stream->add(c);
+ m_stream->add('\n');
+ incIndent();
+}
+
+void PerlModOutput::iclose(char c)
+{
+ decIndent();
+ indent();
+ if (c != 0)
+ m_stream->add(c);
+ m_stream->add(",\n");
+}
+
+/*! @brief Concrete visitor implementation for Perl output. */
+class PerlModDocVisitor : public DocVisitor
+{
+public:
+ PerlModDocVisitor(PerlModOutput &);
+ virtual ~PerlModDocVisitor() {}
+
+ void finish();
+
+ //--------------------------------------
+ // visitor functions for leaf nodes
+ //--------------------------------------
+
+ void visit(DocWord *);
+ void visit(DocLinkedWord *);
+ void visit(DocWhiteSpace *);
+ void visit(DocSymbol *);
+ void visit(DocURL *);
+ void visit(DocLineBreak *);
+ void visit(DocHorRuler *);
+ void visit(DocStyleChange *);
+ void visit(DocVerbatim *);
+ void visit(DocAnchor *);
+ void visit(DocInclude *);
+ void visit(DocIncOperator *);
+ void visit(DocFormula *);
+ void visit(DocIndexEntry *);
+
+ //--------------------------------------
+ // visitor functions for compound nodes
+ //--------------------------------------
+
+ void visitPre(DocAutoList *);
+ void visitPost(DocAutoList *);
+ void visitPre(DocAutoListItem *);
+ void visitPost(DocAutoListItem *);
+ void visitPre(DocPara *) ;
+ void visitPost(DocPara *);
+ void visitPre(DocRoot *);
+ void visitPost(DocRoot *);
+ void visitPre(DocSimpleSect *);
+ void visitPost(DocSimpleSect *);
+ void visitPre(DocTitle *);
+ void visitPost(DocTitle *);
+ void visitPre(DocSimpleList *);
+ void visitPost(DocSimpleList *);
+ void visitPre(DocSimpleListItem *);
+ void visitPost(DocSimpleListItem *);
+ void visitPre(DocSection *);
+ void visitPost(DocSection *);
+ void visitPre(DocHtmlList *);
+ void visitPost(DocHtmlList *) ;
+ void visitPre(DocHtmlListItem *);
+ void visitPost(DocHtmlListItem *);
+ void visitPre(DocHtmlPre *);
+ void visitPost(DocHtmlPre *);
+ void visitPre(DocHtmlDescList *);
+ void visitPost(DocHtmlDescList *);
+ void visitPre(DocHtmlDescTitle *);
+ void visitPost(DocHtmlDescTitle *);
+ void visitPre(DocHtmlDescData *);
+ void visitPost(DocHtmlDescData *);
+ void visitPre(DocHtmlTable *);
+ void visitPost(DocHtmlTable *);
+ void visitPre(DocHtmlRow *);
+ void visitPost(DocHtmlRow *) ;
+ void visitPre(DocHtmlCell *);
+ void visitPost(DocHtmlCell *);
+ void visitPre(DocHtmlCaption *);
+ void visitPost(DocHtmlCaption *);
+ void visitPre(DocInternal *);
+ void visitPost(DocInternal *);
+ void visitPre(DocHRef *);
+ void visitPost(DocHRef *);
+ void visitPre(DocHtmlHeader *);
+ void visitPost(DocHtmlHeader *);
+ void visitPre(DocImage *);
+ void visitPost(DocImage *);
+ void visitPre(DocDotFile *);
+ void visitPost(DocDotFile *);
+ void visitPre(DocLink *);
+ void visitPost(DocLink *);
+ void visitPre(DocRef *);
+ void visitPost(DocRef *);
+ void visitPre(DocSecRefItem *);
+ void visitPost(DocSecRefItem *);
+ void visitPre(DocSecRefList *);
+ void visitPost(DocSecRefList *);
+ void visitPre(DocLanguage *);
+ void visitPost(DocLanguage *);
+ void visitPre(DocParamSect *);
+ void visitPost(DocParamSect *);
+ void visitPre(DocParamList *);
+ void visitPost(DocParamList *);
+ void visitPre(DocXRefItem *);
+ void visitPost(DocXRefItem *);
+ void visitPre(DocInternalRef *);
+ void visitPost(DocInternalRef *);
+ void visitPre(DocCopy *);
+ void visitPost(DocCopy *);
+ void visitPre(DocText *);
+ void visitPost(DocText *);
+
+private:
+
+ //--------------------------------------
+ // helper functions
+ //--------------------------------------
+
+ void addLink(const QString &ref,const QString &file,
+ const QString &anchor);
+
+ void enterText();
+ void leaveText();
+
+ void openItem(const char *);
+ void closeItem();
+ void singleItem(const char *);
+ void openSubBlock(const char * = 0);
+ void closeSubBlock();
+
+ //--------------------------------------
+ // state variables
+ //--------------------------------------
+
+ PerlModOutput &m_output;
+ bool m_textmode;
+ QString m_other;
+};
+
+PerlModDocVisitor::PerlModDocVisitor(PerlModOutput &output)
+ : m_output(output), m_textmode(false)
+{
+ m_output.openList("doc");
+}
+
+void PerlModDocVisitor::finish()
+{
+ leaveText();
+ m_output.closeList()
+ .add(m_other);
+}
+
+void PerlModDocVisitor::addLink(const QString &,const QString &file,const QString &anchor)
+{
+ QString link = file;
+ if (!anchor.isEmpty())
+ (link += "_1") += anchor;
+ m_output.addFieldQuoted("link", link);
+}
+
+void PerlModDocVisitor::openItem(const char *name)
+{
+ leaveText();
+ m_output.openHash().addFieldQuoted("type", name);
+}
+
+void PerlModDocVisitor::closeItem()
+{
+ m_output.closeHash();
+}
+
+void PerlModDocVisitor::enterText()
+{
+ if (m_textmode)
+ return;
+ openItem("text");
+ m_output.addField("content").add('\'');
+ m_textmode = true;
+}
+
+void PerlModDocVisitor::leaveText()
+{
+ if (!m_textmode)
+ return;
+ m_output.add("\'\n");
+ closeItem();
+ m_textmode = false;
+}
+
+void PerlModDocVisitor::singleItem(const char *name)
+{
+ openItem(name);
+ closeItem();
+}
+
+void PerlModDocVisitor::openSubBlock(const char *s)
+{
+ m_output.openList(s);
+}
+
+void PerlModDocVisitor::closeSubBlock()
+{
+ leaveText();
+ m_output.closeList();
+}
+
+void PerlModDocVisitor::visit(DocWord *w)
+{
+ enterText();
+ m_output.addQuoted(w->word());
+}
+
+void PerlModDocVisitor::visit(DocLinkedWord *w)
+{
+ openItem("url");
+ addLink(w->ref(), w->file(), w->anchor());
+ m_output.addFieldQuoted("content", w->word());
+ closeItem();
+}
+
+void PerlModDocVisitor::visit(DocWhiteSpace *)
+{
+ enterText();
+ m_output.add(' ');
+}
+
+void PerlModDocVisitor::visit(DocSymbol *sy)
+{
+ char c = 0;
+ const char *s = 0;
+ switch(sy->symbol())
+ {
+ case DocSymbol::At: c = '@'; break;
+ case DocSymbol::Less: c = '<'; break;
+ case DocSymbol::Greater: c = '>'; break;
+ case DocSymbol::Amp: c = '&'; break;
+ case DocSymbol::Dollar: c = '$'; break;
+ case DocSymbol::Hash: c = '#'; break;
+ case DocSymbol::Percent: c = '%'; break;
+ case DocSymbol::Quot: c = '"'; break;
+ case DocSymbol::Szlig: c = 'ß'; break;
+ case DocSymbol::Nbsp: c = ' '; break;
+ case DocSymbol::Uml: c = sy->letter(); break;
+ case DocSymbol::Acute: c = sy->letter(); break;
+ case DocSymbol::Grave: c = sy->letter(); break;
+ case DocSymbol::Circ: c = sy->letter(); break;
+ case DocSymbol::Tilde: c = sy->letter(); break;
+ case DocSymbol::Cedil: c = sy->letter(); break;
+ case DocSymbol::Ring: c = sy->letter(); break;
+ case DocSymbol::BSlash: s = "\\\\"; break;
+ case DocSymbol::Copy: s = "(c)"; break;
+ case DocSymbol::Apos: s = "\\\'"; break;
+ default:
+ err("Error: unknown symbol found\n");
+ }
+ enterText();
+ if (c != 0)
+ m_output.add(c);
+ else
+ m_output.add(s);
+}
+
+void PerlModDocVisitor::visit(DocURL *u)
+{
+ openItem("url");
+ m_output.addQuoted(u->url());
+ closeItem();
+}
+
+void PerlModDocVisitor::visit(DocLineBreak *) { singleItem("linebreak"); }
+void PerlModDocVisitor::visit(DocHorRuler *) { singleItem("hruler"); }
+void PerlModDocVisitor::visit(DocStyleChange *s)
+{
+ switch (s->style())
+ {
+ case DocStyleChange::Bold: break; // bold
+ case DocStyleChange::Italic: break; // italic
+ case DocStyleChange::Code: break; // code
+ case DocStyleChange::Subscript: break; // subscript
+ case DocStyleChange::Superscript: break; // superscript
+ case DocStyleChange::Center: break; // center
+ case DocStyleChange::Small: break; // small
+ default:
+ err("Error: unknown style found.\n");
+ }
+}
+
+void PerlModDocVisitor::visit(DocVerbatim *s)
+{
+ const char *type = 0;
+ switch(s->type())
+ {
+ case DocVerbatim::Code:
+#if 0
+ m_output.add("<programlisting>");
+ parseCode(m_ci,s->context(),s->text(),FALSE,0);
+ m_output.add("</programlisting>");
+#endif
+ return;
+ case DocVerbatim::Verbatim: type = "preformatted"; break;
+ case DocVerbatim::HtmlOnly: type = "htmlonly"; break;
+ case DocVerbatim::LatexOnly: type = "latexonly"; break;
+ }
+ openItem(type);
+ m_output.addFieldQuoted("content", s->text());
+ closeItem();
+}
+
+void PerlModDocVisitor::visit(DocAnchor *anc)
+{
+ QString anchor = anc->file() + "_1" + anc->anchor();
+ openItem("anchor");
+ m_output.addFieldQuoted("id", anchor);
+ closeItem();
+}
+
+void PerlModDocVisitor::visit(DocInclude *inc)
+{
+ const char *type = 0;
+ switch(inc->type())
+ {
+ case DocInclude::Include:
+#if 0
+ m_output.add("<programlisting>");
+ parseCode(m_ci,inc->context(),inc->text(),FALSE,0);
+ m_output.add("</programlisting>");
+#endif
+ return;
+ case DocInclude::DontInclude: return;
+ case DocInclude::HtmlInclude: type = "htmlonly"; break;
+ case DocInclude::VerbInclude: type = "preformatted"; break;
+ }
+ openItem(type);
+ m_output.addFieldQuoted("content", inc->text());
+ closeItem();
+}
+
+void PerlModDocVisitor::visit(DocIncOperator *)
+{
+#if 0
+ //printf("DocIncOperator: type=%d first=%d, last=%d text=`%s'\n",
+ // op->type(),op->isFirst(),op->isLast(),op->text().data());
+ if (op->isFirst())
+ {
+ m_output.add("<programlisting>");
+ }
+ if (op->type()!=DocIncOperator::Skip)
+ {
+ parseCode(m_ci,op->context(),op->text(),FALSE,0);
+ }
+ if (op->isLast())
+ {
+ m_output.add("</programlisting>");
+ }
+ else
+ {
+ m_output.add('\n');
+ }
+#endif
+}
+
+void PerlModDocVisitor::visit(DocFormula *f)
+{
+ openItem("formula");
+ QString id;
+ id += f->id();
+ m_output.addFieldQuoted("id", id).addFieldQuoted("content", f->text());
+ closeItem();
+}
+
+void PerlModDocVisitor::visit(DocIndexEntry *)
+{
+#if 0
+ m_output.add("<indexentry>"
+ "<primaryie>");
+ m_output.addQuoted(ie->entry());
+ m_output.add("</primaryie>"
+ "<secondaryie></secondaryie>"
+ "</indexentry>");
+#endif
+}
+
+//--------------------------------------
+// visitor functions for compound nodes
+//--------------------------------------
+
+void PerlModDocVisitor::visitPre(DocAutoList *l)
+{
+ openItem(l->isEnumList() ? "ordered_list" : "itemized_list");
+ openSubBlock("content");
+}
+void PerlModDocVisitor::visitPost(DocAutoList *) { closeSubBlock(); }
+
+void PerlModDocVisitor::visitPre(DocAutoListItem *) { openSubBlock(); }
+void PerlModDocVisitor::visitPost(DocAutoListItem *) { closeSubBlock(); }
+void PerlModDocVisitor::visitPre(DocPara *)
+{
+ openItem("para");
+ openSubBlock("content");
+}
+void PerlModDocVisitor::visitPost(DocPara *)
+{
+ closeSubBlock();
+ closeItem();
+}
+
+void PerlModDocVisitor::visitPre(DocRoot *)
+{
+}
+
+void PerlModDocVisitor::visitPost(DocRoot *)
+{
+}
+
+void PerlModDocVisitor::visitPre(DocSimpleSect *s)
+{
+ leaveText();
+ const char *type;
+ switch (s->type())
+ {
+ case DocSimpleSect::See: type = "see"; break;
+ case DocSimpleSect::Return: type = "return"; break;
+ case DocSimpleSect::Author: type = "author"; break;
+ case DocSimpleSect::Authors: type = "authors"; break;
+ case DocSimpleSect::Version: type = "version"; break;
+ case DocSimpleSect::Since: type = "since"; break;
+ case DocSimpleSect::Date: type = "date"; break;
+ case DocSimpleSect::Note: type = "bug"; break;
+ case DocSimpleSect::Warning: type = "warning"; break;
+ case DocSimpleSect::Pre: type = "pre"; break;
+ case DocSimpleSect::Post: type = "post"; break;
+ case DocSimpleSect::Invar: type = "invariant"; break;
+ case DocSimpleSect::Remark: type = "remark"; break;
+ case DocSimpleSect::Attention: type = "attention"; break;
+ case DocSimpleSect::User: type = "par"; break;
+ default: type = "illegal"; break;
+ }
+ m_output.openSave().openList(type);
+}
+
+void PerlModDocVisitor::visitPost(DocSimpleSect *)
+{
+ QString content;
+ leaveText();
+ m_output.closeList().closeSave(content);
+ m_other += content;
+}
+
+void PerlModDocVisitor::visitPre(DocTitle *)
+{
+ openItem("title");
+ openSubBlock("content");
+}
+
+void PerlModDocVisitor::visitPost(DocTitle *)
+{
+ closeSubBlock();
+ closeItem();
+}
+
+void PerlModDocVisitor::visitPre(DocSimpleList *)
+{
+ openItem("itemized_list");
+ openSubBlock("content");
+}
+void PerlModDocVisitor::visitPost(DocSimpleList *) { closeSubBlock(); }
+void PerlModDocVisitor::visitPre(DocSimpleListItem *) { openSubBlock(); }
+void PerlModDocVisitor::visitPost(DocSimpleListItem *) { closeSubBlock(); }
+
+void PerlModDocVisitor::visitPre(DocSection *s)
+{
+ QString sect = "sect" + (s->level() + 1);
+ openItem(sect);
+ openSubBlock("content");
+}
+void PerlModDocVisitor::visitPost(DocSection *) { closeSubBlock(); }
+
+void PerlModDocVisitor::visitPre(DocHtmlList *l)
+{
+ openItem((l->type() == DocHtmlList::Ordered) ? "ordered_list" : "itemized_list");
+ openSubBlock("content");
+}
+void PerlModDocVisitor::visitPost(DocHtmlList *) { closeSubBlock(); }
+void PerlModDocVisitor::visitPre(DocHtmlListItem *) { openSubBlock(); }
+void PerlModDocVisitor::visitPost(DocHtmlListItem *) { closeSubBlock(); }
+
+void PerlModDocVisitor::visitPre(DocHtmlPre *)
+{
+ openItem("preformatted");
+ openSubBlock("content");
+ //m_insidePre=TRUE;
+}
+
+void PerlModDocVisitor::visitPost(DocHtmlPre *)
+{
+ //m_insidePre=FALSE;
+ closeSubBlock();
+ closeItem();
+}
+
+void PerlModDocVisitor::visitPre(DocHtmlDescList *)
+{
+#if 0
+ m_output.add("<variablelist>\n");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocHtmlDescList *)
+{
+#if 0
+ m_output.add("</variablelist>\n");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocHtmlDescTitle *)
+{
+#if 0
+ m_output.add("<varlistentry><term>");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocHtmlDescTitle *)
+{
+#if 0
+ m_output.add("</term></varlistentry>\n");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocHtmlDescData *)
+{
+#if 0
+ m_output.add("<listitem>");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocHtmlDescData *)
+{
+#if 0
+ m_output.add("</listitem>\n");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocHtmlTable *)
+{
+#if 0
+ m_output.add("<table rows=\""); m_output.add(t->numRows());
+ m_output.add("\" cols=\""); m_output.add(t->numCols()); m_output.add("\">");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocHtmlTable *)
+{
+#if 0
+ m_output.add("</table>\n");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocHtmlRow *)
+{
+#if 0
+ m_output.add("<row>\n");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocHtmlRow *)
+{
+#if 0
+ m_output.add("</row>\n");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocHtmlCell *)
+{
+#if 0
+ if (c->isHeading()) m_output.add("<entry thead=\"yes\">"); else m_output.add("<entry thead=\"no\">");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocHtmlCell *)
+{
+#if 0
+ m_output.add("</entry>");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocHtmlCaption *)
+{
+#if 0
+ m_output.add("<caption>");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocHtmlCaption *)
+{
+#if 0
+ m_output.add("</caption>\n");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocInternal *)
+{
+#if 0
+ m_output.add("<internal>");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocInternal *)
+{
+#if 0
+ m_output.add("</internal>");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocHRef *)
+{
+#if 0
+ m_output.add("<ulink url=\""); m_output.add(href->url()); m_output.add("\">");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocHRef *)
+{
+#if 0
+ m_output.add("</ulink>");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocHtmlHeader *)
+{
+#if 0
+ m_output.add("<sect"); m_output.add(header->level()); m_output.add(">");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocHtmlHeader *)
+{
+#if 0
+ m_output.add("</sect"); m_output.add(header->level()); m_output.add(">\n");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocImage *)
+{
+#if 0
+ m_output.add("<image type=\"");
+ switch(img->type())
+ {
+ case DocImage::Html: m_output.add("html"); break;
+ case DocImage::Latex: m_output.add("latex"); break;
+ case DocImage::Rtf: m_output.add("rtf"); break;
+ }
+ m_output.add("\"");
+
+ QCString baseName=img->name();
+ int i;
+ if ((i=baseName.findRev('/'))!=-1 || (i=baseName.findRev('\\'))!=-1)
+ {
+ baseName=baseName.right(baseName.length()-i-1);
+ }
+ m_output.add(" name=\""); m_output.add(baseName); m_output.add("\"");
+ if (!img->width().isEmpty())
+ {
+ m_output.add(" width=\"");
+ m_output.addQuoted(img->width());
+ m_output.add("\"");
+ }
+ else if (!img->height().isEmpty())
+ {
+ m_output.add(" height=\"");
+ m_output.addQuoted(img->height());
+ m_output.add("\"");
+ }
+ m_output.add(">");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocImage *)
+{
+#if 0
+ m_output.add("</image>");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocDotFile *)
+{
+#if 0
+ m_output.add("<dotfile name=\""); m_output.add(df->file()); m_output.add("\">");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocDotFile *)
+{
+#if 0
+ m_output.add("</dotfile>");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocLink *lnk)
+{
+ openItem("link");
+ addLink(lnk->ref(), lnk->file(), lnk->anchor());
+}
+
+void PerlModDocVisitor::visitPost(DocLink *)
+{
+ closeItem();
+}
+
+void PerlModDocVisitor::visitPre(DocRef *ref)
+{
+ openItem("ref");
+ if (!ref->hasLinkText())
+ m_output.addFieldQuoted("text", ref->targetTitle());
+}
+
+void PerlModDocVisitor::visitPost(DocRef *)
+{
+ closeItem();
+}
+
+void PerlModDocVisitor::visitPre(DocSecRefItem *)
+{
+#if 0
+ m_output.add("<tocitem id=\""); m_output.add(ref->file()); m_output.add("_1"); m_output.add(ref->anchor()); m_output.add("\">");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocSecRefItem *)
+{
+#if 0
+ m_output.add("</tocitem>");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocSecRefList *)
+{
+#if 0
+ m_output.add("<toclist>");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocSecRefList *)
+{
+#if 0
+ m_output.add("</toclist>");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocLanguage *l)
+{
+ openItem("language");
+ m_output.addFieldQuoted("id", l->id());
+}
+
+void PerlModDocVisitor::visitPost(DocLanguage *)
+{
+ closeItem();
+}
+
+void PerlModDocVisitor::visitPre(DocParamSect *s)
+{
+ leaveText();
+ const char *type = 0;
+ switch(s->type())
+ {
+ case DocParamSect::Param: type = "params"; break;
+ case DocParamSect::RetVal: type = "retvals"; break;
+ case DocParamSect::Exception: type = "exceptions"; break;
+ default: ASSERT(0);
+ }
+ m_output.openSave().openList(type);
+}
+
+void PerlModDocVisitor::visitPost(DocParamSect *)
+{
+ leaveText();
+ QString content;
+ m_output.closeList().closeSave(content);
+ m_other += content;
+}
+
+void PerlModDocVisitor::visitPre(DocParamList *pl)
+{
+ leaveText();
+ m_output.openHash()
+ .openList("parameters");
+ QStrListIterator li(pl->parameters());
+ const char *s;
+ for (li.toFirst();(s=li.current());++li)
+ {
+ m_output.openHash()
+ .addFieldQuoted("name", s)
+ .closeHash();
+ }
+ m_output.closeList()
+ .openList("doc");
+}
+
+void PerlModDocVisitor::visitPost(DocParamList *)
+{
+ leaveText();
+ m_output.closeList()
+ .closeHash();
+}
+
+void PerlModDocVisitor::visitPre(DocXRefItem *)
+{
+#if 0
+ m_output.add("<xrefsect id=\"");
+ m_output.add(x->file()); m_output.add("_1"); m_output.add(x->anchor());
+ m_output.add("\">");
+ m_output.add("<xreftitle>");
+ m_output.addQuoted(x->title());
+ m_output.add("</xreftitle>");
+ m_output.add("<xrefdescription>");
+#endif
+}
+
+void PerlModDocVisitor::visitPost(DocXRefItem *)
+{
+#if 0
+ m_output.add("</xrefdescription>");
+ m_output.add("</xrefsect>");
+#endif
+}
+
+void PerlModDocVisitor::visitPre(DocInternalRef *ref)
+{
+ openItem("ref");
+ addLink(0,ref->file(),ref->anchor());
+}
+
+void PerlModDocVisitor::visitPost(DocInternalRef *)
+{
+ closeItem();
+}
+
+void PerlModDocVisitor::visitPre(DocCopy *)
+{
+}
+
+void PerlModDocVisitor::visitPost(DocCopy *)
+{
+}
+
+void PerlModDocVisitor::visitPre(DocText *)
+{
+}
+
+void PerlModDocVisitor::visitPost(DocText *)
+{
+}
+
+static void addTemplateArgumentList(ArgumentList *al,
+ PerlModOutput &output,const char * /*name*/)
+{
+ QCString indentStr;
+ if (!al)
+ return;
+ output.openList("template_parameters");
+ ArgumentListIterator ali(*al);
+ Argument *a;
+ for (ali.toFirst();(a=ali.current());++ali)
+ {
+ output.openHash();
+ if (!a->type.isEmpty())
+ output.addFieldQuoted("type", a->type);
+ if (!a->name.isEmpty())
+ output.addFieldQuoted("declaration_name", a->name)
+ .addFieldQuoted("definition_name", a->name);
+ if (!a->defval.isEmpty())
+ output.addFieldQuoted("default", a->defval);
+ output.closeHash();
+ }
+ output.closeList();
+}
+
+/*
+static void addMemberTemplateLists(MemberDef *md,PerlModOutput &output)
+{
+ ClassDef *cd = md->getClassDef();
+ const char *cname = cd ? cd->name().data() : 0;
+ if (md->templateArguments()) // function template prefix
+ addTemplateArgumentList(md->templateArguments(),output,cname);
+}
+*/
+
+static void addTemplateList(ClassDef *cd,PerlModOutput &output)
+{
+ addTemplateArgumentList(cd->templateArguments(),output,cd->name());
+}
+
+static void addPerlModDocBlock(PerlModOutput &output,
+ const char *name,
+ const QCString &fileName,
+ int lineNr,
+ const QCString &scope,
+ MemberDef *md,
+ const QCString &text)
+{
+ QCString stext = text.stripWhiteSpace();
+ if (stext.isEmpty())
+ {
+ output.addField(name).add("{},\n");
+ }
+ else
+ {
+ DocNode *root = validatingParseDoc(fileName,lineNr,scope,md,stext,FALSE);
+ output.openHash(name);
+ PerlModDocVisitor *visitor = new PerlModDocVisitor(output);
+ root->accept(visitor);
+ visitor->finish();
+ output.closeHash();
+ delete visitor;
+ delete root;
+ }
+}
+
+static const char *getProtectionName(Protection prot)
+{
+ switch (prot)
+ {
+ case Public: return "public";
+ case Protected: return "protected";
+ case Private: return "private";
+ }
+ return 0;
+}
+
+static const char *getVirtualnessName(Specifier virt)
+{
+ switch(virt)
+ {
+ case Normal: return "non_virtual";
+ case Virtual: return "virtual";
+ case Pure: return "pure_virtual";
+ }
+ return 0;
+}
+
+static void generatePerlForMember(MemberDef *md,PerlModOutput &output,Definition *)
+{
+
+ // + declaration/definition arg lists
+ // + reimplements
+ // + reimplementedBy
+ // + exceptions
+ // + const/volatile specifiers
+ // - examples
+ // - source definition
+ // - source references
+ // - source referenced by
+ // - body code
+ // - template arguments
+ // (templateArguments(), definitionTemplateParameterLists())
+
+ QCString memType;
+ bool isFunc=FALSE;
+ switch (md->memberType())
+ {
+ case MemberDef::Define: memType="define"; break;
+ case MemberDef::EnumValue: ASSERT(0); break;
+ case MemberDef::Property: memType="property"; break;
+ case MemberDef::Variable: memType="variable"; break;
+ case MemberDef::Typedef: memType="typedef"; break;
+ case MemberDef::Enumeration: memType="enum"; break;
+ case MemberDef::Function: memType="function"; isFunc=TRUE; break;
+ case MemberDef::Signal: memType="signal"; isFunc=TRUE; break;
+ case MemberDef::Prototype: memType="prototype"; isFunc=TRUE; break;
+ case MemberDef::Friend: memType="friend"; isFunc=TRUE; break;
+ case MemberDef::DCOP: memType="dcop"; isFunc=TRUE; break;
+ case MemberDef::Slot: memType="slot"; isFunc=TRUE; break;
+ }
+
+ QCString scopeName;
+ if (md->getClassDef())
+ scopeName=md->getClassDef()->name();
+ else if (md->getNamespaceDef())
+ scopeName=md->getNamespaceDef()->name();
+
+ output.openHash()
+ .addFieldQuoted("kind", memType)
+ .addFieldQuoted("name", md->name())
+ .addFieldQuoted("virtualness", getVirtualnessName(md->virtualness()))
+ .addFieldQuoted("protection", getProtectionName(md->protection()));
+
+ addPerlModDocBlock(output,"brief",md->getDefFileName(),md->getDefLine(),scopeName,md,md->briefDescription());
+ addPerlModDocBlock(output,"detailed",md->getDefFileName(),md->getDefLine(),scopeName,md,md->documentation());
+ if (md->memberType()!=MemberDef::Define &&
+ md->memberType()!=MemberDef::Enumeration)
+ output.addFieldQuoted("type", md->typeString());
+
+ if (isFunc) //function
+ {
+ ArgumentList *al = md->argumentList();
+ output.addFieldQuoted("const", (al && al->constSpecifier) ? "yes" : "no")
+ .addFieldQuoted("volatile", (al && al->volatileSpecifier) ? "yes" : "no");
+
+ output.openList("parameters");
+ ArgumentList *declAl = md->declArgumentList();
+ ArgumentList *defAl = md->argumentList();
+ if (declAl && declAl->count()>0)
+ {
+ ArgumentListIterator declAli(*declAl);
+ ArgumentListIterator defAli(*defAl);
+ Argument *a;
+ for (declAli.toFirst();(a=declAli.current());++declAli)
+ {
+ Argument *defArg = defAli.current();
+ output.openHash();
+
+ if (!a->name.isEmpty())
+ output.addFieldQuoted("declaration_name", a->name);
+
+ if (defArg && !defArg->name.isEmpty() && defArg->name!=a->name)
+ output.addFieldQuoted("definition_name", defArg->name);
+
+ if (!a->type.isEmpty())
+ output.addFieldQuoted("type", a->type);
+
+ if (!a->array.isEmpty())
+ output.addFieldQuoted("array", a->array);
+
+ if (!a->defval.isEmpty())
+ output.addFieldQuoted("default_value", a->defval);
+
+ if (!a->attrib.isEmpty())
+ output.addFieldQuoted("attributes", a->attrib);
+
+ output.closeHash();
+ if (defArg) ++defAli;
+ }
+ }
+ output.closeList();
+ }
+ else if (md->memberType()==MemberDef::Define &&
+ md->argsString()!=0) // define
+ {
+ output.openList("parameters");
+ ArgumentListIterator ali(*md->argumentList());
+ Argument *a;
+ for (ali.toFirst();(a=ali.current());++ali)
+ {
+ output.openHash()
+ .addFieldQuoted("name", a->type)
+ .closeHash();
+ }
+ output.closeList();
+ }
+ if (!md->initializer().isEmpty())
+ output.addFieldQuoted("initializer", md->initializer());
+
+ if (md->excpString())
+ output.addFieldQuoted("exceptions", md->excpString());
+
+ if (md->memberType()==MemberDef::Enumeration) // enum
+ {
+ if (md->enumFieldList())
+ {
+ output.openList("values");
+ MemberListIterator emli(*md->enumFieldList());
+ MemberDef *emd;
+ for (emli.toFirst();(emd=emli.current());++emli)
+ {
+ output.openHash()
+ .addFieldQuoted("name", emd->name());
+
+ if (!emd->initializer().isEmpty())
+ output.addFieldQuoted("initializer", emd->initializer());
+
+ addPerlModDocBlock(output,"brief",emd->getDefFileName(),emd->getDefLine(),scopeName,emd,emd->briefDescription());
+
+ addPerlModDocBlock(output,"detailed",emd->getDefFileName(),emd->getDefLine(),scopeName,emd,emd->documentation());
+
+ output.closeHash();
+ }
+ output.closeList();
+ }
+ }
+
+ MemberDef *rmd = md->reimplements();
+ if (rmd)
+ output.openHash("reimplements")
+ .addFieldQuoted("name", rmd->name())
+ .closeHash();
+
+ MemberList *rbml = md->reimplementedBy();
+ if (rbml)
+ {
+ MemberListIterator mli(*rbml);
+ output.openList("reimplemented_by");
+ for (mli.toFirst();(rmd=mli.current());++mli)
+ output.openHash()
+ .addFieldQuoted("name", rmd->name())
+ .closeHash();
+ output.closeList();
+ }
+
+ output.closeHash();
+}
+
+static void generatePerlSection(Definition *d,PerlModOutput &output,
+ MemberList *ml,const char *name,const char *header=0)
+{
+ if (ml->count()==0) return; // empty list
+
+ output.openHash(name);
+
+ if (header)
+ output.addFieldQuoted("header", header);
+
+ output.openList("members");
+ MemberListIterator mli(*ml);
+ MemberDef *md;
+ for (mli.toFirst();(md=mli.current());++mli)
+ {
+ generatePerlForMember(md,output,d);
+ }
+ output.closeList()
+ .closeHash();
+}
+
+static void addListOfAllMembers(ClassDef *cd, PerlModOutput &output)
+{
+ output.openList("all_members");
+ MemberNameInfoSDict::Iterator mnii(*cd->memberNameInfoSDict());
+ MemberNameInfo *mni;
+ for (mnii.toFirst();(mni=mnii.current());++mnii)
+ {
+ MemberNameInfoIterator mii(*mni);
+ MemberInfo *mi;
+ for (mii.toFirst();(mi=mii.current());++mii)
+ {
+ MemberDef *md=mi->memberDef;
+ ClassDef *cd=md->getClassDef();
+ Definition *d=md->getGroupDef();
+ if (d==0) d = cd;
+
+ output.openHash()
+ .addFieldQuoted("name", md->name())
+ .addFieldQuoted("virtualness", getVirtualnessName(md->virtualness()))
+ .addFieldQuoted("protection", getProtectionName(mi->prot));
+
+ if (!mi->ambiguityResolutionScope.isEmpty())
+ output.addFieldQuoted("ambiguity_scope", mi->ambiguityResolutionScope);
+
+ output.addFieldQuoted("scope", cd->name())
+ .closeHash();
+ }
+ }
+ output.closeList();
+}
+
+static void generatePerlForClass(ClassDef *cd, PerlModOutput &output)
+{
+ // + brief description
+ // + detailed description
+ // + template argument list(s)
+ // - include file
+ // + member groups
+ // + inheritance diagram
+ // + list of direct super classes
+ // + list of direct sub classes
+ // + list of inner classes
+ // + collaboration diagram
+ // + list of all members
+ // + user defined member sections
+ // + standard member sections
+ // + detailed member documentation
+ // - examples using the class
+
+ if (cd->isReference()) return; // skip external references.
+ if (cd->name().find('@')!=-1) return; // skip anonymous compounds.
+ if (cd->templateMaster()!=0) return; // skip generated template instances.
+
+ output.openHash()
+ .addFieldQuoted("name", cd->name());
+
+ if (cd->baseClasses()->count()>0)
+ {
+ output.openList("base");
+ BaseClassListIterator bcli(*cd->baseClasses());
+ BaseClassDef *bcd;
+ for (bcli.toFirst();(bcd=bcli.current());++bcli)
+ output.openHash()
+ .addFieldQuoted("name", bcd->classDef->displayName())
+ .addFieldQuoted("virtualness", getVirtualnessName(bcd->virt))
+ .addFieldQuoted("protection", getProtectionName(bcd->prot))
+ .closeHash();
+ output.closeList();
+ }
+
+ if (cd->subClasses()->count()>0)
+ {
+ output.openList("derived");
+ BaseClassListIterator bcli(*cd->baseClasses());
+ BaseClassDef *bcd;
+ for (bcli.toFirst();(bcd=bcli.current());++bcli)
+ output.openHash()
+ .addFieldQuoted("name", bcd->classDef->displayName())
+ .addFieldQuoted("virtualness", getVirtualnessName(bcd->virt))
+ .addFieldQuoted("protection", getProtectionName(bcd->prot))
+ .closeHash();
+ output.closeList();
+ }
+
+ ClassSDict *cl = cd->getInnerClasses();
+ if (cl)
+ {
+ output.openList("inner");
+ ClassSDict::Iterator cli(*cl);
+ ClassDef *cd;
+ for (cli.toFirst();(cd=cli.current());++cli)
+ output.openHash()
+ .addFieldQuoted("name", cd->name())
+ .closeHash();
+ output.closeList();
+ }
+
+ IncludeInfo *ii=cd->includeInfo();
+ if (ii)
+ {
+ QCString nm = ii->includeName;
+ if (nm.isEmpty() && ii->fileDef) nm = ii->fileDef->docName();
+ if (!nm.isEmpty())
+ {
+ output.openHash("includes");
+#if 0
+ if (ii->fileDef && !ii->fileDef->isReference()) // TODO: support external references
+ t << " id=\"" << ii->fileDef->getOutputFileBase() << "\"";
+#endif
+ output.addFieldQuoted("local", ii->local ? "yes" : "no")
+ .addFieldQuoted("name", nm)
+ .closeHash();
+ }
+ }
+
+ addTemplateList(cd,output);
+ addListOfAllMembers(cd,output);
+ MemberGroupSDict::Iterator mgli(*cd->memberGroupSDict);
+ MemberGroup *mg;
+ for (;(mg=mgli.current());++mgli)
+ generatePerlSection(cd,output,mg->members(),"user_defined",mg->header());
+
+ generatePerlSection(cd,output,&cd->pubTypes,"public_typedefs");
+ generatePerlSection(cd,output,&cd->pubMethods,"public_methods");
+ generatePerlSection(cd,output,&cd->pubAttribs,"public_members");
+ generatePerlSection(cd,output,&cd->pubSlots,"public_slots");
+ generatePerlSection(cd,output,&cd->signals,"signals");
+ generatePerlSection(cd,output,&cd->dcopMethods,"dcop_methods");
+ generatePerlSection(cd,output,&cd->properties,"properties");
+ generatePerlSection(cd,output,&cd->pubStaticMethods,"public_static_methods");
+ generatePerlSection(cd,output,&cd->pubStaticAttribs,"public_static_members");
+ generatePerlSection(cd,output,&cd->proTypes,"protected_typedefs");
+ generatePerlSection(cd,output,&cd->proMethods,"protected_methods");
+ generatePerlSection(cd,output,&cd->proAttribs,"protected_members");
+ generatePerlSection(cd,output,&cd->proSlots,"protected_slots");
+ generatePerlSection(cd,output,&cd->proStaticMethods,"protected_static_methods");
+ generatePerlSection(cd,output,&cd->proStaticAttribs,"protected_static_members");
+ generatePerlSection(cd,output,&cd->priTypes,"private_typedefs");
+ generatePerlSection(cd,output,&cd->priMethods,"private_methods");
+ generatePerlSection(cd,output,&cd->priAttribs,"private_members");
+ generatePerlSection(cd,output,&cd->priSlots,"private_slots");
+ generatePerlSection(cd,output,&cd->priStaticMethods,"private_static_methods");
+ generatePerlSection(cd,output,&cd->priStaticAttribs,"private_static_members");
+ generatePerlSection(cd,output,&cd->friends,"friend_methods");
+ generatePerlSection(cd,output,&cd->related,"related_methods");
+
+ addPerlModDocBlock(output,"brief",cd->getDefFileName(),cd->getDefLine(),cd->name(),0,cd->briefDescription());
+ addPerlModDocBlock(output,"detailed",cd->getDefFileName(),cd->getDefLine(),cd->name(),0,cd->documentation());
+
+#if 0
+ DotClassGraph inheritanceGraph(cd,DotClassGraph::Inheritance);
+ if (!inheritanceGraph.isTrivial())
+ {
+ t << " <inheritancegraph>" << endl;
+ inheritanceGraph.writePerl(t);
+ t << " </inheritancegraph>" << endl;
+ }
+ DotClassGraph collaborationGraph(cd,DotClassGraph::Implementation);
+ if (!collaborationGraph.isTrivial())
+ {
+ t << " <collaborationgraph>" << endl;
+ collaborationGraph.writePerl(t);
+ t << " </collaborationgraph>" << endl;
+ }
+ t << " <location file=\""
+ << cd->getDefFileName() << "\" line=\""
+ << cd->getDefLine() << "\"";
+ if (cd->getStartBodyLine()!=-1)
+ {
+ t << " bodystart=\"" << cd->getStartBodyLine() << "\" bodyend=\""
+ << cd->getEndBodyLine() << "\"";
+ }
+ t << "/>" << endl;
+#endif
+
+ output.closeHash();
+}
+
+static void generatePerlForNamespace(NamespaceDef *nd, PerlModOutput &output)
+{
+ // + contained class definitions
+ // + contained namespace definitions
+ // + member groups
+ // + normal members
+ // + brief desc
+ // + detailed desc
+ // + location
+ // - files containing (parts of) the namespace definition
+
+ if (nd->isReference()) return; // skip external references
+
+ output.openHash()
+ .addFieldQuoted("name", nd->name());
+
+ ClassSDict *cl = nd->classSDict;
+ if (cl)
+ {
+ output.openList("classes");
+ ClassSDict::Iterator cli(*cl);
+ ClassDef *cd;
+ for (cli.toFirst();(cd=cli.current());++cli)
+ output.openHash()
+ .addFieldQuoted("name", cd->name())
+ .closeHash();
+ output.closeList();
+ }
+
+ NamespaceSDict *nl = nd->namespaceSDict;
+ if (nl)
+ {
+ output.openList("namespaces");
+ NamespaceSDict::Iterator nli(*nl);
+ NamespaceDef *nd;
+ for (nli.toFirst();(nd=nli.current());++nli)
+ output.openHash()
+ .addFieldQuoted("name", nd->name())
+ .closeHash();
+ output.closeList();
+ }
+
+ MemberGroupSDict::Iterator mgli(*nd->memberGroupSDict);
+ MemberGroup *mg;
+ for (;(mg=mgli.current());++mgli)
+ generatePerlSection(nd,output,mg->members(),"user-defined",mg->header());
+
+ generatePerlSection(nd,output,&nd->decDefineMembers,"defines");
+ generatePerlSection(nd,output,&nd->decProtoMembers,"prototypes");
+ generatePerlSection(nd,output,&nd->decTypedefMembers,"typedefs");
+ generatePerlSection(nd,output,&nd->decEnumMembers,"enums");
+ generatePerlSection(nd,output,&nd->decFuncMembers,"functions");
+ generatePerlSection(nd,output,&nd->decVarMembers,"variables");
+
+ addPerlModDocBlock(output,"brief",nd->getDefFileName(),nd->getDefLine(),0,0,nd->briefDescription());
+ addPerlModDocBlock(output,"detailed",nd->getDefFileName(),nd->getDefLine(),0,0,nd->documentation());
+
+ output.closeHash();
+}
+
+static void generatePerlForFile(FileDef *fd, PerlModOutput &output)
+{
+ // + includes files
+ // + includedby files
+ // - include graph
+ // - included by graph
+ // - contained class definitions
+ // - contained namespace definitions
+ // - member groups
+ // + normal members
+ // + brief desc
+ // + detailed desc
+ // - source code
+ // - location
+ // - number of lines
+
+ if (fd->isReference()) return;
+
+ output.openHash()
+ .addFieldQuoted("name", fd->name());
+
+ QListIterator<IncludeInfo> ili1(*fd->includeFileList());
+ IncludeInfo *inc;
+ output.openList("includes");
+ for (ili1.toFirst();(inc=ili1.current());++ili1)
+ {
+ output.openHash()
+ .addFieldQuoted("name", inc->includeName);
+ if (inc->fileDef && !inc->fileDef->isReference())
+ {
+ output.addFieldQuoted("ref", inc->fileDef->getOutputFileBase());
+ }
+ output.closeHash();
+ }
+ output.closeList();
+
+ QListIterator<IncludeInfo> ili2(*fd->includedByFileList());
+ output.openList("included_by");
+ for (ili2.toFirst();(inc=ili2.current());++ili2)
+ {
+ output.openHash()
+ .addFieldQuoted("name => ", inc->includeName);
+ if (inc->fileDef && !inc->fileDef->isReference())
+ {
+ output.addFieldQuoted("ref", inc->fileDef->getOutputFileBase());
+ }
+ output.closeHash();
+ }
+ output.closeList();
+
+ generatePerlSection(fd,output,&fd->decDefineMembers,"defines");
+ generatePerlSection(fd,output,&fd->decProtoMembers,"prototypes");
+ generatePerlSection(fd,output,&fd->decTypedefMembers,"typedefs");
+ generatePerlSection(fd,output,&fd->decEnumMembers,"enums");
+ generatePerlSection(fd,output,&fd->decFuncMembers,"functions");
+ generatePerlSection(fd,output,&fd->decVarMembers,"variables");
+
+ addPerlModDocBlock(output,"brief",fd->getDefFileName(),fd->getDefLine(),0,0,fd->briefDescription());
+ addPerlModDocBlock(output,"detailed",fd->getDefFileName(),fd->getDefLine(),0,0,fd->documentation());
+
+ output.closeHash();
+}
+
+static void generatePerlForGroup(GroupDef *gd, PerlModOutput &output)
+{
+ // + members
+ // + member groups
+ // + files
+ // + classes
+ // + namespaces
+ // - packages
+ // + pages
+ // + child groups
+ // - examples
+ // + brief description
+ // + detailed description
+
+ if (gd->isReference()) return; // skip external references
+
+ output.openHash()
+ .addFieldQuoted("name", gd->name())
+ .addFieldQuoted("title", gd->groupTitle());
+
+ FileList *fl = gd->getFiles();
+ if (fl)
+ {
+ output.openList("files");
+ QListIterator<FileDef> fli(*fl);
+ FileDef *fd = fl->first();
+ for (fli.toFirst();(fd=fli.current());++fli)
+ output.openHash()
+ .addFieldQuoted("name", fd->name())
+ .closeHash();
+ output.closeList();
+ }
+
+ ClassSDict *cl = gd->getClasses();
+ if (cl)
+ {
+ output.openList("classes");
+ ClassSDict::Iterator cli(*cl);
+ ClassDef *cd;
+ for (cli.toFirst();(cd=cli.current());++cli)
+ output.openHash()
+ .addFieldQuoted("name", cd->name())
+ .closeHash();
+ output.closeList();
+ }
+
+ NamespaceList *nl = gd->getNamespaces();
+ if (nl)
+ {
+ output.openList("namespaces");
+ NamespaceListIterator nli(*nl);
+ NamespaceDef *nd;
+ for (nli.toFirst();(nd=nli.current());++nli)
+ output.openHash()
+ .addFieldQuoted("name", nd->name())
+ .closeHash();
+ output.closeList();
+ }
+
+ PageSDict *pl = gd->getPages();
+ if (pl)
+ {
+ output.openList("pages");
+ PageSDict::Iterator pli(*pl);
+ PageInfo *pi;
+ for (pli.toFirst();(pi=pli.current());++pli)
+ output.openHash()
+ .addFieldQuoted("title", pi->title)
+ .closeHash();
+ output.closeList();
+ }
+
+ GroupList *gl = gd->getSubGroups();
+ if (gl)
+ {
+ output.openList("groups");
+ GroupListIterator gli(*gl);
+ GroupDef *sgd;
+ for (gli.toFirst();(sgd=gli.current());++gli)
+ output.openHash()
+ .addFieldQuoted("title", gd->groupTitle())
+ .closeHash();
+ output.closeList();
+ }
+
+ MemberGroupSDict::Iterator mgli(*gd->memberGroupSDict);
+ MemberGroup *mg;
+ for (;(mg=mgli.current());++mgli)
+ generatePerlSection(gd,output,mg->members(),"user-defined",mg->header());
+
+ generatePerlSection(gd,output,&gd->decDefineMembers,"defines");
+ generatePerlSection(gd,output,&gd->decProtoMembers,"prototypes");
+ generatePerlSection(gd,output,&gd->decTypedefMembers,"typedefs");
+ generatePerlSection(gd,output,&gd->decEnumMembers,"enums");
+ generatePerlSection(gd,output,&gd->decFuncMembers,"functions");
+ generatePerlSection(gd,output,&gd->decVarMembers,"variables");
+
+ addPerlModDocBlock(output,"brief",gd->getDefFileName(),gd->getDefLine(),0,0,gd->briefDescription());
+ addPerlModDocBlock(output,"detailed",gd->getDefFileName(),gd->getDefLine(),0,0,gd->documentation());
+
+ output.closeHash();
+}
+
+static void generatePerlForPage(PageInfo *pi, PerlModOutput &output)
+{
+ // + name
+ // + title
+ // + documentation
+
+ if (pi->isReference()) return;
+
+ output.openHash()
+ .addFieldQuoted("name", pi->name);
+
+ SectionInfo *si = Doxygen::sectionDict.find(pi->name);
+ if (si)
+ output.addFieldQuoted("title", si->title);
+
+ addPerlModDocBlock(output,"detailed",pi->defFileName,pi->defLine,0,0,pi->doc);
+}
+
+void generatePerlMod()
+{
+ // + classes
+ // + namespaces
+ // + files
+ // - packages
+ // + groups
+ // + related pages
+ // - examples
+
+ QCString outputDirectory = Config_getString("OUTPUT_DIRECTORY");
+ if (outputDirectory.isEmpty())
+ {
+ outputDirectory=QDir::currentDirPath();
+ }
+ else
+ {
+ QDir dir(outputDirectory);
+ if (!dir.exists())
+ {
+ dir.setPath(QDir::currentDirPath());
+ if (!dir.mkdir(outputDirectory))
+ {
+ err("Error: tag OUTPUT_DIRECTORY: Output directory `%s' does not "
+ "exist and cannot be created\n",outputDirectory.data());
+ exit(1);
+ }
+ else if (!Config_getBool("QUIET"))
+ {
+ err("Notice: Output directory `%s' does not exist. "
+ "I have created it for you.\n", outputDirectory.data());
+ }
+ dir.cd(outputDirectory);
+ }
+ outputDirectory=dir.absPath();
+ }
+
+ QDir dir(outputDirectory);
+ if (!dir.exists())
+ {
+ dir.setPath(QDir::currentDirPath());
+ if (!dir.mkdir(outputDirectory))
+ {
+ err("Cannot create directory %s\n",outputDirectory.data());
+ return;
+ }
+ }
+
+ QCString fileName=outputDirectory+"/DoxyDocs.pm";
+ QFile f(fileName);
+ if (!f.open(IO_WriteOnly))
+ {
+ err("Cannot open file %s for writing!\n",fileName.data());
+ return;
+ }
+
+ QTextStream t(&f);
+ PerlModOutputStream os(&t);
+ PerlModOutput output(&os);
+ output.add("$doxydocs =\n").openHash();
+
+ output.openList("classes");
+ ClassSDict::Iterator cli(Doxygen::classSDict);
+ ClassDef *cd;
+ for (cli.toFirst();(cd=cli.current());++cli)
+ generatePerlForClass(cd,output);
+ output.closeList();
+
+ output.openList("namespaces");
+ NamespaceSDict::Iterator nli(Doxygen::namespaceSDict);
+ NamespaceDef *nd;
+ for (nli.toFirst();(nd=nli.current());++nli)
+ generatePerlForNamespace(nd,output);
+ output.closeList();
+
+ output.openList("files");
+ FileNameListIterator fnli(Doxygen::inputNameList);
+ FileName *fn;
+ for (;(fn=fnli.current());++fnli)
+ {
+ FileNameIterator fni(*fn);
+ FileDef *fd;
+ for (;(fd=fni.current());++fni)
+ generatePerlForFile(fd,output);
+ }
+ output.closeList();
+
+ output.openList("groups");
+ GroupSDict::Iterator gli(Doxygen::groupSDict);
+ GroupDef *gd;
+ for (;(gd=gli.current());++gli)
+ generatePerlForGroup(gd,output);
+ output.closeList();
+
+ output.openList("pages");
+ PageSDict::Iterator pdi(*Doxygen::pageSDict);
+ PageInfo *pi=0;
+ for (pdi.toFirst();(pi=pdi.current());++pdi)
+ generatePerlForPage(pi,output);
+ if (Doxygen::mainPage)
+ generatePerlForPage(Doxygen::mainPage,output);
+ output.closeList();
+
+ output.closeHash().add(";\n1;\n");
+}
+
+// Local Variables:
+// c-basic-offset: 2
+// End: