qtbindings 4.6.3.4 → 4.8.3.0

data/ext/generator/cmake/MacroWriteBasicCMakeVersionFile.cmake

@@ -0,0 +1,22 @@
+#  MACRO_WRITE_BASIC_CMAKE_VERSION_FILE( _filename _major _minor _patch)
+#    Writes a file for use as <package>ConfigVersion.cmake file to <_filename>.
+#    See the documentation of FIND_PACKAGE() for details on this.
+#    _filename is the output filename, it should be in the build tree.
+#    _major is the major version number of the project to be installed
+#    _minor is the minor version number of the project to be installed
+#    _patch is the patch version number of the project to be installed
+#
+
+# Copyright (c) 2008, Alexander Neundorf, <neundorf@kde.org>
+#
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+
+get_filename_component(_currentListFileDir ${CMAKE_CURRENT_LIST_FILE} PATH)
+
+function(MACRO_WRITE_BASIC_CMAKE_VERSION_FILE _filename _major _minor _patch)
+   set(PROJECT_VERSION_MAJOR ${_major})
+   set(PROJECT_VERSION_MINOR ${_minor})
+   set(PROJECT_VERSION_PATCH ${_patch})
+   configure_file(${_currentListFileDir}/BasicFindPackageVersion.cmake.in "${_filename}" @ONLY)
+endfunction(MACRO_WRITE_BASIC_CMAKE_VERSION_FILE _major _minor _patch)

data/ext/generator/cmake/SmokeConfig.cmake.in

@@ -0,0 +1,109 @@
+# Find smoke libraries.
+#
+# Use:
+#
+# find_package(Smoke [REQUIRED] COMPONENTS QtCore QtGui <other components>)
+#
+# Defines:
+#
+# SMOKE_INCLUDE_DIR                 Directory in which smoke.h is located
+# SMOKE_CMAKE_MODULE_DIR            Directory with additional cmake files used by kdebindings
+# SMOKE_GEN_BIN                     The path of the smokegen executable
+# SMOKE_GEN_SHARED                  Directory in which commonly used smokegen files reside
+# SMOKE_API_BIN                     The path of the smokeapi executable
+# SMOKE_GENERATOR_SMOKE_LIB         Path of generator_smoke library
+# SMOKE_GENERATOR_DUMP_LIB          Path of generator_dump library
+# SMOKE_<component>_INCLUDE_DIR     Directory in which to find smoke/<component>_smoke.h
+# SMOKE_<component>_LIBRARY         Library for the smoke lib
+#
+# Copyright (c) 2010, Arno Rehn <arno@arnorehn.de>
+#           (c) 2010, Ian Monroe <ian@monroe.nu>
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+
+#####################
+# utility functions #
+#####################
+
+function (_print type message)
+    if (NOT Smoke_FIND_QUIETLY)
+        message (${type} "${message}")
+    endif (NOT Smoke_FIND_QUIETLY)
+endfunction (_print type message)
+
+
+##############################
+# find individual smoke libs #
+##############################Smoke_FIND_REQUIRED
+
+macro (find_smoke_component name)
+    string(TOUPPER ${name} uppercase)
+    string(TOLOWER ${name} lowercase)
+
+    if (NOT SMOKE_${uppercase}_FOUND)
+        set (SMOKE_${uppercase}_FOUND FALSE CACHE INTERNAL "")
+
+        find_path(SMOKE_${uppercase}_INCLUDE_DIR 
+            ${lowercase}_smoke.h 
+            PATH ${SMOKE_INCLUDE_DIR}
+            NO_DEFAULT_PATH
+            )
+        if(WIN32)
+		    # DLLs are in the bin directory.
+            find_library(SMOKE_${uppercase}_LIBRARY
+                smoke${lowercase}
+                PATHS "@CMAKE_INSTALL_PREFIX@/bin"
+                NO_DEFAULT_PATH)
+        else(WIN32)
+            find_library(SMOKE_${uppercase}_LIBRARY
+                smoke${lowercase}
+                PATHS "@SMOKE_LIBRARY_PREFIX@"
+                NO_DEFAULT_PATH)
+        endif(WIN32)
+
+        if (NOT SMOKE_${uppercase}_INCLUDE_DIR OR NOT SMOKE_${uppercase}_LIBRARY)
+            if (Smoke_FIND_REQUIRED)
+                _print(FATAL_ERROR "Could not find Smoke${name}")
+            else (Smoke_FIND_REQUIRED)
+                _print(STATUS "Could not find Smoke${name}")
+            endif (Smoke_FIND_REQUIRED)
+        else (NOT SMOKE_${uppercase}_INCLUDE_DIR OR NOT SMOKE_${uppercase}_LIBRARY)
+            set (SMOKE_${uppercase}_FOUND TRUE CACHE INTERNAL "")
+            _print(STATUS "Found Smoke${name}: ${SMOKE_${uppercase}_LIBRARY}")
+        endif (NOT SMOKE_${uppercase}_INCLUDE_DIR OR NOT SMOKE_${uppercase}_LIBRARY)
+
+        mark_as_advanced(SMOKE_${uppercase}_INCLUDE_DIR SMOKE_${uppercase}_LIBRARY SMOKE_${uppercase}_FOUND)
+    endif (NOT SMOKE_${uppercase}_FOUND)
+endmacro (find_smoke_component)
+
+################
+# find smoke.h #
+################
+set(SMOKE_INCLUDE_DIR "@SMOKE_INCLUDE_DIR@")
+set(SMOKE_CMAKE_MODULE_DIR "@SMOKE_CMAKE_MODULE_DIR@")
+set(SMOKE_INSTALL_PREFIX "@CMAKE_INSTALL_PREFIX@")
+set(SMOKE_GENERATOR_SMOKE_LIB "@SMOKE_GENERATOR_SMOKE_LIB@")
+set(SMOKE_GENERATOR_DUMP_LIB "@SMOKE_GENERATOR_DUMP_LIB@")
+set(SMOKE_GEN_BIN "@SMOKE_GEN_BIN@")
+set(SMOKE_GEN_SHARED "@SMOKE_GEN_SHARED@")
+set(SMOKE_API_BIN "@SMOKE_API_BIN@")
+
+find_library(SMOKE_BASE_LIBRARY smokebase 
+              PATHS "@SMOKE_LIBRARY_PREFIX@"
+              NO_DEFAULT_PATH)
+
+if (NOT SMOKE_BASE_LIBRARY)
+    if (Smoke_FIND_REQUIRED)
+        _print(FATAL_ERROR "Could not find SMOKE")
+    else (Smoke_FIND_REQUIRED)
+        _print(STATUS "Could not find SMOKE")
+    endif (Smoke_FIND_REQUIRED)
+endif (NOT SMOKE_BASE_LIBRARY)
+
+mark_as_advanced(SMOKE_INCLUDE_DIR SMOKE_BASE_LIBRARY)
+
+if (Smoke_FIND_COMPONENTS)
+    foreach (component ${Smoke_FIND_COMPONENTS})
+        find_smoke_component(${component})
+    endforeach(component)
+endif (Smoke_FIND_COMPONENTS)

