QDoc: Code cleanup

* Unify members; use s_ or m_ prefix instead of _ suffix.
* Remove unnecessary member that duplicates content in base class.
* Add [[nodiscard]] annotations where applicable.
* Add overloads to virtual methods that have been extended with
  parameters with default values.
* Make single argument ctors explicit.
* Remove semi-colon from namespace declaration.

Change-Id: Ie1ff39079722b81ba6754f945a898dc9b335bbae
Reviewed-by: Topi Reiniö <topi.reinio@qt.io>

1 files changed, 125 insertions, 124 deletions

diff --git a/src/qdoc/docparser.cpp b/src/qdoc/docparser.cpp
index d46a4bc86..4a84020f7 100644
--- a/src/qdoc/docparser.cpp
+++ b/src/qdoc/docparser.cpp
@@ -44,7 +44,7 @@
 
 QT_BEGIN_NAMESPACE
 
-DocUtilities &DocParser::m_utilities = DocUtilities::instance();
+DocUtilities &DocParser::s_utilities = DocUtilities::instance();
 
 enum {
     CMD_A,
@@ -257,13 +257,13 @@ static struct
              { "endjs", CMD_ENDJS, nullptr },
              { nullptr, 0, nullptr } };
 
-int DocParser::tabSize;
-QStringList DocParser::exampleFiles;
-QStringList DocParser::exampleDirs;
-QStringList DocParser::sourceFiles;
-QStringList DocParser::sourceDirs;
-QStringList DocParser::ignoreWords;
-bool DocParser::quoting = false;
+int DocParser::s_tabSize;
+QStringList DocParser::s_exampleFiles;
+QStringList DocParser::s_exampleDirs;
+QStringList DocParser::s_sourceFiles;
+QStringList DocParser::s_sourceDirs;
+QStringList DocParser::s_ignoreWords;
+bool DocParser::s_quoting = false;
 
 static QString cleanLink(const QString &link)
 {
@@ -275,17 +275,17 @@ static QString cleanLink(const QString &link)
 
 void DocParser::initialize(const Config &config)
 {
-    tabSize = config.getInt(CONFIG_TABSIZE);
-    exampleFiles = config.getCanonicalPathList(CONFIG_EXAMPLES);
-    exampleDirs = config.getCanonicalPathList(CONFIG_EXAMPLEDIRS);
-    sourceFiles = config.getCanonicalPathList(CONFIG_SOURCES);
-    sourceDirs = config.getCanonicalPathList(CONFIG_SOURCEDIRS);
-    ignoreWords = config.getStringList(CONFIG_IGNOREWORDS);
+    s_tabSize = config.getInt(CONFIG_TABSIZE);
+    s_exampleFiles = config.getCanonicalPathList(CONFIG_EXAMPLES);
+    s_exampleDirs = config.getCanonicalPathList(CONFIG_EXAMPLEDIRS);
+    s_sourceFiles = config.getCanonicalPathList(CONFIG_SOURCES);
+    s_sourceDirs = config.getCanonicalPathList(CONFIG_SOURCEDIRS);
+    s_ignoreWords = config.getStringList(CONFIG_IGNOREWORDS);
 
     int i = 0;
     while (cmds[i].english) {
         cmds[i].alias = new QString(Doc::alias(cmds[i].english));
-        m_utilities.cmdHash.insert(*cmds[i].alias, cmds[i].no);
+        s_utilities.cmdHash.insert(*cmds[i].alias, cmds[i].no);
 
         if (cmds[i].no != i)
             Location::internalError(QStringLiteral("command %1 missing").arg(i));
@@ -293,18 +293,18 @@ void DocParser::initialize(const Config &config)
     }
 
     // If any of the formats define quotinginformation, activate quoting
-    DocParser::quoting = config.getBool(CONFIG_QUOTINGINFORMATION);
+    DocParser::s_quoting = config.getBool(CONFIG_QUOTINGINFORMATION);
     for (const auto &format : config.getOutputFormats())
-        DocParser::quoting = DocParser::quoting
+        DocParser::s_quoting = DocParser::s_quoting
                 || config.getBool(format + Config::dot + CONFIG_QUOTINGINFORMATION);
 }
 
 void DocParser::terminate()
 {
-    exampleFiles.clear();
-    exampleDirs.clear();
-    sourceFiles.clear();
-    sourceDirs.clear();
+    s_exampleFiles.clear();
+    s_exampleDirs.clear();
+    s_sourceFiles.clear();
+    s_sourceDirs.clear();
 
     int i = 0;
     while (cmds[i].english) {
@@ -329,11 +329,11 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
     m_input = source;
     m_position = 0;
     m_inputLength = m_input.length();
-    m_cachedLocation = docPrivate->start_loc;
+    m_cachedLocation = docPrivate->m_start_loc;
     m_cachedPosition = 0;
     m_private = docPrivate;
-    m_private->text << Atom::Nop;
-    m_private->topics_.clear();
+    m_private->m_text << Atom::Nop;
+    m_private->m_topics.clear();
 
     m_paragraphState = OutsideParagraph;
     m_inTableHeader = false;
@@ -385,10 +385,10 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
             } else {
                 // Ignore quoting atoms to make appendToCode()
                 // append to the correct atom.
-                if (!quoting || !isQuote(m_private->text.lastAtom()))
-                    m_lastAtom = m_private->text.lastAtom();
+                if (!s_quoting || !isQuote(m_private->m_text.lastAtom()))
+                    m_lastAtom = m_private->m_text.lastAtom();
 
-                int cmd = m_utilities.cmdHash.value(cmdStr, NOT_A_CMD);
+                int cmd = s_utilities.cmdHash.value(cmdStr, NOT_A_CMD);
                 switch (cmd) {
                 case CMD_A:
                     enterPara();
@@ -396,7 +396,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                     append(Atom::FormattingLeft, ATOM_FORMATTING_PARAMETER);
                     append(Atom::String, p1);
                     append(Atom::FormattingRight, ATOM_FORMATTING_PARAMETER);
-                    m_private->params.insert(p1);
+                    m_private->m_params.insert(p1);
                     break;
                 case CMD_BADCODE:
                     leavePara();
@@ -459,7 +459,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                     closeCommand(cmd);
                     break;
                 case CMD_CODELINE:
-                    if (quoting) {
+                    if (s_quoting) {
                         append(Atom::CodeQuoteCommand, cmdStr);
                         append(Atom::CodeQuoteArgument, " ");
                     }
@@ -471,7 +471,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                     QString arg = getOptionalArgument();
                     if (arg.isEmpty())
                         arg = "4";
-                    if (quoting) {
+                    if (s_quoting) {
                         append(Atom::CodeQuoteCommand, cmdStr);
                         append(Atom::CodeQuoteArgument, arg);
                     }
@@ -538,9 +538,9 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                     break;
                 case CMD_ENDLINK:
                     if (closeCommand(cmd)) {
-                        if (m_private->text.lastAtom()->type() == Atom::String
-                            && m_private->text.lastAtom()->string().endsWith(QLatin1Char(' ')))
-                            m_private->text.lastAtom()->chopString();
+                        if (m_private->m_text.lastAtom()->type() == Atom::String
+                            && m_private->m_text.lastAtom()->string().endsWith(QLatin1Char(' ')))
+                            m_private->m_text.lastAtom()->chopString();
                         append(Atom::FormattingRight, ATOM_FORMATTING_LINK);
                     }
                     break;
@@ -671,7 +671,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                         enterPara();
                         m_indexStartedParagraph = true;
                     } else {
-                        const Atom *last = m_private->text.lastAtom();
+                        const Atom *last = m_private->m_text.lastAtom();
                         if (m_indexStartedParagraph
                             && (last->type() != Atom::FormattingRight
                                 || last->string() != ATOM_FORMATTING_INDEX))
@@ -689,14 +689,14 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                     if (isLeftBraceAhead()) {
                         p1 = getArgument();
                         append(p1, p2);
-                        if (!p2.isEmpty() && !(m_private->text.lastAtom()->error().isEmpty()))
+                        if (!p2.isEmpty() && !(m_private->m_text.lastAtom()->error().isEmpty()))
                             location().warning(
                                     QStringLiteral(
                                             "Check parameter in '[ ]' of '\\l' command: '%1', "
                                             "possible misspelling, or unrecognized module name")
-                                            .arg(m_private->text.lastAtom()->error()));
+                                            .arg(m_private->m_text.lastAtom()->error()));
                         if (isLeftBraceAhead()) {
-                            currentLinkAtom = m_private->text.lastAtom();
+                            currentLinkAtom = m_private->m_text.lastAtom();
                             startFormat(ATOM_FORMATTING_LINK, cmd);
                         } else {
                             append(Atom::FormattingLeft, ATOM_FORMATTING_LINK);
@@ -706,12 +706,12 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                     } else {
                         p1 = getArgument();
                         append(p1, p2);
-                        if (!p2.isEmpty() && !(m_private->text.lastAtom()->error().isEmpty()))
+                        if (!p2.isEmpty() && !(m_private->m_text.lastAtom()->error().isEmpty()))
                             location().warning(
                                     QStringLiteral(
                                             "Check parameter in '[ ]' of '\\l' command: '%1', "
                                             "possible misspelling, or unrecognized module name")
-                                            .arg(m_private->text.lastAtom()->error()));
+                                            .arg(m_private->m_text.lastAtom()->error()));
                         append(Atom::FormattingLeft, ATOM_FORMATTING_LINK);
                         append(Atom::String, cleanLink(p1));
                         append(Atom::FormattingRight, ATOM_FORMATTING_LINK);
@@ -722,7 +722,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                     leavePara();
                     if (openCommand(cmd))
                         append(Atom::LegaleseLeft);
-                    docPrivate->hasLegalese = true;
+                    docPrivate->m_hasLegalese = true;
                     break;
                 case CMD_LINK:
                     if (openCommand(cmd)) {
@@ -742,7 +742,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                 case CMD_META:
                     m_private->constructExtra();
                     p1 = getArgument();
-                    m_private->extra->metaMap_.insert(p1, getArgument());
+                    m_private->extra->m_metaMap.insert(p1, getArgument());
                     break;
                 case CMD_NEWCODE:
                     location().warning(
@@ -804,10 +804,10 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                     break;
                 case CMD_OMITVALUE: {
                     p1 = getArgument();
-                    if (!m_private->enumItemList.contains(p1))
-                        m_private->enumItemList.append(p1);
-                    if (!m_private->omitEnumItemList.contains(p1))
-                        m_private->omitEnumItemList.append(p1);
+                    if (!m_private->m_enumItemList.contains(p1))
+                        m_private->m_enumItemList.append(p1);
+                    if (!m_private->m_omitEnumItemList.contains(p1))
+                        m_private->m_omitEnumItemList.append(p1);
                     skipSpacesOrOneEndl();
                     // Skip potential description paragraph
                     while (m_position < m_inputLength && !isBlankLine()) {
@@ -817,7 +817,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                             QString nextCmdStr;
                             while (pos < m_input.size() && m_input[pos].isLetterOrNumber())
                                 nextCmdStr += m_input[pos++];
-                            int nextCmd = m_utilities.cmdHash.value(cmdStr, NOT_A_CMD);
+                            int nextCmd = s_utilities.cmdHash.value(cmdStr, NOT_A_CMD);
                             if (nextCmd == cmd || nextCmd == CMD_VALUE)
                                 break;
                         }
@@ -828,7 +828,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                 case CMD_PRINTLINE: {
                     leavePara();
                     QString rest = getRestOfLine();
-                    if (quoting) {
+                    if (s_quoting) {
                         append(Atom::CodeQuoteCommand, cmdStr);
                         append(Atom::CodeQuoteArgument, rest);
                     }
@@ -838,7 +838,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                 case CMD_PRINTTO: {
                     leavePara();
                     QString rest = getRestOfLine();
-                    if (quoting) {
+                    if (s_quoting) {
                         append(Atom::CodeQuoteCommand, cmdStr);
                         append(Atom::CodeQuoteArgument, rest);
                     }
@@ -848,7 +848,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                 case CMD_PRINTUNTIL: {
                     leavePara();
                     QString rest = getRestOfLine();
-                    if (quoting) {
+                    if (s_quoting) {
                         append(Atom::CodeQuoteCommand, cmdStr);
                         append(Atom::CodeQuoteArgument, rest);
                     }
@@ -865,7 +865,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                     leavePara();
                     QString fileName = getArgument();
                     Doc::quoteFromFile(location(), m_quoter, fileName);
-                    if (quoting) {
+                    if (s_quoting) {
                         append(Atom::CodeQuoteCommand, cmdStr);
                         append(Atom::CodeQuoteArgument, fileName);
                     }
@@ -876,7 +876,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                 case CMD_QUOTEFROMFILE: {
                     leavePara();
                     QString arg = getArgument();
-                    if (quoting) {
+                    if (s_quoting) {
                         append(Atom::CodeQuoteCommand, cmdStr);
                         append(Atom::CodeQuoteArgument, arg);
                     }
@@ -887,7 +887,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                     leavePara();
                     marker = quoteFromFile();
                     p1 = getRestOfLine();
-                    if (quoting) {
+                    if (s_quoting) {
                         append(Atom::CodeQuoteCommand, cmdStr);
                         append(Atom::CodeQuoteArgument, slashed(marker->functionEndRegExp(p1)));
                     }
@@ -951,7 +951,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                 case CMD_SKIPLINE: {
                     leavePara();
                     QString rest = getRestOfLine();
-                    if (quoting) {
+                    if (s_quoting) {
                         append(Atom::CodeQuoteCommand, cmdStr);
                         append(Atom::CodeQuoteArgument, rest);
                     }
@@ -961,7 +961,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                 case CMD_SKIPTO: {
                     leavePara();
                     QString rest = getRestOfLine();
-                    if (quoting) {
+                    if (s_quoting) {
                         append(Atom::CodeQuoteCommand, cmdStr);
                         append(Atom::CodeQuoteArgument, rest);
                     }
@@ -971,7 +971,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                 case CMD_SKIPUNTIL: {
                     leavePara();
                     QString rest = getRestOfLine();
-                    if (quoting) {
+                    if (s_quoting) {
                         append(Atom::CodeQuoteCommand, cmdStr);
                         append(Atom::CodeQuoteArgument, rest);
                     }
@@ -986,7 +986,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                     leavePara();
                     QString snippet = getArgument();
                     QString identifier = getRestOfLine();
-                    if (quoting) {
+                    if (s_quoting) {
                         append(Atom::SnippetCommand, cmdStr);
                         append(Atom::SnippetLocation, snippet);
                         append(Atom::SnippetIdentifier, identifier);
@@ -1055,8 +1055,8 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                             p2 = p1.mid(7, p1.length() - 8);
                             p1 = getArgument();
                         }
-                        if (!m_private->enumItemList.contains(p1))
-                            m_private->enumItemList.append(p1);
+                        if (!m_private->m_enumItemList.contains(p1))
+                            m_private->m_enumItemList.append(p1);
 
                         m_openedLists.top().next();
                         append(Atom::ListTagLeft, ATOM_LIST_VALUE);
@@ -1085,7 +1085,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                     append(Atom::String, " ");
                     break;
                 case CMD_OVERLOAD:
-                    m_private->metacommandsUsed.insert(cmdStr);
+                    m_private->m_metacommandsUsed.insert(cmdStr);
                     p1.clear();
                     if (!isBlankLine())
                         p1 = getRestOfLine();
@@ -1101,15 +1101,15 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                         append(Atom::ParaRight);
                         p1 = getMetaCommandArgument(cmdStr);
                     }
-                    m_private->metaCommandMap[cmdStr].append(ArgLocPair(p1, location()));
+                    m_private->m_metaCommandMap[cmdStr].append(ArgLocPair(p1, location()));
                     break;
                 case NOT_A_CMD:
                     if (metaCommandSet.contains(cmdStr)) {
                         QString arg;
-                        m_private->metacommandsUsed.insert(cmdStr);
+                        m_private->m_metacommandsUsed.insert(cmdStr);
                         if (isLeftBracketAhead()) {
                             m_private->constructExtra();
-                            m_private->extra->bracketedArgs_[cmdStr] = getBracketedArgument();
+                            m_private->extra->m_bracketedArgs[cmdStr] = getBracketedArgument();
                         }
                         // Force a linebreak after \obsolete or \deprecated
                         // to treat potential arguments as a new text paragraph.
@@ -1119,25 +1119,25 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                             m_input[m_position] = '\n';
                         else
                             arg = getMetaCommandArgument(cmdStr);
-                        m_private->metaCommandMap[cmdStr].append(ArgLocPair(arg, location()));
+                        m_private->m_metaCommandMap[cmdStr].append(ArgLocPair(arg, location()));
                         if (possibleTopics.contains(cmdStr)) {
                             if (!cmdStr.endsWith(QLatin1String("propertygroup")))
-                                m_private->topics_.append(Topic(cmdStr, arg));
+                                m_private->m_topics.append(Topic(cmdStr, arg));
                         }
-                    } else if (m_utilities.macroHash.contains(cmdStr)) {
-                        const Macro &macro = m_utilities.macroHash.value(cmdStr);
+                    } else if (s_utilities.macroHash.contains(cmdStr)) {
+                        const Macro &macro = s_utilities.macroHash.value(cmdStr);
                         int numPendingFi = 0;
                         int numFormatDefs = 0;
                         QString matchExpr;
-                        for (auto it = macro.otherDefs.constBegin();
-                             it != macro.otherDefs.constEnd(); ++it) {
+                        for (auto it = macro.m_otherDefs.constBegin();
+                             it != macro.m_otherDefs.constEnd(); ++it) {
                             if (it.key() == "match") {
                                 matchExpr = it.value();
                             } else {
                                 append(Atom::FormatIf, it.key());
                                 expandMacro(cmdStr, *it, macro.numParams);
                                 ++numFormatDefs;
-                                if (it == macro.otherDefs.constEnd()) {
+                                if (it == macro.m_otherDefs.constEnd()) {
                                     append(Atom::FormatEndif);
                                 } else {
                                     append(Atom::FormatElse);
@@ -1148,14 +1148,14 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                         while (numPendingFi-- > 0)
                             append(Atom::FormatEndif);
 
-                        if (!macro.defaultDef.isEmpty()) {
+                        if (!macro.m_defaultDef.isEmpty()) {
                             if (numFormatDefs > 0) {
-                                macro.defaultDefLocation.warning(
+                                macro.m_defaultDefLocation.warning(
                                         QStringLiteral("Macro cannot have both "
                                                        "format-specific and qdoc-"
                                                        "syntax definitions"));
                             } else {
-                                QString expanded = expandMacroToString(cmdStr, macro.defaultDef,
+                                QString expanded = expandMacroToString(cmdStr, macro.m_defaultDef,
                                                                        macro.numParams, matchExpr);
                                 m_input.replace(m_backslashPosition,
                                                 m_endPosition - m_backslashPosition, expanded);
@@ -1202,8 +1202,9 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                     // hack for C++ to support links like
                     // \l{QString::}{count()}
                     if (currentLinkAtom && currentLinkAtom->string().endsWith("::")) {
-                        QString suffix = Text::subText(currentLinkAtom, m_private->text.lastAtom())
-                                                 .toString();
+                        QString suffix =
+                                Text::subText(currentLinkAtom, m_private->m_text.lastAtom())
+                                        .toString();
                         currentLinkAtom->appendString(suffix);
                     }
                     currentLinkAtom = nullptr;
@@ -1225,7 +1226,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
         }
         default: {
             bool newWord;
-            switch (m_private->text.lastAtom()->type()) {
+            switch (m_private->m_text.lastAtom()->type()) {
             case Atom::ParaLeft:
                 newWord = true;
                 break;
@@ -1268,7 +1269,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
                 } else {
                     QString word = m_input.mid(startPos, m_position - startPos);
                     if (autolink) {
-                        if (ignoreWords.contains(word) || word.startsWith(QString("__")))
+                        if (s_ignoreWords.contains(word) || word.startsWith(QString("__")))
                             appendWord(word);
                         else
                             append(Atom::AutoLink, word);
@@ -1300,7 +1301,7 @@ void DocParser::parse(const QString &source, DocPrivate *docPrivate,
         m_currentSection = Doc::NoSection;
     }
 
-    m_private->text.stripFirstAtom();
+    m_private->m_text.stripFirstAtom();
 }
 
 /*!
@@ -1326,10 +1327,10 @@ QString DocParser::detailsUnknownCommand(const QSet<QString> &metaCommandSet, co
         ++i;
     }
 
-    if (m_utilities.aliasMap.contains(str))
+    if (s_utilities.aliasMap.contains(str))
         return QStringLiteral("The command '\\%1' was renamed '\\%2' by the configuration"
                               " file. Use the new name.")
-                .arg(str, m_utilities.aliasMap[str]);
+                .arg(str, s_utilities.aliasMap[str]);
 
     QString best = nearestName(str, commandSet);
     if (best.isEmpty())
@@ -1347,10 +1348,10 @@ void DocParser::insertTarget(const QString &target, bool keyword)
         m_private->constructExtra();
         if (keyword) {
             append(Atom::Keyword, target);
-            m_private->extra->keywords_.append(m_private->text.lastAtom());
+            m_private->extra->m_keywords.append(m_private->m_text.lastAtom());
         } else {
             append(Atom::Target, target);
-            m_private->extra->targets_.append(m_private->text.lastAtom());
+            m_private->extra->m_targets.append(m_private->m_text.lastAtom());
         }
     }
 }
@@ -1576,8 +1577,8 @@ void DocParser::startSection(Doc::Sections unit, int cmd)
 
     append(Atom::SectionLeft, QString::number(unit));
     m_private->constructExtra();
-    m_private->extra->tableOfContents_.append(m_private->text.lastAtom());
-    m_private->extra->tableOfContentsLevels_.append(unit);
+    m_private->extra->m_tableOfContents.append(m_private->m_text.lastAtom());
+    m_private->extra->m_tableOfContentsLevels.append(unit);
     enterPara(Atom::SectionHeadingLeft, Atom::SectionHeadingRight, QString::number(unit));
     m_currentSection = unit;
 }
@@ -1636,48 +1637,48 @@ void DocParser::parseAlso()
 
 void DocParser::append(Atom::AtomType type, const QString &string)
 {
-    Atom::AtomType lastType = m_private->text.lastAtom()->type();
+    Atom::AtomType lastType = m_private->m_text.lastAtom()->type();
     if ((lastType == Atom::Code)
-        && m_private->text.lastAtom()->string().endsWith(QLatin1String("\n\n")))
-        m_private->text.lastAtom()->chopString();
-    m_private->text << Atom(type, string);
+        && m_private->m_text.lastAtom()->string().endsWith(QLatin1String("\n\n")))
+        m_private->m_text.lastAtom()->chopString();
+    m_private->m_text << Atom(type, string);
 }
 
 void DocParser::append(const QString &string)
 {
-    Atom::AtomType lastType = m_private->text.lastAtom()->type();
+    Atom::AtomType lastType = m_private->m_text.lastAtom()->type();
     if ((lastType == Atom::Code)
-        && m_private->text.lastAtom()->string().endsWith(QLatin1String("\n\n")))
-        m_private->text.lastAtom()->chopString();
-    m_private->text << Atom(Atom::Link, string);
+        && m_private->m_text.lastAtom()->string().endsWith(QLatin1String("\n\n")))
+        m_private->m_text.lastAtom()->chopString();
+    m_private->m_text << Atom(Atom::Link, string);
 }
 
 void DocParser::append(Atom::AtomType type, const QString &p1, const QString &p2)
 {
-    Atom::AtomType lastType = m_private->text.lastAtom()->type();
+    Atom::AtomType lastType = m_private->m_text.lastAtom()->type();
     if ((lastType == Atom::Code)
-        && m_private->text.lastAtom()->string().endsWith(QLatin1String("\n\n")))
-        m_private->text.lastAtom()->chopString();
-    m_private->text << Atom(type, p1, p2);
+        && m_private->m_text.lastAtom()->string().endsWith(QLatin1String("\n\n")))
+        m_private->m_text.lastAtom()->chopString();
+    m_private->m_text << Atom(type, p1, p2);
 }
 
 void DocParser::append(const QString &p1, const QString &p2)
 {
-    Atom::AtomType lastType = m_private->text.lastAtom()->type();
+    Atom::AtomType lastType = m_private->m_text.lastAtom()->type();
     if ((lastType == Atom::Code)
-        && m_private->text.lastAtom()->string().endsWith(QLatin1String("\n\n")))
-        m_private->text.lastAtom()->chopString();
+        && m_private->m_text.lastAtom()->string().endsWith(QLatin1String("\n\n")))
+        m_private->m_text.lastAtom()->chopString();
     if (p2.isEmpty())
-        m_private->text << Atom(Atom::Link, p1);
+        m_private->m_text << Atom(Atom::Link, p1);
     else
-        m_private->text << LinkAtom(p1, p2);
+        m_private->m_text << LinkAtom(p1, p2);
 }
 
 void DocParser::appendChar(QChar ch)
 {
-    if (m_private->text.lastAtom()->type() != Atom::String)
+    if (m_private->m_text.lastAtom()->type() != Atom::String)
         append(Atom::String);
-    Atom *atom = m_private->text.lastAtom();
+    Atom *atom = m_private->m_text.lastAtom();
     if (ch == QLatin1Char(' ')) {
         if (!atom->string().endsWith(QLatin1Char(' ')))
             atom->appendChar(QLatin1Char(' '));
@@ -1687,17 +1688,17 @@ void DocParser::appendChar(QChar ch)
 
 void DocParser::appendWord(const QString &word)
 {
-    if (m_private->text.lastAtom()->type() != Atom::String) {
+    if (m_private->m_text.lastAtom()->type() != Atom::String) {
         append(Atom::String, word);
     } else
-        m_private->text.lastAtom()->appendString(word);
+        m_private->m_text.lastAtom()->appendString(word);
 }
 
 void DocParser::appendToCode(const QString &markedCode)
 {
     if (!isCode(m_lastAtom)) {
         append(Atom::Code);
-        m_lastAtom = m_private->text.lastAtom();
+        m_lastAtom = m_private->m_text.lastAtom();
     }
     m_lastAtom->appendString(markedCode);
 }
@@ -1706,7 +1707,7 @@ void DocParser::appendToCode(const QString &markedCode, Atom::AtomType defaultTy
 {
     if (!isCode(m_lastAtom)) {
         append(defaultType, markedCode);
-        m_lastAtom = m_private->text.lastAtom();
+        m_lastAtom = m_private->m_text.lastAtom();
     } else {
         m_lastAtom->appendString(markedCode);
     }
@@ -1716,8 +1717,8 @@ void DocParser::enterPara(Atom::AtomType leftType, Atom::AtomType rightType, con
 {
     if (m_paragraphState == OutsideParagraph) {
 
-        if ((m_private->text.lastAtom()->type() != Atom::ListItemLeft)
-            && (m_private->text.lastAtom()->type() != Atom::DivLeft)) {
+        if ((m_private->m_text.lastAtom()->type() != Atom::ListItemLeft)
+            && (m_private->m_text.lastAtom()->type() != Atom::DivLeft)) {
             leaveValueList();
         }
 
@@ -1743,12 +1744,12 @@ void DocParser::leavePara()
             m_pendingFormats.clear();
         }
 
-        if (m_private->text.lastAtom()->type() == m_pendingParagraphLeftType) {
-            m_private->text.stripLastAtom();
+        if (m_private->m_text.lastAtom()->type() == m_pendingParagraphLeftType) {
+            m_private->m_text.stripLastAtom();
         } else {
-            if (m_private->text.lastAtom()->type() == Atom::String
-                && m_private->text.lastAtom()->string().endsWith(QLatin1Char(' '))) {
-                m_private->text.lastAtom()->chopString();
+            if (m_private->m_text.lastAtom()->type() == Atom::String
+                && m_private->m_text.lastAtom()->string().endsWith(QLatin1Char(' '))) {
+                m_private->m_text.lastAtom()->chopString();
             }
             append(m_pendingParagraphRightType, m_pendingParagraphString);
         }
@@ -1766,8 +1767,8 @@ void DocParser::leaveValue()
         m_openedLists.push(OpenedList(OpenedList::Value));
         append(Atom::ListLeft, ATOM_LIST_VALUE);
     } else {
-        if (m_private->text.lastAtom()->type() == Atom::Nop)
-            m_private->text.stripLastAtom();
+        if (m_private->m_text.lastAtom()->type() == Atom::Nop)
+            m_private->m_text.stripLastAtom();
         append(Atom::ListItemRight, ATOM_LIST_VALUE);
     }
 }
@@ -1776,8 +1777,8 @@ void DocParser::leaveValueList()
 {
     leavePara();
     if (!m_openedLists.isEmpty() && (m_openedLists.top().style() == OpenedList::Value)) {
-        if (m_private->text.lastAtom()->type() == Atom::Nop)
-            m_private->text.stripLastAtom();
+        if (m_private->m_text.lastAtom()->type() == Atom::Nop)
+            m_private->m_text.stripLastAtom();
         append(Atom::ListItemRight, ATOM_LIST_VALUE);
         append(Atom::ListRight, ATOM_LIST_VALUE);
         m_openedLists.pop();
@@ -1829,11 +1830,11 @@ bool DocParser::expandMacro()
 
     m_endPosition = m_position;
     if (!cmdStr.isEmpty()) {
-        if (m_utilities.macroHash.contains(cmdStr)) {
-            const Macro &macro = m_utilities.macroHash.value(cmdStr);
-            if (!macro.defaultDef.isEmpty()) {
-                QString expanded = expandMacroToString(cmdStr, macro.defaultDef, macro.numParams,
-                                                       macro.otherDefs.value("match"));
+        if (s_utilities.macroHash.contains(cmdStr)) {
+            const Macro &macro = s_utilities.macroHash.value(cmdStr);
+            if (!macro.m_defaultDef.isEmpty()) {
+                QString expanded = expandMacroToString(cmdStr, macro.m_defaultDef, macro.numParams,
+                                                       macro.m_otherDefs.value("match"));
                 m_input.replace(backslashPos, m_position - backslashPos, expanded);
                 m_inputLength = m_input.length();
                 m_position = backslashPos;
@@ -2402,8 +2403,8 @@ QString DocParser::untabifyEtc(const QString &str)
         if (character == QLatin1Char('\r'))
             continue;
         if (character == QLatin1Char('\t')) {
-            result += &"        "[column % tabSize];
-            column = ((column / tabSize) + 1) * tabSize;
+            result += &"        "[column % s_tabSize];
+            column = ((column / s_tabSize) + 1) * s_tabSize;
             continue;
         }
         if (character == QLatin1Char('\n')) {