rock-qtbindings 4.8.6.5

data/ext/generator/cmake/MacroOptionalFindPackage.cmake

@@ -0,0 +1,28 @@
+# - MACRO_OPTIONAL_FIND_PACKAGE() combines FIND_PACKAGE() with an OPTION()
+# MACRO_OPTIONAL_FIND_PACKAGE( <name> [QUIT] )
+# This macro is a combination of OPTION() and FIND_PACKAGE(), it
+# works like FIND_PACKAGE(), but additionally it automatically creates
+# an option name WITH_<name>, which can be disabled via the cmake GUI.
+# or via -DWITH_<name>=OFF
+# The standard <name>_FOUND variables can be used in the same way
+# as when using the normal FIND_PACKAGE()
+
+# Copyright (c) 2006, 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.
+
+
+macro (MACRO_OPTIONAL_FIND_PACKAGE _name )
+   option(WITH_${_name} "Search for ${_name} package" ON)
+   if (WITH_${_name})
+      find_package(${_name} ${ARGN})
+   else (WITH_${_name})
+      set(${_name}_FOUND)
+      set(${_name}_INCLUDE_DIR)
+      set(${_name}_INCLUDES)
+      set(${_name}_LIBRARY)
+      set(${_name}_LIBRARIES)
+   endif (WITH_${_name})
+endmacro (MACRO_OPTIONAL_FIND_PACKAGE)
+

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/generator_export.h