data/ext/generator/config.h

@@ -0,0 +1,25 @@
+#ifndef SMOKEGEN_CONFIG_H_7990E7PK
+#define SMOKEGEN_CONFIG_H_7990E7PK
+/*
+   Copyright (C) 2011 Michael Jansen <kde@michael-jansen.biz>
+
+    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.
+*/
+
+
+// The library suffix used when compiling smoke
+#define LIB_SUFFIX "@LIB_SUFFIX@"
+
+#endif // #define SMOKEGEN_CONFIG_H_7990E7PK

data/ext/generator/generatorpreprocessor.cpp

@@ -22,6 +22,8 @@
 #include <rpp/pp-environment.h>
 #include <rpp/pp-macro.h>
 
+#include <QCoreApplication>
+
 #include <QtDebug>
 
 QList<QString> parsedHeaders;
@@ -100,6 +102,32 @@ Preprocessor::Preprocessor(const QList<QDir>& includeDirs, const QStringList& de
     exportMacro->variadics = false;
     m_topBlock->setMacro(exportMacro);
 
+    // the following macros are gcc specialties
+    exportMacro = new rpp::pp_macro;
+    exportMacro->name = IndexedString("__extension__");
+    exportMacro->function_like = false;
+    exportMacro->variadics = false;
+    m_topBlock->setMacro(exportMacro);
+
+    exportMacro = new rpp::pp_macro;
+    exportMacro->name = IndexedString("__restrict");
+    exportMacro->function_like = false;
+    exportMacro->variadics = false;
+    m_topBlock->setMacro(exportMacro);
+
+    exportMacro = new rpp::pp_macro;
+    exportMacro->name = IndexedString("__const");
+    exportMacro->definition.append(IndexedString("const"));
+    exportMacro->function_like = false;
+    exportMacro->variadics = false;
+    m_topBlock->setMacro(exportMacro);
+
+    exportMacro = new rpp::pp_macro;
+    exportMacro->name = IndexedString("__attribute__");
+    exportMacro->function_like = true;
+    exportMacro->variadics = false;
+    m_topBlock->setMacro(exportMacro);
+
     exportMacro = new rpp::pp_macro;
     exportMacro->name = IndexedString("__SMOKEGEN_RUN__");
     exportMacro->definition.append(IndexedString('1'));
@@ -175,9 +203,13 @@ PreprocessedContents Preprocessor::preprocess()
 
 rpp::Stream* Preprocessor::sourceNeeded(QString& fileName, rpp::Preprocessor::IncludeType type, int sourceLine, bool skipCurrentPath)
 {
+#ifdef Q_WS_MAC
+    static QRegExp frameworkExpr("([^/]+)/(.*)");
+#endif
+
     if (m_fileStack.top().fileName() == fileName && type == rpp::Preprocessor::IncludeGlobal) {
 #ifdef DEBUG
-        qDebug("prevented possible endless loop because of #include<%s>", qPrintable(fileName));
+        qDebug("prevented possible endless loop because of #include <%s>", qPrintable(fileName));
 #endif
         return 0;
     }
@@ -191,8 +223,12 @@ rpp::Stream* Preprocessor::sourceNeeded(QString& fileName, rpp::Preprocessor::In
     
     QString path;
     QFileInfo info(fileName);
-    
-    if (info.isAbsolute()) {
+
+    // smokegen chokes on gcc's string.h, so use our simplified version here
+    if (type == rpp::Preprocessor::IncludeGlobal && fileName == "string.h") {
+        static QString customStringHPath = qApp->applicationDirPath() + "/../share/smokegen/string.h";
+        path = customStringHPath;
+    } else if (info.isAbsolute()) {
         path = fileName;
     } else if (type == rpp::Preprocessor::IncludeLocal) {
         info.setFile(m_fileStack.last().dir(), fileName);
@@ -200,57 +236,40 @@ rpp::Stream* Preprocessor::sourceNeeded(QString& fileName, rpp::Preprocessor::In
             path = info.absoluteFilePath();
     }
     if (path.isEmpty()) {
-        foreach (QDir dir, m_includeDirs) {
-#if 0
-            if (dir.absolutePath().endsWith(".framework"))
-            {
-                dir.setPath(dir.absolutePath() + "/Headers");
-            }
+#ifdef Q_WS_MAC
+        QString framework;
+        QString header;
+        if (frameworkExpr.exactMatch(fileName)) {
+            framework = frameworkExpr.cap(1);
+            header = frameworkExpr.cap(2);
+        }
 #endif
-            // qWarning("Searching in %s", qPrintable(dir.absolutePath()));
+
+        Q_FOREACH (const QDir& dir, m_includeDirs) {
             info.setFile(dir, fileName);
             if (info.isFile()) {
                 path = info.absoluteFilePath();
-                // qWarning("Found #include<%s>", qPrintable(fileName));
                 break;
             }
-        }
-    }
- 
-#if defined(Q_OS_DARWIN)
-    /* Try searching for frameworks in default locations */
-    if (path.isEmpty()) {
-        QStringList splitString = fileName.split("/");
-        if (splitString.size() >= 2) {
-            QString frameworkName = splitString.takeFirst();
-            QString remainingFileName = splitString.join("/");
-            QDir dir1 = QDir(("/System/Library/Frameworks/" + frameworkName) + ".framework/Headers");
-            QDir dir2 = QDir(("/Library/Frameworks/" + frameworkName) + ".framework/Headers");
-            info.setFile(dir1, remainingFileName);
-            if (info.isFile()) {
-                path = info.absoluteFilePath();
-                // qWarning("Found #include<%s>", qPrintable(fileName));
-            }
-            else {
-                info.setFile(dir2, remainingFileName);
+
+#ifdef Q_WS_MAC
+            QDir parentDir = dir;
+            parentDir.cdUp();
+            if (parentDir.dirName() == framework + ".framework" && dir.dirName() == "Headers") {
+                info.setFile(dir, header);
                 if (info.isFile()) {
                     path = info.absoluteFilePath();
-                    // qWarning("Found #include<%s>", qPrintable(fileName));
+                    break;
                 }
             }
+#endif
         }
     }
+    
+    if (path.isEmpty()) {
+#ifdef DEBUG
+        qDebug("PP: File not found: %s", qPrintable(fileName));
 #endif
-
-    if (fileName == "stdio.h")
-    {
-        qWarning("Not parsing stdio.h because it is not handled correctly by smokegen on FreeBSD based systems");
-        return 0;
-    }
- 
-    if (path.isEmpty())
-    {
-        qWarning("Couldn't find file for #include<%s>", qPrintable(fileName));
         return 0;
     }
     

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

@@ -7,4 +7,9 @@ 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/smoke/CMakeLists.txt

@@ -10,4 +10,9 @@ 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/globals.h

@@ -127,7 +127,9 @@ struct Util
 
     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);

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

@@ -191,8 +191,13 @@ void Util::preparse(QSet<Type*> *usedTypes, QSet<const Class*> *superClasses, co
                 }
                 addOverloads(m);
                 (*usedTypes) << m.type();
-                foreach (const Parameter& param, m.parameters())
+                foreach (const Parameter& param, m.parameters()) {
                     (*usedTypes) << param.type();
+
+                    if (m.isSlot() || m.isSignal() || m.isQPropertyAccessor()) {
+                        (*usedTypes) << Util::normalizeType(param.type());
+                    }
+                }
             }
             foreach (const Field& f, klass.fields()) {
                 if (f.access() == Access_private)
@@ -490,6 +495,20 @@ QString Util::mungedName(const Method& meth) {
     return ret;
 }
 
+Type* Util::normalizeType(const Type* type) {
+    Type normalizedType = *type;
+    if (normalizedType.isConst() && normalizedType.isRef()) {
+        normalizedType.setIsConst(false);
+        normalizedType.setIsRef(false);
+    }
+
+    if (normalizedType.pointerDepth() == 0) {
+        normalizedType.setIsConst(false);
+    }
+
+    return Type::registerType(normalizedType);
+}
+
 QString Util::stackItemField(const Type* type)
 {
     if (type->getTypedef()) {
@@ -590,7 +609,7 @@ void Util::addAccessorMethods(const Field& field, QSet<Type*> *usedTypes)
 {
     Class* klass = field.getClass();
     Type* type = field.type();
-    if (type->getClass() && type->pointerDepth() == 0) {
+    if (type->getClass() && type->pointerDepth() == 0 && !(ParserOptions::qtMode && type->getClass()->name() == "QFlags")) {
         Type newType = *type;
         newType.setIsRef(true);
         type = Type::registerType(newType);

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

@@ -59,6 +59,9 @@ SmokeDataFile::SmokeDataFile()
             usedTypes << meth->type();
             foreach (const Parameter& param, meth->parameters()) {
                 usedTypes << param.type();
+                if (meth->isSlot() || meth->isSignal() || meth->isQPropertyAccessor()) {
+                    usedTypes << Util::normalizeType(param.type());
+                }
             }
             declaredVirtualMethods[meth->getClass()] << meth;
         }
@@ -173,6 +176,9 @@ void SmokeDataFile::write()
     QFile smokedata(Options::outputDir.filePath("smokedata.cpp"));
     smokedata.open(QFile::ReadWrite | QFile::Truncate);
     QTextStream out(&smokedata);
+    QFile argNames(Options::outputDir.filePath(QString("%1.argnames.txt").arg(Options::module)));
+    argNames.open(QFile::ReadWrite | QFile::Truncate);
+    QTextStream outArgNames(&argNames);
     foreach (const QFileInfo& file, Options::headerList)
         out << "#include <" << file.fileName() << ">\n";
     out << "\n#include <smoke.h>\n";
@@ -419,14 +425,32 @@ void SmokeDataFile::write()
             }
             QVector<int> indices(meth.parameters().count());
             QStringList comment;
+            if (meth.parameters().size() > 0) {
+                outArgNames << klass->name() << "," << meth.name();
+            }
             for (int i = 0; i < indices.size(); i++) {
                 Type* t = meth.parameters()[i].type();
                 if (!typeIndex.contains(t)) {
                     qFatal("missing type: %s in method %s (while building munged names map)", qPrintable(t->toString()), qPrintable(meth.toString(false, true)));
                 }
-                indices[i] = typeIndex[t];
+                outArgNames << ",";
+                outArgNames << (indices[i] = typeIndex[t]);
                 comment << t->toString();
             }
+            if (meth.parameters().size() > 0) {
+                outArgNames << ";";
+                for (int i = 0; i < meth.parameters().size(); i++) {
+                    QString paramName = meth.parameters()[i].name();
+                    if (paramName == "") {
+                        paramName = "arg" + QString::number(i + 1);
+                    }
+                    outArgNames << paramName;
+                    if (i < meth.parameters().size() - 1) {
+                        outArgNames << ",";
+                    }
+                }
+                outArgNames << "\n";
+            }
             int idx = 0;
             if ((idx = parameterList.value(indices, -1)) == -1) {
                 idx = currentIdx;
@@ -726,4 +750,5 @@ void SmokeDataFile::write()
     out << "}\n";
 
     smokedata.close();
+    argNames.close();
 }