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

6 files changed, 641 insertions, 454 deletions

diff --git a/Examples/test-suite/doxygen_translate.i b/Examples/test-suite/doxygen_translate.i
index a41391dc9..3c2930ff1 100644
--- a/Examples/test-suite/doxygen_translate.i
+++ b/Examples/test-suite/doxygen_translate.i
@@ -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;
diff --git a/Examples/test-suite/java/doxygen_translate_runme.java b/Examples/test-suite/java/doxygen_translate_runme.java
index b3db6a816..55e5d23d3 100644
--- a/Examples/test-suite/java/doxygen_translate_runme.java
+++ b/Examples/test-suite/java/doxygen_translate_runme.java
@@ -232,6 +232,21 @@ public class doxygen_translate_runme {
                 "\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)",
                 "All entities are treated as commands &copy; &trade; &reg;\n" +
                 "should work also&lt;in text                              \n" +
diff --git a/Examples/test-suite/python/doxygen_translate_runme.py b/Examples/test-suite/python/doxygen_translate_runme.py
index 9365d1ce6..48d2971a5 100755
--- a/Examples/test-suite/python/doxygen_translate_runme.py
+++ b/Examples/test-suite/python/doxygen_translate_runme.py
@@ -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__,
 r"""
   All entities are treated as commands (C)  TM (R)
diff --git a/Source/DoxygenTranslator/src/DoxygenCommands.h b/Source/DoxygenTranslator/src/DoxygenCommands.h
index 7fa1dbb54..ff2527ace 100644
--- a/Source/DoxygenTranslator/src/DoxygenCommands.h
+++ b/Source/DoxygenTranslator/src/DoxygenCommands.h
@@ -104,26 +104,26 @@ const int commandHtmlSize = sizeof(commandHtml) / sizeof(*commandHtml);
 // Only entities which are translatable to plain text are used here. Others
 // are copied unchanged to output.
 const char *commandHtmlEntities[] = { "&copy", "&trade", "&reg", // (C), (TM), (R)
-"&lt",  // less-than symbol
-"&gt",  // greater-than symbol
-"&amp", // ampersand
-"&apos", // single quotation mark (straight)
-"&quot", // double quotation mark (straight)
-"&lsquo", // left single quotation mark
-"&rsquo", // right single quotation mark
-"&ldquo", // left double quotation mark
-"&rdquo", // right double quotation mark
-"&ndash", // n-dash (for numeric ranges, e.g. 2–8)
-"&mdash", // --
-"&nbsp", //
-"&times", // x
-"&minus", // -
-"&sdot", // .
-"&sim", // ~
-"&le", // <=
-"&ge", // >=
-"&larr", // <--
-"&rarr" // -->
+  "&lt",  // less-than symbol
+  "&gt",  // greater-than symbol
+  "&amp", // ampersand
+  "&apos", // single quotation mark (straight)
+  "&quot", // double quotation mark (straight)
+  "&lsquo", // left single quotation mark
+  "&rsquo", // right single quotation mark
+  "&ldquo", // left double quotation mark
+  "&rdquo", // right double quotation mark
+  "&ndash", // n-dash (for numeric ranges, e.g. 2–8)
+  "&mdash", // --
+  "&nbsp", //
+  "&times", // x
+  "&minus", // -
+  "&sdot", // .
+  "&sim", // ~
+  "&le", // <=
+  "&ge", // >=
+  "&larr", // <--
+  "&rarr" // -->
 };
 
 const int commandHtmlEntitiesSize = sizeof(commandHtmlEntities) / sizeof(*commandHtmlEntities);
diff --git a/Source/DoxygenTranslator/src/JavaDocConverter.cpp b/Source/DoxygenTranslator/src/JavaDocConverter.cpp
index 22a3ccc96..f14fefafd 100644
--- a/Source/DoxygenTranslator/src/JavaDocConverter.cpp
+++ b/Source/DoxygenTranslator/src/JavaDocConverter.cpp
@@ -20,13 +20,14 @@
 //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
-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::list;
 using std::vector;
 
-void JavaDocConverter::fillStaticTables() {
+void JavaDocConverter::fillStaticTables()
+{
   if (tagHandlers.size()) // fill only once
     return;
 
@@ -62,7 +63,6 @@ void JavaDocConverter::fillStaticTables() {
    *   Commenting methods of std types is simple - add comment to std_*.i file.
    */
 
-
   // these commands insert HTML tags
   tagHandlers["a"] = make_pair(&JavaDocConverter::handleTagHtml, "i");
   tagHandlers["arg"] = make_pair(&JavaDocConverter::handleTagHtml, "li");
@@ -98,13 +98,15 @@ void JavaDocConverter::fillStaticTables() {
   tagHandlers["invariant"] = make_pair(&JavaDocConverter::handleParagraph, "");
   tagHandlers["latexonly"] = 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["short"] = make_pair(&JavaDocConverter::handleParagraph, "");
   tagHandlers["xmlonly"] = make_pair(&JavaDocConverter::handleParagraph, "");
   // these commands are kept as-is, they are supported by JavaDoc
   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["exception"] = make_pair(&JavaDocConverter::handleTagSame, "");
   tagHandlers["package"] = make_pair(&JavaDocConverter::handleTagSame, "");
@@ -112,7 +114,8 @@ void JavaDocConverter::fillStaticTables() {
   tagHandlers["tparam"] = make_pair(&JavaDocConverter::handleTagParam, "");
   tagHandlers["result"] = make_pair(&JavaDocConverter::handleTagSame, "return");
   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["sa"] = make_pair(&JavaDocConverter::handleTagSame, "see");
   tagHandlers["since"] = make_pair(&JavaDocConverter::handleTagSame, "");
@@ -121,118 +124,160 @@ void JavaDocConverter::fillStaticTables() {
   tagHandlers["version"] = make_pair(&JavaDocConverter::handleTagSame, "");
   // these commands have special handlers
   tagHandlers["code"] = make_pair(&JavaDocConverter::handleTagExtended, "code");
-  tagHandlers["cond"] = make_pair(&JavaDocConverter::handleTagMessage, "Conditional comment: ");
-  tagHandlers["copyright"] = make_pair(&JavaDocConverter::handleTagMessage, "Copyright: ");
+  tagHandlers["cond"] = make_pair(&JavaDocConverter::handleTagMessage,
+      "Conditional comment: ");
+  tagHandlers["copyright"] = make_pair(&JavaDocConverter::handleTagMessage,
+      "Copyright: ");
   tagHandlers["else"] = make_pair(&JavaDocConverter::handleTagIf, "Else: ");
-  tagHandlers["elseif"] = make_pair(&JavaDocConverter::handleTagIf, "Else if: ");
-  tagHandlers["endcond"] = make_pair(&JavaDocConverter::handleTagMessage, "End of conditional comment.");
+  tagHandlers["elseif"] = make_pair(&JavaDocConverter::handleTagIf,
+      "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
   // 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["ifnot"] = make_pair(&JavaDocConverter::handleTagIf, "If not: ");
   tagHandlers["image"] = make_pair(&JavaDocConverter::handleTagImage, "");
   tagHandlers["link"] = make_pair(&JavaDocConverter::handleTagLink, "");
   tagHandlers["see"] = make_pair(&JavaDocConverter::handleTagSee, "");
   tagHandlers["sa"] = make_pair(&JavaDocConverter::handleTagSee, "");
-  tagHandlers["note"] = make_pair(&JavaDocConverter::handleTagMessage, "Note: ");
-  tagHandlers["overload"] = make_pair(&JavaDocConverter::handleTagMessage, "This is an overloaded member function, provided for"
-      " convenience. It differs from the above function only in what"
-      " argument(s) it accepts.");
+  tagHandlers["note"] = make_pair(&JavaDocConverter::handleTagMessage,
+      "Note: ");
+  tagHandlers["overload"] = make_pair(&JavaDocConverter::handleTagMessage,
+      "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["remark"] = make_pair(&JavaDocConverter::handleTagMessage, "Remarks: ");
-  tagHandlers["remarks"] = make_pair(&JavaDocConverter::handleTagMessage, "Remarks: ");
-  tagHandlers["todo"] = make_pair(&JavaDocConverter::handleTagMessage, "TODO: ");
-  tagHandlers["verbatim"] = make_pair(&JavaDocConverter::handleTagExtended, "literal");
+  tagHandlers["remark"] = make_pair(&JavaDocConverter::handleTagMessage,
+      "Remarks: ");
+  tagHandlers["remarks"] = make_pair(&JavaDocConverter::handleTagMessage,
+      "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.
   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
   // (it is internal command of swig's parser, contains plain text)
-  tagHandlers["plainstd::string"] = make_pair(&JavaDocConverter::handlePlainString, "");
-  tagHandlers["plainstd::endl"] = make_pair(&JavaDocConverter::handleNewLine, "");
+  tagHandlers["plainstd::string"] = make_pair(
+      &JavaDocConverter::handlePlainString, "");
+  tagHandlers["plainstd::endl"] = make_pair(&JavaDocConverter::handleNewLine,
+      "");
   tagHandlers["n"] = make_pair(&JavaDocConverter::handleNewLine, "");
 
   // HTML tags
-  tagHandlers["<a"      ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<a"      );
-  tagHandlers["<b"      ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<b"      );
-  tagHandlers["<blockquote"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<blockquote");
-  tagHandlers["<body"   ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<body"   );
-  tagHandlers["<br"     ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<br"     );
-  tagHandlers["<center" ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<center" );
-  tagHandlers["<caption"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<caption");
-  tagHandlers["<code"   ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<code"   );
-  tagHandlers["<dd"     ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dd"     );
-  tagHandlers["<dfn"    ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dfn"    );
-  tagHandlers["<div"    ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<div"    );
-  tagHandlers["<dl"     ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dl"     );
-  tagHandlers["<dt"     ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dt"     );
-  tagHandlers["<em"     ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<em"     );
-  tagHandlers["<form"   ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<form"   );
-  tagHandlers["<hr"     ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<hr"     );
-  tagHandlers["<h1"     ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<h1"     );
-  tagHandlers["<h2"     ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<h2"     );
-  tagHandlers["<h3"     ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<h3"     );
-  tagHandlers["<i"      ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<i"      );
-  tagHandlers["<input"  ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<input"  );
-  tagHandlers["<img"    ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<img"    );
-  tagHandlers["<li"     ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<li"     );
-  tagHandlers["<meta"   ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<meta"   );
-  tagHandlers["<multicol"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<multicol");
-  tagHandlers["<ol"     ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<ol"     );
-  tagHandlers["<p"      ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<p"      );
-  tagHandlers["<pre"    ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<pre"    );
-  tagHandlers["<small"  ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<small"  );
-  tagHandlers["<span"   ] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<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"    );
+  tagHandlers["<a"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<a");
+  tagHandlers["<b"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<b");
+  tagHandlers["<blockquote"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
+      "<blockquote");
+  tagHandlers["<body"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
+      "<body");
+  tagHandlers["<br"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<br");
+  tagHandlers["<center"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
+      "<center");
+  tagHandlers["<caption"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
+      "<caption");
+  tagHandlers["<code"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
+      "<code");
+  tagHandlers["<dd"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dd");
+  tagHandlers["<dfn"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dfn");
+  tagHandlers["<div"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<div");
+  tagHandlers["<dl"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dl");
+  tagHandlers["<dt"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<dt");
+  tagHandlers["<em"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<em");
+  tagHandlers["<form"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
+      "<form");
+  tagHandlers["<hr"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<hr");
+  tagHandlers["<h1"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<h1");
+  tagHandlers["<h2"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<h2");
+  tagHandlers["<h3"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<h3");
+  tagHandlers["<i"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<i");
+  tagHandlers["<input"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
+      "<input");
+  tagHandlers["<img"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<img");
+  tagHandlers["<li"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<li");
+  tagHandlers["<meta"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
+      "<meta");
+  tagHandlers["<multicol"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
+      "<multicol");
+  tagHandlers["<ol"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<ol");
+  tagHandlers["<p"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<p");
+  tagHandlers["<pre"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag, "<pre");
+  tagHandlers["<small"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
+      "<small");
+  tagHandlers["<span"] = make_pair(&JavaDocConverter::handleDoxyHtmlTag,
+      "<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
-  tagHandlers["&copy" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&copy");
-  tagHandlers["&trade"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&trade");
-  tagHandlers["&reg"  ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&reg");
-  tagHandlers["&lt"   ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&lt");
-  tagHandlers["&gt"   ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&gt");
-  tagHandlers["&amp"  ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&amp");
-  tagHandlers["&apos" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&apos");
-  tagHandlers["&quot" ] = make_pair(&JavaDocConverter::handleHtmlEntity, "&quot");
-  tagHandlers["&lsquo"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&lsquo");
-  tagHandlers["&rsquo"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&rsquo");
-  tagHandlers["&ldquo"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&ldquo");
-  tagHandlers["&rdquo"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&rdquo");
-  tagHandlers["&ndash"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&ndash");
-  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");
+  tagHandlers["&copy"] = make_pair(&JavaDocConverter::handleHtmlEntity,
+      "&copy");
+  tagHandlers["&trade"] = make_pair(&JavaDocConverter::handleHtmlEntity,
+      "&trade");
+  tagHandlers["&reg"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&reg");
+  tagHandlers["&lt"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&lt");
+  tagHandlers["&gt"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&gt");
+  tagHandlers["&amp"] = make_pair(&JavaDocConverter::handleHtmlEntity, "&amp");
+  tagHandlers["&apos"] = make_pair(&JavaDocConverter::handleHtmlEntity,
+      "&apos");
+  tagHandlers["&quot"] = make_pair(&JavaDocConverter::handleHtmlEntity,
+      "&quot");
+  tagHandlers["&lsquo"] = make_pair(&JavaDocConverter::handleHtmlEntity,
+      "&lsquo");
+  tagHandlers["&rsquo"] = make_pair(&JavaDocConverter::handleHtmlEntity,
+      "&rsquo");
+  tagHandlers["&ldquo"] = make_pair(&JavaDocConverter::handleHtmlEntity,
+      "&ldquo");
+  tagHandlers["&rdquo"] = make_pair(&JavaDocConverter::handleHtmlEntity,
+      "&rdquo");
+  tagHandlers["&ndash"] = make_pair(&JavaDocConverter::handleHtmlEntity,
+      "&ndash");
+  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)
-: DoxygenTranslator(debugTranslator, debugParser) {
+JavaDocConverter::JavaDocConverter(bool debugTranslator, bool debugParser) :
+    DoxygenTranslator(debugTranslator, debugParser)
+{
   fillStaticTables();
 }
 
-
 /**
  * Formats comment lines by inserting '\n *' at to long lines and tabs for
  * indent. Currently it is disabled, which means original comment format is
@@ -242,7 +287,8 @@ JavaDocConverter::JavaDocConverter(bool debugTranslator, bool debugParser)
  * better algorithm.
  */
 std::string JavaDocConverter::formatCommand(std::string unformattedLine,
-                                                int indent) {
+                                            int indent)
+{
   std::string formattedLines;
   return unformattedLine;  // currently disabled
   int lastPosition = 0;
@@ -262,10 +308,12 @@ std::string JavaDocConverter::formatCommand(std::string unformattedLine,
       if (!isFirstLine)
         for (int j = 0; j < indent; j++) {
           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 *");
 
     }
@@ -276,13 +324,14 @@ std::string JavaDocConverter::formatCommand(std::string unformattedLine,
         formattedLines.append("\t");
       }
     }
-    formattedLines.append(unformattedLine.substr(lastPosition, unformattedLine.length() - lastPosition));
+    formattedLines.append(
+        unformattedLine.substr(lastPosition,
+            unformattedLine.length() - lastPosition));
   }
 
   return formattedLines;
 }
 
-
 /**
  * Returns true, if the given parameter exists in the current node
  * (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
  * function params list.
  */
-bool JavaDocConverter::paramExists(std::string param) {
+bool JavaDocConverter::paramExists(std::string param)
+{
 
   if (GetFlag(currentNode, "feature:doxygen:nostripparams")) {
     return true;
@@ -300,7 +350,7 @@ bool JavaDocConverter::paramExists(std::string param) {
 
   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;
     }
     /* doesn't seem to work always: in some cases (especially for 'self' parameters)
@@ -315,80 +365,92 @@ bool JavaDocConverter::paramExists(std::string param) {
   return false;
 }
 
-
-std::string JavaDocConverter::translateSubtree(DoxygenEntity &doxygenEntity) {
+std::string JavaDocConverter::translateSubtree(DoxygenEntity &doxygenEntity)
+{
   std::string translatedComment;
-  
+
   if (doxygenEntity.isLeaf) {
     return translatedComment;
   }
-  
+
   for (DoxygenEntityListIt p = doxygenEntity.entityList.begin();
-       p != doxygenEntity.entityList.end(); p++) {
+      p != doxygenEntity.entityList.end(); p++) {
 
     translateEntity(*p, translatedComment);
     translateSubtree(*p);
   }
-  
+
   return translatedComment;
 }
 
-
 /**
  * Checks if a handler for the given tag exists, and calls it.
  */
 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);
 
   if (it != tagHandlers.end()) {
     (this->*(it->second.first))(tag, translatedComment, it->second.second);
   } else {
-      // do NOT print warning, since there are many tags, which are not
-      // translatable - many warnings hide important ones
-      // addError(WARN_DOXYGEN_COMMAND_ERROR, "Unknown doxygen or HTML tag: " + tag.typeOfEntity);
+    // do NOT print warning, since there are many tags, which are not
+    // translatable - many warnings hide important ones
+    // addError(WARN_DOXYGEN_COMMAND_ERROR, "Unknown doxygen or HTML tag: " + tag.typeOfEntity);
   }
 }
 
-
-void JavaDocConverter::handleTagHtml(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) {
+void JavaDocConverter::handleTagHtml(DoxygenEntity& tag,
+                                     std::string& translatedComment,
+                                     std::string &arg)
+{
   if (tag.entityList.size()) { // do not include empty tags
     std::string tagData = translateSubtree(tag);
     // wrap the thing, ignoring whitespaces
     size_t wsPos = tagData.find_last_not_of("\n\t ");
     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
-      translatedComment += "<" + arg + ">" + translateSubtree(tag) + "</" + arg + "> ";
+      translatedComment += "<" + arg + ">" + translateSubtree(tag) + "</" + arg
+          + "> ";
   }
 }
 
-
-void JavaDocConverter::handleDoxyHtmlTag(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) {
-    std::string htmlTagArgs = tag.data;
-    if (htmlTagArgs == "/") {
-        // end html tag, for example "</ul>
-        translatedComment += "</" + arg.substr(1) + ">";
-    } else {
-        translatedComment += arg + htmlTagArgs + ">";
-    }
+void JavaDocConverter::handleDoxyHtmlTag(DoxygenEntity& tag,
+                                         std::string& translatedComment,
+                                         std::string &arg)
+{
+  std::string htmlTagArgs = tag.data;
+  if (htmlTagArgs == "/") {
+    // end html tag, for example "</ul>
+    translatedComment += "</" + arg.substr(1) + ">";
+  } else {
+    translatedComment += arg + htmlTagArgs + ">";
+  }
 }
 
-
-void JavaDocConverter::handleHtmlEntity(DoxygenEntity&, std::string& translatedComment, std::string &arg) {
-    // html entities can be preserved for Java
-    translatedComment += arg + ';';
+void JavaDocConverter::handleHtmlEntity(DoxygenEntity&,
+                                        std::string& translatedComment,
+                                        std::string &arg)
+{
+  // html entities can be preserved for Java
+  translatedComment += arg + ';';
 }
 
-
-void JavaDocConverter::handleNewLine(DoxygenEntity&, std::string& translatedComment, std::string&) {
+void JavaDocConverter::handleNewLine(DoxygenEntity&,
+                                     std::string& translatedComment,
+                                     std::string&)
+{
   translatedComment += "\n * ";
 }
 
-
-void JavaDocConverter::handleTagChar(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) {
+void JavaDocConverter::handleTagChar(DoxygenEntity& tag,
+                                     std::string& translatedComment,
+                                     std::string &arg)
+{
   // escape it if we need to, else just print
   if (arg.size())
     translatedComment += arg;
@@ -397,42 +459,57 @@ void JavaDocConverter::handleTagChar(DoxygenEntity& tag, std::string& translated
 }
 
 // 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())
     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, std::string& translatedComment, std::string&) {
+void JavaDocConverter::handleParagraph(DoxygenEntity& tag,
+                                       std::string& translatedComment,
+                                       std::string&)
+{
   translatedComment += formatCommand(translateSubtree(tag), 0);
 }
 
-
-void JavaDocConverter::handlePlainString(DoxygenEntity& tag, std::string& translatedComment, std::string&) {
+void JavaDocConverter::handlePlainString(DoxygenEntity& tag,
+                                         std::string& translatedComment,
+                                         std::string&)
+{
   translatedComment += tag.data;
- // if (tag.data.size() && tag.data[tag.data.size()-1] != ' ')
- // 	translatedComment += " ";
+  // if (tag.data.size() && tag.data[tag.data.size()-1] != ' ')
+  // 	translatedComment += " ";
 }
 
-
-void JavaDocConverter::handleTagVerbatim(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) {
+void JavaDocConverter::handleTagVerbatim(DoxygenEntity& tag,
+                                         std::string& translatedComment,
+                                         std::string &arg)
+{
   translatedComment += arg + " ";
-  for (DoxygenEntityListCIt it = tag.entityList.begin(); it != tag.entityList.end(); it++) {
-      translatedComment += it->data;
+  for (DoxygenEntityListCIt it = tag.entityList.begin();
+      it != tag.entityList.end(); it++) {
+    translatedComment += it->data;
   }
 }
 
-
-void JavaDocConverter::handleTagExtended(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) {
+void JavaDocConverter::handleTagExtended(DoxygenEntity& tag,
+                                         std::string& translatedComment,
+                                         std::string &arg)
+{
   std::string dummy;
   translatedComment += "{@" + arg + " ";
   handleParagraph(tag, translatedComment, dummy);
   translatedComment += "}";
 }
 
-
-void JavaDocConverter::handleTagIf(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) {
+void JavaDocConverter::handleTagIf(DoxygenEntity& tag,
+                                   std::string& translatedComment,
+                                   std::string &arg)
+{
   std::string dummy;
   translatedComment += arg;
   if (tag.entityList.size()) {
@@ -442,22 +519,26 @@ void JavaDocConverter::handleTagIf(DoxygenEntity& tag, std::string& translatedCo
   }
 }
 
-
-void JavaDocConverter::handleTagMessage(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) {
+void JavaDocConverter::handleTagMessage(DoxygenEntity& tag,
+                                        std::string& translatedComment,
+                                        std::string &arg)
+{
   std::string dummy;
   translatedComment += formatCommand(arg, 0);
   handleParagraph(tag, translatedComment, dummy);
 }
 
-
-void JavaDocConverter::handleTagImage(DoxygenEntity& tag, std::string& translatedComment, std::string&) {
+void JavaDocConverter::handleTagImage(DoxygenEntity& tag,
+                                      std::string& translatedComment,
+                                      std::string&)
+{
   if (tag.entityList.size() < 2)
     return;
 
   std::string file;
   std::string title;
 
-  std::list <DoxygenEntity>::iterator it = tag.entityList.begin();
+  std::list<DoxygenEntity>::iterator it = tag.entityList.begin();
   if (it->data != "html")
     return;
 
@@ -477,8 +558,10 @@ void JavaDocConverter::handleTagImage(DoxygenEntity& tag, std::string& translate
   translatedComment += "/>";
 }
 
-
-void JavaDocConverter::handleTagPar(DoxygenEntity& tag, std::string& translatedComment, std::string&) {
+void JavaDocConverter::handleTagPar(DoxygenEntity& tag,
+                                    std::string& translatedComment,
+                                    std::string&)
+{
   std::string dummy;
   translatedComment += "<p";
   if (tag.entityList.size()) {
@@ -490,10 +573,10 @@ void JavaDocConverter::handleTagPar(DoxygenEntity& tag, std::string& translatedC
   translatedComment += "</p>";
 }
 
-
 void JavaDocConverter::handleTagParam(DoxygenEntity& tag,
                                       std::string& translatedComment,
-                                      std::string&) {
+                                      std::string&)
+{
   std::string dummy;
 
   if (!tag.entityList.size())
@@ -507,17 +590,19 @@ void JavaDocConverter::handleTagParam(DoxygenEntity& tag,
   handleParagraph(tag, translatedComment, dummy);
 }
 
-
-string JavaDocConverter::convertLink(string linkObject) {
+string JavaDocConverter::convertLink(string linkObject)
+{
   if (GetFlag(currentNode, "feature:doxygen:nolinktranslate"))
     return linkObject;
   // find the params in function in linkObject (if any)
   size_t lbracePos = 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 "";
 
-  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
   linkObject = linkObject.substr(0, lbracePos);
 
@@ -539,7 +624,7 @@ string JavaDocConverter::convertLink(string 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
     // i e 'int **arr[100][10]' -> 'a(100).a(10).p.p.int'
     // also converting arrays to pointers
@@ -551,18 +636,17 @@ string JavaDocConverter::convertLink(string linkObject) {
       SwigType_add_qualifier(swigType, "const");
 
     // 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
       if (paramStr[j] == ']') {
-        while (j>=0 && paramStr[j] != '[')
+        while (j >= 0 && paramStr[j] != '[')
           j--;
         // no closing brace
         if (j < 0)
           return "";
         SwigType_add_pointer(swigType);
         continue;
-      }
-      else if (paramStr[j] == '*')
+      } else if (paramStr[j] == '*')
         SwigType_add_pointer(swigType);
       else if (paramStr[j] == '&')
         SwigType_add_reference(swigType);
@@ -572,7 +656,8 @@ string JavaDocConverter::convertLink(string linkObject) {
           typeNameStart = 0;
         else
           typeNameStart++;
-        Append(swigType, paramStr.substr(typeNameStart, j - typeNameStart + 1).c_str());
+        Append(swigType,
+            paramStr.substr(typeNameStart, j - typeNameStart + 1).c_str());
         break;
       }
     }
@@ -580,10 +665,11 @@ string JavaDocConverter::convertLink(string linkObject) {
     // make dummy param list, to lookup typemaps for it
     Parm *dummyParam = NewParm(swigType, "", 0);
     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);
-    linkObject += Char(Getattr(dummyParam, "tmap:jstype"));
+    linkObject += Char (Getattr(dummyParam, "tmap:jstype"));
     if (i != params.size() - 1)
       linkObject += ",";
 
@@ -595,8 +681,10 @@ string JavaDocConverter::convertLink(string linkObject) {
   return linkObject;
 }
 
-
-void JavaDocConverter::handleTagLink(DoxygenEntity& tag, std::string& translatedComment, std::string&) {
+void JavaDocConverter::handleTagLink(DoxygenEntity& tag,
+                                     std::string& translatedComment,
+                                     std::string&)
+{
   std::string dummy;
   if (!tag.entityList.size())
     return;
@@ -612,8 +700,10 @@ void JavaDocConverter::handleTagLink(DoxygenEntity& tag, std::string& translated
   translatedComment += "}";
 }
 
-
-void JavaDocConverter::handleTagSee(DoxygenEntity& tag, std::string& translatedComment, std::string&) {
+void JavaDocConverter::handleTagSee(DoxygenEntity& tag,
+                                    std::string& translatedComment,
+                                    std::string&)
+{
   std::string dummy;
   if (!tag.entityList.size())
     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.
   list<DoxygenEntity>::iterator it;
   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") {
       // handleNewLine(*it, translatedComment, dummy);
       continue;
@@ -632,13 +722,13 @@ void JavaDocConverter::handleTagSee(DoxygenEntity& tag, std::string& translatedC
 
     // restore entities which may be used in C++ type declaration
     if (it->typeOfEntity == "&amp") {
-        methodRef += '&';
+      methodRef += '&';
     } else if (it->typeOfEntity == "&lt") {
-        methodRef += '<';
+      methodRef += '<';
     } else if (it->typeOfEntity == "&gt") {
-        methodRef += '>';
+      methodRef += '>';
     } 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 dblColon = methodRef.find("::");
   if (dblColon < lbrace) {
-      methodRef = methodRef.substr(0, dblColon) + '#' + methodRef.substr(dblColon + 2);
+    methodRef = methodRef.substr(0, dblColon) + '#'
+        + methodRef.substr(dblColon + 2);
   }
 
   translatedComment += "@see ";
@@ -657,22 +748,21 @@ void JavaDocConverter::handleTagSee(DoxygenEntity& tag, std::string& translatedC
   translatedComment += linkObject;
 }
 
-
 /* This function moves all endlines at the end of child entities
  * out of the child entities to the parent.
  * For example, entity tree:
 
-   -root
-    |-param
-      |-paramText
-      |-endline
+ -root
+ |-param
+ |-paramText
+ |-endline
 
-   should be turned to
+ should be turned to
 
-   -root
-    |-param
-      |-paramText
-    |-endline
+ -root
+ |-param
+ |-paramText
+ |-endline
  *
  */
 int JavaDocConverter::shiftEndlinesUpTree(DoxygenEntity &root, int level)
@@ -694,21 +784,22 @@ int JavaDocConverter::shiftEndlinesUpTree(DoxygenEntity &root, int level)
   }
 
   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();
     removedCount++;
   }
   return removedCount;
 }
 
-
 /**
  * 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
  * to indentation of the first line. Indentation of non-empty lines is not
  * 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 indent = 0;
@@ -743,17 +834,17 @@ std::string JavaDocConverter::indentAndInsertAsterisks(const string &doc) {
   while (idx != string::npos) {
 
     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?
       if (translatedStr[nonspaceIdx] != '\n') {
         // add '* ' to each line without it
-        translatedStr = translatedStr.substr(0, nonspaceIdx) + "* " +
-                translatedStr.substr(nonspaceIdx);
+        translatedStr = translatedStr.substr(0, nonspaceIdx) + "* "
+            + translatedStr.substr(nonspaceIdx);
         //printf(translatedStr.c_str());
       } else {
         // we found empty line, replace it with indented '*'
-        translatedStr = translatedStr.substr(0, idx + 1) + indentStr +
-                "* " + translatedStr.substr(nonspaceIdx);
+        translatedStr = translatedStr.substr(0, idx + 1) + indentStr + "* "
+            + translatedStr.substr(nonspaceIdx);
       }
     }
     idx = translatedStr.find('\n', nonspaceIdx);
@@ -774,8 +865,8 @@ std::string JavaDocConverter::indentAndInsertAsterisks(const string &doc) {
   return translatedStr;
 }
 
-
-String *JavaDocConverter::makeDocumentation(Node *node) {
+String *JavaDocConverter::makeDocumentation(Node *node)
+{
 
   String *documentation = getDoxygenComment(node);
 
@@ -785,7 +876,7 @@ String *JavaDocConverter::makeDocumentation(Node *node) {
 
   if (GetFlag(node, "feature:doxygen:notranslate")) {
 
-    string doc = Char(documentation);
+    string doc = Char (documentation);
 
     string translatedStr = indentAndInsertAsterisks(doc);
 
@@ -794,9 +885,8 @@ String *JavaDocConverter::makeDocumentation(Node *node) {
     return comment;
   }
 
-  DoxygenEntityList entityList = parser.createTree(Char(documentation),
-                                                   Char(Getfile(documentation)),
-                                                   Getline(documentation));
+  DoxygenEntityList entityList = parser.createTree(Char (documentation),
+      Char (Getfile(documentation)), Getline(documentation));
 
   // entityList.sort(CompareDoxygenEntities()); sorting currently not used,
 
@@ -816,14 +906,14 @@ String *JavaDocConverter::makeDocumentation(Node *node) {
   shiftEndlinesUpTree(root);
 
   // strip endlines at the beginning
-  while (!root.entityList.empty()  &&
-          root.entityList.begin()->typeOfEntity == "plainstd::endl") {
+  while (!root.entityList.empty()
+      && root.entityList.begin()->typeOfEntity == "plainstd::endl") {
     root.entityList.pop_front();
   }
 
   // and at the end
-  while (!root.entityList.empty()  &&
-          root.entityList.rbegin()->typeOfEntity == "plainstd::endl") {
+  while (!root.entityList.empty()
+      && root.entityList.rbegin()->typeOfEntity == "plainstd::endl") {
     root.entityList.pop_back();
   }
 
@@ -835,13 +925,12 @@ String *JavaDocConverter::makeDocumentation(Node *node) {
     std::cout << "\n---RESULT IN JAVADOC---" << std::endl;
     std::cout << javaDocString;
   }
-  
+
   return NewString(javaDocString.c_str());
 }
 
-
-void JavaDocConverter::addError(int warningType,
-                                     const std::string &message) {
-  Swig_warning(warningType, "", 0,
-               "Doxygen parser warning: %s. \n", message.c_str());
+void JavaDocConverter::addError(int warningType, const std::string &message)
+{
+  Swig_warning(warningType, "", 0, "Doxygen parser warning: %s. \n",
+      message.c_str());
 }
diff --git a/Source/DoxygenTranslator/src/PyDocConverter.cpp b/Source/DoxygenTranslator/src/PyDocConverter.cpp
index 7200a2de6..4346fb99c 100644
--- a/Source/DoxygenTranslator/src/PyDocConverter.cpp
+++ b/Source/DoxygenTranslator/src/PyDocConverter.cpp
@@ -19,13 +19,13 @@
 #include <iostream>
 
 // 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;
 
 using std::string;
 
-
-void PyDocConverter::fillStaticTables() {
+void PyDocConverter::fillStaticTables()
+{
   if (tagHandlers.size()) // fill only once
     return;
 
@@ -94,15 +94,18 @@ void PyDocConverter::fillStaticTables() {
   tagHandlers["manonly"] = make_pair(&PyDocConverter::handleParagraph, "");
   tagHandlers["note"] = 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["return"] = make_pair(&PyDocConverter::handleParagraph, "");
   tagHandlers["returns"] = make_pair(&PyDocConverter::handleParagraph, "");
   tagHandlers["result"] = make_pair(&PyDocConverter::handleParagraph, "");
   tagHandlers["remark"] = make_pair(&PyDocConverter::handleParagraph, "");
   tagHandlers["remarks"] = make_pair(&PyDocConverter::handleParagraph, "");
-  tagHandlers["sa"] = make_pair(&PyDocConverter::handleTagMessage, "See also: ");
-  tagHandlers["see"] = make_pair(&PyDocConverter::handleTagMessage, "See also: ");
+  tagHandlers["sa"] = make_pair(&PyDocConverter::handleTagMessage,
+      "See also: ");
+  tagHandlers["see"] = make_pair(&PyDocConverter::handleTagMessage,
+      "See also: ");
   tagHandlers["since"] = make_pair(&PyDocConverter::handleParagraph, "");
   tagHandlers["short"] = make_pair(&PyDocConverter::handleParagraph, "");
   tagHandlers["throw"] = make_pair(&PyDocConverter::handleParagraph, "");
@@ -114,23 +117,27 @@ void PyDocConverter::fillStaticTables() {
   tagHandlers["xmlonly"] = make_pair(&PyDocConverter::handleParagraph, "");
   // these commands have special handlers
   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["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["ifnot"] = make_pair(&PyDocConverter::handleTagIf, "If not: ");
   tagHandlers["image"] = make_pair(&PyDocConverter::handleTagImage, "");
   tagHandlers["li"] = make_pair(&PyDocConverter::handleTagMessage, " -");
-  tagHandlers["overload"] = make_pair(&PyDocConverter::handleTagMessage, "This is an overloaded member function, provided for"
-      " convenience.\nIt differs from the above function only in what"
-      " argument(s) it accepts.");
+  tagHandlers["overload"] = make_pair(&PyDocConverter::handleTagMessage,
+      "This is an overloaded member function, provided for"
+          " convenience.\nIt differs from the above function only in what"
+          " argument(s) it accepts.");
   tagHandlers["par"] = make_pair(&PyDocConverter::handleTagPar, "");
   tagHandlers["param"] = make_pair(&PyDocConverter::handleTagParam, "");
   tagHandlers["tparam"] = make_pair(&PyDocConverter::handleTagParam, "");
   // this command just prints it's contents
   // (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["n"] = make_pair(&PyDocConverter::handleNewLine, "");
 
@@ -140,97 +147,99 @@ void PyDocConverter::fillStaticTables() {
   tagHandlers["f{"] = make_pair(&PyDocConverter::handleTagVerbatim, "");
 
   // HTML tags
-  tagHandlers["<a"      ] = make_pair(&PyDocConverter::handleDoxyHtmlTag_A, ""      );
-  tagHandlers["<b"      ] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "__");
-  tagHandlers["<blockquote"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_A, "Quote: ");
-  tagHandlers["<body"   ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""   );
-  tagHandlers["<br"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "\n"     );
+  tagHandlers["<a"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_A, "");
+  tagHandlers["<b"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "__");
+  tagHandlers["<blockquote"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_A,
+      "Quote: ");
+  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
   // not used in HTML 5
-  tagHandlers["<center" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "" );
+  tagHandlers["<center"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
   tagHandlers["<caption"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
-  tagHandlers["<code"   ] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "'"   );
-
-  tagHandlers["<dl"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
-  tagHandlers["<dd"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "    ");
-  tagHandlers["<dt"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
-
-  tagHandlers["<dfn"    ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""    );
-  tagHandlers["<div"    ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""    );
-  tagHandlers["<em"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "__");
-  tagHandlers["<form"   ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""   );
-  tagHandlers["<hr"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag,
-              "--------------------------------------------------------------------\n"     );
-  tagHandlers["<h1"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "# "     );
-  tagHandlers["<h2"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "## "     );
-  tagHandlers["<h3"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "### "     );
-  tagHandlers["<i"      ] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "_");
-  tagHandlers["<input"  ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""  );
-  tagHandlers["<img"    ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "Image:"  );
-  tagHandlers["<li"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "- ");
-  tagHandlers["<meta"   ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
+  tagHandlers["<code"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "'");
+
+  tagHandlers["<dl"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
+  tagHandlers["<dd"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "    ");
+  tagHandlers["<dt"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
+
+  tagHandlers["<dfn"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
+  tagHandlers["<div"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
+  tagHandlers["<em"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "__");
+  tagHandlers["<form"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
+  tagHandlers["<hr"] = make_pair(&PyDocConverter::handleDoxyHtmlTag,
+      "--------------------------------------------------------------------\n");
+  tagHandlers["<h1"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "# ");
+  tagHandlers["<h2"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "## ");
+  tagHandlers["<h3"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "### ");
+  tagHandlers["<i"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "_");
+  tagHandlers["<input"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
+  tagHandlers["<img"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "Image:");
+  tagHandlers["<li"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "- ");
+  tagHandlers["<meta"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
   tagHandlers["<multicol"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
-  tagHandlers["<ol"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
-  tagHandlers["<p"      ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "\n");
-  tagHandlers["<pre"    ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""    );
-  tagHandlers["<small"  ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, ""  );
-  tagHandlers["<span"   ] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "'"   );
-  tagHandlers["<strong" ] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "__");
+  tagHandlers["<ol"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
+  tagHandlers["<p"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "\n");
+  tagHandlers["<pre"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
+  tagHandlers["<small"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
+  tagHandlers["<span"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "'");
+  tagHandlers["<strong"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "__");
 
   // make a space between text and super/sub script.
-  tagHandlers["<sub"    ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, " ");
-  tagHandlers["<sup"    ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, " ");
-
-  tagHandlers["<table"  ] = make_pair(&PyDocConverter::handleDoxyHtmlTagNoParam, "");
-  tagHandlers["<td"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag_td, "");
-  tagHandlers["<th"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag_th, "");
-  tagHandlers["<tr"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag_tr, "");
-  tagHandlers["<tt"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
-  tagHandlers["<kbd"    ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
-  tagHandlers["<ul"     ] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
-  tagHandlers["<var"    ] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "_");
+  tagHandlers["<sub"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, " ");
+  tagHandlers["<sup"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, " ");
+
+  tagHandlers["<table"] = make_pair(&PyDocConverter::handleDoxyHtmlTagNoParam,
+      "");
+  tagHandlers["<td"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_td, "");
+  tagHandlers["<th"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_th, "");
+  tagHandlers["<tr"] = make_pair(&PyDocConverter::handleDoxyHtmlTag_tr, "");
+  tagHandlers["<tt"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
+  tagHandlers["<kbd"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
+  tagHandlers["<ul"] = make_pair(&PyDocConverter::handleDoxyHtmlTag, "");
+  tagHandlers["<var"] = make_pair(&PyDocConverter::handleDoxyHtmlTag2, "_");
 
   // HTML entities
-  tagHandlers["&copy" ] = make_pair(&PyDocConverter::handleHtmlEntity, "(C)");
+  tagHandlers["&copy"] = make_pair(&PyDocConverter::handleHtmlEntity, "(C)");
   tagHandlers["&trade"] = make_pair(&PyDocConverter::handleHtmlEntity, " TM");
-  tagHandlers["&reg"  ] = make_pair(&PyDocConverter::handleHtmlEntity, "(R)");
-  tagHandlers["&lt"   ] = make_pair(&PyDocConverter::handleHtmlEntity, "<");
-  tagHandlers["&gt"   ] = make_pair(&PyDocConverter::handleHtmlEntity, ">");
-  tagHandlers["&amp"  ] = make_pair(&PyDocConverter::handleHtmlEntity, "&");
-  tagHandlers["&apos" ] = make_pair(&PyDocConverter::handleHtmlEntity, "'");
-  tagHandlers["&quot" ] = make_pair(&PyDocConverter::handleHtmlEntity, "\"");
+  tagHandlers["&reg"] = make_pair(&PyDocConverter::handleHtmlEntity, "(R)");
+  tagHandlers["&lt"] = make_pair(&PyDocConverter::handleHtmlEntity, "<");
+  tagHandlers["&gt"] = make_pair(&PyDocConverter::handleHtmlEntity, ">");
+  tagHandlers["&amp"] = make_pair(&PyDocConverter::handleHtmlEntity, "&");
+  tagHandlers["&apos"] = make_pair(&PyDocConverter::handleHtmlEntity, "'");
+  tagHandlers["&quot"] = make_pair(&PyDocConverter::handleHtmlEntity, "\"");
   tagHandlers["&lsquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "`");
   tagHandlers["&rsquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "'");
   tagHandlers["&ldquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "\"");
   tagHandlers["&rdquo"] = make_pair(&PyDocConverter::handleHtmlEntity, "\"");
   tagHandlers["&ndash"] = 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["&minus"] = make_pair(&PyDocConverter::handleHtmlEntity, "-");
-  tagHandlers["&sdot" ] = make_pair(&PyDocConverter::handleHtmlEntity, ".");
-  tagHandlers["&sim"  ] = make_pair(&PyDocConverter::handleHtmlEntity, "~");
-  tagHandlers["&le"   ] = make_pair(&PyDocConverter::handleHtmlEntity, "<=");
-  tagHandlers["&ge"   ] = make_pair(&PyDocConverter::handleHtmlEntity, ">=");
-  tagHandlers["&larr" ] = make_pair(&PyDocConverter::handleHtmlEntity, "<--");
-  tagHandlers["&rarr" ] = make_pair(&PyDocConverter::handleHtmlEntity, "-->");
+  tagHandlers["&sdot"] = make_pair(&PyDocConverter::handleHtmlEntity, ".");
+  tagHandlers["&sim"] = make_pair(&PyDocConverter::handleHtmlEntity, "~");
+  tagHandlers["&le"] = make_pair(&PyDocConverter::handleHtmlEntity, "<=");
+  tagHandlers["&ge"] = make_pair(&PyDocConverter::handleHtmlEntity, ">=");
+  tagHandlers["&larr"] = make_pair(&PyDocConverter::handleHtmlEntity, "<--");
+  tagHandlers["&rarr"] = make_pair(&PyDocConverter::handleHtmlEntity, "-->");
 }
 
-PyDocConverter::PyDocConverter(bool debugTranslator, bool debugParser)
-: DoxygenTranslator(debugTranslator, debugParser),
-  m_tableLineLen(0),
-  m_prevRowIsTH(false)
+PyDocConverter::PyDocConverter(bool debugTranslator, bool debugParser) :
+    DoxygenTranslator(debugTranslator, debugParser), m_tableLineLen(0), m_prevRowIsTH(
+        false)
 {
   fillStaticTables();
 }
 
-std::string PyDocConverter::getParamType(std::string param) {
+std::string PyDocConverter::getParamType(std::string param)
+{
   ParmList *plist = CopyParmList(Getattr(currentNode, "parms"));
   Parm *p = NULL;
   for (p = plist; p;) {
-    if (Char(Getattr(p, "name")) == param) {
-      std::string type = Char(SwigType_str(Getattr(p, "type"), ""));
+    if (Char (Getattr(p, "name")) == param) {
+      std::string type = Char (SwigType_str(Getattr(p, "type"), ""));
       return type;
     }
     /*
@@ -244,17 +253,21 @@ std::string PyDocConverter::getParamType(std::string param) {
   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 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)
       currentLine.resize(indent, ' ');
 
     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";
       currentLine = "";
     }
@@ -267,14 +280,15 @@ std::string PyDocConverter::justifyString(std::string documentString, int indent
   return formattedString;
 }
 
-std::string PyDocConverter::translateSubtree(DoxygenEntity & doxygenEntity) {
+std::string PyDocConverter::translateSubtree(DoxygenEntity & doxygenEntity)
+{
   std::string translatedComment;
 
   if (doxygenEntity.isLeaf)
     return translatedComment;
 
   std::string currentSection;
-  std::list < DoxygenEntity >::iterator p = doxygenEntity.entityList.begin();
+  std::list<DoxygenEntity>::iterator p = doxygenEntity.entityList.begin();
   while (p != doxygenEntity.entityList.end()) {
     std::map<std::string, std::string>::iterator it;
     it = sectionTitles.find(p->typeOfEntity);
@@ -292,50 +306,63 @@ std::string PyDocConverter::translateSubtree(DoxygenEntity & doxygenEntity) {
   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
-  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);
-  if (it!=tagHandlers.end())
-    (this->*(it->second.first))(doxyEntity, translatedComment, it->second.second);
+  if (it != tagHandlers.end())
+    (this->*(it->second.first))(doxyEntity, translatedComment,
+        it->second.second);
 }
 
-
-void PyDocConverter::handleParagraph(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) {
+void PyDocConverter::handleParagraph(DoxygenEntity& tag,
+                                     std::string& translatedComment,
+                                     std::string &arg)
+{
   translatedComment += translateSubtree(tag) + arg;
 }
 
-
-void PyDocConverter::handlePlainString(DoxygenEntity& tag, std::string& translatedComment, std::string&) {
+void PyDocConverter::handlePlainString(DoxygenEntity& tag,
+                                       std::string& translatedComment,
+                                       std::string&)
+{
   translatedComment += tag.data;
-  if (tag.data.size() && tag.data[tag.data.size()-1] != ' ')
+  if (tag.data.size() && tag.data[tag.data.size() - 1] != ' ')
     translatedComment += "";
 }
 
-
 void PyDocConverter::handleTagVerbatim(DoxygenEntity& tag,
-                                            std::string& translatedComment,
-                                            std::string &arg) {
+                                       std::string& translatedComment,
+                                       std::string &arg)
+{
   translatedComment += arg + " ";
-  for (DoxygenEntityListCIt it = tag.entityList.begin(); it != tag.entityList.end(); it++) {
-      translatedComment += it->data;
+  for (DoxygenEntityListCIt it = tag.entityList.begin();
+      it != tag.entityList.end(); it++) {
+    translatedComment += it->data;
   }
 }
 
-
-void PyDocConverter::handleTagMessage(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) {
+void PyDocConverter::handleTagMessage(DoxygenEntity& tag,
+                                      std::string& translatedComment,
+                                      std::string &arg)
+{
   std::string dummy;
   translatedComment += arg;
   handleParagraph(tag, translatedComment, dummy);
 }
 
-
-void PyDocConverter::handleTagChar(DoxygenEntity& tag, std::string& translatedComment, std::string&) {
+void PyDocConverter::handleTagChar(DoxygenEntity& tag,
+                                   std::string& translatedComment, std::string&)
+{
   translatedComment += tag.typeOfEntity;
 }
 
-
-void PyDocConverter::handleTagIf(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) {
+void PyDocConverter::handleTagIf(DoxygenEntity& tag,
+                                 std::string& translatedComment,
+                                 std::string &arg)
+{
   std::string dummy;
   translatedComment += arg;
   if (tag.entityList.size()) {
@@ -345,8 +372,9 @@ void PyDocConverter::handleTagIf(DoxygenEntity& tag, std::string& translatedComm
   }
 }
 
-
-void PyDocConverter::handleTagPar(DoxygenEntity& tag, std::string& translatedComment, std::string&) {
+void PyDocConverter::handleTagPar(DoxygenEntity& tag,
+                                  std::string& translatedComment, std::string&)
+{
   std::string dummy;
   translatedComment += "Title: ";
   if (tag.entityList.size())
@@ -355,8 +383,10 @@ void PyDocConverter::handleTagPar(DoxygenEntity& tag, std::string& translatedCom
   handleParagraph(tag, translatedComment, dummy);
 }
 
-
-void PyDocConverter::handleTagImage(DoxygenEntity& tag, std::string& translatedComment, std::string&) {
+void PyDocConverter::handleTagImage(DoxygenEntity& tag,
+                                    std::string& translatedComment,
+                                    std::string&)
+{
   if (tag.entityList.size() < 2)
     return;
   tag.entityList.pop_front();
@@ -367,10 +397,10 @@ void PyDocConverter::handleTagImage(DoxygenEntity& tag, std::string& translatedC
     translatedComment += "(" + tag.entityList.begin()->data + ")";
 }
 
-
 void PyDocConverter::handleTagParam(DoxygenEntity& tag,
-                                         std::string& translatedComment,
-                                         std::string&) {
+                                    std::string& translatedComment,
+                                    std::string&)
+{
   std::string dummy;
   if (tag.entityList.size() < 2)
     return;
@@ -386,140 +416,152 @@ void PyDocConverter::handleTagParam(DoxygenEntity& tag,
   handleParagraph(tag, translatedComment, dummy);
 }
 
-
-void PyDocConverter::handleTagWrap(DoxygenEntity& tag, std::string& translatedComment, std::string &arg) {
+void PyDocConverter::handleTagWrap(DoxygenEntity& tag,
+                                   std::string& translatedComment,
+                                   std::string &arg)
+{
   if (tag.entityList.size()) { // do not include empty tags
     std::string tagData = translateSubtree(tag);
     // wrap the thing, ignoring whitespaces
     size_t wsPos = tagData.find_last_not_of("\n\t ");
     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
       translatedComment += arg + tagData + arg;
   }
 }
 
-
 void PyDocConverter::handleDoxyHtmlTag(DoxygenEntity& tag,
-                                            std::string& translatedComment,
-                                            std::string &arg) {
-    std::string htmlTagArgs = tag.data;
-    if (htmlTagArgs == "/") {
-        // end html tag, for example "</ul>
-        // translatedComment += "</" + arg.substr(1) + ">";
-    } else {
-        translatedComment += arg + htmlTagArgs;
-    }
+                                       std::string& translatedComment,
+                                       std::string &arg)
+{
+  std::string htmlTagArgs = tag.data;
+  if (htmlTagArgs == "/") {
+    // end html tag, for example "</ul>
+    // translatedComment += "</" + arg.substr(1) + ">";
+  } else {
+    translatedComment += arg + htmlTagArgs;
+  }
 }
 
-
 void PyDocConverter::handleDoxyHtmlTagNoParam(DoxygenEntity& tag,
-                                                    std::string& translatedComment,
-                                                    std::string &arg) {
-    std::string htmlTagArgs = tag.data;
-    if (htmlTagArgs == "/") {
-        // end html tag, for example "</ul>
-    } else {
-        translatedComment += arg;
-    }
+                                              std::string& translatedComment,
+                                              std::string &arg)
+{
+  std::string htmlTagArgs = tag.data;
+  if (htmlTagArgs == "/") {
+    // end html tag, for example "</ul>
+  } else {
+    translatedComment += arg;
+  }
 }
 
-
 void PyDocConverter::handleDoxyHtmlTag_A(DoxygenEntity& tag,
-                                              std::string& translatedComment,
-                                              std::string &arg) {
-    std::string htmlTagArgs = tag.data;
-    if (htmlTagArgs == "/") {
-        // end html tag, "</a>
-        translatedComment += " (" + m_url + ')';
-        m_url.clear();
-    } else {
-      m_url.clear();
-      size_t pos = htmlTagArgs.find('=');
-      if (pos != string::npos) {
-        m_url = htmlTagArgs.substr(pos + 1);
-      }
-      translatedComment += arg;
+                                         std::string& translatedComment,
+                                         std::string &arg)
+{
+  std::string htmlTagArgs = tag.data;
+  if (htmlTagArgs == "/") {
+    // end html tag, "</a>
+    translatedComment += " (" + m_url + ')';
+    m_url.clear();
+  } else {
+    m_url.clear();
+    size_t pos = htmlTagArgs.find('=');
+    if (pos != string::npos) {
+      m_url = htmlTagArgs.substr(pos + 1);
     }
+    translatedComment += arg;
+  }
 }
 
-
 void PyDocConverter::handleDoxyHtmlTag2(DoxygenEntity& tag,
-                                             std::string& translatedComment,
-                                             std::string &arg) {
-    std::string htmlTagArgs = tag.data;
-    if (htmlTagArgs == "/") {
-        // end html tag, for example "</em>
-        translatedComment += arg;
-    } else {
-        translatedComment += arg;
-    }
+                                        std::string& translatedComment,
+                                        std::string &arg)
+{
+  std::string htmlTagArgs = tag.data;
+  if (htmlTagArgs == "/") {
+    // end html tag, for example "</em>
+    translatedComment += arg;
+  } else {
+    translatedComment += arg;
+  }
 }
 
 void PyDocConverter::handleDoxyHtmlTag_tr(DoxygenEntity& tag,
-                                                std::string& translatedComment,
-                                                std::string &) {
-    std::string htmlTagArgs = tag.data;
-    if (htmlTagArgs == "/") {
-      // end tag, </tr> appends vertical table line '|'
-      translatedComment += '|';
-      size_t nlPos = translatedComment.rfind('\n');
-      if (nlPos != string::npos) {
-        size_t startOfTableLinePos = translatedComment.find_first_not_of(" \t", nlPos);
-        if (startOfTableLinePos != string::npos) {
-          m_tableLineLen = translatedComment.size() - startOfTableLinePos - 1;
-        }
-      }
-    } else {
-      if (m_prevRowIsTH) {
-        // if previous row contained <th> tag, add horizontal separator
-        translatedComment += string(m_tableLineLen, '-') + '\n';
-        m_prevRowIsTH = false;
+                                          std::string& translatedComment,
+                                          std::string &)
+{
+  std::string htmlTagArgs = tag.data;
+  size_t nlPos = translatedComment.rfind('\n');
+  if (htmlTagArgs == "/") {
+    // end tag, </tr> appends vertical table line '|'
+    translatedComment += '|';
+    if (nlPos != string::npos) {
+      size_t startOfTableLinePos = translatedComment.find_first_not_of(" \t",
+          nlPos + 1);
+      if (startOfTableLinePos != string::npos) {
+        m_tableLineLen = translatedComment.size() - startOfTableLinePos;
       }
     }
-}
+  } 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';
 
-void PyDocConverter::handleDoxyHtmlTag_th(DoxygenEntity& tag,
-                                                std::string& translatedComment,
-                                                std::string &) {
-    std::string htmlTagArgs = tag.data;
-    if (htmlTagArgs == "/") {
-      // end tag, </th> is ignored
-    } else {
-        translatedComment += '|';
-        m_prevRowIsTH = true;
+      if (nlPos != string::npos) {
+        translatedComment += string(numLeadingSpaces, ' ');
+      }
+      m_prevRowIsTH = false;
     }
+  }
 }
 
+void PyDocConverter::handleDoxyHtmlTag_th(DoxygenEntity& tag,
+                                          std::string& translatedComment,
+                                          std::string &)
+{
+  std::string htmlTagArgs = tag.data;
+  if (htmlTagArgs == "/") {
+    // end tag, </th> is ignored
+  } else {
+    translatedComment += '|';
+    m_prevRowIsTH = true;
+  }
+}
 
 void PyDocConverter::handleDoxyHtmlTag_td(DoxygenEntity& tag,
-                                                std::string& translatedComment,
-                                                std::string &) {
-    std::string htmlTagArgs = tag.data;
-    if (htmlTagArgs == "/") {
-        // end tag, </td> is ignored
-    } else {
-      translatedComment += '|';
-    }
+                                          std::string& translatedComment,
+                                          std::string &)
+{
+  std::string htmlTagArgs = tag.data;
+  if (htmlTagArgs == "/") {
+    // end tag, </td> is ignored
+  } else {
+    translatedComment += '|';
+  }
 }
 
-
-
 void PyDocConverter::handleHtmlEntity(DoxygenEntity&,
-                                           std::string& translatedComment,
-                                           std::string &arg) {
-    // html entities
-    translatedComment += arg;
+                                      std::string& translatedComment,
+                                      std::string &arg)
+{
+  // html entities
+  translatedComment += arg;
 }
 
-
-void PyDocConverter::handleNewLine(DoxygenEntity&, std::string& translatedComment, std::string&) {
+void PyDocConverter::handleNewLine(DoxygenEntity&,
+                                   std::string& translatedComment, std::string&)
+{
   translatedComment += "\n";
 }
 
-
-String *PyDocConverter::makeDocumentation(Node *n) {
+String *PyDocConverter::makeDocumentation(Node *n)
+{
   String *documentation;
   std::string pyDocString, result;
 
@@ -532,25 +574,26 @@ String *PyDocConverter::makeDocumentation(Node *n) {
     while (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
     while (n) {
       documentation = getDoxygenComment(n);
       if (!Swig_is_generated_overload(n) && documentation) {
-	currentNode = n;
-	if (GetFlag(n, "feature:doxygen:notranslate")) {
-	  String *comment = NewString("");
-	  Append(comment, documentation);
-	  Replaceall(comment, "\n *", "\n");
-	  allDocumentation.push_back(Char(comment));
-	  Delete(comment);
-	}
-	else {
-	  std::list < DoxygenEntity > entityList = parser.createTree(Char(documentation), Char(Getfile(documentation)), Getline(documentation));
-	  DoxygenEntity root("root", entityList);
-	  allDocumentation.push_back(translateSubtree(root));
-	}
+        currentNode = n;
+        if (GetFlag(n, "feature:doxygen:notranslate")) {
+          String *comment = NewString("");
+          Append(comment, documentation);
+          Replaceall(comment, "\n *", "\n");
+          allDocumentation.push_back(Char (comment));
+          Delete(comment);
+        } else {
+          std::list<DoxygenEntity> entityList = parser.createTree(
+              Char (documentation), Char (Getfile(documentation)),
+              Getline(documentation));
+          DoxygenEntity root("root", entityList);
+          allDocumentation.push_back(translateSubtree(root));
+        }
       }
       n = Getattr(n, "sym:nextSibling");
     }
@@ -558,9 +601,12 @@ String *PyDocConverter::makeDocumentation(Node *n) {
     // construct final documentation string
     if (allDocumentation.size() > 1) {
       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 << "Overload " << (realOverloadCount + 1) << ":" << std::endl;
+        concatDocString << "Overload " << (realOverloadCount + 1) << ":"
+            << std::endl;
         concatDocString << generateDivider();
         concatDocString << allDocumentation[realOverloadCount] << std::endl;
       }
@@ -577,11 +623,12 @@ String *PyDocConverter::makeDocumentation(Node *n) {
         String *comment = NewString("");
         Append(comment, documentation);
         Replaceall(comment, "\n *", "\n");
-        pyDocString = Char(comment);
+        pyDocString = Char (comment);
         Delete(comment);
-      }
-      else {
-        std::list < DoxygenEntity > entityList = parser.createTree(Char(documentation), Char(Getfile(documentation)), Getline(documentation));
+      } else {
+        std::list<DoxygenEntity> entityList = parser.createTree(
+            Char (documentation), Char (Getfile(documentation)),
+            Getline(documentation));
         DoxygenEntity root("root", entityList);
         pyDocString = translateSubtree(root);
       }
@@ -610,7 +657,8 @@ String *PyDocConverter::makeDocumentation(Node *n) {
   return NewString("");
 }
 
-std::string PyDocConverter::generateDivider() {
+std::string PyDocConverter::generateDivider()
+{
   static string dividerString(DOC_STRING_LENGTH, '-');
   return dividerString;
 }