@@ -0,0 +1,31 @@
+/*
+    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 GENERATOR_EXPORT_H
+#define GENERATOR_EXPORT_H
+
+#include <qglobal.h>
+
+// When building the library, export the symbols - otherwise import them.
+#ifdef __GENERATOR_BUILDING
+#   define GENERATOR_EXPORT Q_DECL_EXPORT
+#else
+#   define GENERATOR_EXPORT Q_DECL_IMPORT
+#endif
+
+#endif

data/ext/generator/generatorenvironment.cpp

@@ -0,0 +1,52 @@
+/*
+    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 "generatorenvironment.h"
+
+#include <rpp/pp-macro.h>
+#include "options.h"
+
+GeneratorEnvironment::GeneratorEnvironment(rpp::pp * preprocessor) : rpp::Environment(preprocessor), q_property(new rpp::pp_macro("Q_PROPERTY"))
+{
+    q_property->formals.append(IndexedString("text"));
+    q_property->setDefinitionText("void __q_property(const char* foo = #text);");
+    q_property->function_like = true;
+}
+
+GeneratorEnvironment::~GeneratorEnvironment()
+{
+    if (!ParserOptions::qtMode) {
+        // if not in qt-mode, this won't be deleted by rpp::Environment
+        delete q_property;
+    }
+}
+
+void GeneratorEnvironment::setMacro(rpp::pp_macro* macro)
+{
+    QString macroName = macro->name.str();
+    if (   macroName == "signals" || macroName == "slots" || macroName == "Q_SIGNALS" || macroName == "Q_SLOTS"
+        || ParserOptions::dropMacros.contains(macroName)) {
+        delete macro;
+        return;
+    } else if (ParserOptions::qtMode && macroName == "Q_PROPERTY") {
+        delete macro;
+        rpp::Environment::setMacro(q_property);
+        return;
+    }
+    rpp::Environment::setMacro(macro);
+}

data/ext/generator/generatorenvironment.h

@@ -0,0 +1,35 @@
+/*
+    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 PARSERENVIRONMENT_H
+#define PARSERENVIRONMENT_H
+
+#include <rpp/pp-environment.h>
+
+class GeneratorEnvironment : public rpp::Environment
+{
+public:
+    GeneratorEnvironment(rpp::pp* preprocessor);
+    ~GeneratorEnvironment();
+    virtual void setMacro(rpp::pp_macro* macro);
+
+private:
+    rpp::pp_macro* q_property;
+};
+
+#endif // PARSERENVIRONMENT_H

data/ext/generator/generatorpreprocessor.cpp

@@ -0,0 +1,303 @@
+/*
+    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 "generatorpreprocessor.h"
+#include "generatorenvironment.h"
+
+#include <rpp/pp-environment.h>
+#include <rpp/pp-macro.h>
+
+#include <QCoreApplication>
+
+#include <QtDebug>
+
+QList<QString> parsedHeaders;
+
+Preprocessor::Preprocessor(const QList<QDir>& includeDirs, const QStringList& defines, const QFileInfo& file)
+    : m_includeDirs(includeDirs), m_defines(defines), m_file(file)
+{
+    pp = new rpp::pp(this);
+    pp->setEnvironment(new GeneratorEnvironment(pp));
+    if (file.exists())
+        m_fileStack.push(file);
+    
+    m_topBlock = new rpp::MacroBlock(0);
+    
+    // some basic definitions
+    rpp::pp_macro* exportMacro = new rpp::pp_macro;
+    exportMacro->name = IndexedString("__cplusplus");
+    exportMacro->definition.append(IndexedString('1'));
+    exportMacro->function_like = false;
+    exportMacro->variadics = false;
+    m_topBlock->setMacro(exportMacro);
+
+    exportMacro = new rpp::pp_macro;
+    exportMacro->name = IndexedString("__GNUC__");
+    exportMacro->definition.append(IndexedString('4'));
+    exportMacro->function_like = false;
+    exportMacro->variadics = false;
+    m_topBlock->setMacro(exportMacro);
+
+    exportMacro = new rpp::pp_macro;
+    exportMacro->name = IndexedString("__GNUC_MINOR__");
+    exportMacro->definition.append(IndexedString('1'));
+    exportMacro->function_like = false;
+    exportMacro->variadics = false;
+    m_topBlock->setMacro(exportMacro);
+
+    exportMacro = new rpp::pp_macro;
+#if defined(Q_OS_LINUX)
+    exportMacro->name = IndexedString("__linux__");
+#elif defined(Q_OS_WIN32)
+    exportMacro->name = IndexedString("WIN32");
+#elif defined(Q_OS_WIN64)
+    exportMacro->name = IndexedString("WIN64");
+#elif defined(Q_OS_DARWIN)
+    exportMacro->name = IndexedString("__APPLE__");
+#elif defined(Q_OS_SOLARIS)
+    exportMacro->name = IndexedString("__sun");
+#else
+    // fall back to linux if nothing matches
+    exportMacro->name = IndexedString("__linux__");
+#endif
+    exportMacro->function_like = false;
+    exportMacro->variadics = false;
+    m_topBlock->setMacro(exportMacro);
+
+#if defined(Q_OS_DARWIN64)
+    exportMacro = new rpp::pp_macro;
+    exportMacro->name = IndexedString("__LP64__");
+    exportMacro->function_like = false;
+    exportMacro->variadics = false;
+    m_topBlock->setMacro(exportMacro);
+#endif
+
+#if (defined(QT_ARCH_ARM) || defined (QT_ARCH_ARMV6)) && !defined(QT_NO_ARM_EABI)
+    exportMacro = new rpp::pp_macro;
+    exportMacro->name = IndexedString("__ARM_EABI__");
+    exportMacro->function_like = false;
+    exportMacro->variadics = false;
+    m_topBlock->setMacro(exportMacro);
+#endif
+
+    // ansidecl.h will define macros for keywords if we don't define __STDC__
+    exportMacro = new rpp::pp_macro;
+    exportMacro->name = IndexedString("__STDC__");
+    exportMacro->function_like = false;
+    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'));
+    exportMacro->function_like = false;
+    exportMacro->variadics = false;
+    m_topBlock->setMacro(exportMacro);
+
+    foreach (QString define, defines) {
+        exportMacro = new rpp::pp_macro;
+        exportMacro->name = IndexedString(define);
+        exportMacro->function_like = false;
+        exportMacro->variadics = false;
+        m_topBlock->setMacro(exportMacro);
+    }
+    
+    pp->environment()->visitBlock(m_topBlock);
+}
+
+
+Preprocessor::~Preprocessor()
+{
+    delete pp;
+}
+
+void Preprocessor::setFile(const QFileInfo& file)
+{
+    m_fileStack.clear();
+    m_fileStack.push(file);
+    m_file = file;
+}
+
+QFileInfo Preprocessor::file()
+{
+    return m_file;
+}
+
+
+void Preprocessor::setIncludeDirs(QList< QDir > dirs)
+{
+    m_includeDirs = dirs;
+}
+
+
+QList< QDir > Preprocessor::includeDirs()
+{
+    return m_includeDirs;
+}
+
+
+void Preprocessor::setDefines(QStringList defines)
+{
+    m_defines = defines;
+}
+
+
+QStringList Preprocessor::defines()
+{
+    return m_defines;
+}
+
+
+PreprocessedContents Preprocessor::lastContents()
+{
+    return m_contents;
+}
+
+
+PreprocessedContents Preprocessor::preprocess()
+{
+    m_contents = pp->processFile(m_file.absoluteFilePath());
+    return m_contents;
+}
+
+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));
+#endif
+        return 0;
+    }
+    
+    // are the contents already cached?
+    if (type == rpp::Preprocessor::IncludeGlobal && m_cache.contains(fileName)) { 
+        QPair<QFileInfo, PreprocessedContents>& cached = m_cache[fileName];
+        m_fileStack.push(cached.first);
+        return new HeaderStream(&cached.second, &m_fileStack);
+    }
+    
+    QString path;
+    QFileInfo info(fileName);
+
+    // 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);
+        if (info.isFile())
+            path = info.absoluteFilePath();
+    }
+    if (path.isEmpty()) {
+#ifdef Q_WS_MAC
+        QString framework;
+        QString header;
+        if (frameworkExpr.exactMatch(fileName)) {
+            framework = frameworkExpr.cap(1);
+            header = frameworkExpr.cap(2);
+        }
+#endif
+
+        Q_FOREACH (const QDir& dir, m_includeDirs) {
+            info.setFile(dir, fileName);
+            if (info.isFile()) {
+                path = info.absoluteFilePath();
+                break;
+            }
+
+#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();
+                    break;
+                }
+            }
+#endif
+        }
+    }
+    
+    if (path.isEmpty()) {
+#ifdef DEBUG
+        qDebug("PP: File not found: %s", qPrintable(fileName));
+#endif
+        return 0;
+    }
+    
+    QFile file(path);
+    file.open(QFile::ReadOnly);
+    QByteArray array = file.readAll();
+    file.close();
+    
+    parsedHeaders << path;
+    
+    if (type == rpp::Preprocessor::IncludeGlobal) {
+        // cache the identifier (fileName), the accompanying QFileInfo and the contents
+        QHash<QString, QPair<QFileInfo, PreprocessedContents> >::iterator iter =
+            m_cache.insert(fileName, qMakePair(QFileInfo(path), convertFromByteArray(array)));
+        /* Push the QFileInfo of the included file on the file stack, so if sourceNeeded() is called for that file,
+           we know where to search for headers included with a IncludeLocal. The HeaderStream will be destroyed when the
+           file has been processed and it'll then pop() the stack */
+        m_fileStack.push(iter.value().first);
+        return new HeaderStream(&iter.value().second, &m_fileStack);
+    } else {
+        /* Don't cache locally included files - the meaning of a file name may change when recursing into
+           other directories.
+           We also don't need to push any files on the fileStack because the directory for local includes is
+           not changing. */
+        m_localContent.append(convertFromByteArray(array));
+        m_fileStack.push(QFileInfo(path));
+        return new HeaderStream(&m_localContent.last(), &m_fileStack);
+    }
+    return 0;
+}
+

