1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 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