Initial import of statemachine branch from the old kinetic repository

1 files changed, 944 insertions, 0 deletions

diff --git a/tools/qdoc3/qscodeparser.cpp b/tools/qdoc3/qscodeparser.cpp
new file mode 100644
index 0000000..1a8902e
--- /dev/null
+++ b/tools/qdoc3/qscodeparser.cpp
@@ -0,0 +1,944 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*
+  qscodeparser.cpp
+*/
+
+#include <qfile.h>
+#include <qregexp.h>
+
+#include "config.h"
+#include "qscodeparser.h"
+#include "text.h"
+#include "tokenizer.h"
+#include "tree.h"
+
+QT_BEGIN_NAMESPACE
+
+#define CONFIG_QUICK                    "quick"
+#define CONFIG_REPLACES                 "replaces"
+
+#define COMMAND_BRIEF                   Doc::alias( "brief")
+#define COMMAND_CODE                    Doc::alias( "code")
+#define COMMAND_ENDCODE                 Doc::alias( "endcode")
+#define COMMAND_ENDQUICKCODE            Doc::alias( "endquickcode")
+#define COMMAND_FILE                    Doc::alias( "file")
+#define COMMAND_GROUP                   Doc::alias( "group")
+#define COMMAND_MODULE                  Doc::alias( "module")
+#define COMMAND_PAGE                    Doc::alias( "page")
+#define COMMAND_QUICKCLASS              Doc::alias( "quickclass")
+#define COMMAND_QUICKCODE               Doc::alias( "quickcode")
+#define COMMAND_QUICKENUM               Doc::alias( "quickenum")
+#define COMMAND_QUICKFN                 Doc::alias( "quickfn")
+#define COMMAND_QUICKIFY                Doc::alias( "quickify")
+#define COMMAND_QUICKPROPERTY           Doc::alias( "quickproperty")
+#define COMMAND_PROTECTED               Doc::alias( "protected")
+#define COMMAND_REPLACE                 Doc::alias( "replace")
+
+static QString balancedParens = "(?:[^()]+|\\([^()]*\\))*";
+
+QsCodeParser::QsCodeParser(Tree *cppTree)
+    : cppTre(cppTree), qsTre(0), replaceRegExp("/(.+)/([^/]*)/")
+{
+}
+
+QsCodeParser::~QsCodeParser()
+{
+}
+
+void QsCodeParser::initializeParser(const Config& config)
+{
+    CppCodeParser::initializeParser(config);
+
+    nodeTypeMap.insert(COMMAND_QUICKCLASS, Node::Class);
+    nodeTypeMap.insert(COMMAND_QUICKENUM, Node::Enum);
+    nodeTypeMap.insert(COMMAND_QUICKPROPERTY, Node::Property);
+    nodeTypeMap.insert(COMMAND_QUICKFN, Node::Function);
+
+    QString quickDotReplaces = CONFIG_QUICK + Config::dot + CONFIG_REPLACES;
+    QStringList replaces = config.getStringList(quickDotReplaces);
+    QStringList::ConstIterator r = replaces.begin();
+    while (r != replaces.end()) {
+	if (replaceRegExp.exactMatch(*r)) {
+	    QRegExp before(replaceRegExp.cap(1));
+	    before.setMinimal(true);
+	    QString after = replaceRegExp.cap(2);
+
+	    if (before.isValid()) {
+		replaceBefores << before;
+		replaceAfters << after;
+	    }
+            else {
+		config.lastLocation().warning(
+			tr("Invalid regular expression '%1'")
+			.arg(before.pattern()));
+	    }
+	}
+        else {
+	    config.lastLocation().warning(tr("Bad syntax in '%1'")
+					   .arg(quickDotReplaces));
+	}
+	++r;
+    }
+}
+
+void QsCodeParser::terminateParser()
+{
+    nodeTypeMap.clear();
+    classesWithNoQuickDoc.clear();
+    replaceBefores.clear();
+    replaceAfters.clear();
+    CppCodeParser::terminateParser();
+}
+
+QString QsCodeParser::language()
+{
+    return "Qt Script";
+}
+
+QString QsCodeParser::headerFileNameFilter()
+{
+    return "*";
+}
+
+QString QsCodeParser::sourceFileNameFilter()
+{
+    return "*.qs *.qsd";
+}
+
+void QsCodeParser::parseHeaderFile(const Location& location,
+                                   const QString& filePath,
+                                   Tree *tree)
+{
+    qsTre = tree;
+
+    FILE *in = fopen(QFile::encodeName(filePath), "r");
+    if (in == 0) {
+	location.error(tr("Cannot open Qt Script class list '%1'")
+			.arg(filePath));
+	return;
+    }
+
+    Location fileLocation(filePath);
+    Tokenizer fileTokenizer(fileLocation, in);
+    int tok = fileTokenizer.getToken();
+    while (tok != Tok_Eoi) {
+	if (tok == Tok_Ident) {
+	    ClassNode *quickClass = new ClassNode(qsTre->root(),
+						   fileTokenizer.lexeme());
+	    quickClass->setLocation(fileTokenizer.location());
+	}
+        else {
+	    fileTokenizer.location().error(tr("Unexpected token '%1' in Qt"
+					       " Script class list")
+					    .arg(fileTokenizer.lexeme()));
+	    break;
+	}
+	tok = fileTokenizer.getToken();
+    }
+    fclose(in);
+}
+
+void QsCodeParser::parseSourceFile(const Location& location,
+                                   const QString& filePath,
+                                   Tree *tree)
+{
+    qsTre = tree;
+    CppCodeParser::parseSourceFile(location, filePath, tree);
+}
+
+void QsCodeParser::doneParsingHeaderFiles(Tree *tree)
+{
+    NodeList::ConstIterator c = tree->root()->childNodes().begin();
+    while (c != tree->root()->childNodes().end()) {
+	if ((*c)->type() == Node::Class)
+	    quickifyClass((ClassNode *) *c);
+	++c;
+    }
+    cppTre->root()->deleteChildren(); // save memory
+    tree->resolveInheritance();
+    tree->resolveProperties();
+}
+
+void QsCodeParser::doneParsingSourceFiles(Tree *tree)
+{
+    tree->root()->normalizeOverloads();
+
+    NodeList::ConstIterator c = tree->root()->childNodes().begin();
+    while (c != tree->root()->childNodes().end()) {
+	if ((*c)->type() == Node::Class) {
+	    QMap<QString, Node *>::ConstIterator cwnqd =
+		    classesWithNoQuickDoc.find((*c)->name());
+	    if (cwnqd != classesWithNoQuickDoc.end()) {
+		(*cwnqd)->location().warning(tr("No '\\%1' documentation for"
+						 " class '%2'")
+					      .arg(COMMAND_QUICKCLASS)
+					      .arg(cwnqd.key()));
+		(*cwnqd)->setDoc(Doc(), true);
+	    }
+	}
+	++c;
+    }
+
+    // ### check which enum types are used
+}
+
+FunctionNode *QsCodeParser::findFunctionNode(const QString& synopsis,
+					      Tree *tree)
+{
+    QStringList parentPath;
+    FunctionNode *clone;
+    FunctionNode *func = 0;
+
+    if (makeFunctionNode(synopsis, &parentPath, &clone)) {
+	func = tree->findFunctionNode(parentPath, clone);
+	delete clone;
+    }
+    return func;
+}
+
+QSet<QString> QsCodeParser::topicCommands()
+{
+    return QSet<QString>() << COMMAND_FILE << COMMAND_GROUP << COMMAND_MODULE
+			   << COMMAND_PAGE << COMMAND_QUICKCLASS
+			   << COMMAND_QUICKENUM << COMMAND_QUICKFN
+			   << COMMAND_QUICKPROPERTY;
+}
+
+Node *QsCodeParser::processTopicCommand(const Doc& doc,
+                                        const QString& command,
+                                        const QString& arg)
+{
+    if (command == COMMAND_QUICKFN) {
+	QStringList parentPath;
+	FunctionNode *quickFunc = 0;
+	FunctionNode *clone;
+
+	if (makeFunctionNode(arg, &parentPath, &clone)) {
+	    FunctionNode *kernelFunc = findKernelFunction(parentPath,
+							   clone->name());
+	    if (kernelFunc != 0)
+		kernelFunc->setAccess(Node::Private);
+
+	    quickFunc = qsTre->findFunctionNode(parentPath, clone);
+	    if (quickFunc == 0 && kernelFunc != 0) {
+		quickFunc = new FunctionNode(kernelFunc->parent(),
+					      kernelFunc->name());
+		quickFunc->setLocation(kernelFunc->location());
+		quickFunc->setReturnType(clone->returnType());
+		quickFunc->setParameters(clone->parameters());
+	    }
+
+	    if (quickFunc == 0) {
+		doc.location().warning(tr("Cannot find '%1' specified with '\\%2'")
+					.arg(arg).arg(command));
+	    }
+            else {
+		quickFunc->setAccess(Node::Public);
+		QStringList qtParams = quickFunc->parameterNames();
+		quickFunc->borrowParameterNames(clone);
+		QStringList quickParams = quickFunc->parameterNames();
+		setQuickDoc(quickFunc, doc, qtParams, quickParams);
+	    }
+	    delete clone;
+	}
+        else {
+	    doc.location().warning(tr("Cannot find '%1' specified with '\\%2'")
+				    .arg(arg).arg(command));
+	}
+	return 0;
+    }
+    else if (nodeTypeMap.contains(command)) {
+	QStringList subArgs = arg.split(" ");
+	QString dataType;
+
+	if (subArgs.count() == 3 && subArgs[1] == ":") {
+	    dataType = subArgs[2];
+	}
+        else if (subArgs.count() != 1) {
+	    doc.location().warning(tr("Invalid syntax in '\\%1'")
+				    .arg(command));
+	}
+
+	QStringList path = subArgs[0].split(".");
+	Node *quickNode = qsTre->findNode(path, nodeTypeMap[command]);
+	if (quickNode == 0) {
+	    doc.location().warning(tr("Cannot find '%1' specified with '\\%2'")
+				    .arg(arg).arg(command));
+	}
+        else {
+	    setQuickDoc(quickNode, doc);
+	    if (quickNode->type() == Node::Class) {
+		classesWithNoQuickDoc.remove(quickNode->name());
+		if (doc.briefText().isEmpty())
+		    doc.location().warning(tr("Missing '\\%1' for class '%2'")
+					    .arg(COMMAND_BRIEF)
+					    .arg(quickNode->name()));
+	    }
+            else if (quickNode->type() == Node::Property) {
+		PropertyNode *quickProperty = (PropertyNode *) quickNode;
+		if (quickProperty->dataType() == "Object") {
+		    if (dataType.isEmpty()) {
+			doc.location().warning(tr("Missing data type in '\\%1'"
+						   " (assuming 'Object')")
+						.arg(command));
+		    }
+                    else {
+			quickProperty->setDataType(dataType);
+		    }
+		}
+                else if (dataType != quickProperty->dataType()) {
+		    doc.location().warning(tr("Ignored contradictory data type"
+					       " in '\\%1'")
+					    .arg(command));
+		}
+	    }
+	}
+	return 0;
+    }
+    else {
+	return CppCodeParser::processTopicCommand(doc, command, arg);
+    }
+}
+
+QSet<QString> QsCodeParser::otherMetaCommands()
+{
+    return commonMetaCommands() << COMMAND_ENDQUICKCODE << COMMAND_QUICKCODE
+				<< COMMAND_QUICKIFY << COMMAND_REPLACE;
+}
+
+void QsCodeParser::processOtherMetaCommand(const Doc& doc,
+                                           const QString& command,
+                                           const QString& arg,
+                                           Node *node)
+{
+    if (command == COMMAND_PROTECTED) {
+	doc.location().warning(tr("Cannot use '\\%1' in %2")
+				.arg(COMMAND_PROTECTED).arg(language()));
+    }
+    else {
+	CppCodeParser::processOtherMetaCommand(doc,command,arg,node);
+    }
+}
+
+ClassNode *QsCodeParser::tryClass(const QString& className)
+{
+    return (ClassNode*) cppTre->findNode(QStringList(className),Node::Class);
+}
+
+FunctionNode *QsCodeParser::findKernelFunction(const QStringList& parentPath,
+                                               const QString& name)
+{
+    FunctionNode clone(0, name);
+    clone.setReturnType("Object");
+    clone.addParameter(Parameter("..."));
+    return qsTre->findFunctionNode(parentPath, &clone);
+}
+
+void QsCodeParser::extractRegExp(const QRegExp& regExp,
+                                 QString& source,
+                                 const Doc& doc)
+{
+    QRegExp blankLineRegExp(
+	    "[ \t]*(?:\n(?:[ \t]*\n)+[ \t]*|[ \n\t]*\\\\code|"
+	    "\\\\endcode[ \n\t]*)");
+    QStringList paras = source.trimmed().split(blankLineRegExp);
+    paras = paras.filter(regExp);
+    if (paras.count() == 0) {
+	doc.location().warning(tr("Cannot find regular expression '%1'")
+				.arg(regExp.pattern()));
+    }
+    else if (paras.count() > 1) {
+	doc.location().warning(tr("Regular rexpression '%1' matches multiple"
+				   "times").arg(regExp.pattern()));
+    }
+    else {
+	source = paras.first() + "\n\n";
+    }
+}
+
+void QsCodeParser::extractTarget(const QString& target,
+                                 QString& source,
+                                 const Doc& doc)
+{
+    QRegExp targetRegExp(
+	    "(\\\\target\\s+(\\S+)[^\n]*\n"
+	    "(?:(?!\\s*\\\\code)[^\n]+\n|\\s*\\\\code.*\\\\endcode\\s*\n)*)"
+	    "(?:\\s*\n|[^\n]*$)");
+    targetRegExp.setMinimal(true);
+
+    int pos = 0;
+    while ((pos = source.indexOf(targetRegExp, pos)) != -1) {
+	if (targetRegExp.cap(2) == target) {
+	    source = targetRegExp.cap(1) + "\n\n";
+	    return;
+	}
+	pos += targetRegExp.matchedLength();
+    }
+    doc.location().warning(tr("Cannot find target '%1'").arg(target));
+}
+
+void QsCodeParser::renameParameters(QString& source,
+                                    const Doc& /* doc */,
+                                    const QStringList& qtParams,
+                                    const QStringList& quickParams)
+{
+    QRegExp paramRegExp("(\\\\a\\s*\\{?\\s*)([A-Za-z0-9_]+)");
+
+    int pos = 0;
+    while ((pos = paramRegExp.indexIn(source, pos)) != -1) {
+	pos += paramRegExp.cap(1).length();
+	QString before = paramRegExp.cap(2);
+	int index = qtParams.indexOf(before);
+	if (index != -1) {
+	    QString after = quickParams[index];
+	    source.replace(pos, before.size(), after);
+	}
+    }
+}
+
+void QsCodeParser::applyReplacementList(QString& source, const Doc& doc)
+{
+    QStringList args = doc.metaCommandArgs(COMMAND_REPLACE);
+    QStringList::ConstIterator a = args.begin();
+    while (a != args.end()) {
+	if (replaceRegExp.exactMatch(*a)) {
+	    QRegExp before(replaceRegExp.cap(1));
+	    before.setMinimal(true);
+	    QString after = replaceRegExp.cap(2);
+
+	    if (before.isValid()) {
+		int oldLen = source.size();
+		source.replace(before, after);
+
+		// this condition is sufficient but not necessary
+		if (oldLen == source.size() && !source.contains(after))
+		    doc.location().warning(
+			    tr("Regular expression '%1' did not match anything")
+			    .arg(before.pattern()));
+	    }
+            else {
+		doc.location().warning(
+			tr("Invalid regular expression '%1'")
+			.arg(before.pattern()));
+	    }
+	}
+        else {
+	    doc.location().warning(tr("Bad syntax in '\\%1'")
+				    .arg(COMMAND_REPLACE));
+	}
+	++a;
+    }
+
+    QRegExp codeRegExp("\\\\" + COMMAND_CODE + "(.*)\\\\" + COMMAND_ENDCODE);
+    codeRegExp.setMinimal(true);
+
+    QRegExp quickcodeRegExp(
+	    "\\\\" + COMMAND_QUICKCODE + "(.*)\\\\" + COMMAND_ENDQUICKCODE);
+    quickcodeRegExp.setMinimal(true);
+
+    int quickcodePos = doc.source().indexOf(quickcodeRegExp);
+    if (quickcodePos != -1) {
+	int codePos = source.indexOf(codeRegExp);
+	if (codePos == -1) {
+	    doc.location().warning(
+		    tr("Cannot find any '\\%1' snippet corresponding to '\\%2'")
+		    .arg(COMMAND_CODE).arg(COMMAND_QUICKCODE));
+	}
+        else {
+	    source.replace(codeRegExp.pos(1), codeRegExp.cap(1).length(),
+			    quickcodeRegExp.cap(1));
+	    codePos = codeRegExp.pos(1) + quickcodeRegExp.cap(1).length();
+
+	    if (doc.source().indexOf(quickcodeRegExp, quickcodePos + 1) != -1) {
+		doc.location().warning(
+			tr("Cannot use '\\%1' twice in a row")
+			.arg(COMMAND_QUICKCODE));
+	    }
+            else if (source.indexOf(codeRegExp, codePos + 1) != -1) {
+		doc.location().warning(tr("Ambiguous '\\%1'")
+					.arg(COMMAND_QUICKCODE));
+	    }
+	}
+    }
+}
+
+void QsCodeParser::quickifyClass(ClassNode *quickClass)
+{
+    QString qtClassName = quickClass->name();
+    QString bare = quickClass->name();
+    if (bare != "Qt" && bare != "Object") {
+	if (bare.startsWith("Q")) {
+	    bare = bare.mid(1);
+	}
+        else {
+	    qtClassName.prepend("Q");
+	    classesWithNoQ.insert(bare);
+	}
+    }
+
+    ClassNode *qtClass = 0;
+    ClassNode *wrapperClass = 0;
+
+    if ((wrapperClass = tryClass("Quick" + bare)) != 0 ||
+	 (wrapperClass = tryClass("QS" + bare + "Class")) != 0) {
+	qtClass = tryClass(qtClassName);
+	if (qtClass == 0) {
+	    qtClass = wrapperClass;
+	    wrapperClass = 0;
+	}
+    }
+    else if ((wrapperClass = tryClass("Quick" + bare + "Ptr")) != 0) {
+	QRegExp ptrToQtType("(Q[A-Za-z0-9_]+)\\s*\\*");
+	FunctionNode *ctor =
+		wrapperClass->findFunctionNode(wrapperClass->name());
+	if (ctor != 0 && !ctor->parameters().isEmpty() &&
+	     ptrToQtType.exactMatch(ctor->parameters().first().leftType()))
+	    qtClassName = ptrToQtType.cap(1);
+	qtClass = tryClass(qtClassName);
+    }
+    else {
+	wrapperClass = tryClass("Q" + bare + "Ptr");
+	if (wrapperClass == 0)
+	    wrapperClass = tryClass("Quick" + bare + "Interface");
+	qtClass = tryClass(qtClassName);
+    }
+
+    if (qtClass == 0) {
+	if (wrapperClass == 0) {
+	    quickClass->location().warning(tr("Cannot find Qt class '%1'")
+					    .arg(qtClassName));
+	}
+        else {
+	    quickClass->location().warning(tr("Cannot find Qt class '%1'"
+					       " wrapped by '%2'")
+					    .arg(qtClassName)
+					    .arg(wrapperClass->name()));
+	}
+	return;
+    }
+
+    QList<RelatedClass>::ConstIterator r = qtClass->baseClasses().begin();
+    while (r != qtClass->baseClasses().end()) {
+	ClassNode *quickBaseClass = cpp2qs.findClassNode(qsTre,
+                                                         (*r).node->name());
+	if (quickBaseClass)
+	    quickClass->addBaseClass((*r).access, quickBaseClass);
+	++r;
+    }
+    if (quickClass->baseClasses().isEmpty() && quickClass->name() != "Object")
+	quickClass->addBaseClass(Node::Public,
+                                 cpp2qs.findClassNode(qsTre,"Object"));
+
+    QSet<QString> funcBlackList;
+    QSet<QString> propertyBlackList;
+
+    NodeList children;
+    if (wrapperClass != 0) {
+	children = wrapperClass->childNodes();
+
+	funcBlackList.insert(wrapperClass->name());
+	funcBlackList.insert("~" + wrapperClass->name());
+    }
+    children += qtClass->childNodes();
+
+    for (int pass = 0; pass < 2; pass++) {
+	NodeList::ConstIterator c = children.begin();
+	while (c != children.end()) {
+	    if ((*c)->access() != Node::Private &&
+		 (*c)->status() == Node::Commendable) {
+		if (pass == 0) {
+		    if ((*c)->type() == Node::Enum) {
+			EnumNode *enume = (EnumNode *) *c;
+			quickifyEnum(quickClass, enume);
+		    }
+                    else if ((*c)->type() == Node::Property) {
+			if (!propertyBlackList.contains((*c)->name())) {
+			    PropertyNode *property = (PropertyNode *) *c;
+			    quickifyProperty(quickClass, qtClass, property);
+			    if (!property->getters().isEmpty())
+				funcBlackList.insert(property->getters().first()->name());
+			    if (!property->setters().isEmpty())
+				funcBlackList.insert(property->setters().first()->name());
+			    if (!property->resetters().isEmpty())
+				funcBlackList.insert(property->resetters().first()->name());
+			    propertyBlackList.insert(property->name());
+			}
+		    }
+		}
+                else if ((*c)->type() == Node::Function)  {
+		    FunctionNode *func = (FunctionNode *) *c;
+		    quickifyFunction(quickClass, qtClass, func,
+				      funcBlackList.contains((*c)->name()) &&
+				      func->parameters().count() < 2);
+		}
+	    }
+	    ++c;
+	}
+    }
+    setQtDoc(quickClass, qtClass->doc());
+    classesWithNoQuickDoc.insert(quickClass->name(), quickClass);
+}
+
+void QsCodeParser::quickifyEnum(ClassNode *quickClass, EnumNode *enume)
+{
+    EnumNode *quickEnum = new EnumNode(quickClass, enume->name());
+    quickEnum->setLocation(enume->location());
+#if 0 // ### not yet
+    quickEnum->setAccess(Node::Protected);
+#endif
+
+    QList<EnumItem>::ConstIterator it = enume->items().begin();
+    while (it != enume->items().end()) {
+	QString name = (*it).name();
+	QString value = (*it).value();
+	quickEnum->addItem(EnumItem(name, value));
+	++it;
+    }
+    setQtDoc(quickEnum, enume->doc());
+}
+
+void QsCodeParser::quickifyFunction(ClassNode *quickClass, ClassNode *qtClass,
+				     FunctionNode *func, bool onBlackList)
+{
+    if (func->metaness() == FunctionNode::Dtor)
+	return;
+
+    FunctionNode *kernelFunc = findKernelFunction(
+	    QStringList() << quickClass->name(), func->name());
+
+    QString quickName = func->name();
+    if (func->metaness() == FunctionNode::Ctor)
+	quickName = quickClass->name();
+    FunctionNode *quickFunc = new FunctionNode(quickClass, quickName);
+    quickFunc->setLocation(func->location());
+
+    if (onBlackList) {
+	quickFunc->setAccess(Node::Protected);
+    }
+    else {
+	if (kernelFunc != 0 && func->numOverloads() == 1 &&
+	     (func->parameters().count() == 0 ||
+	      func->parameters().last().defaultValue().isEmpty())) {
+	    kernelFunc->setAccess(Node::Private);
+	}
+        else {
+	    if (func->metaness() == FunctionNode::Plain)
+		quickFunc->setAccess(Node::Protected);
+	}
+    }
+
+    quickFunc->setReturnType(cpp2qs.convertedDataType(qsTre,
+						       func->returnType()));
+    if (func->metaness() != FunctionNode::Slot)
+	quickFunc->setMetaness(func->metaness());
+    quickFunc->setVirtualness(FunctionNode::ImpureVirtual);
+    quickFunc->setOverload(func->isOverload());
+
+    QList<Parameter>::ConstIterator q = func->parameters().begin();
+    while (q != func->parameters().end()) {
+	QString dataType = cpp2qs.convertedDataType(qsTre, (*q).leftType(),
+						     (*q).rightType());
+	if (dataType.isEmpty()) {
+	    dataType = "UNKNOWN";
+	    quickFunc->setAccess(Node::Private);
+	}
+	Parameter param(dataType, "", (*q).name(),
+			 (*q).defaultValue().isEmpty() ? "" : "undefined");
+	quickFunc->addParameter(param);
+	++q;
+    }
+
+    if (func->doc().isEmpty()) {
+	if (func->parent() != (InnerNode *) qtClass) {
+	    func = qtClass->findFunctionNode(func);
+	    if (func != 0)
+		setQtDoc(quickFunc, func->doc());
+	}
+    }
+    else {
+	setQtDoc(quickFunc, func->doc());
+    }
+}
+
+void QsCodeParser::quickifyProperty(ClassNode *quickClass,
+                                    ClassNode * /* qtClass */,
+				    PropertyNode *property)
+{
+    PropertyNode *quickProperty = new PropertyNode(quickClass,
+                                                   property->name());
+    quickProperty->setLocation(property->location());
+    quickProperty->setDataType(cpp2qs.convertedDataType(qsTre,
+                                                        property->dataType()));
+#if 0
+    quickProperty->setGetter(property->getter());
+    quickProperty->setSetter(property->setter());
+    quickProperty->setResetter(property->resetter());
+#endif
+    quickProperty->setStored(property->isStored());
+    quickProperty->setDesignable(property->isDesignable());
+
+    setQtDoc(quickProperty, property->doc());
+}
+
+QString QsCodeParser::quickifiedDoc(const QString& source)
+{
+    QString result;
+    int i = 0;
+
+    while (i < (int) source.length()) {
+	if (leftWordBoundary(source, i)) {
+	    if (source[i] == 'Q') {
+		if (source[i + 1] == 'C' && source.mid(i, 8) == "QCString") {
+		    i += 2;
+		}
+                else {
+		    int end = i + 1;
+		    while (isWord(source[end]))
+			++end;
+		    if (!classesWithNoQ.contains(
+				  source.mid(i + 1, end - (i + 1))))
+			result += "Q";
+		    i++;
+		}
+	    }
+            else if (source[i] == 'T' && source.mid(i, 4) == "TRUE" &&
+			rightWordBoundary(source, i + 4)) {
+		result += "\\c{true}";
+		i += 4;
+	    }
+            else if (source[i] == 'F' && source.mid(i, 5) == "FALSE" &&
+			rightWordBoundary(source, i + 5)) {
+		result += "\\c{false}";
+		i += 5;
+	    }
+            else if (source[i] == 'c' && source.mid(i, 6) == "const ") {
+		i += 6;
+	    }
+            else {
+		result += source[i++];
+	    }
+	}
+        else if ((source[i] == ':' && source[i + 1] == ':') ||
+		    (source[i] == '-' && source[i + 1] == '>')) {
+	    result += '.';
+	    i += 2;
+	}
+        else if (source[i] == '\\') {
+	    // ### make independent of the command name
+	    if (source.mid(i, 5) == "\\code") {
+		do {
+		    result += source[i++];
+		} while (source[i - 1] != '\n');
+
+		int begin = i;
+		int end = source.indexOf("\\endcode", i);
+		if (end != -1) {
+		    QString code = source.mid(begin, end - begin);
+		    result += cpp2qs.convertedCode(qsTre, code,
+						    classesWithNoQ);
+		    i = end;
+		}
+	    }
+            else {
+		result += source[i++];
+	    }
+	}
+        else {
+	    result += source[i++];
+	}
+    }
+
+    QList<QRegExp>::ConstIterator b = replaceBefores.begin();
+    QStringList::ConstIterator a = replaceAfters.begin();
+    while (a != replaceAfters.end()) {
+	result.replace(*b, *a);
+	++b;
+	++a;
+    }
+    return result;
+}
+
+void QsCodeParser::setQtDoc(Node *quickNode, const Doc& doc)
+{
+    if (!doc.isEmpty()) {
+	Doc quickDoc(doc.location(), doc.location(),
+                     quickifiedDoc(doc.source()),
+		     CppCodeParser::topicCommands() +
+                     CppCodeParser::otherMetaCommands());
+	quickNode->setDoc(quickDoc, true);
+    }
+}
+
+void QsCodeParser::setQuickDoc(Node *quickNode,
+                               const Doc& doc,
+                               const QStringList& qtParams,
+                               const QStringList& quickParams)
+{
+    QRegExp quickifyCommand("\\\\" + COMMAND_QUICKIFY + "([^\n]*)(?:\n|$)");
+
+    if (quickNode->type() == Node::Function) {
+	FunctionNode *quickFunc = (FunctionNode *) quickNode;
+	quickFunc->setOverload(false);
+    }
+
+    if (doc.metaCommandsUsed().contains(COMMAND_QUICKIFY)) {
+	QString source = doc.source();
+	int pos = source.indexOf(quickifyCommand);
+	if (pos != -1) {
+	    QString quickifiedSource = quickNode->doc().source();
+	    if (!qtParams.isEmpty() && qtParams != quickParams)
+		renameParameters(quickifiedSource, doc, qtParams,
+				  quickParams);
+	    applyReplacementList(quickifiedSource, doc);
+
+	    do {
+		QString extract = quickifiedSource;
+		QString arg = quickifyCommand.cap(1).simplified();
+		if (!arg.isEmpty()) {
+		    if (arg.startsWith("/") && arg.endsWith("/") &&
+			 arg.length() > 2) {
+			QString pattern = arg.mid(1, arg.length() - 2);
+			extractRegExp(QRegExp(pattern), extract, doc);
+		    }
+                    else {
+			extractTarget(arg, extract, doc);
+		    }
+		}
+		source.replace(pos, quickifyCommand.matchedLength(), extract);
+		pos += extract.length();
+	    } while ((pos = source.indexOf(quickifyCommand, pos)) != -1);
+
+	    QRegExp quickcodeRegExp(
+		    "\\\\" + COMMAND_QUICKCODE + "(.*)\\\\" +
+		    COMMAND_ENDQUICKCODE);
+	    quickcodeRegExp.setMinimal(true);
+	    source.replace(quickcodeRegExp, "");
+	}
+
+	Doc quickDoc(doc.location(),
+                     doc.location(),
+                     source,
+                     (CppCodeParser::topicCommands() + topicCommands() +
+                      CppCodeParser::otherMetaCommands()) << COMMAND_REPLACE);
+	quickNode->setDoc(quickDoc, true);
+	processOtherMetaCommands(quickDoc, quickNode);
+    }
+    else {
+	quickNode->setDoc(doc, true);
+	processOtherMetaCommands(doc, quickNode);
+    }
+}
+
+bool QsCodeParser::makeFunctionNode(const QString& synopsis,
+				     QStringList *parentPathPtr,
+				     FunctionNode **funcPtr)
+{
+    QRegExp funcRegExp(
+	    "\\s*([A-Za-z0-9_]+)\\.([A-Za-z0-9_]+)\\s*\\((" +
+            balancedParens +
+	    ")\\)(?:\\s*:\\s*([A-Za-z0-9_]+))?\\s*");
+    QRegExp paramRegExp(
+	    "\\s*(\\[)?\\s*(?:([A-Za-z0-9_]+)\\s*:\\s*)?"
+	    "([A-Za-z0-9_]+|\\.\\.\\.)\\s*(\\[)?[\\s\\]]*");
+
+    if (!funcRegExp.exactMatch(synopsis))
+	return false;
+
+    ClassNode *classe = (ClassNode*)
+        qsTre->findNode(QStringList(funcRegExp.cap(1)),Node::Class);
+    if (classe == 0)
+	return false;
+
+    FunctionNode *clone = new FunctionNode(0, funcRegExp.cap(2));
+    bool optional = false;
+
+    QString paramStr = funcRegExp.cap(3);
+    QStringList params = paramStr.split(",");
+    QStringList::ConstIterator p = params.begin();
+    while (p != params.end()) {
+	if (paramRegExp.exactMatch(*p)) {
+	    if (!paramRegExp.cap(1).isEmpty())
+		optional = true;
+	    clone->addParameter(Parameter(paramRegExp.cap(3),
+                                          "",
+                                          paramRegExp.cap(2),
+                                          optional ? "undefined" : ""));
+	    if (!paramRegExp.cap(4).isEmpty())
+		optional = true;
+	}
+        else {
+	    delete clone;
+	    return false;
+	}
+	++p;
+    }
+    QString returnType = funcRegExp.cap(4);
+    if (!returnType.isEmpty())
+	clone->setReturnType(returnType);
+    if (parentPathPtr != 0)
+	*parentPathPtr = QStringList() << classe->name();
+    if (funcPtr != 0) {
+	*funcPtr = clone;
+    }
+    else {
+	delete clone;
+    }
+    return true;
+}
+
+bool QsCodeParser::isWord(QChar ch)
+{
+    return ch.isLetterOrNumber() || ch == QChar('_');
+}
+
+bool QsCodeParser::leftWordBoundary(const QString& str, int pos)
+{
+    return !isWord(str[pos - 1]) && isWord(str[pos]);
+}
+
+bool QsCodeParser::rightWordBoundary(const QString& str, int pos)
+{
+    return isWord(str[pos - 1]) && !isWord(str[pos]);
+}
+
+QT_END_NAMESPACE