data/ext/generator/generatorpreprocessor.h

@@ -0,0 +1,83 @@
+/*
+    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 GENERATORPREPROCESSOR_H
+#define GENERATORPREPROCESSOR_H
+
+#include <QDir>
+#include <QFileInfo>
+#include <QHash>
+#include <QList>
+#include <QPair>
+#include <QStack>
+#include <QString>
+
+#include <rpp/pp-engine.h>
+#include <rpp/pp-stream.h>
+#include <rpp/preprocessor.h>
+
+namespace rpp {
+    class MacroBlock;
+}
+
+extern QList<QString> parsedHeaders;
+
+class Preprocessor : public rpp::Preprocessor
+{
+public:
+    Preprocessor(const QList<QDir>& includeDirs = QList<QDir>(), const QStringList& defines = QStringList(),
+                 const QFileInfo& file = QFileInfo());
+    virtual ~Preprocessor();
+    
+    virtual rpp::Stream* sourceNeeded(QString& fileName, rpp::Preprocessor::IncludeType type, int sourceLine, bool skipCurrentPath);
+
+    void setFile(const QFileInfo& file);
+    QFileInfo file();
+    
+    void setIncludeDirs(QList<QDir> dirs);
+    QList<QDir> includeDirs();
+    
+    void setDefines(QStringList defines);
+    QStringList defines();
+    
+    PreprocessedContents preprocess();
+    PreprocessedContents lastContents();
+
+private:
+    rpp::pp *pp;
+    rpp::MacroBlock *m_topBlock;
+    QList<QDir> m_includeDirs;
+    QStringList m_defines;
+    QFileInfo m_file;
+    PreprocessedContents m_contents;
+    QHash<QString, QPair<QFileInfo, PreprocessedContents> > m_cache;
+    QList<PreprocessedContents> m_localContent;
+    QStack<QFileInfo> m_fileStack;
+};
+
+class HeaderStream : public rpp::Stream
+{
+public:
+    HeaderStream(PreprocessedContents* contents, QStack<QFileInfo>* stack) : rpp::Stream(contents), m_stack(stack) {}
+    virtual ~HeaderStream() { m_stack->pop(); }
+
+private:
+    QStack<QFileInfo>* m_stack;
+};
+
+#endif // GENERATORPREPROCESSOR_H