tools/qdoc3/codeparser.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the tools applications of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 /*
  43   codeparser.cpp
  44 */
  45
  46 #include <QtCore>
  47 #include "codeparser.h"
  48 #include "node.h"
  49 #include "tree.h"
  50 #include "config.h"
  51
  52 QT_BEGIN_NAMESPACE
  53
  54 #define COMMAND_COMPAT                  Doc::alias(QLatin1String("compat"))
  55 #define COMMAND_DEPRECATED              Doc::alias(QLatin1String("deprecated")) // ### don't document
  56 #define COMMAND_INGROUP                 Doc::alias(QLatin1String("ingroup"))
  57 #define COMMAND_INMODULE                Doc::alias(QLatin1String("inmodule"))  // ### don't document
  58 #define COMMAND_INTERNAL                Doc::alias(QLatin1String("internal"))
  59 #define COMMAND_MAINCLASS               Doc::alias(QLatin1String("mainclass"))
  60 #define COMMAND_NONREENTRANT            Doc::alias(QLatin1String("nonreentrant"))
  61 #define COMMAND_OBSOLETE                Doc::alias(QLatin1String("obsolete"))
  62 #define COMMAND_PRELIMINARY             Doc::alias(QLatin1String("preliminary"))
  63 #define COMMAND_INPUBLICGROUP           Doc::alias(QLatin1String("inpublicgroup"))
  64 #define COMMAND_REENTRANT               Doc::alias(QLatin1String("reentrant"))
  65 #define COMMAND_SINCE                   Doc::alias(QLatin1String("since"))
  66 #define COMMAND_SUBTITLE                Doc::alias(QLatin1String("subtitle"))
  67 #define COMMAND_THREADSAFE              Doc::alias(QLatin1String("threadsafe"))
  68 #define COMMAND_TITLE                   Doc::alias(QLatin1String("title"))
  69
  70 QList<CodeParser *> CodeParser::parsers;
  71 bool CodeParser::showInternal = false;
  72
  73 /*!
  74   The constructor adds this code parser to the static
  75   list of code parsers.
  76  */
  77 CodeParser::CodeParser()
  78 {
  79     parsers.prepend(this);
  80 }
  81
  82 /*!
  83   The destructor removes this code parser from the static
  84   list of code parsers.
  85  */
  86 CodeParser::~CodeParser()
  87 {
  88     parsers.removeAll(this);
  89 }
  90
  91 /*!
  92   Initialize the code parser base class.
  93  */
  94 void CodeParser::initializeParser(const Config& config)
  95 {
  96     showInternal = config.getBool(QLatin1String(CONFIG_SHOWINTERNAL));
  97 }
  98
  99 /*!
 100   Teerminating a code parser is trivial.
 101  */
 102 void CodeParser::terminateParser()
 103 {
 104     // nothing.
 105 }
 106
 107 QString CodeParser::headerFileNameFilter()
 108 {
 109     return sourceFileNameFilter();
 110 }
 111
 112 void CodeParser::parseHeaderFile(const Location& location,
 113                                  const QString& filePath,
 114                                  Tree *tree)
 115 {
 116     parseSourceFile(location, filePath, tree);
 117 }
 118
 119 void CodeParser::doneParsingHeaderFiles(Tree *tree)
 120 {
 121     doneParsingSourceFiles(tree);
 122 }
 123
 124 /*!
 125   All the code parsers in the static list are initialized here,
 126   after the qdoc configuration variables have been set.
 127  */
 128 void CodeParser::initialize(const Config& config)
 129 {
 130     QList<CodeParser *>::ConstIterator p = parsers.begin();
 131     while (p != parsers.end()) {
 132         (*p)->initializeParser(config);
 133         ++p;
 134     }
 135 }
 136
 137 /*!
 138   All the code parsers in the static list are terminated here.
 139  */
 140 void CodeParser::terminate()
 141 {
 142     QList<CodeParser *>::ConstIterator p = parsers.begin();
 143     while (p != parsers.end()) {
 144         (*p)->terminateParser();
 145         ++p;
 146     }
 147 }
 148
 149 CodeParser *CodeParser::parserForLanguage(const QString& language)
 150 {
 151     QList<CodeParser *>::ConstIterator p = parsers.begin();
 152     while (p != parsers.end()) {
 153         if ((*p)->language() == language)
 154             return *p;
 155         ++p;
 156     }
 157     return 0;
 158 }
 159
 160 /*!
 161   Returns the set of strings representing the common metacommands.
 162  */
 163 QSet<QString> CodeParser::commonMetaCommands()
 164 {
 165     return QSet<QString>() << COMMAND_COMPAT
 166                            << COMMAND_DEPRECATED
 167                            << COMMAND_INGROUP
 168                            << COMMAND_INMODULE
 169                            << COMMAND_INTERNAL
 170                            << COMMAND_MAINCLASS
 171                            << COMMAND_NONREENTRANT
 172                            << COMMAND_OBSOLETE
 173                            << COMMAND_PRELIMINARY
 174                            << COMMAND_INPUBLICGROUP
 175                            << COMMAND_REENTRANT
 176                            << COMMAND_SINCE
 177                            << COMMAND_SUBTITLE
 178                            << COMMAND_THREADSAFE
 179                            << COMMAND_TITLE;
 180 }
 181
 182 /*!
 183   The topic command has been processed. Now process the other
 184   metacommands that were found. These are not the text markup
 185   commands.
 186  */
 187 void CodeParser::processCommonMetaCommand(const Location &location,
 188                                           const QString &command,
 189                                           const QString &arg,
 190                                           Node *node,
 191                                           Tree *tree)
 192 {
 193     if (command == COMMAND_COMPAT) {
 194         node->setStatus(Node::Compat);
 195     }
 196     else if (command == COMMAND_DEPRECATED) {
 197         node->setStatus(Node::Deprecated);
 198     }
 199     else if (command == COMMAND_INGROUP) {
 200         tree->addToGroup(node, arg);
 201     }
 202     else if (command == COMMAND_INPUBLICGROUP) {
 203         tree->addToPublicGroup(node, arg);
 204     }
 205     else if (command == COMMAND_INMODULE) {
 206         node->setModuleName(arg);
 207     }
 208     else if (command == COMMAND_MAINCLASS) {
 209         node->setStatus(Node::Main);
 210     }
 211     else if (command == COMMAND_OBSOLETE) {
 212         if (node->status() != Node::Compat)
 213             node->setStatus(Node::Obsolete);
 214     }
 215     else if (command == COMMAND_NONREENTRANT) {
 216         node->setThreadSafeness(Node::NonReentrant);
 217     }
 218     else if (command == COMMAND_PRELIMINARY) {
 219         node->setStatus(Node::Preliminary);
 220     }
 221     else if (command == COMMAND_INTERNAL) {
 222         if (!showInternal) {
 223             node->setAccess(Node::Private);
 224             node->setStatus(Node::Internal);
 225         }
 226     }
 227     else if (command == COMMAND_REENTRANT) {
 228         node->setThreadSafeness(Node::Reentrant);
 229     }
 230     else if (command == COMMAND_SINCE) {
 231         node->setSince(arg);
 232     }
 233     else if (command == COMMAND_SUBTITLE) {
 234         if (node->type() == Node::Fake) {
 235             FakeNode *fake = static_cast<FakeNode *>(node);
 236             fake->setSubTitle(arg);
 237         }
 238         else
 239             location.warning(tr("Ignored '\\%1'").arg(COMMAND_SUBTITLE));
 240     }
 241     else if (command == COMMAND_THREADSAFE) {
 242         node->setThreadSafeness(Node::ThreadSafe);
 243     }
 244     else if (command == COMMAND_TITLE) {
 245         if (node->type() == Node::Fake) {
 246             FakeNode *fake = static_cast<FakeNode *>(node);
 247             fake->setTitle(arg);
 248         }
 249         else
 250             location.warning(tr("Ignored '\\%1'").arg(COMMAND_TITLE));
 251     }
 252 }
 253
 254 QT_END_NAMESPACE