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

fixed leading spaces for the second row of table in pydoc, sources formatted

Browse source
This commit is contained in:
Marko Klopcic 2013-02-23 15:20:27 +01:00
commit 3b7908fa6e
6 changed files with 639 additions and 452 deletions
Download patch file Download diff file Expand all files Collapse all files

17
Examples/test-suite/doxygen_translate.i
View file

@ -209,6 +209,23 @@ int htmlFunction(int a, float b)
{ {
} }
/**
* The meaning of flags:
*
* @param byFlags bits marking required items:
* <table>
* <tr><th> Size in bits</th><th> Items Required </th></tr>
* <tr><td> 1 - 8 </td><td> 1 </td></tr>
* <tr><td> 9 - 16 </td><td> 2 </td></tr>
* <tr><td> 17 - 32 </td><td> 4 </td></tr>
* </table>
* Almost all combinations of above flags are supported by
* \c htmlTable... functions.
*/
int htmlTableFunction(int byFlags)
{
}
/** /**
* All entities are treated as commands &copy; &trade; &reg; * All entities are treated as commands &copy; &trade; &reg;

15
Examples/test-suite/java/doxygen_translate_runme.java
View file

@ -232,6 +232,21 @@ public class doxygen_translate_runme {
"\n" + "\n" +
""); "");
wantedComments.put("doxygen_translate.doxygen_translate.htmlTableFunction(int)",
"The meaning of flags:\n" +
"\n" +
" @param byFlags bits marking required items:\n" +
" <table>\n" +
" <tr><th> Size in bits</th><th> Items Required </th></tr>\n" +
" <tr><td> 1 - 8 </td><td> 1 </td></tr>\n" +
" <tr><td> 9 - 16 </td><td> 2 </td></tr>\n" +
" <tr><td> 17 - 32 </td><td> 4 </td></tr>\n" +
" </table>\n" +
" Almost all combinations of above flags are supported by\n" +
" <code>htmlTable...</code> functions.\n" +
"");
wantedComments.put("doxygen_translate.doxygen_translate.htmlEntitiesFunction(int, float)", wantedComments.put("doxygen_translate.doxygen_translate.htmlEntitiesFunction(int, float)",
"All entities are treated as commands &copy; &trade; &reg;\n" + "All entities are treated as commands &copy; &trade; &reg;\n" +
"should work also&lt;in text \n" + "should work also&lt;in text \n" +

18
Examples/test-suite/python/doxygen_translate_runme.py
View file

@ -221,6 +221,24 @@ r"""
""") """)
commentVerifier.check(doxygen_translate.htmlTableFunction.__doc__,
r"""
The meaning of flags:
Arguments:
byFlags (int) -- bits marking required items:
| Size in bits| Items Required |
--------------------------------
| 1 - 8 | 1 |
| 9 - 16 | 2 |
| 17 - 32 | 4 |
Almost all combinations of above flags are supported by
'htmlTable...' functions.
""")
commentVerifier.check(doxygen_translate.htmlEntitiesFunction.__doc__, commentVerifier.check(doxygen_translate.htmlEntitiesFunction.__doc__,
r""" r"""
All entities are treated as commands (C) TM (R) All entities are treated as commands (C) TM (R)

40
Source/DoxygenTranslator/src/DoxygenCommands.h
View file

@ -104,26 +104,26 @@ const int commandHtmlSize = sizeof(commandHtml) / sizeof(*commandHtml);
// Only entities which are translatable to plain text are used here. Others // Only entities which are translatable to plain text are used here. Others
// are copied unchanged to output. // are copied unchanged to output.
const char *commandHtmlEntities[] = { "&copy", "&trade", "&reg", // (C), (TM), (R) const char *commandHtmlEntities[] = { "&copy", "&trade", "&reg", // (C), (TM), (R)
"&lt", // less-than symbol "&lt", // less-than symbol
"&gt", // greater-than symbol "&gt", // greater-than symbol
"&amp", // ampersand "&amp", // ampersand
"&apos", // single quotation mark (straight) "&apos", // single quotation mark (straight)
"&quot", // double quotation mark (straight) "&quot", // double quotation mark (straight)
"&lsquo", // left single quotation mark "&lsquo", // left single quotation mark
"&rsquo", // right single quotation mark "&rsquo", // right single quotation mark
"&ldquo", // left double quotation mark "&ldquo", // left double quotation mark
"&rdquo", // right double quotation mark "&rdquo", // right double quotation mark
"&ndash", // n-dash (for numeric ranges, e.g. 2–8) "&ndash", // n-dash (for numeric ranges, e.g. 2–8)
"&mdash", // -- "&mdash", // --
"&nbsp", // "&nbsp", //
"&times", // x "&times", // x
"&minus", // - "&minus", // -
"&sdot", // . "&sdot", // .
"&sim", // ~ "&sim", // ~
"&le", // <= "&le", // <=
"&ge", // >= "&ge", // >=
"&larr", // <-- "&larr", // <--
"&rarr" // --> "&rarr" // -->
}; };
const int commandHtmlEntitiesSize = sizeof(commandHtmlEntities) / sizeof(*commandHtmlEntities); const int commandHtmlEntitiesSize = sizeof(commandHtmlEntities) / sizeof(*commandHtmlEntities);

505
Source/DoxygenTranslator/src/JavaDocConverter.cpp
View file

@ -20,13 +20,14 @@
//TODO {@link} {@linkplain} {@docRoot}, and other useful doxy commands that are not a javadoc tag //TODO {@link} {@linkplain} {@docRoot}, and other useful doxy commands that are not a javadoc tag
// define static tables, they are filled in JavaDocConverter's constructor // define static tables, they are filled in JavaDocConverter's constructor
std::map<std::string, std::pair<JavaDocConverter::tagHandler, std::string > > JavaDocConverter::tagHandlers; std::map<std::string, std::pair<JavaDocConverter::tagHandler, std::string> > JavaDocConverter::tagHandlers;
using std::string; using std::string;
using std::list; using std::list;
using std::vector; using std::vector;
void JavaDocConverter::fillStaticTables() { void JavaDocConverter::fillStaticTables()
{
if (tagHandlers.size()) // fill only once if (tagHandlers.size()) // fill only once
return; return;
@ -62,7 +63,6 @@ void JavaDocConverter::fillStaticTables() {
* Commenting methods of std types is simple - add comment to std_*.i file. * Commenting methods of std types is simple - add comment to std_*.i file.
*/ */
// these commands insert HTML tags // these commands insert HTML tags
tagHandlers["a"] = make_pair(&JavaDocConverter::handleTagHtml, "i"); tagHandlers["a"] = make_pair(&JavaDocConverter::handleTagHtml, "i");
tagHandlers["arg"] = make_pair(&JavaDocConverter::handleTagHtml, "li"); tagHandlers["arg"] = make_pair(&JavaDocConverter::handleTagHtml, "li");
@ -98,13 +98,15 @@ void JavaDocConverter::fillStaticTables() {
tagHandlers["invariant"] = make_pair(&JavaDocConverter::handleParagraph, ""); tagHandlers["invariant"] = make_pair(&JavaDocConverter::handleParagraph, "");
tagHandlers["latexonly"] = make_pair(&JavaDocConverter::handleParagraph, ""); tagHandlers["latexonly"] = make_pair(&JavaDocConverter::handleParagraph, "");
tagHandlers["manonly"] = make_pair(&JavaDocConverter::handleParagraph, ""); tagHandlers["manonly"] = make_pair(&JavaDocConverter::handleParagraph, "");
tagHandlers["partofdescription"] = make_pair(&JavaDocConverter::handleParagraph, ""); tagHandlers["partofdescription"] = make_pair(
&JavaDocConverter::handleParagraph, "");
tagHandlers["rtfonly"] = make_pair(&JavaDocConverter::handleParagraph, ""); tagHandlers["rtfonly"] = make_pair(&JavaDocConverter::handleParagraph, "");
tagHandlers["short"] = make_pair(&JavaDocConverter::handleParagraph, ""); tagHandlers["short"] = make_pair(&JavaDocConverter::handleParagraph, "");
tagHandlers["xmlonly"] = make_pair(&JavaDocConverter::handleParagraph, ""); tagHandlers["xmlonly"] = make_pair(&JavaDocConverter::handleParagraph, "");
// these commands are kept as-is, they are supported by JavaDoc // these commands are kept as-is, they are supported by JavaDoc
tagHandlers["author"] = make_pair(&JavaDocConverter::handleTagSame, ""); tagHandlers["author"] = make_pair(&JavaDocConverter::handleTagSame, "");
tagHandlers["authors"] = make_pair(&JavaDocConverter::handleTagSame, "author"); tagHandlers["authors"] = make_pair(&JavaDocConverter::handleTagSame,
"author");
tagHandlers["deprecated"] = make_pair(&JavaDocConverter::handleTagSame, ""); tagHandlers["deprecated"] = make_pair(&JavaDocConverter::handleTagSame, "");
tagHandlers["exception"] = make_pair(&JavaDocConverter::handleTagSame, ""); tagHandlers["exception"] = make_pair(&JavaDocConverter::handleTagSame, "");
tagHandlers["package"] = make_pair(&JavaDocConverter::handleTagSame, ""); tagHandlers["package"] = make_pair(&JavaDocConverter::handleTagSame, "");
@ -112,7 +114,8 @@ void JavaDocConverter::fillStaticTables() {
tagHandlers["tparam"] = make_pair(&JavaDocConverter::handleTagParam, ""); tagHandlers["tparam"] = make_pair(&JavaDocConverter::handleTagParam, "");
tagHandlers["result"] = make_pair(&JavaDocConverter::handleTagSame, "return"); tagHandlers["result"] = make_pair(&JavaDocConverter::handleTagSame, "return");
tagHandlers["return"] = make_pair(&JavaDocConverter::handleTagSame, ""); tagHandlers["return"] = make_pair(&JavaDocConverter::handleTagSame, "");
tagHandlers["returns"] = make_pair(&JavaDocConverter::handleTagSame, "return"); tagHandlers["returns"] = make_pair(&JavaDocConverter::handleTagSame,
"return");
//tagHandlers["see"] = make_pair(&JavaDocConverter::handleTagSame, ""); //tagHandlers["see"] = make_pair(&JavaDocConverter::handleTagSame, "");
//tagHandlers["sa"] = make_pair(&JavaDocConverter::handleTagSame, "see"); //tagHandlers["sa"] = make_pair(&JavaDocConverter::handleTagSame, "see");
tagHandlers["since"] = make_pair(&JavaDocConverter::handleTagSame, ""); tagHandlers["since"] = make_pair(&JavaDocConverter::handleTagSame, "");
@ -121,118 +124,160 @@ void JavaDocConverter::fillStaticTables() {
tagHandlers["version"] = make_pair(&JavaDocConverter::handleTagSame, ""); tagHandlers["version"] = make_pair(&JavaDocConverter::handleTagSame, "");
// these commands have special handlers // these commands have special handlers
tagHandlers["code"] = make_pair(&JavaDocConverter::handleTagExtended, "code"); tagHandlers["code"] = make_pair(&JavaDocConverter::handleTagExtended, "code");
tagHandlers["cond"] = make_pair(&JavaDocConverter::handleTagMessage, "Conditional comment: "); tagHandlers["cond"] = make_pair(&JavaDocConverter::handleTagMessage,
tagHandlers["copyright"] = make_pair(&JavaDocConverter::handleTagMessage, "Copyright: "); "Conditional comment: ");
tagHandlers["copyright"] = make_pair(&JavaDocConverter::handleTagMessage,
"Copyright: ");
tagHandlers["else"] = make_pair(&JavaDocConverter::handleTagIf, "Else: "); tagHandlers["else"] = make_pair(&JavaDocConverter::handleTagIf, "Else: ");
tagHandlers["elseif"] = make_pair(&JavaDocConverter::handleTagIf, "Else if: "); tagHandlers["elseif"] = make_pair(&JavaDocConverter::handleTagIf,
tagHandlers["endcond"] = make_pair(&JavaDocConverter::handleTagMessage, "End of conditional comment."); "Else if: ");
tagHandlers["endcond"] = make_pair(&JavaDocConverter::handleTagMessage,
"End of conditional comment.");
// space in second arg prevents Javadoc to treat '@ example' as command. File name of // space in second arg prevents Javadoc to treat '@ example' as command. File name of
// example is still informative to user. // example is still informative to user.
tagHandlers["example"] = make_pair(&JavaDocConverter::handleTagSame, " example"); tagHandlers["example"] = make_pair(&JavaDocConverter::handleTagSame,
" example");
tagHandlers["if"] = make_pair(&JavaDocConverter::handleTagIf, "If: "); tagHandlers["if"] = make_pair(&JavaDocConverter::handleTagIf, "If: ");
tagHandlers["ifnot"] = make_pair(&JavaDocConverter::handleTagIf, "If not: "); tagHandlers["ifnot"] = make_pair(&JavaDocConverter::handleTagIf, "If not: ");
tagHandlers["image"] = make_pair(&JavaDocConverter::handleTagImage, ""); tagHandlers["image"] = make_pair(&JavaDocConverter::handleTagImage, "");
tagHandlers["link"] = make_pair(&JavaDocConverter::handleTagLink, ""); tagHandlers["link"] = make_pair(&JavaDocConverter::handleTagLink, "");
tagHandlers["see"] = make_pair(&JavaDocConverter::handleTagSee, ""); tagHandlers["see"] = make_pair(&JavaDocConverter::handleTagSee, "");
tagHandlers["sa"] = make_pair(&JavaDocConverter::handleTagSee, ""); tagHandlers["sa"] = make_pair(&JavaDocConverter::handleTagSee, "");
tagHandlers["note"] = make_pair(&JavaDocConverter::handleTagMessage, "Note: "); tagHandlers["note"] = make_pair(&JavaDocConverter::handleTagMessage,
tagHandlers["overload"] = make_pair(&JavaDocConverter::handleTagMessage, "This is an overloaded member function, provided for" "Note: ");
" convenience. It differs from the above function only in what" tagHandlers["overload"] = make_pair(&JavaDocConverter::handleTagMessage,
" argument(s) it accepts."); "This is an overloaded member function, provided for"
" convenience. It differs from the above function only in what"
" argument(s) it accepts.");
tagHandlers["par"] = make_pair(&JavaDocConverter::handleTagPar, ""); tagHandlers["par"] = make_pair(&JavaDocConverter::handleTagPar, "");
tagHandlers["remark"] = make_pair(&JavaDocConverter::handleTagMessage, "Remarks: "); tagHandlers["remark"] = make_pair(&JavaDocConverter::handleTagMessage,
tagHandlers["remarks"] = make_pair(&JavaDocConverter::handleTagMessage, "Remarks: "); "Remarks: ");
tagHandlers["todo"] = make_pair(&JavaDocConverter::handleTagMessage, "TODO: "); tagHandlers["remarks"] = make_pair(&JavaDocConverter::handleTagMessage,
tagHandlers["verbatim"] = make_pair(&JavaDocConverter::handleTagExtended, "literal"); "Remarks: ");
tagHandlers["todo"] = make_pair(&JavaDocConverter::handleTagMessage,
"TODO: ");
tagHandlers["verbatim"] = make_pair(&JavaDocConverter::handleTagExtended,
"literal");
// \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(&JavaDocConverter::handleTagVerbatim, ""); tagHandlers["f$"] = make_pair(&JavaDocConverter::handleTagVerbatim, "");
tagHandlers["f["] = make_pair(&JavaDocConverter::handleTagVerbatim, ""); tagHandlers["f["] = make_pair(&JavaDocConverter::handleTagVerbatim, "");
tagHandlers["f{"] = make_pair(&JavaDocConverter::handleTagVerbatim, ""); tagHandlers["f{"] = make_pair(&JavaDocConverter::handleTagVerbatim, "");
tagHandlers["warning"] = make_pair(&JavaDocConverter::handleTagMessage, "Warning: "); tagHandlers["warning"] = make_pair(&JavaDocConverter::handleTagMessage,
"Warning: ");
// 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(&JavaDocConverter::handlePlainString, ""); tagHandlers["plainstd::string"] = make_pair(
tagHandlers["plainstd::endl"] = make_pair(&JavaDocConverter::handleNewLine, ""); &JavaDocConverter::handlePlainString, "");
tagHandlers["plainstd::endl"] = make_pair(&JavaDocConverter::handleNewLine,
"");
tagHandlers["n"] = make_pair(&JavaDocConverter::handleNewLine, ""); tagHandlers["n"] = make_pair(&JavaDocConverter::handleNewLine, "");
// HTML tags // HTML tags
tagHandlers["<a" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<a" ); tagHandlers["<a"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<a");
tagHandlers["<b" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<b" ); tagHandlers["<b"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<b");
tagHandlers["<blockquote"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<blockquote"); tagHandlers["<blockquote"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
tagHandlers["<body" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<body" ); "<blockquote");
tagHandlers["<br" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<br" ); tagHandlers["<body"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
tagHandlers["<center" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<center" ); "<body");
tagHandlers["<caption"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<caption"); tagHandlers["<br"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<br");
tagHandlers["<code" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<code" ); tagHandlers["<center"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
tagHandlers["<dd" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dd" ); "<center");
tagHandlers["<dfn" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dfn" ); tagHandlers["<caption"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
tagHandlers["<div" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<div" ); "<caption");
tagHandlers["<dl" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dl" ); tagHandlers["<code"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
tagHandlers["<dt" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dt" ); "<code");
tagHandlers["<em" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<em" ); tagHandlers["<dd"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dd");
tagHandlers["<form" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<form" ); tagHandlers["<dfn"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dfn");
tagHandlers["<hr" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<hr" ); tagHandlers["<div"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<div");
tagHandlers["<h1" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<h1" ); tagHandlers["<dl"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dl");
tagHandlers["<h2" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<h2" ); tagHandlers["<dt"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dt");
tagHandlers["<h3" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<h3" ); tagHandlers["<em"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<em");
tagHandlers["<i" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<i" ); tagHandlers["<form"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
tagHandlers["<input" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<input" ); "<form");
tagHandlers["<img" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<img" ); tagHandlers["<hr"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<hr");
tagHandlers["<li" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<li" ); tagHandlers["<h1"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<h1");
tagHandlers["<meta" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<meta" ); tagHandlers["<h2"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<h2");
tagHandlers["<multicol"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<multicol"); tagHandlers["<h3"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<h3");
tagHandlers["<ol" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<ol" ); tagHandlers["<i"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<i");
tagHandlers["<p" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<p" ); tagHandlers["<input"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
tagHandlers["<pre" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<pre" ); "<input");
tagHandlers["<small" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<small" ); tagHandlers["<img"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<img");
tagHandlers["<span" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<span" ); tagHandlers["<li"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<li");
tagHandlers["<strong" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<strong" ); tagHandlers["<meta"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
tagHandlers["<sub" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<sub" ); "<meta");
tagHandlers["<sup" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<sup" ); tagHandlers["<multicol"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
tagHandlers["<table" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<table" ); "<multicol");
tagHandlers["<td" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<td" ); tagHandlers["<ol"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<ol");
tagHandlers["<th" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<th" ); tagHandlers["<p"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<p");
tagHandlers["<tr" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<tr" ); tagHandlers["<pre"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<pre");
tagHandlers["<tt" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<tt" ); tagHandlers["<small"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
tagHandlers["<kbd" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<kbd" ); "<small");
tagHandlers["<ul" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<ul" ); tagHandlers["<span"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
tagHandlers["<var" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<var" ); "<span");
tagHandlers["<strong"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
"<strong");
tagHandlers["<sub"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<sub");
tagHandlers["<sup"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<sup");
tagHandlers["<table"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
"<table");
tagHandlers["<td"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<td");
tagHandlers["<th"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<th");
tagHandlers["<tr"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<tr");
tagHandlers["<tt"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<tt");
tagHandlers["<kbd"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<kbd");
tagHandlers["<ul"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<ul");
tagHandlers["<var"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<var");
// HTML entities // HTML entities
tagHandlers["&copy" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&copy"); tagHandlers["&copy"] = make_pair(&JavaDocConverter::handleHtmlEntity,
tagHandlers["&trade"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&trade"); "&copy");
tagHandlers["&reg" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&reg"); tagHandlers["&trade"] = make_pair(&JavaDocConverter::handleHtmlEntity,
tagHandlers["&lt" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&lt"); "&trade");
tagHandlers["&gt" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&gt"); tagHandlers["&reg"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&reg");
tagHandlers["&amp" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&amp"); tagHandlers["&lt"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&lt");
tagHandlers["&apos" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&apos"); tagHandlers["&gt"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&gt");
tagHandlers["&quot" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&quot"); tagHandlers["&amp"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&amp");
tagHandlers["&lsquo"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&lsquo"); tagHandlers["&apos"] = make_pair(&JavaDocConverter::handleHtmlEntity,
tagHandlers["&rsquo"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&rsquo"); "&apos");
tagHandlers["&ldquo"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&ldquo"); tagHandlers["&quot"] = make_pair(&JavaDocConverter::handleHtmlEntity,
tagHandlers["&rdquo"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&rdquo"); "&quot");
tagHandlers["&ndash"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&ndash"); tagHandlers["&lsquo"] = make_pair(&JavaDocConverter::handleHtmlEntity,
tagHandlers["&mdash"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&mdash"); "&lsquo");
tagHandlers["&nbsp" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&nbsp"); tagHandlers["&rsquo"] = make_pair(&JavaDocConverter::handleHtmlEntity,
tagHandlers["&times"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&times"); "&rsquo");
tagHandlers["&minus"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&minus"); tagHandlers["&ldquo"] = make_pair(&JavaDocConverter::handleHtmlEntity,
tagHandlers["&sdot" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&sdot"); "&ldquo");
tagHandlers["&sim" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&sim"); tagHandlers["&rdquo"] = make_pair(&JavaDocConverter::handleHtmlEntity,
tagHandlers["&le" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&le"); "&rdquo");
tagHandlers["&ge" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&ge"); tagHandlers["&ndash"] = make_pair(&JavaDocConverter::handleHtmlEntity,
tagHandlers["&larr" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&larr"); "&ndash");
tagHandlers["&rarr" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&rarr"); tagHandlers["&mdash"] = make_pair(&JavaDocConverter::handleHtmlEntity,
"&mdash");
tagHandlers["&nbsp"] = make_pair(&JavaDocConverter::handleHtmlEntity,
"&nbsp");
tagHandlers["&times"] = make_pair(&JavaDocConverter::handleHtmlEntity,
"&times");
tagHandlers["&minus"] = make_pair(&JavaDocConverter::handleHtmlEntity,
"&minus");
tagHandlers["&sdot"] = make_pair(&JavaDocConverter::handleHtmlEntity,
"&sdot");
tagHandlers["&sim"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&sim");
tagHandlers["&le"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&le");
tagHandlers["&ge"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&ge");
tagHandlers["&larr"] = make_pair(&JavaDocConverter::handleHtmlEntity,
"&larr");
tagHandlers["&rarr"] = make_pair(&JavaDocConverter::handleHtmlEntity,
"&rarr");
} }
JavaDocConverter::JavaDocConverter(bool debugTranslator, bool debugParser) :
JavaDocConverter::JavaDocConverter(bool debugTranslator, bool debugParser) DoxygenTranslator(debugTranslator, debugParser)
: DoxygenTranslator(debugTranslator, debugParser) { {
fillStaticTables(); fillStaticTables();
} }
/** /**
* Formats comment lines by inserting '\n *' at to long lines and tabs for * Formats comment lines by inserting '\n *' at to long lines and tabs for
* indent. Currently it is disabled, which means original comment format is * indent. Currently it is disabled, which means original comment format is
@ -242,7 +287,8 @@ JavaDocConverter::JavaDocConverter(bool debugTranslator, bool debugParser)
* better algorithm. * better algorithm.
*/ */
std::string JavaDocConverter::formatCommand(std::string unformattedLine, std::string JavaDocConverter::formatCommand(std::string unformattedLine,
int indent) { int indent)
{
std::string formattedLines; std::string formattedLines;
return unformattedLine; // currently disabled return unformattedLine; // currently disabled
int lastPosition = 0; int lastPosition = 0;
@ -262,10 +308,12 @@ std::string JavaDocConverter::formatCommand(std::string unformattedLine,
if (!isFirstLine) if (!isFirstLine)
for (int j = 0; j < indent; j++) { for (int j = 0; j < indent; j++) {
formattedLines.append("\t"); formattedLines.append("\t");
} else {
isFirstLine = 0;
} }
formattedLines.append(unformattedLine.substr(lastPosition, i - lastPosition + 1)); else {
isFirstLine = 0;
}
formattedLines.append(
unformattedLine.substr(lastPosition, i - lastPosition + 1));
formattedLines.append("\n *"); formattedLines.append("\n *");
} }
@ -276,13 +324,14 @@ std::string JavaDocConverter::formatCommand(std::string unformattedLine,
formattedLines.append("\t"); formattedLines.append("\t");
} }
} }
formattedLines.append(unformattedLine.substr(lastPosition, unformattedLine.length() - lastPosition)); formattedLines.append(
unformattedLine.substr(lastPosition,
unformattedLine.length() - lastPosition));
} }
return formattedLines; return formattedLines;
} }
/** /**
* Returns true, if the given parameter exists in the current node * Returns true, if the given parameter exists in the current node
* (for example param is a name of function parameter). If feature * (for example param is a name of function parameter). If feature
@ -290,7 +339,8 @@ std::string JavaDocConverter::formatCommand(std::string unformattedLine,
* true - parameters are copied to output regardless of presence in * true - parameters are copied to output regardless of presence in
* function params list. * function params list.
*/ */
bool JavaDocConverter::paramExists(std::string param) { bool JavaDocConverter::paramExists(std::string param)
{
if (GetFlag(currentNode, "feature:doxygen:nostripparams")) { if (GetFlag(currentNode, "feature:doxygen:nostripparams")) {
return true; return true;
@ -300,7 +350,7 @@ bool JavaDocConverter::paramExists(std::string param) {
for (Parm *p = plist; p;) { for (Parm *p = plist; p;) {
if (Getattr(p, "name") && Char(Getattr(p, "name")) == param) { if (Getattr(p, "name") && Char (Getattr(p, "name")) == param) {
return true; return true;
} }
/* doesn't seem to work always: in some cases (especially for 'self' parameters) /* doesn't seem to work always: in some cases (especially for 'self' parameters)
@ -315,8 +365,8 @@ bool JavaDocConverter::paramExists(std::string param) {
return false; return false;
} }
std::string JavaDocConverter::translateSubtree(DoxygenEntity &doxygenEntity)
std::string JavaDocConverter::translateSubtree(DoxygenEntity &doxygenEntity) { {
std::string translatedComment; std::string translatedComment;
if (doxygenEntity.isLeaf) { if (doxygenEntity.isLeaf) {
@ -324,7 +374,7 @@ std::string JavaDocConverter::translateSubtree(DoxygenEntity &doxygenEntity) {
} }
for (DoxygenEntityListIt p = doxygenEntity.entityList.begin(); for (DoxygenEntityListIt p = doxygenEntity.entityList.begin();
p != doxygenEntity.entityList.end(); p++) { p != doxygenEntity.entityList.end(); p++) {
translateEntity(*p, translatedComment); translateEntity(*p, translatedComment);
translateSubtree(*p); translateSubtree(*p);
@ -333,62 +383,74 @@ std::string JavaDocConverter::translateSubtree(DoxygenEntity &doxygenEntity) {
return translatedComment; return translatedComment;
} }
/** /**
* Checks if a handler for the given tag exists, and calls it. * Checks if a handler for the given tag exists, and calls it.
*/ */
void JavaDocConverter::translateEntity(DoxygenEntity &tag, void JavaDocConverter::translateEntity(DoxygenEntity &tag,
std::string &translatedComment) { std::string &translatedComment)
{
std::map<std::string, std::pair<tagHandler, std::string > >::iterator it; std::map<std::string, std::pair<tagHandler, std::string> >::iterator it;
it = tagHandlers.find(tag.typeOfEntity); it = tagHandlers.find(tag.typeOfEntity);
if (it != tagHandlers.end()) { if (it != tagHandlers.end()) {
(this->*(it->second.first))(tag, translatedComment, it->second.second); (this->*(it->second.first))(tag, translatedComment, it->second.second);
} else { } else {
// do NOT print warning, since there are many tags, which are not // do NOT print warning, since there are many tags, which are not
// translatable - many warnings hide important ones // translatable - many warnings hide important ones
// addError(WARN_DOXYGEN_COMMAND_ERROR, "Unknown doxygen or HTML tag: " + tag.typeOfEntity); // addError(WARN_DOXYGEN_COMMAND_ERROR, "Unknown doxygen or HTML tag: " + tag.typeOfEntity);
} }
} }
void JavaDocConverter::handleTagHtml(DoxygenEntity& tag,
void JavaDocConverter::handleTagHtml(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) { std::string& translatedComment,
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);
// wrap the thing, ignoring whitespaces // wrap the thing, ignoring whitespaces
size_t wsPos = tagData.find_last_not_of("\n\t "); size_t wsPos = tagData.find_last_not_of("\n\t ");
if (wsPos != std::string::npos) if (wsPos != std::string::npos)
translatedComment += "<" + arg + ">" + tagData.substr(0, wsPos + 1) + "</" + arg + ">" + tagData.substr(wsPos + 1); translatedComment += "<" + arg + ">" + tagData.substr(0, wsPos + 1) + "</"
+ arg + ">" + tagData.substr(wsPos + 1);
else else
translatedComment += "<" + arg + ">" + translateSubtree(tag) + "</" + arg + "> "; translatedComment += "<" + arg + ">" + translateSubtree(tag) + "</" + arg
+ "> ";
} }
} }
void JavaDocConverter::handleDoxyHtmlTag(DoxygenEntity& tag,
void JavaDocConverter::handleDoxyHtmlTag(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) { std::string& translatedComment,
std::string htmlTagArgs = tag.data; std::string &arg)
if (htmlTagArgs == "/") { {
// end html tag, for example "</ul> std::string htmlTagArgs = tag.data;
translatedComment += "</" + arg.substr(1) + ">"; if (htmlTagArgs == "/") {
} else { // end html tag, for example "</ul>
translatedComment += arg + htmlTagArgs + ">"; translatedComment += "</" + arg.substr(1) + ">";
} } else {
translatedComment += arg + htmlTagArgs + ">";
}
} }
void JavaDocConverter::handleHtmlEntity(DoxygenEntity&,
void JavaDocConverter::handleHtmlEntity(DoxygenEntity&, std::string& translatedComment, std::string &arg) { std::string& translatedComment,
// html entities can be preserved for Java std::string &arg)
translatedComment += arg + ';'; {
// html entities can be preserved for Java
translatedComment += arg + ';';
} }
void JavaDocConverter::handleNewLine(DoxygenEntity&,
void JavaDocConverter::handleNewLine(DoxygenEntity&, std::string& translatedComment, std::string&) { std::string& translatedComment,
std::string&)
{
translatedComment += "\n * "; translatedComment += "\n * ";
} }
void JavaDocConverter::handleTagChar(DoxygenEntity& tag,
void JavaDocConverter::handleTagChar(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) { std::string& translatedComment,
std::string &arg)
{
// escape it if we need to, else just print // escape it if we need to, else just print
if (arg.size()) if (arg.size())
translatedComment += arg; translatedComment += arg;
@ -397,42 +459,57 @@ void JavaDocConverter::handleTagChar(DoxygenEntity& tag, std::string& translated
} }
// handles tags which are the same in Doxygen and Javadoc. // handles tags which are the same in Doxygen and Javadoc.
void JavaDocConverter::handleTagSame(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) { void JavaDocConverter::handleTagSame(DoxygenEntity& tag,
std::string& translatedComment,
std::string &arg)
{
if (arg.size()) if (arg.size())
tag.typeOfEntity = arg; tag.typeOfEntity = arg;
translatedComment += formatCommand(std::string("@" + tag.typeOfEntity + " " + translateSubtree(tag)), 2); translatedComment += formatCommand(
std::string("@" + tag.typeOfEntity + " " + translateSubtree(tag)), 2);
} }
void JavaDocConverter::handleParagraph(DoxygenEntity& tag,
void JavaDocConverter::handleParagraph(DoxygenEntity& tag, std::string& translatedComment, std::string&) { std::string& translatedComment,
std::string&)
{
translatedComment += formatCommand(translateSubtree(tag), 0); translatedComment += formatCommand(translateSubtree(tag), 0);
} }
void JavaDocConverter::handlePlainString(DoxygenEntity& tag,
void JavaDocConverter::handlePlainString(DoxygenEntity& tag, std::string& translatedComment, std::string&) { std::string& translatedComment,
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] != ' ')
// translatedComment += " "; // translatedComment += " ";
} }
void JavaDocConverter::handleTagVerbatim(DoxygenEntity& tag,
void JavaDocConverter::handleTagVerbatim(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) { std::string& translatedComment,
std::string &arg)
{
translatedComment += arg + " "; translatedComment += arg + " ";
for (DoxygenEntityListCIt it = tag.entityList.begin(); it != tag.entityList.end(); it++) { for (DoxygenEntityListCIt it = tag.entityList.begin();
translatedComment += it->data; it != tag.entityList.end(); it++) {
translatedComment += it->data;
} }
} }
void JavaDocConverter::handleTagExtended(DoxygenEntity& tag,
void JavaDocConverter::handleTagExtended(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) { std::string& translatedComment,
std::string &arg)
{
std::string dummy; std::string dummy;
translatedComment += "{@" + arg + " "; translatedComment += "{@" + arg + " ";
handleParagraph(tag, translatedComment, dummy); handleParagraph(tag, translatedComment, dummy);
translatedComment += "}"; translatedComment += "}";
} }
void JavaDocConverter::handleTagIf(DoxygenEntity& tag,
void JavaDocConverter::handleTagIf(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) { std::string& translatedComment,
std::string &arg)
{
std::string dummy; std::string dummy;
translatedComment += arg; translatedComment += arg;
if (tag.entityList.size()) { if (tag.entityList.size()) {
@ -442,22 +519,26 @@ void JavaDocConverter::handleTagIf(DoxygenEntity& tag, std::string& translatedCo
} }
} }
void JavaDocConverter::handleTagMessage(DoxygenEntity& tag,
void JavaDocConverter::handleTagMessage(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) { std::string& translatedComment,
std::string &arg)
{
std::string dummy; std::string dummy;
translatedComment += formatCommand(arg, 0); translatedComment += formatCommand(arg, 0);
handleParagraph(tag, translatedComment, dummy); handleParagraph(tag, translatedComment, dummy);
} }
void JavaDocConverter::handleTagImage(DoxygenEntity& tag,
void JavaDocConverter::handleTagImage(DoxygenEntity& tag, std::string& translatedComment, std::string&) { std::string& translatedComment,
std::string&)
{
if (tag.entityList.size() < 2) if (tag.entityList.size() < 2)
return; return;
std::string file; std::string file;
std::string title; std::string title;
std::list <DoxygenEntity>::iterator it = tag.entityList.begin(); std::list<DoxygenEntity>::iterator it = tag.entityList.begin();
if (it->data != "html") if (it->data != "html")
return; return;
@ -477,8 +558,10 @@ void JavaDocConverter::handleTagImage(DoxygenEntity& tag, std::string& translate
translatedComment += "/>"; translatedComment += "/>";
} }
void JavaDocConverter::handleTagPar(DoxygenEntity& tag,
void JavaDocConverter::handleTagPar(DoxygenEntity& tag, std::string& translatedComment, std::string&) { std::string& translatedComment,
std::string&)
{
std::string dummy; std::string dummy;
translatedComment += "<p"; translatedComment += "<p";
if (tag.entityList.size()) { if (tag.entityList.size()) {
@ -490,10 +573,10 @@ void JavaDocConverter::handleTagPar(DoxygenEntity& tag, std::string& translatedC
translatedComment += "</p>"; translatedComment += "</p>";
} }
void JavaDocConverter::handleTagParam(DoxygenEntity& tag, void JavaDocConverter::handleTagParam(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string&) { std::string&)
{
std::string dummy; std::string dummy;
if (!tag.entityList.size()) if (!tag.entityList.size())
@ -507,17 +590,19 @@ void JavaDocConverter::handleTagParam(DoxygenEntity& tag,
handleParagraph(tag, translatedComment, dummy); handleParagraph(tag, translatedComment, dummy);
} }
string JavaDocConverter::convertLink(string linkObject)
string JavaDocConverter::convertLink(string linkObject) { {
if (GetFlag(currentNode, "feature:doxygen:nolinktranslate")) if (GetFlag(currentNode, "feature:doxygen:nolinktranslate"))
return linkObject; return linkObject;
// find the params in function in linkObject (if any) // find the params in function in linkObject (if any)
size_t lbracePos = linkObject.find('(', 0); size_t lbracePos = linkObject.find('(', 0);
size_t rbracePos = linkObject.find(')', 0); size_t rbracePos = linkObject.find(')', 0);
if (lbracePos == string::npos || rbracePos == string::npos || lbracePos >= rbracePos) if (lbracePos == string::npos || rbracePos == string::npos
|| lbracePos >= rbracePos)
return ""; return "";
string paramsStr = linkObject.substr(lbracePos + 1, rbracePos - lbracePos - 1); string paramsStr = linkObject.substr(lbracePos + 1,
rbracePos - lbracePos - 1);
// strip the params, to fill them later // strip the params, to fill them later
linkObject = linkObject.substr(0, lbracePos); linkObject = linkObject.substr(0, lbracePos);
@ -539,7 +624,7 @@ string JavaDocConverter::convertLink(string linkObject) {
} }
linkObject += "("; linkObject += "(";
for (size_t i=0; i<params.size(); i++) { for (size_t i = 0; i < params.size(); i++) {
// translate c/c++ type string to swig's type // translate c/c++ type string to swig's type
// i e 'int **arr[100][10]' -> 'a(100).a(10).p.p.int' // i e 'int **arr[100][10]' -> 'a(100).a(10).p.p.int'
// also converting arrays to pointers // also converting arrays to pointers
@ -551,18 +636,17 @@ string JavaDocConverter::convertLink(string linkObject) {
SwigType_add_qualifier(swigType, "const"); SwigType_add_qualifier(swigType, "const");
// handle pointers, references and arrays // handle pointers, references and arrays
for (int j=(int)params[i].size() - 1; j>=0; j--) { for (int j = (int) params[i].size() - 1; j >= 0; j--) {
// skip all the [...] blocks, write 'p.' for every of it // skip all the [...] blocks, write 'p.' for every of it
if (paramStr[j] == ']') { if (paramStr[j] == ']') {
while (j>=0 && paramStr[j] != '[') while (j >= 0 && paramStr[j] != '[')
j--; j--;
// no closing brace // no closing brace
if (j < 0) if (j < 0)
return ""; return "";
SwigType_add_pointer(swigType); SwigType_add_pointer(swigType);
continue; continue;
} } else if (paramStr[j] == '*')
else if (paramStr[j] == '*')
SwigType_add_pointer(swigType); SwigType_add_pointer(swigType);
else if (paramStr[j] == '&') else if (paramStr[j] == '&')
SwigType_add_reference(swigType); SwigType_add_reference(swigType);
@ -572,7 +656,8 @@ string JavaDocConverter::convertLink(string linkObject) {
typeNameStart = 0; typeNameStart = 0;
else else
typeNameStart++; typeNameStart++;
Append(swigType, paramStr.substr(typeNameStart, j - typeNameStart + 1).c_str()); Append(swigType,
paramStr.substr(typeNameStart, j - typeNameStart + 1).c_str());
break; break;
} }
} }
@ -580,10 +665,11 @@ string JavaDocConverter::convertLink(string linkObject) {
// make dummy param list, to lookup typemaps for it // make dummy param list, to lookup typemaps for it
Parm *dummyParam = NewParm(swigType, "", 0); Parm *dummyParam = NewParm(swigType, "", 0);
Swig_typemap_attach_parms("jstype", dummyParam, NULL); Swig_typemap_attach_parms("jstype", dummyParam, NULL);
Language::instance()->replaceSpecialVariables(0, Getattr(dummyParam, "tmap:jstype"), dummyParam); Language::instance()->replaceSpecialVariables(0,
Getattr(dummyParam, "tmap:jstype"), dummyParam);
//Swig_print(dummyParam, 1); //Swig_print(dummyParam, 1);
linkObject += Char(Getattr(dummyParam, "tmap:jstype")); linkObject += Char (Getattr(dummyParam, "tmap:jstype"));
if (i != params.size() - 1) if (i != params.size() - 1)
linkObject += ","; linkObject += ",";
@ -595,8 +681,10 @@ string JavaDocConverter::convertLink(string linkObject) {
return linkObject; return linkObject;
} }
void JavaDocConverter::handleTagLink(DoxygenEntity& tag,
void JavaDocConverter::handleTagLink(DoxygenEntity& tag, std::string& translatedComment, std::string&) { std::string& translatedComment,
std::string&)
{
std::string dummy; std::string dummy;
if (!tag.entityList.size()) if (!tag.entityList.size())
return; return;
@ -612,8 +700,10 @@ void JavaDocConverter::handleTagLink(DoxygenEntity& tag, std::string& translated
translatedComment += "}"; translatedComment += "}";
} }
void JavaDocConverter::handleTagSee(DoxygenEntity& tag,
void JavaDocConverter::handleTagSee(DoxygenEntity& tag, std::string& translatedComment, std::string&) { std::string& translatedComment,
std::string&)
{
std::string dummy; std::string dummy;
if (!tag.entityList.size()) if (!tag.entityList.size())
return; return;
@ -624,7 +714,7 @@ void JavaDocConverter::handleTagSee(DoxygenEntity& tag, std::string& translatedC
// :: or # may be used as a separator between class name and method name. // :: or # may be used as a separator between class name and method name.
list<DoxygenEntity>::iterator it; list<DoxygenEntity>::iterator it;
string methodRef; string methodRef;
for (it = tag.entityList.begin(); it!=tag.entityList.end(); it++) { for (it = tag.entityList.begin(); it != tag.entityList.end(); it++) {
if (it->typeOfEntity == "plainstd::endl") { if (it->typeOfEntity == "plainstd::endl") {
// handleNewLine(*it, translatedComment, dummy); // handleNewLine(*it, translatedComment, dummy);
continue; continue;
@ -632,13 +722,13 @@ void JavaDocConverter::handleTagSee(DoxygenEntity& tag, std::string& translatedC
// restore entities which may be used in C++ type declaration // restore entities which may be used in C++ type declaration
if (it->typeOfEntity == "&amp") { if (it->typeOfEntity == "&amp") {
methodRef += '&'; methodRef += '&';
} else if (it->typeOfEntity == "&lt") { } else if (it->typeOfEntity == "&lt") {
methodRef += '<'; methodRef += '<';
} else if (it->typeOfEntity == "&gt") { } else if (it->typeOfEntity == "&gt") {
methodRef += '>'; methodRef += '>';
} else { } else {
methodRef += it->data; methodRef += it->data;
} }
} }
@ -646,7 +736,8 @@ void JavaDocConverter::handleTagSee(DoxygenEntity& tag, std::string& translatedC
size_t lbrace = methodRef.find('('); size_t lbrace = methodRef.find('(');
size_t dblColon = methodRef.find("::"); size_t dblColon = methodRef.find("::");
if (dblColon < lbrace) { if (dblColon < lbrace) {
methodRef = methodRef.substr(0, dblColon) + '#' + methodRef.substr(dblColon + 2); methodRef = methodRef.substr(0, dblColon) + '#'
+ methodRef.substr(dblColon + 2);
} }
translatedComment += "@see "; translatedComment += "@see ";
@ -657,22 +748,21 @@ void JavaDocConverter::handleTagSee(DoxygenEntity& tag, std::string& translatedC
translatedComment += linkObject; translatedComment += linkObject;
} }
/* This function moves all endlines at the end of child entities /* This function moves all endlines at the end of child entities
* out of the child entities to the parent. * out of the child entities to the parent.
* For example, entity tree: * For example, entity tree:
-root -root
|-param |-param
|-paramText |-paramText
|-endline |-endline
should be turned to should be turned to
-root -root
|-param |-param
|-paramText |-paramText
|-endline |-endline
* *
*/ */
int JavaDocConverter::shiftEndlinesUpTree(DoxygenEntity &root, int level) int JavaDocConverter::shiftEndlinesUpTree(DoxygenEntity &root, int level)
@ -694,21 +784,22 @@ int JavaDocConverter::shiftEndlinesUpTree(DoxygenEntity &root, int level)
} }
int removedCount = 0; int removedCount = 0;
while (!root.entityList.empty() && root.entityList.rbegin()->typeOfEntity == "plainstd::endl") { while (!root.entityList.empty()
&& root.entityList.rbegin()->typeOfEntity == "plainstd::endl") {
root.entityList.pop_back(); root.entityList.pop_back();
removedCount++; removedCount++;
} }
return removedCount; return removedCount;
} }
/** /**
* This makes sure that all comment lines contain '*'. It is not mandatory in doxygen, * This makes sure that all comment lines contain '*'. It is not mandatory in doxygen,
* but highly recommended for Javadoc. '*' in empty lines are indented according * but highly recommended for Javadoc. '*' in empty lines are indented according
* to indentation of the first line. Indentation of non-empty lines is not * to indentation of the first line. Indentation of non-empty lines is not
* changed - garbage in garbage out. * changed - garbage in garbage out.
*/ */
std::string JavaDocConverter::indentAndInsertAsterisks(const string &doc) { std::string JavaDocConverter::indentAndInsertAsterisks(const string &doc)
{
size_t idx = doc.find('\n'); size_t idx = doc.find('\n');
size_t indent = 0; size_t indent = 0;
@ -743,17 +834,17 @@ std::string JavaDocConverter::indentAndInsertAsterisks(const string &doc) {
while (idx != string::npos) { while (idx != string::npos) {
size_t nonspaceIdx = translatedStr.find_first_not_of(" \t", idx + 1); size_t nonspaceIdx = translatedStr.find_first_not_of(" \t", idx + 1);
if (nonspaceIdx != string::npos && translatedStr[nonspaceIdx] != '*') { if (nonspaceIdx != string::npos && translatedStr[nonspaceIdx] != '*') {
// line without '*' found - is it empty? // line without '*' found - is it empty?
if (translatedStr[nonspaceIdx] != '\n') { if (translatedStr[nonspaceIdx] != '\n') {
// add '* ' to each line without it // add '* ' to each line without it
translatedStr = translatedStr.substr(0, nonspaceIdx) + "* " + translatedStr = translatedStr.substr(0, nonspaceIdx) + "* "
translatedStr.substr(nonspaceIdx); + translatedStr.substr(nonspaceIdx);
//printf(translatedStr.c_str()); //printf(translatedStr.c_str());
} else { } else {
// we found empty line, replace it with indented '*' // we found empty line, replace it with indented '*'
translatedStr = translatedStr.substr(0, idx + 1) + indentStr + translatedStr = translatedStr.substr(0, idx + 1) + indentStr + "* "
"* " + translatedStr.substr(nonspaceIdx); + translatedStr.substr(nonspaceIdx);
} }
} }
idx = translatedStr.find('\n', nonspaceIdx); idx = translatedStr.find('\n', nonspaceIdx);
@ -774,8 +865,8 @@ std::string JavaDocConverter::indentAndInsertAsterisks(const string &doc) {
return translatedStr; return translatedStr;
} }
String *JavaDocConverter::makeDocumentation(Node *node)
String *JavaDocConverter::makeDocumentation(Node *node) { {
String *documentation = getDoxygenComment(node); String *documentation = getDoxygenComment(node);
@ -785,7 +876,7 @@ String *JavaDocConverter::makeDocumentation(Node *node) {
if (GetFlag(node, "feature:doxygen:notranslate")) { if (GetFlag(node, "feature:doxygen:notranslate")) {
string doc = Char(documentation); string doc = Char (documentation);
string translatedStr = indentAndInsertAsterisks(doc); string translatedStr = indentAndInsertAsterisks(doc);
@ -794,9 +885,8 @@ String *JavaDocConverter::makeDocumentation(Node *node) {
return comment; return comment;
} }
DoxygenEntityList entityList = parser.createTree(Char(documentation), DoxygenEntityList entityList = parser.createTree(Char (documentation),
Char(Getfile(documentation)), Char (Getfile(documentation)), Getline(documentation));
Getline(documentation));
// entityList.sort(CompareDoxygenEntities()); sorting currently not used, // entityList.sort(CompareDoxygenEntities()); sorting currently not used,
@ -816,14 +906,14 @@ String *JavaDocConverter::makeDocumentation(Node *node) {
shiftEndlinesUpTree(root); shiftEndlinesUpTree(root);
// strip endlines at the beginning // strip endlines at the beginning
while (!root.entityList.empty() && while (!root.entityList.empty()
root.entityList.begin()->typeOfEntity == "plainstd::endl") { && root.entityList.begin()->typeOfEntity == "plainstd::endl") {
root.entityList.pop_front(); root.entityList.pop_front();
} }
// and at the end // and at the end
while (!root.entityList.empty() && while (!root.entityList.empty()
root.entityList.rbegin()->typeOfEntity == "plainstd::endl") { && root.entityList.rbegin()->typeOfEntity == "plainstd::endl") {
root.entityList.pop_back(); root.entityList.pop_back();
} }
@ -839,9 +929,8 @@ String *JavaDocConverter::makeDocumentation(Node *node) {
return NewString(javaDocString.c_str()); return NewString(javaDocString.c_str());
} }
void JavaDocConverter::addError(int warningType, const std::string &message)
void JavaDocConverter::addError(int warningType, {
const std::string &message) { Swig_warning(warningType, "", 0, "Doxygen parser warning: %s. \n",
Swig_warning(warningType, "", 0, message.c_str());
"Doxygen parser warning: %s. \n", message.c_str());
} }

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

@ -19,13 +19,13 @@
#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; std::map<std::string, std::pair<PyDocConverter::tagHandler, std::string> > PyDocConverter::tagHandlers;
std::map<std::string, std::string> PyDocConverter::sectionTitles; std::map<std::string, std::string> PyDocConverter::sectionTitles;
using std::string; using std::string;
void PyDocConverter::fillStaticTables()
void PyDocConverter::fillStaticTables() { {
if (tagHandlers.size()) // fill only once if (tagHandlers.size()) // fill only once
return; return;
@ -94,15 +94,18 @@ void PyDocConverter::fillStaticTables() {
tagHandlers["manonly"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["manonly"] = make_pair(&PyDocConverter::handleParagraph, "");
tagHandlers["note"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["note"] = make_pair(&PyDocConverter::handleParagraph, "");
tagHandlers["p"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["p"] = make_pair(&PyDocConverter::handleParagraph, "");
tagHandlers["partofdescription"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["partofdescription"] = make_pair(&PyDocConverter::handleParagraph,
"");
tagHandlers["rtfonly"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["rtfonly"] = make_pair(&PyDocConverter::handleParagraph, "");
tagHandlers["return"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["return"] = make_pair(&PyDocConverter::handleParagraph, "");
tagHandlers["returns"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["returns"] = make_pair(&PyDocConverter::handleParagraph, "");
tagHandlers["result"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["result"] = make_pair(&PyDocConverter::handleParagraph, "");
tagHandlers["remark"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["remark"] = make_pair(&PyDocConverter::handleParagraph, "");
tagHandlers["remarks"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["remarks"] = make_pair(&PyDocConverter::handleParagraph, "");
tagHandlers["sa"] = make_pair(&PyDocConverter::handleTagMessage, "See also: "); tagHandlers["sa"] = make_pair(&PyDocConverter::handleTagMessage,
tagHandlers["see"] = make_pair(&PyDocConverter::handleTagMessage, "See also: "); "See also: ");
tagHandlers["see"] = make_pair(&PyDocConverter::handleTagMessage,
"See also: ");
tagHandlers["since"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["since"] = make_pair(&PyDocConverter::handleParagraph, "");
tagHandlers["short"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["short"] = make_pair(&PyDocConverter::handleParagraph, "");
tagHandlers["throw"] = make_pair(&PyDocConverter::handleParagraph, ""); tagHandlers["throw"] = make_pair(&PyDocConverter::handleParagraph, "");
@ -114,23 +117,27 @@ void PyDocConverter::fillStaticTables() {
tagHandlers["xmlonly"] = 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_pair(&PyDocConverter::handleTagMessage, " -");
tagHandlers["cond"] = make_pair(&PyDocConverter::handleTagMessage, "Conditional comment: "); tagHandlers["cond"] = make_pair(&PyDocConverter::handleTagMessage,
"Conditional comment: ");
tagHandlers["else"] = make_pair(&PyDocConverter::handleTagIf, "Else: "); tagHandlers["else"] = make_pair(&PyDocConverter::handleTagIf, "Else: ");
tagHandlers["elseif"] = make_pair(&PyDocConverter::handleTagIf, "Else if: "); tagHandlers["elseif"] = make_pair(&PyDocConverter::handleTagIf, "Else if: ");
tagHandlers["endcond"] = make_pair(&PyDocConverter::handleTagMessage, "End of conditional comment."); tagHandlers["endcond"] = make_pair(&PyDocConverter::handleTagMessage,
"End of conditional comment.");
tagHandlers["if"] = make_pair(&PyDocConverter::handleTagIf, "If: "); tagHandlers["if"] = make_pair(&PyDocConverter::handleTagIf, "If: ");
tagHandlers["ifnot"] = make_pair(&PyDocConverter::handleTagIf, "If not: "); tagHandlers["ifnot"] = make_pair(&PyDocConverter::handleTagIf, "If not: ");
tagHandlers["image"] = make_pair(&PyDocConverter::handleTagImage, ""); tagHandlers["image"] = make_pair(&PyDocConverter::handleTagImage, "");
tagHandlers["li"] = make_pair(&PyDocConverter::handleTagMessage, " -"); tagHandlers["li"] = make_pair(&PyDocConverter::handleTagMessage, " -");
tagHandlers["overload"] = make_pair(&PyDocConverter::handleTagMessage, "This is an overloaded member function, provided for" tagHandlers["overload"] = make_pair(&PyDocConverter::handleTagMessage,
" convenience.\nIt differs from the above function only in what" "This is an overloaded member function, provided for"
" argument(s) it accepts."); " convenience.\nIt differs from the above function only in what"
" argument(s) it accepts.");
tagHandlers["par"] = make_pair(&PyDocConverter::handleTagPar, ""); tagHandlers["par"] = make_pair(&PyDocConverter::handleTagPar, "");
tagHandlers["param"] = make_pair(&PyDocConverter::handleTagParam, ""); tagHandlers["param"] = make_pair(&PyDocConverter::handleTagParam, "");
tagHandlers["tparam"] = make_pair(&PyDocConverter::handleTagParam, ""); tagHandlers["tparam"] = make_pair(&PyDocConverter::handleTagParam, "");
// 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(&PyDocConverter::handlePlainString, ""); tagHandlers["plainstd::string"] = make_pair(
&PyDocConverter::handlePlainString, "");
tagHandlers["plainstd::endl"] = make_pair(&PyDocConverter::handleNewLine, ""); tagHandlers["plainstd::endl"] = make_pair(&PyDocConverter::handleNewLine, "");
tagHandlers["n"] = make_pair(&PyDocConverter::handleNewLine, ""); tagHandlers["n"] = make_pair(&PyDocConverter::handleNewLine, "");
@ -140,97 +147,99 @@ void PyDocConverter::fillStaticTables() {
tagHandlers["f{"] = make_pair(&PyDocConverter::handleTagVerbatim, ""); tagHandlers["f{"] = make_pair(&PyDocConverter::handleTagVerbatim, "");
// HTML tags // HTML tags
tagHandlers["<a" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag_A, "" ); tagHandlers["<a"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_A, "");
tagHandlers["<b" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "__"); tagHandlers["<b"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "__");
tagHandlers["<blockquote"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_A, "Quote: "); tagHandlers["<blockquote"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_A,
tagHandlers["<body" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "" ); "Quote: ");
tagHandlers["<br" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "\n" ); tagHandlers["<body"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<br"] = make_pair(&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_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<caption"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<caption"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<code" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "'" ); tagHandlers["<code"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "'");
tagHandlers["<dl" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<dl"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<dd" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, " "); tagHandlers["<dd"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, " ");
tagHandlers["<dt" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<dt"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<dfn" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "" ); tagHandlers["<dfn"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<div" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "" ); tagHandlers["<div"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<em" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "__"); tagHandlers["<em"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "__");
tagHandlers["<form" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "" ); tagHandlers["<form"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<hr" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, tagHandlers["<hr"] = make_pair(&PyDocConverter::handleDoxyHtmlTag,
"--------------------------------------------------------------------\n" ); "--------------------------------------------------------------------\n");
tagHandlers["<h1" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "# " ); tagHandlers["<h1"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "# ");
tagHandlers["<h2" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "## " ); tagHandlers["<h2"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "## ");
tagHandlers["<h3" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "### " ); tagHandlers["<h3"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "### ");
tagHandlers["<i" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "_"); tagHandlers["<i"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "_");
tagHandlers["<input" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "" ); tagHandlers["<input"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<img" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "Image:" ); tagHandlers["<img"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "Image:");
tagHandlers["<li" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "- "); tagHandlers["<li"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "- ");
tagHandlers["<meta" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<meta"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<multicol"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<multicol"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<ol" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<ol"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<p" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "\n"); tagHandlers["<p"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "\n");
tagHandlers["<pre" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "" ); tagHandlers["<pre"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<small" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "" ); tagHandlers["<small"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<span" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "'" ); tagHandlers["<span"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "'");
tagHandlers["<strong" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "__"); tagHandlers["<strong"] = make_pair(&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_pair(&PyDocConverter::handleDoxyHtmlTag, " ");
tagHandlers["<sup" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, " "); tagHandlers["<sup"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, " ");
tagHandlers["<table" ] = make_pair(&PyDocConverter::handleDoxyHtmlTagNoParam, ""); tagHandlers["<table"] = make_pair(&PyDocConverter::handleDoxyHtmlTagNoParam,
tagHandlers["<td" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag_td, ""); "");
tagHandlers["<th" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag_th, ""); tagHandlers["<td"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_td, "");
tagHandlers["<tr" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag_tr, ""); tagHandlers["<th"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_th, "");
tagHandlers["<tt" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<tr"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_tr, "");
tagHandlers["<kbd" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<tt"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<ul" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""); tagHandlers["<kbd"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<var" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "_"); tagHandlers["<ul"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
tagHandlers["<var"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "_");
// HTML entities // HTML entities
tagHandlers["&copy" ] = make_pair(&PyDocConverter::handleHtmlEntity, "(C)"); tagHandlers["&copy"] = make_pair(&PyDocConverter::handleHtmlEntity, "(C)");
tagHandlers["&trade"] = make_pair(&PyDocConverter::handleHtmlEntity, " TM"); tagHandlers["&trade"] = make_pair(&PyDocConverter::handleHtmlEntity, " TM");
tagHandlers["&reg" ] = make_pair(&PyDocConverter::handleHtmlEntity, "(R)"); tagHandlers["&reg"] = make_pair(&PyDocConverter::handleHtmlEntity, "(R)");
tagHandlers["&lt" ] = make_pair(&PyDocConverter::handleHtmlEntity, "<"); tagHandlers["&lt"] = make_pair(&PyDocConverter::handleHtmlEntity, "<");
tagHandlers["&gt" ] = make_pair(&PyDocConverter::handleHtmlEntity, ">"); tagHandlers["&gt"] = make_pair(&PyDocConverter::handleHtmlEntity, ">");
tagHandlers["&amp" ] = make_pair(&PyDocConverter::handleHtmlEntity, "&"); tagHandlers["&amp"] = make_pair(&PyDocConverter::handleHtmlEntity, "&");
tagHandlers["&apos" ] = make_pair(&PyDocConverter::handleHtmlEntity, "'"); tagHandlers["&apos"] = make_pair(&PyDocConverter::handleHtmlEntity, "'");
tagHandlers["&quot" ] = make_pair(&PyDocConverter::handleHtmlEntity, "\""); tagHandlers["&quot"] = make_pair(&PyDocConverter::handleHtmlEntity, "\"");
tagHandlers["&lsquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "`"); tagHandlers["&lsquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "`");
tagHandlers["&rsquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "'"); tagHandlers["&rsquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "'");
tagHandlers["&ldquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "\""); tagHandlers["&ldquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "\"");
tagHandlers["&rdquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "\""); tagHandlers["&rdquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "\"");
tagHandlers["&ndash"] = make_pair(&PyDocConverter::handleHtmlEntity, "-"); tagHandlers["&ndash"] = make_pair(&PyDocConverter::handleHtmlEntity, "-");
tagHandlers["&mdash"] = make_pair(&PyDocConverter::handleHtmlEntity, "--"); tagHandlers["&mdash"] = make_pair(&PyDocConverter::handleHtmlEntity, "--");
tagHandlers["&nbsp" ] = make_pair(&PyDocConverter::handleHtmlEntity, " "); tagHandlers["&nbsp"] = make_pair(&PyDocConverter::handleHtmlEntity, " ");
tagHandlers["&times"] = make_pair(&PyDocConverter::handleHtmlEntity, "x"); tagHandlers["&times"] = make_pair(&PyDocConverter::handleHtmlEntity, "x");
tagHandlers["&minus"] = make_pair(&PyDocConverter::handleHtmlEntity, "-"); tagHandlers["&minus"] = make_pair(&PyDocConverter::handleHtmlEntity, "-");
tagHandlers["&sdot" ] = make_pair(&PyDocConverter::handleHtmlEntity, "."); tagHandlers["&sdot"] = make_pair(&PyDocConverter::handleHtmlEntity, ".");
tagHandlers["&sim" ] = make_pair(&PyDocConverter::handleHtmlEntity, "~"); tagHandlers["&sim"] = make_pair(&PyDocConverter::handleHtmlEntity, "~");
tagHandlers["&le" ] = make_pair(&PyDocConverter::handleHtmlEntity, "<="); tagHandlers["&le"] = make_pair(&PyDocConverter::handleHtmlEntity, "<=");
tagHandlers["&ge" ] = make_pair(&PyDocConverter::handleHtmlEntity, ">="); tagHandlers["&ge"] = make_pair(&PyDocConverter::handleHtmlEntity, ">=");
tagHandlers["&larr" ] = make_pair(&PyDocConverter::handleHtmlEntity, "<--"); tagHandlers["&larr"] = make_pair(&PyDocConverter::handleHtmlEntity, "<--");
tagHandlers["&rarr" ] = make_pair(&PyDocConverter::handleHtmlEntity, "-->"); tagHandlers["&rarr"] = make_pair(&PyDocConverter::handleHtmlEntity, "-->");
} }
PyDocConverter::PyDocConverter(bool debugTranslator, bool debugParser) PyDocConverter::PyDocConverter(bool debugTranslator, bool debugParser) :
: DoxygenTranslator(debugTranslator, debugParser), DoxygenTranslator(debugTranslator, debugParser), m_tableLineLen(0), m_prevRowIsTH(
m_tableLineLen(0), false)
m_prevRowIsTH(false)
{ {
fillStaticTables(); fillStaticTables();
} }
std::string PyDocConverter::getParamType(std::string param) { std::string PyDocConverter::getParamType(std::string param)
{
ParmList *plist = CopyParmList(Getattr(currentNode, "parms")); ParmList *plist = CopyParmList(Getattr(currentNode, "parms"));
Parm *p = NULL; Parm *p = NULL;
for (p = plist; p;) { for (p = plist; p;) {
if (Char(Getattr(p, "name")) == param) { if (Char (Getattr(p, "name")) == param) {
std::string type = Char(SwigType_str(Getattr(p, "type"), "")); std::string type = Char (SwigType_str(Getattr(p, "type"), ""));
return type; return type;
} }
/* /*
@ -244,17 +253,21 @@ std::string PyDocConverter::getParamType(std::string param) {
return ""; return "";
} }
std::string PyDocConverter::justifyString(std::string documentString, int indent, int maxWidth) { std::string PyDocConverter::justifyString(std::string documentString,
int indent, int maxWidth)
{
std::string formattedString; std::string formattedString;
std::string currentLine; std::string currentLine;
for (std::string::iterator stringPosition = documentString.begin(); stringPosition != documentString.end(); ++stringPosition) { for (std::string::iterator stringPosition = documentString.begin();
stringPosition != documentString.end(); ++stringPosition) {
if (currentLine.length() == 0) if (currentLine.length() == 0)
currentLine.resize(indent, ' '); currentLine.resize(indent, ' ');
currentLine += *stringPosition; currentLine += *stringPosition;
if ((iswspace(*stringPosition) && (int) currentLine.size() >= maxWidth) || (stringPosition + 1) == documentString.end()) { if ((iswspace(*stringPosition) && (int) currentLine.size() >= maxWidth)
|| (stringPosition + 1) == documentString.end()) {
formattedString += currentLine + "\n"; formattedString += currentLine + "\n";
currentLine = ""; currentLine = "";
} }
@ -267,14 +280,15 @@ std::string PyDocConverter::justifyString(std::string documentString, int indent
return formattedString; return formattedString;
} }
std::string PyDocConverter::translateSubtree(DoxygenEntity & doxygenEntity) { std::string PyDocConverter::translateSubtree(DoxygenEntity & doxygenEntity)
{
std::string translatedComment; std::string translatedComment;
if (doxygenEntity.isLeaf) if (doxygenEntity.isLeaf)
return translatedComment; return translatedComment;
std::string currentSection; std::string currentSection;
std::list < DoxygenEntity >::iterator p = doxygenEntity.entityList.begin(); std::list<DoxygenEntity>::iterator p = doxygenEntity.entityList.begin();
while (p != doxygenEntity.entityList.end()) { while (p != doxygenEntity.entityList.end()) {
std::map<std::string, std::string>::iterator it; std::map<std::string, std::string>::iterator it;
it = sectionTitles.find(p->typeOfEntity); it = sectionTitles.find(p->typeOfEntity);
@ -292,50 +306,63 @@ std::string PyDocConverter::translateSubtree(DoxygenEntity & doxygenEntity) {
return translatedComment; return translatedComment;
} }
void PyDocConverter::translateEntity(DoxygenEntity & doxyEntity, std::string &translatedComment) { void PyDocConverter::translateEntity(DoxygenEntity & doxyEntity,
std::string &translatedComment)
{
// check if we have needed handler and call it // check if we have needed handler and call it
std::map<std::string, std::pair<tagHandler, std::string > >::iterator it; std::map<std::string, std::pair<tagHandler, std::string> >::iterator it;
it = tagHandlers.find(doxyEntity.typeOfEntity); it = tagHandlers.find(doxyEntity.typeOfEntity);
if (it!=tagHandlers.end()) if (it != tagHandlers.end())
(this->*(it->second.first))(doxyEntity, translatedComment, it->second.second); (this->*(it->second.first))(doxyEntity, translatedComment,
it->second.second);
} }
void PyDocConverter::handleParagraph(DoxygenEntity& tag,
void PyDocConverter::handleParagraph(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) { std::string& translatedComment,
std::string &arg)
{
translatedComment += translateSubtree(tag) + arg; translatedComment += translateSubtree(tag) + arg;
} }
void PyDocConverter::handlePlainString(DoxygenEntity& tag,
void PyDocConverter::handlePlainString(DoxygenEntity& tag, std::string& translatedComment, std::string&) { std::string& translatedComment,
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] != ' ')
translatedComment += ""; translatedComment += "";
} }
void PyDocConverter::handleTagVerbatim(DoxygenEntity& tag, void PyDocConverter::handleTagVerbatim(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) { std::string &arg)
{
translatedComment += arg + " "; translatedComment += arg + " ";
for (DoxygenEntityListCIt it = tag.entityList.begin(); it != tag.entityList.end(); it++) { for (DoxygenEntityListCIt it = tag.entityList.begin();
translatedComment += it->data; it != tag.entityList.end(); it++) {
translatedComment += it->data;
} }
} }
void PyDocConverter::handleTagMessage(DoxygenEntity& tag,
void PyDocConverter::handleTagMessage(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) { std::string& translatedComment,
std::string &arg)
{
std::string dummy; std::string dummy;
translatedComment += arg; translatedComment += arg;
handleParagraph(tag, translatedComment, dummy); handleParagraph(tag, translatedComment, dummy);
} }
void PyDocConverter::handleTagChar(DoxygenEntity& tag,
void PyDocConverter::handleTagChar(DoxygenEntity& tag, std::string& translatedComment, std::string&) { std::string& translatedComment, std::string&)
{
translatedComment += tag.typeOfEntity; translatedComment += tag.typeOfEntity;
} }
void PyDocConverter::handleTagIf(DoxygenEntity& tag,
void PyDocConverter::handleTagIf(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) { std::string& translatedComment,
std::string &arg)
{
std::string dummy; std::string dummy;
translatedComment += arg; translatedComment += arg;
if (tag.entityList.size()) { if (tag.entityList.size()) {
@ -345,8 +372,9 @@ void PyDocConverter::handleTagIf(DoxygenEntity& tag, std::string& translatedComm
} }
} }
void PyDocConverter::handleTagPar(DoxygenEntity& tag,
void PyDocConverter::handleTagPar(DoxygenEntity& tag, std::string& translatedComment, std::string&) { std::string& translatedComment, std::string&)
{
std::string dummy; std::string dummy;
translatedComment += "Title: "; translatedComment += "Title: ";
if (tag.entityList.size()) if (tag.entityList.size())
@ -355,8 +383,10 @@ void PyDocConverter::handleTagPar(DoxygenEntity& tag, std::string& translatedCom
handleParagraph(tag, translatedComment, dummy); handleParagraph(tag, translatedComment, dummy);
} }
void PyDocConverter::handleTagImage(DoxygenEntity& tag,
void PyDocConverter::handleTagImage(DoxygenEntity& tag, std::string& translatedComment, std::string&) { std::string& translatedComment,
std::string&)
{
if (tag.entityList.size() < 2) if (tag.entityList.size() < 2)
return; return;
tag.entityList.pop_front(); tag.entityList.pop_front();
@ -367,10 +397,10 @@ void PyDocConverter::handleTagImage(DoxygenEntity& tag, std::string& translatedC
translatedComment += "(" + tag.entityList.begin()->data + ")"; translatedComment += "(" + tag.entityList.begin()->data + ")";
} }
void PyDocConverter::handleTagParam(DoxygenEntity& tag, void PyDocConverter::handleTagParam(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string&) { std::string&)
{
std::string dummy; std::string dummy;
if (tag.entityList.size() < 2) if (tag.entityList.size() < 2)
return; return;
@ -386,140 +416,152 @@ void PyDocConverter::handleTagParam(DoxygenEntity& tag,
handleParagraph(tag, translatedComment, dummy); handleParagraph(tag, translatedComment, dummy);
} }
void PyDocConverter::handleTagWrap(DoxygenEntity& tag,
void PyDocConverter::handleTagWrap(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) { std::string& translatedComment,
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);
// wrap the thing, ignoring whitespaces // wrap the thing, ignoring whitespaces
size_t wsPos = tagData.find_last_not_of("\n\t "); size_t wsPos = tagData.find_last_not_of("\n\t ");
if (wsPos != std::string::npos && wsPos != tagData.size() - 1) if (wsPos != std::string::npos && wsPos != tagData.size() - 1)
translatedComment += arg + tagData.substr(0, wsPos + 1) + arg + tagData.substr(wsPos + 1); translatedComment += arg + tagData.substr(0, wsPos + 1) + arg
+ tagData.substr(wsPos + 1);
else else
translatedComment += arg + tagData + arg; translatedComment += arg + tagData + arg;
} }
} }
void PyDocConverter::handleDoxyHtmlTag(DoxygenEntity& tag, void PyDocConverter::handleDoxyHtmlTag(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) { std::string &arg)
std::string htmlTagArgs = tag.data; {
if (htmlTagArgs == "/") { std::string htmlTagArgs = tag.data;
// end html tag, for example "</ul> if (htmlTagArgs == "/") {
// translatedComment += "</" + arg.substr(1) + ">"; // end html tag, for example "</ul>
} else { // translatedComment += "</" + arg.substr(1) + ">";
translatedComment += arg + htmlTagArgs; } else {
} translatedComment += arg + htmlTagArgs;
}
} }
void PyDocConverter::handleDoxyHtmlTagNoParam(DoxygenEntity& tag, void PyDocConverter::handleDoxyHtmlTagNoParam(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) { std::string &arg)
std::string htmlTagArgs = tag.data; {
if (htmlTagArgs == "/") { std::string htmlTagArgs = tag.data;
// end html tag, for example "</ul> if (htmlTagArgs == "/") {
} else { // end html tag, for example "</ul>
translatedComment += arg; } else {
} translatedComment += arg;
}
} }
void PyDocConverter::handleDoxyHtmlTag_A(DoxygenEntity& tag, void PyDocConverter::handleDoxyHtmlTag_A(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) { std::string &arg)
std::string htmlTagArgs = tag.data; {
if (htmlTagArgs == "/") { std::string htmlTagArgs = tag.data;
// end html tag, "</a> if (htmlTagArgs == "/") {
translatedComment += " (" + m_url + ')'; // end html tag, "</a>
m_url.clear(); translatedComment += " (" + m_url + ')';
} else { m_url.clear();
m_url.clear(); } else {
size_t pos = htmlTagArgs.find('='); m_url.clear();
if (pos != string::npos) { size_t pos = htmlTagArgs.find('=');
m_url = htmlTagArgs.substr(pos + 1); if (pos != string::npos) {
} m_url = htmlTagArgs.substr(pos + 1);
translatedComment += arg;
} }
translatedComment += arg;
}
} }
void PyDocConverter::handleDoxyHtmlTag2(DoxygenEntity& tag, void PyDocConverter::handleDoxyHtmlTag2(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) { std::string &arg)
std::string htmlTagArgs = tag.data; {
if (htmlTagArgs == "/") { std::string htmlTagArgs = tag.data;
// end html tag, for example "</em> if (htmlTagArgs == "/") {
translatedComment += arg; // end html tag, for example "</em>
} else { translatedComment += arg;
translatedComment += arg; } else {
} translatedComment += arg;
}
} }
void PyDocConverter::handleDoxyHtmlTag_tr(DoxygenEntity& tag, void PyDocConverter::handleDoxyHtmlTag_tr(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &) { std::string &)
std::string htmlTagArgs = tag.data; {
if (htmlTagArgs == "/") { std::string htmlTagArgs = tag.data;
// end tag, </tr> appends vertical table line '|' size_t nlPos = translatedComment.rfind('\n');
translatedComment += '|'; if (htmlTagArgs == "/") {
size_t nlPos = translatedComment.rfind('\n'); // end tag, </tr> appends vertical table line '|'
if (nlPos != string::npos) { translatedComment += '|';
size_t startOfTableLinePos = translatedComment.find_first_not_of(" \t", nlPos); if (nlPos != string::npos) {
if (startOfTableLinePos != string::npos) { size_t startOfTableLinePos = translatedComment.find_first_not_of(" \t",
m_tableLineLen = translatedComment.size() - startOfTableLinePos - 1; nlPos + 1);
} if (startOfTableLinePos != string::npos) {
} m_tableLineLen = translatedComment.size() - startOfTableLinePos;
} else {
if (m_prevRowIsTH) {
// if previous row contained <th> tag, add horizontal separator
translatedComment += string(m_tableLineLen, '-') + '\n';
m_prevRowIsTH = false;
} }
} }
} } else {
if (m_prevRowIsTH) {
// if previous row contained <th> tag, add horizontal separator
// but first get leading spaces, because they'll be needed for the next row
size_t numLeadingSpaces = translatedComment.size() - nlPos - 1;
translatedComment += string(m_tableLineLen, '-') + '\n';
if (nlPos != string::npos) {
translatedComment += string(numLeadingSpaces, ' ');
}
m_prevRowIsTH = false;
}
}
}
void PyDocConverter::handleDoxyHtmlTag_th(DoxygenEntity& tag, void PyDocConverter::handleDoxyHtmlTag_th(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &) { std::string &)
std::string htmlTagArgs = tag.data; {
if (htmlTagArgs == "/") { std::string htmlTagArgs = tag.data;
// end tag, </th> is ignored if (htmlTagArgs == "/") {
} else { // end tag, </th> is ignored
translatedComment += '|'; } else {
m_prevRowIsTH = true; translatedComment += '|';
} m_prevRowIsTH = true;
}
} }
void PyDocConverter::handleDoxyHtmlTag_td(DoxygenEntity& tag, void PyDocConverter::handleDoxyHtmlTag_td(DoxygenEntity& tag,
std::string& translatedComment, std::string& translatedComment,
std::string &) { std::string &)
std::string htmlTagArgs = tag.data; {
if (htmlTagArgs == "/") { std::string htmlTagArgs = tag.data;
// end tag, </td> is ignored if (htmlTagArgs == "/") {
} else { // end tag, </td> is ignored
translatedComment += '|'; } else {
} translatedComment += '|';
}
} }
void PyDocConverter::handleHtmlEntity(DoxygenEntity&, void PyDocConverter::handleHtmlEntity(DoxygenEntity&,
std::string& translatedComment, std::string& translatedComment,
std::string &arg) { std::string &arg)
// html entities {
translatedComment += arg; // html entities
translatedComment += arg;
} }
void PyDocConverter::handleNewLine(DoxygenEntity&,
void PyDocConverter::handleNewLine(DoxygenEntity&, std::string& translatedComment, std::string&) { std::string& translatedComment, std::string&)
{
translatedComment += "\n"; translatedComment += "\n";
} }
String *PyDocConverter::makeDocumentation(Node *n)
String *PyDocConverter::makeDocumentation(Node *n) { {
String *documentation; String *documentation;
std::string pyDocString, result; std::string pyDocString, result;
@ -532,25 +574,26 @@ String *PyDocConverter::makeDocumentation(Node *n) {
while (Getattr(n, "sym:previousSibling")) while (Getattr(n, "sym:previousSibling"))
n = Getattr(n, "sym:previousSibling"); n = Getattr(n, "sym:previousSibling");
std::vector < std::string > allDocumentation; std::vector<std::string> allDocumentation;
// for each real method (not a generated overload) append the documentation // for each real method (not a generated overload) append the documentation
while (n) { while (n) {
documentation = getDoxygenComment(n); documentation = getDoxygenComment(n);
if (!Swig_is_generated_overload(n) && documentation) { if (!Swig_is_generated_overload(n) && documentation) {
currentNode = n; currentNode = n;
if (GetFlag(n, "feature:doxygen:notranslate")) { if (GetFlag(n, "feature:doxygen:notranslate")) {
String *comment = NewString(""); String *comment = NewString("");
Append(comment, documentation); Append(comment, documentation);
Replaceall(comment, "\n *", "\n"); Replaceall(comment, "\n *", "\n");
allDocumentation.push_back(Char(comment)); allDocumentation.push_back(Char (comment));
Delete(comment); Delete(comment);
} } else {
else { std::list<DoxygenEntity> entityList = parser.createTree(
std::list < DoxygenEntity > entityList = parser.createTree(Char(documentation), Char(Getfile(documentation)), Getline(documentation)); Char (documentation), Char (Getfile(documentation)),
DoxygenEntity root("root", entityList); Getline(documentation));
allDocumentation.push_back(translateSubtree(root)); DoxygenEntity root("root", entityList);
} allDocumentation.push_back(translateSubtree(root));
}
} }
n = Getattr(n, "sym:nextSibling"); n = Getattr(n, "sym:nextSibling");
} }
@ -558,9 +601,12 @@ String *PyDocConverter::makeDocumentation(Node *n) {
// construct final documentation string // construct final documentation string
if (allDocumentation.size() > 1) { if (allDocumentation.size() > 1) {
std::ostringstream concatDocString; std::ostringstream concatDocString;
for (int realOverloadCount = 0; realOverloadCount < (int) allDocumentation.size(); realOverloadCount++) { for (int realOverloadCount = 0;
realOverloadCount < (int) allDocumentation.size();
realOverloadCount++) {
concatDocString << generateDivider() << std::endl; concatDocString << generateDivider() << std::endl;
concatDocString << "Overload " << (realOverloadCount + 1) << ":" << std::endl; concatDocString << "Overload " << (realOverloadCount + 1) << ":"
<< std::endl;
concatDocString << generateDivider(); concatDocString << generateDivider();
concatDocString << allDocumentation[realOverloadCount] << std::endl; concatDocString << allDocumentation[realOverloadCount] << std::endl;
} }
@ -577,11 +623,12 @@ String *PyDocConverter::makeDocumentation(Node *n) {
String *comment = NewString(""); String *comment = NewString("");
Append(comment, documentation); Append(comment, documentation);
Replaceall(comment, "\n *", "\n"); Replaceall(comment, "\n *", "\n");
pyDocString = Char(comment); pyDocString = Char (comment);
Delete(comment); Delete(comment);
} } else {
else { std::list<DoxygenEntity> entityList = parser.createTree(
std::list < DoxygenEntity > entityList = parser.createTree(Char(documentation), Char(Getfile(documentation)), Getline(documentation)); Char (documentation), Char (Getfile(documentation)),
Getline(documentation));
DoxygenEntity root("root", entityList); DoxygenEntity root("root", entityList);
pyDocString = translateSubtree(root); pyDocString = translateSubtree(root);
} }
@ -610,7 +657,8 @@ String *PyDocConverter::makeDocumentation(Node *n) {
return NewString(""); return NewString("");
} }
std::string PyDocConverter::generateDivider() { std::string PyDocConverter::generateDivider()
{
static string dividerString(DOC_STRING_LENGTH, '-'); static string dividerString(DOC_STRING_LENGTH, '-');
return dividerString; return dividerString;
} }