rock-qtbindings 4.8.6.5

data/ext/generator/generators/CMakeLists.txt

@@ -0,0 +1,4 @@
+string(REPLACE "-Wl,--no-undefined" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+add_subdirectory(smoke)
+add_subdirectory(dump)

data/ext/generator/generators/dump/CMakeLists.txt

@@ -0,0 +1,15 @@
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../..)
+
+set(generator_dump_SRC
+    generator_dump.cpp)
+
+add_library(generator_dump MODULE ${generator_dump_SRC})
+target_link_libraries(generator_dump ${QT_QTCORE_LIBRARY} smokegen)
+set_target_properties(generator_dump PROPERTIES PREFIX "")
+
+if (WIN32)
+	# Realign the stack, for compatibility with an older ABI.
+	set_target_properties (generator_dump PROPERTIES COMPILE_FLAGS -mstackrealign)
+endif (WIN32)
+
+install(TARGETS generator_dump LIBRARY DESTINATION ${LIB_INSTALL_DIR}/smokegen)

data/ext/generator/generators/dump/generator_dump.cpp

@@ -0,0 +1,36 @@
+/*
+    Dump all parsed classes to stdout.
+    Copyright (C) 2009 Arno Rehn <arno@arnorehn.de>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include <QFileInfo>
+#include <QList>
+
+#include <type.h>
+
+#include <iostream>
+
+extern "C" Q_DECL_EXPORT
+void generate()
+{
+    foreach (const QString& className, classes.keys()) {
+        std::cout << qPrintable(className);
+        if (classes[className].isForwardDecl())
+            std::cout << " [forward declaration]";
+        std::cout << std::endl;
+    }
+}

data/ext/generator/generators/smoke/CMakeLists.txt

@@ -0,0 +1,18 @@
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../..)
+
+set(generator_smoke_SRC
+    generator_smoke.cpp
+    writeClasses.cpp
+    writeSmokeDataFile.cpp
+    helpers.cpp)
+
+add_library(generator_smoke MODULE ${generator_smoke_SRC})
+target_link_libraries(generator_smoke ${QT_QTCORE_LIBRARY} ${QT_QTXML_LIBRARY} smokegen)
+set_target_properties(generator_smoke PROPERTIES PREFIX "")
+
+if (WIN32)
+	# Realign the stack, for compatibility with an older ABI.
+	set_target_properties (generator_smoke PROPERTIES COMPILE_FLAGS -mstackrealign)
+endif (WIN32)
+
+install(TARGETS generator_smoke LIBRARY DESTINATION ${LIB_INSTALL_DIR}/smokegen/)

data/ext/generator/generators/smoke/generator_smoke.cpp

@@ -0,0 +1,240 @@
+/*
+    Generator for the SMOKE sources
+    Copyright (C) 2009 Arno Rehn <arno@arnorehn.de>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include <QCoreApplication>
+#include <QDir>
+#include <QFileInfo>
+#include <QHash>
+#include <QSet>
+#include <QString>
+#include <QtDebug>
+
+#include <QtXml>
+
+#include <iostream>
+
+#include <type.h>
+
+#include "globals.h"
+#include "../../options.h"
+
+QDir Options::outputDir = QDir::current();
+QList<QFileInfo> Options::headerList;
+QStringList Options::classList;
+
+int Options::parts = 20;
+QString Options::module = "qt";
+QStringList Options::parentModules;
+QStringList Options::scalarTypes;
+QStringList Options::voidpTypes;
+bool Options::qtMode = false;
+QList<QRegExp> Options::excludeExpressions;
+QList<QRegExp> Options::includeFunctionNames;
+QList<QRegExp> Options::includeFunctionSignatures;
+
+static void showUsage()
+{
+    std::cout <<
+    "Usage: generator -g smoke [smoke generator options] [other generator options] -- <headers>" << std::endl <<
+    "    -m <module name> (default: 'qt')" << std::endl <<
+    "    -p <parts> (default: 20)" << std::endl <<
+    "    -pm <comma-seperated list of parent modules>" << std::endl <<
+    "    -st <comma-seperated list of types that should be munged to scalars>" << std::endl <<
+    "    -vt <comma-seperated list of types that should be mapped to Smoke::t_voidp>" << std::endl;
+}
+
+extern "C" Q_DECL_EXPORT
+int generate()
+{
+    Options::headerList = ParserOptions::headerList;
+    
+    QFileInfo smokeConfig;
+    
+    const QStringList& args = QCoreApplication::arguments();
+    for (int i = 0; i < args.count(); i++) {
+        if ((args[i] == "-m" || args[i] == "-p" || args[i] == "-pm" || args[i] == "-o" ||
+             args[i] == "-st" || args[i] == "-vt" || args[i] == "-smokeconfig") && i + 1 >= args.count())
+        {
+            qCritical() << "generator_smoke: not enough parameters for option" << args[i];
+            return EXIT_FAILURE;
+        } else if (args[i] == "-m") {
+            Options::module = args[++i];
+        } else if (args[i] == "-p") {
+            bool ok = false;
+            Options::parts = args[++i].toInt(&ok);
+            if (!ok) {
+                qCritical() << "generator_smoke: couldn't parse argument for option" << args[i - 1];
+                return EXIT_FAILURE;
+            }
+        } else if (args[i] == "-pm") {
+            Options::parentModules = args[++i].split(',');
+        } else if (args[i] == "-st") {
+            Options::scalarTypes = args[++i].split(',');
+        } else if (args[i] == "-vt") {
+            Options::voidpTypes = args[++i].split(',');
+        } else if (args[i] == "-smokeconfig") {
+            smokeConfig = QFileInfo(args[++i]);
+        } else if (args[i] == "-o") {
+            Options::outputDir = QDir(args[++i]);
+        } else if (args[i] == "-h" || args[i] == "--help") {
+            showUsage();
+            return EXIT_SUCCESS;
+        }
+    }
+    
+    if (smokeConfig.exists()) {
+        QFile file(smokeConfig.filePath());
+        file.open(QIODevice::ReadOnly);
+        QDomDocument doc;
+        doc.setContent(file.readAll());
+        file.close();
+        QDomElement root = doc.documentElement();
+        QDomNode node = root.firstChild();
+        while (!node.isNull()) {
+            QDomElement elem = node.toElement();
+            if (elem.isNull()) {
+                node = node.nextSibling();
+                continue;
+            }
+            if (elem.tagName() == "outputDir") {
+                Options::outputDir = QDir(elem.text());
+            } else if (elem.tagName() == "moduleName") {
+                Options::module = elem.text();
+            } else if (elem.tagName() == "parts") {
+                Options::parts = elem.text().toInt();
+            } else if (elem.tagName() == "parentModules") {
+                QDomNode parent = elem.firstChild();
+                while (!parent.isNull()) {
+                    QDomElement elem = parent.toElement();
+                    if (elem.isNull()) {
+                        parent = parent.nextSibling();
+                        continue;
+                    }
+                    if (elem.tagName() == "module") {
+                        Options::parentModules << elem.text();
+                    }
+                    parent = parent.nextSibling();
+                }
+            } else if (elem.tagName() == "scalarTypes") {
+                QDomNode typeName = elem.firstChild();
+                while (!typeName.isNull()) {
+                    QDomElement elem = typeName.toElement();
+                    if (elem.isNull()) {
+                        typeName = typeName.nextSibling();
+                        continue;
+                    }
+                    if (elem.tagName() == "typeName") {
+                        Options::scalarTypes << elem.text();
+                    }
+                    typeName = typeName.nextSibling();
+                }
+            } else if (elem.tagName() == "voidpTypes") {
+                QDomNode typeName = elem.firstChild();
+                while (!typeName.isNull()) {
+                    QDomElement elem = typeName.toElement();
+                    if (elem.isNull()) {
+                        typeName = typeName.nextSibling();
+                        continue;
+                    }
+                    if (elem.tagName() == "typeName") {
+                        Options::voidpTypes << elem.text();
+                    }
+                    typeName = typeName.nextSibling();
+                }
+            } else if (elem.tagName() == "classList") {
+                QDomNode klass = elem.firstChild();
+                while (!klass.isNull()) {
+                    QDomElement elem = klass.toElement();
+                    if (elem.isNull()) {
+                        klass = klass.nextSibling();
+                        continue;
+                    }
+                    if (elem.tagName() == "class") {
+                        Options::classList << elem.text();
+                    }
+                    klass = klass.nextSibling();
+                }
+            } else if (elem.tagName() == "exclude") {
+                QDomNode typeName = elem.firstChild();
+                while (!typeName.isNull()) {
+                    QDomElement elem = typeName.toElement();
+                    if (elem.isNull()) {
+                        typeName = typeName.nextSibling();
+                        continue;
+                    }
+                    if (elem.tagName() == "signature") {
+                        Options::excludeExpressions << QRegExp(elem.text());
+                    }
+                    typeName = typeName.nextSibling();
+                }
+            } else if (elem.tagName() == "functions") {
+                QDomNode function = elem.firstChild();
+                while (!function.isNull()) {
+                    QDomElement elem = function.toElement();
+                    if (elem.isNull()) {
+                        function = function.nextSibling();
+                        continue;
+                    }
+                    if (elem.tagName() == "name") {
+                        Options::includeFunctionNames << QRegExp(elem.text());
+                    } else if (elem.tagName() == "signature") {
+                        Options::includeFunctionSignatures << QRegExp(elem.text());
+                    }
+                    function = function.nextSibling();
+                }
+            }
+            node = node.nextSibling();
+        }
+    } else {
+        qWarning() << "Couldn't find config file" << smokeConfig.filePath();
+    }
+    
+    if (!Options::outputDir.exists()) {
+        qWarning() << "output directoy" << Options::outputDir.path() << "doesn't exist; creating it...";
+        QDir::current().mkpath(Options::outputDir.path());
+    }
+    
+    Options::qtMode = ParserOptions::qtMode;
+
+    Options::voidpTypes << "long long" << "long long int" << "unsigned long long" << "unsigned long long int";
+    Options::scalarTypes << "long long" << "long long int" << "unsigned long long" << "unsigned long long int";
+    
+    // Fill the type map. It maps some long integral types to shorter forms as used in SMOKE.
+    Util::typeMap["long int"] = "long";
+    Util::typeMap["short int"] = "short";
+    Util::typeMap["long double"] = "double";
+    Util::typeMap["wchar_t"] = "int";   // correct?
+
+    if (sizeof(unsigned int) == sizeof(size_t)) {
+        Util::typeMap["size_t"] = "uint";
+    } else if (sizeof(unsigned long) == sizeof(size_t)) {
+        Util::typeMap["size_t"] = "ulong";
+    }
+
+    qDebug() << "Generating SMOKE sources...";
+    
+    SmokeDataFile smokeData;
+    smokeData.write();
+    SmokeClassFiles classFiles(&smokeData);
+    classFiles.write();
+    
+    qDebug() << "Done.";
+    
+    return EXIT_SUCCESS;
+}

data/ext/generator/generators/smoke/globals.h

@@ -0,0 +1,140 @@
+/*
+    Generator for the SMOKE sources
+    Copyright (C) 2009 Arno Rehn <arno@arnorehn.de>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef GLOBALS_H
+#define GLOBALS_H
+
+#include <QMap>
+#include <QSet>
+#include <QString>
+#include <QStringList>
+
+template<typename T>
+class QStack;
+
+class QDir;
+class QFileInfo;
+class QString;
+class QStringList;
+class QTextStream;
+
+class Class;
+class Function;
+class Member;
+class Method;
+class Field;
+class Type;
+
+struct Options
+{
+    static QDir outputDir;
+    static int parts;
+    static QString module;
+    static QStringList parentModules;
+    static QStringList scalarTypes;
+    static QStringList voidpTypes;
+    static QList<QFileInfo> headerList;
+    static QStringList classList;
+    static bool qtMode;
+    
+    static QList<QRegExp> excludeExpressions;
+    static QList<QRegExp> includeFunctionNames;
+    static QList<QRegExp> includeFunctionSignatures;
+    
+    static bool typeExcluded(const QString& typeName);
+    static bool functionNameIncluded(const QString& fnName);
+    static bool functionSignatureIncluded(const QString& sig);
+};
+
+struct SmokeDataFile
+{
+    SmokeDataFile();
+
+    void write();
+    bool isClassUsed(const Class* klass);
+    QString getTypeFlags(const Type *type, int *classIdx);
+
+    QMap<QString, int> classIndex;
+    QHash<const Member*, int> methodIdx;
+    QHash<Type*, int> typeIndex;
+    QSet<Class*> externalClasses;
+    QSet<Type*> usedTypes;
+    QStringList includedClasses;
+    QHash<const Class*, QSet<const Method*> > declaredVirtualMethods;
+};
+
+struct SmokeClassFiles
+{
+    SmokeClassFiles(SmokeDataFile *data);
+    void write();
+    void write(const QList<QString>& keys);
+
+private:
+    QString generateMethodBody(const QString& indent, const QString& className, const QString& smokeClassName, const Method& meth, int index, bool dynamicDispatch, QSet< QString >& includes);
+    void generateMethod(QTextStream& out, const QString& className, const QString& smokeClassName, const Method& meth, int index, QSet<QString>& includes);
+    void generateGetAccessor(QTextStream& out, const QString& className, const Field& field, const Type* type, int index);
+    void generateSetAccessor(QTextStream& out, const QString& className, const Field& field, const Type* type, int index);
+    void generateEnumMemberCall(QTextStream& out, const QString& className, const QString& member, int index);
+    void generateVirtualMethod(QTextStream& out, const Method& meth, QSet<QString>& includes);
+    
+    void writeClass(QTextStream& out, const Class* klass, const QString& className, QSet<QString>& includes);
+    
+    SmokeDataFile *m_smokeData;
+};
+    
+struct Util
+{
+    static QHash<QString, QString> typeMap;
+    static QHash<const Method*, const Function*> globalFunctionMap;
+    static QHash<const Method*, const Field*> fieldAccessors;
+    
+    static bool isVirtualInheritancePath(const Class* desc, const Class* super);
+    static QList<const Class*> superClassList(const Class* klass);
+    static QList<const Class*> descendantsList(const Class* klass);
+
+    static void preparse(QSet<Type*> *usedTypes, QSet<const Class*> *superClasses, const QList<QString>& keys);
+
+    static bool canClassBeInstanciated(const Class* klass);
+    static bool canClassBeCopied(const Class* klass);
+    static bool hasClassVirtualDestructor(const Class* klass);
+    static bool hasClassPublicDestructor(const Class* klass);
+    static const Method* findDestructor(const Class* klass);
+
+    static bool derivesFromInvalid(const Class* klass);
+
+    static void checkForAbstractClass(Class* klass);
+    static void addDefaultConstructor(Class* klass);
+    static void addCopyConstructor(Class* klass);
+    static void addDestructor(Class* klass);
+    static void addOverloads(const Method& meth);
+    static void addAccessorMethods(const Field& field, QSet<Type*> *usedTypes);
+
+    static QChar munge(const Type *type);
+    static QString mungedName(const Method&);
+
+    static Type* normalizeType(const Type* type);
+
+    static QString stackItemField(const Type* type);
+    static QString assignmentString(const Type* type, const QString& var);
+    static QList<const Method*> collectVirtualMethods(const Class* klass);
+    static const Method* isVirtualOverriden(const Method& meth, const Class* klass);
+    static QList<const Method*> virtualMethodsForClass(const Class* klass);
+};
+
+#endif