jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Simplify management of tag handlers in PyDocConverter.

Browse source 
Avoid having to pass dummy empty string arguments, just use default value for
the unused last parameter of handleParagraph().

Also get rid of dozens of "" occurrences in the tag map initialization code,
use a helper function instead.

No real changes.
This commit is contained in:
Vadim Zeitlin 2014-06-15 17:55:45 +02:00
commit a76c1343b7
2 changed files with 213 additions and 196 deletions
Download patch file Download diff file Expand all files Collapse all files

354
Source/DoxygenTranslator/src/PyDocConverter.cpp
View file

@ -19,11 +19,25 @@
#include <iostream> #include <iostream>
// define static tables, they are filled in PyDocConverter's constructor // define static tables, they are filled in PyDocConverter's constructor
std::map<std::string, std::pair<PyDocConverter::tagHandler, std::string> > PyDocConverter::tagHandlers; PyDocConverter::TagHandlersMap PyDocConverter::tagHandlers;
std::map<std::string, std::string> PyDocConverter::sectionTitles; std::map<std::string, std::string> PyDocConverter::sectionTitles;
using std::string; using std::string;
/* static */
PyDocConverter::TagHandlersMap::mapped_type
PyDocConverter::make_handler(tagHandler handler)
{
return make_pair(handler, std::string());
}
/* static */
PyDocConverter::TagHandlersMap::mapped_type
PyDocConverter::make_handler(tagHandler handler, const char* arg)
{
return make_pair(handler, arg);
}
void PyDocConverter::fillStaticTables() void PyDocConverter::fillStaticTables()
{ {
if (tagHandlers.size()) // fill only once if (tagHandlers.size()) // fill only once
@ -54,177 +68,173 @@ void PyDocConverter::fillStaticTables()
sectionTitles["todo"] = "TODO: "; sectionTitles["todo"] = "TODO: ";
sectionTitles["version"] = "Version: "; sectionTitles["version"] = "Version: ";
tagHandlers["a"] = make_pair(&PyDocConverter::handleTagWrap, "_"); tagHandlers["a"] = make_handler(&PyDocConverter::handleTagWrap, "_");
tagHandlers["b"] = make_pair(&PyDocConverter::handleTagWrap, "__"); tagHandlers["b"] = make_handler(&PyDocConverter::handleTagWrap, "__");
// \c command is translated as single quotes around next word // \c command is translated as single quotes around next word
tagHandlers["c"] = make_pair(&PyDocConverter::handleTagWrap, "'"); // see markdown support in doxy, section 'code wraps' tagHandlers["c"] = make_handler(&PyDocConverter::handleTagWrap, "'"); // see markdown support in doxy, section 'code wraps'
tagHandlers["cite"] = make_pair(&PyDocConverter::handleTagWrap, "'"); tagHandlers["cite"] = make_handler(&PyDocConverter::handleTagWrap, "'");
tagHandlers["e"] = make_pair(&PyDocConverter::handleTagWrap, "_"); tagHandlers["e"] = make_handler(&PyDocConverter::handleTagWrap, "_");
// these commands insert just a single char, some of them need to be escaped // these commands insert just a single char, some of them need to be escaped
tagHandlers["$"] = make_pair(&PyDocConverter::handleTagChar, ""); tagHandlers["$"] = make_handler(&PyDocConverter::handleTagChar);
tagHandlers["@"] = make_pair(&PyDocConverter::handleTagChar, ""); tagHandlers["@"] = make_handler(&PyDocConverter::handleTagChar);
tagHandlers["\\"] = make_pair(&PyDocConverter::handleTagChar, ""); tagHandlers["\\"] = make_handler(&PyDocConverter::handleTagChar);
tagHandlers["<"] = make_pair(&PyDocConverter::handleTagChar, ""); tagHandlers["<"] = make_handler(&PyDocConverter::handleTagChar);
tagHandlers[">"] = make_pair(&PyDocConverter::handleTagChar, ""); tagHandlers[">"] = make_handler(&PyDocConverter::handleTagChar);
tagHandlers["&"] = make_pair(&PyDocConverter::handleTagChar, ""); tagHandlers["&"] = make_handler(&PyDocConverter::handleTagChar);
tagHandlers["#"] = make_pair(&PyDocConverter::handleTagChar, ""); tagHandlers["#"] = make_handler(&PyDocConverter::handleTagChar);
tagHandlers["%"] = make_pair(&PyDocConverter::handleTagChar, ""); tagHandlers["%"] = make_handler(&PyDocConverter::handleTagChar);
tagHandlers["~"] = make_pair(&PyDocConverter::handleTagChar, ""); tagHandlers["~"] = make_handler(&PyDocConverter::handleTagChar);
tagHandlers["\""] = make_pair(&PyDocConverter::handleTagChar, ""); tagHandlers["\""] = make_handler(&PyDocConverter::handleTagChar);
tagHandlers["."] = make_pair(&PyDocConverter::handleTagChar, ""); tagHandlers["."] = make_handler(&PyDocConverter::handleTagChar);
tagHandlers["::"] = make_pair(&PyDocConverter::handleTagChar, ""); tagHandlers["::"] = make_handler(&PyDocConverter::handleTagChar);
// these commands are stripped out, and only their content is printed // these commands are stripped out, and only their content is printed
tagHandlers["attention"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["attention"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["author"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["author"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["authors"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["authors"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["brief"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["brief"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["bug"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["bug"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["code"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["code"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["copyright"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["copyright"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["date"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["date"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["deprecated"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["deprecated"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["details"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["details"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["em"] = make_pair(&PyDocConverter::handleParagraph, " "); tagHandlers["em"] = make_handler(&PyDocConverter::handleParagraph, " ");
tagHandlers["example"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["example"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["exception"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["exception"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["htmlonly"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["htmlonly"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["invariant"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["invariant"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["latexonly"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["latexonly"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["link"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["link"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["manonly"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["manonly"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["note"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["note"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["p"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["p"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["partofdescription"] = make_pair(&PyDocConverter::handleParagraph, tagHandlers["partofdescription"] = make_handler(&PyDocConverter::handleParagraph);
""); tagHandlers["rtfonly"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["rtfonly"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["return"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["return"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["returns"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["returns"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["result"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["result"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["remark"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["remark"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["remarks"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["remarks"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["sa"] = make_handler(&PyDocConverter::handleTagMessage, "See also: ");
tagHandlers["sa"] = make_pair(&PyDocConverter::handleTagMessage, tagHandlers["see"] = make_handler(&PyDocConverter::handleTagMessage,
"See also: "); "See also: ");
tagHandlers["see"] = make_pair(&PyDocConverter::handleTagMessage, tagHandlers["since"] = make_handler(&PyDocConverter::handleParagraph);
"See also: "); tagHandlers["short"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["since"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["throw"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["short"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["throws"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["throw"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["todo"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["throws"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["version"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["todo"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["verbatim"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["version"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["warning"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["verbatim"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["xmlonly"] = make_handler(&PyDocConverter::handleParagraph);
tagHandlers["warning"] = make_pair(&PyDocConverter::handleParagraph, "");
tagHandlers["xmlonly"] = make_pair(&PyDocConverter::handleParagraph, "");
// these commands have special handlers // these commands have special handlers
tagHandlers["arg"] = make_pair(&PyDocConverter::handleTagMessage, " -"); tagHandlers["arg"] = make_handler(&PyDocConverter::handleTagMessage, " -");
tagHandlers["cond"] = make_pair(&PyDocConverter::handleTagMessage, tagHandlers["cond"] = make_handler(&PyDocConverter::handleTagMessage,
"Conditional comment: "); "Conditional comment: ");
tagHandlers["else"] = make_pair(&PyDocConverter::handleTagIf, "Else: "); tagHandlers["else"] = make_handler(&PyDocConverter::handleTagIf, "Else: ");
tagHandlers["elseif"] = make_pair(&PyDocConverter::handleTagIf, "Else if: "); tagHandlers["elseif"] = make_handler(&PyDocConverter::handleTagIf, "Else if: ");
tagHandlers["endcond"] = make_pair(&PyDocConverter::handleTagMessage, tagHandlers["endcond"] = make_handler(&PyDocConverter::handleTagMessage,
"End of conditional comment."); "End of conditional comment.");
tagHandlers["if"] = make_pair(&PyDocConverter::handleTagIf, "If: "); tagHandlers["if"] = make_handler(&PyDocConverter::handleTagIf, "If: ");
tagHandlers["ifnot"] = make_pair(&PyDocConverter::handleTagIf, "If not: "); tagHandlers["ifnot"] = make_handler(&PyDocConverter::handleTagIf, "If not: ");
tagHandlers["image"] = make_pair(&PyDocConverter::handleTagImage, ""); tagHandlers["image"] = make_handler(&PyDocConverter::handleTagImage);
tagHandlers["li"] = make_pair(&PyDocConverter::handleTagMessage, " -"); tagHandlers["li"] = make_handler(&PyDocConverter::handleTagMessage, " -");
tagHandlers["overload"] = make_pair(&PyDocConverter::handleTagMessage, tagHandlers["overload"] = make_handler(&PyDocConverter::handleTagMessage,
"This is an overloaded member function, provided for" "This is an overloaded member function, provided for"
" convenience.\nIt differs from the above function only in what" " convenience.\nIt differs from the above function only in what"
" argument(s) it accepts."); " argument(s) it accepts.");
tagHandlers["par"] = make_pair(&PyDocConverter::handleTagPar, ""); tagHandlers["par"] = make_handler(&PyDocConverter::handleTagPar);
tagHandlers["param"] = make_pair(&PyDocConverter::handleTagParam, ""); tagHandlers["param"] = make_handler(&PyDocConverter::handleTagParam);
tagHandlers["tparam"] = make_pair(&PyDocConverter::handleTagParam, ""); tagHandlers["tparam"] = make_handler(&PyDocConverter::handleTagParam);
tagHandlers["ref"] = make_pair(&PyDocConverter::handleTagRef, ""); tagHandlers["ref"] = make_handler(&PyDocConverter::handleTagRef);
// this command just prints it's contents // this command just prints it's contents
// (it is internal command of swig's parser, contains plain text) // (it is internal command of swig's parser, contains plain text)
tagHandlers["plainstd::string"] = make_pair( tagHandlers["plainstd::string"] = make_handler(&PyDocConverter::handlePlainString);
&PyDocConverter::handlePlainString, ""); tagHandlers["plainstd::endl"] = make_handler(&PyDocConverter::handleNewLine);
tagHandlers["plainstd::endl"] = make_pair(&PyDocConverter::handleNewLine, ""); tagHandlers["n"] = make_handler(&PyDocConverter::handleNewLine);
tagHandlers["n"] = make_pair(&PyDocConverter::handleNewLine, "");
// \f commands output literal Latex formula, which is still better than nothing. // \f commands output literal Latex formula, which is still better than nothing.
tagHandlers["f$"] = make_pair(&PyDocConverter::handleTagVerbatim, ""); tagHandlers["f$"] = make_handler(&PyDocConverter::handleTagVerbatim);
tagHandlers["f["] = make_pair(&PyDocConverter::handleTagVerbatim, ""); tagHandlers["f["] = make_handler(&PyDocConverter::handleTagVerbatim);
tagHandlers["f{"] = make_pair(&PyDocConverter::handleTagVerbatim, ""); tagHandlers["f{"] = make_handler(&PyDocConverter::handleTagVerbatim);
// HTML tags // HTML tags
tagHandlers["<a"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_A, ""); tagHandlers["<a"] = make_handler(&PyDocConverter::handleDoxyHtmlTag_A);
tagHandlers["<b"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "__"); tagHandlers["<b"] = make_handler(&PyDocConverter::handleDoxyHtmlTag2, "__");
tagHandlers["<blockquote"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_A, tagHandlers["<blockquote"] = make_handler(&PyDocConverter::handleDoxyHtmlTag_A,
"Quote: "); "Quote: ");
tagHandlers["<body"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<body"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<br"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "\n"); tagHandlers["<br"] = make_handler(&PyDocConverter::handleDoxyHtmlTag, "\n");
// there is no formatting for this tag as it was deprecated in HTML 4.01 and // there is no formatting for this tag as it was deprecated in HTML 4.01 and
// not used in HTML 5 // not used in HTML 5
tagHandlers["<center"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<center"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<caption"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<caption"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<code"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "'"); tagHandlers["<code"] = make_handler(&PyDocConverter::handleDoxyHtmlTag2, "'");
tagHandlers["<dl"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<dl"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<dd"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, " "); tagHandlers["<dd"] = make_handler(&PyDocConverter::handleDoxyHtmlTag, " ");
tagHandlers["<dt"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<dt"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<dfn"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<dfn"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<div"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<div"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<em"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "__"); tagHandlers["<em"] = make_handler(&PyDocConverter::handleDoxyHtmlTag2, "__");
tagHandlers["<form"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<form"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<hr"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, tagHandlers["<hr"] = make_handler(&PyDocConverter::handleDoxyHtmlTag,
"--------------------------------------------------------------------\n"); "--------------------------------------------------------------------\n");
tagHandlers["<h1"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "# "); tagHandlers["<h1"] = make_handler(&PyDocConverter::handleDoxyHtmlTag, "# ");
tagHandlers["<h2"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "## "); tagHandlers["<h2"] = make_handler(&PyDocConverter::handleDoxyHtmlTag, "## ");
tagHandlers["<h3"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "### "); tagHandlers["<h3"] = make_handler(&PyDocConverter::handleDoxyHtmlTag, "### ");
tagHandlers["<i"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "_"); tagHandlers["<i"] = make_handler(&PyDocConverter::handleDoxyHtmlTag2, "_");
tagHandlers["<input"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<input"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<img"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "Image:"); tagHandlers["<img"] = make_handler(&PyDocConverter::handleDoxyHtmlTag, "Image:");
tagHandlers["<li"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "- "); tagHandlers["<li"] = make_handler(&PyDocConverter::handleDoxyHtmlTag, "- ");
tagHandlers["<meta"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<meta"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<multicol"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<multicol"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<ol"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<ol"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<p"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "\n"); tagHandlers["<p"] = make_handler(&PyDocConverter::handleDoxyHtmlTag, "\n");
tagHandlers["<pre"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<pre"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<small"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<small"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<span"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "'"); tagHandlers["<span"] = make_handler(&PyDocConverter::handleDoxyHtmlTag2, "'");
tagHandlers["<strong"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "__"); tagHandlers["<strong"] = make_handler(&PyDocConverter::handleDoxyHtmlTag2, "__");
// make a space between text and super/sub script. // make a space between text and super/sub script.
tagHandlers["<sub"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, " "); tagHandlers["<sub"] = make_handler(&PyDocConverter::handleDoxyHtmlTag, " ");
tagHandlers["<sup"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, " "); tagHandlers["<sup"] = make_handler(&PyDocConverter::handleDoxyHtmlTag, " ");
tagHandlers["<table"] = make_pair(&PyDocConverter::handleDoxyHtmlTagNoParam, tagHandlers["<table"] = make_handler(&PyDocConverter::handleDoxyHtmlTagNoParam);
""); tagHandlers["<td"] = make_handler(&PyDocConverter::handleDoxyHtmlTag_td);
tagHandlers["<td"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_td, ""); tagHandlers["<th"] = make_handler(&PyDocConverter::handleDoxyHtmlTag_th);
tagHandlers["<th"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_th, ""); tagHandlers["<tr"] = make_handler(&PyDocConverter::handleDoxyHtmlTag_tr);
tagHandlers["<tr"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_tr, ""); tagHandlers["<tt"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<tt"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<kbd"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<kbd"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<ul"] = make_handler(&PyDocConverter::handleDoxyHtmlTag);
tagHandlers["<ul"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<var"] = make_handler(&PyDocConverter::handleDoxyHtmlTag2, "_");
tagHandlers["<var"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "_");
// HTML entities // HTML entities
tagHandlers["&copy"] = make_pair(&PyDocConverter::handleHtmlEntity, "(C)"); tagHandlers["&copy"] = make_handler(&PyDocConverter::handleHtmlEntity, "(C)");
tagHandlers["&trade"] = make_pair(&PyDocConverter::handleHtmlEntity, " TM"); tagHandlers["&trade"] = make_handler(&PyDocConverter::handleHtmlEntity, " TM");
tagHandlers["&reg"] = make_pair(&PyDocConverter::handleHtmlEntity, "(R)"); tagHandlers["&reg"] = make_handler(&PyDocConverter::handleHtmlEntity, "(R)");
tagHandlers["&lt"] = make_pair(&PyDocConverter::handleHtmlEntity, "<"); tagHandlers["&lt"] = make_handler(&PyDocConverter::handleHtmlEntity, "<");
tagHandlers["&gt"] = make_pair(&PyDocConverter::handleHtmlEntity, ">"); tagHandlers["&gt"] = make_handler(&PyDocConverter::handleHtmlEntity, ">");
tagHandlers["&amp"] = make_pair(&PyDocConverter::handleHtmlEntity, "&"); tagHandlers["&amp"] = make_handler(&PyDocConverter::handleHtmlEntity, "&");
tagHandlers["&apos"] = make_pair(&PyDocConverter::handleHtmlEntity, "'"); tagHandlers["&apos"] = make_handler(&PyDocConverter::handleHtmlEntity, "'");
tagHandlers["&quot"] = make_pair(&PyDocConverter::handleHtmlEntity, "\""); tagHandlers["&quot"] = make_handler(&PyDocConverter::handleHtmlEntity, "\"");
tagHandlers["&lsquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "`"); tagHandlers["&lsquo"] = make_handler(&PyDocConverter::handleHtmlEntity, "`");
tagHandlers["&rsquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "'"); tagHandlers["&rsquo"] = make_handler(&PyDocConverter::handleHtmlEntity, "'");
tagHandlers["&ldquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "\""); tagHandlers["&ldquo"] = make_handler(&PyDocConverter::handleHtmlEntity, "\"");
tagHandlers["&rdquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "\""); tagHandlers["&rdquo"] = make_handler(&PyDocConverter::handleHtmlEntity, "\"");
tagHandlers["&ndash"] = make_pair(&PyDocConverter::handleHtmlEntity, "-"); tagHandlers["&ndash"] = make_handler(&PyDocConverter::handleHtmlEntity, "-");
tagHandlers["&mdash"] = make_pair(&PyDocConverter::handleHtmlEntity, "--"); tagHandlers["&mdash"] = make_handler(&PyDocConverter::handleHtmlEntity, "--");
tagHandlers["&nbsp"] = make_pair(&PyDocConverter::handleHtmlEntity, " "); tagHandlers["&nbsp"] = make_handler(&PyDocConverter::handleHtmlEntity, " ");
tagHandlers["&times"] = make_pair(&PyDocConverter::handleHtmlEntity, "x"); tagHandlers["&times"] = make_handler(&PyDocConverter::handleHtmlEntity, "x");
tagHandlers["&minus"] = make_pair(&PyDocConverter::handleHtmlEntity, "-"); tagHandlers["&minus"] = make_handler(&PyDocConverter::handleHtmlEntity, "-");
tagHandlers["&sdot"] = make_pair(&PyDocConverter::handleHtmlEntity, "."); tagHandlers["&sdot"] = make_handler(&PyDocConverter::handleHtmlEntity, ".");
tagHandlers["&sim"] = make_pair(&PyDocConverter::handleHtmlEntity, "~"); tagHandlers["&sim"] = make_handler(&PyDocConverter::handleHtmlEntity, "~");
tagHandlers["&le"] = make_pair(&PyDocConverter::handleHtmlEntity, "<="); tagHandlers["&le"] = make_handler(&PyDocConverter::handleHtmlEntity, "<=");
tagHandlers["&ge"] = make_pair(&PyDocConverter::handleHtmlEntity, ">="); tagHandlers["&ge"] = make_handler(&PyDocConverter::handleHtmlEntity, ">=");
tagHandlers["&larr"] = make_pair(&PyDocConverter::handleHtmlEntity, "<--"); tagHandlers["&larr"] = make_handler(&PyDocConverter::handleHtmlEntity, "<--");
tagHandlers["&rarr"] = make_pair(&PyDocConverter::handleHtmlEntity, "-->"); tagHandlers["&rarr"] = make_handler(&PyDocConverter::handleHtmlEntity, "-->");
} }
PyDocConverter::PyDocConverter(int flags) : PyDocConverter::PyDocConverter(int flags) :
@ -320,14 +330,14 @@ void PyDocConverter::translateEntity(DoxygenEntity & doxyEntity,
void PyDocConverter::handleParagraph(DoxygenEntity& tag, void PyDocConverter::handleParagraph(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) const std::string&)
{ {
translatedComment += translateSubtree(tag) + arg; translatedComment += translateSubtree(tag);
} }
void PyDocConverter::handlePlainString(DoxygenEntity& tag, void PyDocConverter::handlePlainString(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string&) const std::string&)
{ {
translatedComment += tag.data; translatedComment += tag.data;
if (tag.data.size() && tag.data[tag.data.size() - 1] != ' ') if (tag.data.size() && tag.data[tag.data.size() - 1] != ' ')
@ -336,7 +346,7 @@ void PyDocConverter::handlePlainString(DoxygenEntity& tag,
void PyDocConverter::handleTagVerbatim(DoxygenEntity& tag, void PyDocConverter::handleTagVerbatim(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) const std::string &arg)
{ {
translatedComment += arg + " "; translatedComment += arg + " ";
for (DoxygenEntityListCIt it = tag.entityList.begin(); for (DoxygenEntityListCIt it = tag.entityList.begin();
@ -347,24 +357,23 @@ void PyDocConverter::handleTagVerbatim(DoxygenEntity& tag,
void PyDocConverter::handleTagMessage(DoxygenEntity& tag, void PyDocConverter::handleTagMessage(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) const std::string &arg)
{ {
std::string dummy;
translatedComment += arg; translatedComment += arg;
handleParagraph(tag, translatedComment, dummy); handleParagraph(tag, translatedComment);
} }
void PyDocConverter::handleTagChar(DoxygenEntity& tag, void PyDocConverter::handleTagChar(DoxygenEntity& tag,
std::string& translatedComment, std::string&) std::string& translatedComment,
const std::string&)
{ {
translatedComment += tag.typeOfEntity; translatedComment += tag.typeOfEntity;
} }
void PyDocConverter::handleTagIf(DoxygenEntity& tag, void PyDocConverter::handleTagIf(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) const std::string &arg)
{ {
std::string dummy;
translatedComment += arg; translatedComment += arg;
if (tag.entityList.size()) { if (tag.entityList.size()) {
translatedComment += tag.entityList.begin()->data; translatedComment += tag.entityList.begin()->data;
@ -374,19 +383,19 @@ void PyDocConverter::handleTagIf(DoxygenEntity& tag,
} }
void PyDocConverter::handleTagPar(DoxygenEntity& tag, void PyDocConverter::handleTagPar(DoxygenEntity& tag,
std::string& translatedComment, std::string&) std::string& translatedComment,
const std::string&)
{ {
std::string dummy;
translatedComment += "Title: "; translatedComment += "Title: ";
if (tag.entityList.size()) if (tag.entityList.size())
translatedComment += tag.entityList.begin()->data; translatedComment += tag.entityList.begin()->data;
tag.entityList.pop_front(); tag.entityList.pop_front();
handleParagraph(tag, translatedComment, dummy); handleParagraph(tag, translatedComment);
} }
void PyDocConverter::handleTagImage(DoxygenEntity& tag, void PyDocConverter::handleTagImage(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string&) const std::string&)
{ {
if (tag.entityList.size() < 2) if (tag.entityList.size() < 2)
return; return;
@ -400,9 +409,8 @@ void PyDocConverter::handleTagImage(DoxygenEntity& tag,
void PyDocConverter::handleTagParam(DoxygenEntity& tag, void PyDocConverter::handleTagParam(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string&) const std::string&)
{ {
std::string dummy;
if (tag.entityList.size() < 2) if (tag.entityList.size() < 2)
return; return;
@ -414,15 +422,14 @@ void PyDocConverter::handleTagParam(DoxygenEntity& tag,
paramType = "none"; paramType = "none";
translatedComment += " " + paramNameEntity.data + " (" + paramType + ") --"; translatedComment += " " + paramNameEntity.data + " (" + paramType + ") --";
handleParagraph(tag, translatedComment, dummy); handleParagraph(tag, translatedComment);
} }
void PyDocConverter::handleTagRef(DoxygenEntity& tag, void PyDocConverter::handleTagRef(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string&) const std::string&)
{ {
std::string dummy;
if (!tag.entityList.size()) if (!tag.entityList.size())
return; return;
@ -438,7 +445,7 @@ void PyDocConverter::handleTagRef(DoxygenEntity& tag,
void PyDocConverter::handleTagWrap(DoxygenEntity& tag, void PyDocConverter::handleTagWrap(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) const std::string &arg)
{ {
if (tag.entityList.size()) { // do not include empty tags if (tag.entityList.size()) { // do not include empty tags
std::string tagData = translateSubtree(tag); std::string tagData = translateSubtree(tag);
@ -454,7 +461,7 @@ void PyDocConverter::handleTagWrap(DoxygenEntity& tag,
void PyDocConverter::handleDoxyHtmlTag(DoxygenEntity& tag, void PyDocConverter::handleDoxyHtmlTag(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) const std::string &arg)
{ {
std::string htmlTagArgs = tag.data; std::string htmlTagArgs = tag.data;
if (htmlTagArgs == "/") { if (htmlTagArgs == "/") {
@ -467,7 +474,7 @@ void PyDocConverter::handleDoxyHtmlTag(DoxygenEntity& tag,
void PyDocConverter::handleDoxyHtmlTagNoParam(DoxygenEntity& tag, void PyDocConverter::handleDoxyHtmlTagNoParam(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) const std::string &arg)
{ {
std::string htmlTagArgs = tag.data; std::string htmlTagArgs = tag.data;
if (htmlTagArgs == "/") { if (htmlTagArgs == "/") {
@ -479,7 +486,7 @@ void PyDocConverter::handleDoxyHtmlTagNoParam(DoxygenEntity& tag,
void PyDocConverter::handleDoxyHtmlTag_A(DoxygenEntity& tag, void PyDocConverter::handleDoxyHtmlTag_A(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) const std::string &arg)
{ {
std::string htmlTagArgs = tag.data; std::string htmlTagArgs = tag.data;
if (htmlTagArgs == "/") { if (htmlTagArgs == "/") {
@ -498,7 +505,7 @@ void PyDocConverter::handleDoxyHtmlTag_A(DoxygenEntity& tag,
void PyDocConverter::handleDoxyHtmlTag2(DoxygenEntity& tag, void PyDocConverter::handleDoxyHtmlTag2(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) const std::string &arg)
{ {
std::string htmlTagArgs = tag.data; std::string htmlTagArgs = tag.data;
if (htmlTagArgs == "/") { if (htmlTagArgs == "/") {
@ -511,7 +518,7 @@ void PyDocConverter::handleDoxyHtmlTag2(DoxygenEntity& tag,
void PyDocConverter::handleDoxyHtmlTag_tr(DoxygenEntity& tag, void PyDocConverter::handleDoxyHtmlTag_tr(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &) const std::string &)
{ {
std::string htmlTagArgs = tag.data; std::string htmlTagArgs = tag.data;
size_t nlPos = translatedComment.rfind('\n'); size_t nlPos = translatedComment.rfind('\n');
@ -543,7 +550,7 @@ void PyDocConverter::handleDoxyHtmlTag_tr(DoxygenEntity& tag,
void PyDocConverter::handleDoxyHtmlTag_th(DoxygenEntity& tag, void PyDocConverter::handleDoxyHtmlTag_th(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &) const std::string &)
{ {
std::string htmlTagArgs = tag.data; std::string htmlTagArgs = tag.data;
if (htmlTagArgs == "/") { if (htmlTagArgs == "/") {
@ -556,7 +563,7 @@ void PyDocConverter::handleDoxyHtmlTag_th(DoxygenEntity& tag,
void PyDocConverter::handleDoxyHtmlTag_td(DoxygenEntity& tag, void PyDocConverter::handleDoxyHtmlTag_td(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &) const std::string &)
{ {
std::string htmlTagArgs = tag.data; std::string htmlTagArgs = tag.data;
if (htmlTagArgs == "/") { if (htmlTagArgs == "/") {
@ -568,14 +575,15 @@ void PyDocConverter::handleDoxyHtmlTag_td(DoxygenEntity& tag,
void PyDocConverter::handleHtmlEntity(DoxygenEntity&, void PyDocConverter::handleHtmlEntity(DoxygenEntity&,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) const std::string &arg)
{ {
// html entities // html entities
translatedComment += arg; translatedComment += arg;
} }
void PyDocConverter::handleNewLine(DoxygenEntity&, void PyDocConverter::handleNewLine(DoxygenEntity&,
std::string& translatedComment, std::string&) std::string& translatedComment,
const std::string&)
{ {
translatedComment += "\n"; translatedComment += "\n";
} }

55
Source/DoxygenTranslator/src/PyDocConverter.h
View file

@ -56,78 +56,79 @@ protected:
* arg - some string argument to easily pass it through lookup table * arg - some string argument to easily pass it through lookup table
*/ */
typedef void (PyDocConverter::*tagHandler)(DoxygenEntity &tag, typedef void (PyDocConverter::*tagHandler)(DoxygenEntity &tag,
std::string &translatedComment, std::string &arg); std::string &translatedComment, const std::string &arg);
/* /*
* Wrap the command data with the some string * Wrap the command data with the some string
* arg - string to wrap with, like '_' or '*' * arg - string to wrap with, like '_' or '*'
*/ */
void handleTagWrap(DoxygenEntity &tag, std::string &translatedComment, std::string &arg); void handleTagWrap(DoxygenEntity &tag, std::string &translatedComment, const std::string &arg);
/* /*
* Just prints new line * Just prints new line
*/ */
void handleNewLine(DoxygenEntity &tag, std::string &translatedComment, std::string &arg); void handleNewLine(DoxygenEntity &tag, std::string &translatedComment, const std::string &arg);
/* /*
* Print the name of tag to the output, used for escape-commands * Print the name of tag to the output, used for escape-commands
*/ */
void handleTagChar(DoxygenEntity &tag, std::string &translatedComment, std::string &arg); void handleTagChar(DoxygenEntity &tag, std::string &translatedComment, const std::string &arg);
/* /*
* Print only the content and strip original tag * Print only the content and strip original tag
*/ */
void handleParagraph(DoxygenEntity &tag, std::string &translatedComment, std::string &arg); void handleParagraph(DoxygenEntity &tag, std::string &translatedComment,
const std::string &arg = std::string());
/* /*
* Print only data part of code * Print only data part of code
*/ */
void handlePlainString(DoxygenEntity &tag, std::string &translatedComment, std::string &arg); void handlePlainString(DoxygenEntity &tag, std::string &translatedComment, const std::string &arg);
/** /**
* Copies verbatim args of the tag to output, used for commands like \f$, ... * Copies verbatim args of the tag to output, used for commands like \f$, ...
*/ */
void handleTagVerbatim(DoxygenEntity& tag, void handleTagVerbatim(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg); const std::string &arg);
/* /*
* Print the if-elseif-else-endif section * Print the if-elseif-else-endif section
*/ */
void handleTagIf(DoxygenEntity &tag, std::string &translatedComment, std::string &arg); void handleTagIf(DoxygenEntity &tag, std::string &translatedComment, const std::string &arg);
/* /*
* Prints the specified message, than the contents of the tag * Prints the specified message, than the contents of the tag
* arg - message * arg - message
*/ */
void handleTagMessage(DoxygenEntity &tag, std::string &translatedComment, std::string &arg); void handleTagMessage(DoxygenEntity &tag, std::string &translatedComment, const std::string &arg);
/* /*
* Insert 'Title: ...' * Insert 'Title: ...'
*/ */
void handleTagPar(DoxygenEntity &tag, std::string &translatedComment, std::string &arg); void handleTagPar(DoxygenEntity &tag, std::string &translatedComment, const std::string &arg);
/* /*
* Insert 'Image: ...' * Insert 'Image: ...'
*/ */
void handleTagImage(DoxygenEntity &tag, std::string &translatedComment, std::string &arg); void handleTagImage(DoxygenEntity &tag, std::string &translatedComment, const std::string &arg);
/* /*
* Format nice param description with type information * Format nice param description with type information
*/ */
void handleTagParam(DoxygenEntity &tag, std::string &translatedComment, std::string &arg); void handleTagParam(DoxygenEntity &tag, std::string &translatedComment, const std::string &arg);
/* /*
* Writes text for \ref tag. * Writes text for \ref tag.
*/ */
void handleTagRef(DoxygenEntity& tag, std::string& translatedComment, std::string&); void handleTagRef(DoxygenEntity& tag, std::string& translatedComment, const std::string &arg);
/* Handles HTML tags recognized by Doxygen, like <A ...>, <ul>, <table>, ... */ /* Handles HTML tags recognized by Doxygen, like <A ...>, <ul>, <table>, ... */
void handleDoxyHtmlTag(DoxygenEntity& tag, std::string& translatedComment, std::string &arg); void handleDoxyHtmlTag(DoxygenEntity& tag, std::string& translatedComment, const std::string &arg);
/** Does not output params of HTML tag, for example in <table border='1'> /** Does not output params of HTML tag, for example in <table border='1'>
* 'border=1' is not written to output. * 'border=1' is not written to output.
*/ */
void handleDoxyHtmlTagNoParam(DoxygenEntity& tag, void handleDoxyHtmlTagNoParam(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg); const std::string &arg);
/** Translates tag <a href = "url">text</a> to: text ("url"). */ /** Translates tag <a href = "url">text</a> to: text ("url"). */
void handleDoxyHtmlTag_A(DoxygenEntity& tag, void handleDoxyHtmlTag_A(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg); const std::string &arg);
/* /*
* Handles HTML tags, which are translated to markdown-like syntax, for example * Handles HTML tags, which are translated to markdown-like syntax, for example
@ -135,22 +136,22 @@ protected:
*/ */
void handleDoxyHtmlTag2(DoxygenEntity& tag, void handleDoxyHtmlTag2(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg); const std::string &arg);
/* Handles HTML table, tag <tr> */ /* Handles HTML table, tag <tr> */
void handleDoxyHtmlTag_tr(DoxygenEntity& tag, std::string& translatedComment, void handleDoxyHtmlTag_tr(DoxygenEntity& tag, std::string& translatedComment,
std::string &arg); const std::string &arg);
/* Handles HTML table, tag <th> */ /* Handles HTML table, tag <th> */
void handleDoxyHtmlTag_th(DoxygenEntity& tag, std::string& translatedComment, void handleDoxyHtmlTag_th(DoxygenEntity& tag, std::string& translatedComment,
std::string &arg); const std::string &arg);
/* Handles HTML table, tag <td> */ /* Handles HTML table, tag <td> */
void handleDoxyHtmlTag_td(DoxygenEntity& tag, std::string& translatedComment, void handleDoxyHtmlTag_td(DoxygenEntity& tag, std::string& translatedComment,
std::string &arg); const std::string &arg);
/* Handles HTML entities recognized by Doxygen, like &lt;, &copy;, ... */ /* Handles HTML entities recognized by Doxygen, like &lt;, &copy;, ... */
void handleHtmlEntity(DoxygenEntity&, std::string& translatedComment, std::string &arg); void handleHtmlEntity(DoxygenEntity&, std::string& translatedComment, const std::string &arg);
/* /*
@ -168,10 +169,18 @@ protected:
private: private:
// temporary thing, should be refactored somehow // temporary thing, should be refactored somehow
Node *currentNode; Node *currentNode;
// this contains the handler pointer and one string argument // this contains the handler pointer and one string argument
static std::map<std::string, std::pair<tagHandler, std::string> > tagHandlers; typedef std::map<std::string, std::pair<tagHandler, std::string> > TagHandlersMap;
static TagHandlersMap tagHandlers;
// this contains the sections tittles, like 'Arguments:' or 'Notes:', that are printed only once // this contains the sections tittles, like 'Arguments:' or 'Notes:', that are printed only once
static std::map<std::string, std::string> sectionTitles; static std::map<std::string, std::string> sectionTitles;
// Helper functions for fillStaticTables(): make a new tag handler object.
TagHandlersMap::mapped_type make_handler(tagHandler handler);
TagHandlersMap::mapped_type make_handler(tagHandler handler, const char* arg);
void fillStaticTables(); void fillStaticTables();
}; };