Initial import of statemachine branch from the old kinetic repository

1 files changed, 1785 insertions, 0 deletions

diff --git a/qmake/generators/win32/msvc_vcproj.cpp b/qmake/generators/win32/msvc_vcproj.cpp
new file mode 100644
index 0000000..08159b0
--- /dev/null
+++ b/qmake/generators/win32/msvc_vcproj.cpp
@@ -0,0 +1,1785 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the qmake application 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$
+**
+****************************************************************************/
+
+#include "msvc_vcproj.h"
+#include "option.h"
+#include "xmloutput.h"
+#include <qdir.h>
+#include <qdiriterator.h>
+#include <qcryptographichash.h>
+#include <qregexp.h>
+#include <qhash.h>
+#include <quuid.h>
+#include <stdlib.h>
+
+//#define DEBUG_SOLUTION_GEN
+//#define DEBUG_PROJECT_GEN
+
+QT_BEGIN_NAMESPACE
+// Filter GUIDs (Do NOT change these!) ------------------------------
+const char _GUIDSourceFiles[]          = "{4FC737F1-C7A5-4376-A066-2A32D752A2FF}";
+const char _GUIDHeaderFiles[]          = "{93995380-89BD-4b04-88EB-625FBE52EBFB}";
+const char _GUIDGeneratedFiles[]       = "{71ED8ED8-ACB9-4CE9-BBE1-E00B30144E11}";
+const char _GUIDResourceFiles[]        = "{D9D6E242-F8AF-46E4-B9FD-80ECBC20BA3E}";
+const char _GUIDLexYaccFiles[]         = "{E12AE0D2-192F-4d59-BD23-7D3FA58D3183}";
+const char _GUIDTranslationFiles[]     = "{639EADAA-A684-42e4-A9AD-28FC9BCB8F7C}";
+const char _GUIDFormFiles[]            = "{99349809-55BA-4b9d-BF79-8FDBB0286EB3}";
+const char _GUIDExtraCompilerFiles[]   = "{E0D8C965-CC5F-43d7-AD63-FAEF0BBC0F85}";
+QT_END_NAMESPACE
+
+#ifdef Q_OS_WIN32
+#include <qt_windows.h>
+
+QT_BEGIN_NAMESPACE
+
+struct {
+    DotNET version;
+    const char *versionStr;
+    const char *regKey;
+} dotNetCombo[] = {
+#ifdef Q_OS_WIN64
+    {NET2008, "MSVC.NET 2008 (9.0)", "Software\\Wow6432Node\\Microsoft\\VisualStudio\\9.0\\Setup\\VC\\ProductDir"},
+    {NET2008, "MSVC.NET 2008 Express Edition (9.0)", "Software\\Wow6432Node\\Microsoft\\VCExpress\\9.0\\Setup\\VC\\ProductDir"},
+    {NET2005, "MSVC.NET 2005 (8.0)", "Software\\Wow6432Node\\Microsoft\\VisualStudio\\8.0\\Setup\\VC\\ProductDir"},
+    {NET2005, "MSVC.NET 2005 Express Edition (8.0)", "Software\\Wow6432Node\\Microsoft\\VCExpress\\8.0\\Setup\\VC\\ProductDir"},
+    {NET2003, "MSVC.NET 2003 (7.1)", "Software\\Wow6432Node\\Microsoft\\VisualStudio\\7.1\\Setup\\VC\\ProductDir"},
+    {NET2002, "MSVC.NET 2002 (7.0)", "Software\\Wow6432Node\\Microsoft\\VisualStudio\\7.0\\Setup\\VC\\ProductDir"},
+#else
+    {NET2008, "MSVC.NET 2008 (9.0)", "Software\\Microsoft\\VisualStudio\\9.0\\Setup\\VC\\ProductDir"},
+    {NET2008, "MSVC.NET 2008 Express Edition (9.0)", "Software\\Microsoft\\VCExpress\\9.0\\Setup\\VC\\ProductDir"},
+    {NET2005, "MSVC.NET 2005 (8.0)", "Software\\Microsoft\\VisualStudio\\8.0\\Setup\\VC\\ProductDir"},
+    {NET2005, "MSVC.NET 2005 Express Edition (8.0)", "Software\\Microsoft\\VCExpress\\8.0\\Setup\\VC\\ProductDir"},
+    {NET2003, "MSVC.NET 2003 (7.1)", "Software\\Microsoft\\VisualStudio\\7.1\\Setup\\VC\\ProductDir"},
+    {NET2002, "MSVC.NET 2002 (7.0)", "Software\\Microsoft\\VisualStudio\\7.0\\Setup\\VC\\ProductDir"},
+#endif
+    {NETUnknown, "", ""},
+};
+
+static QString keyPath(const QString &rKey)
+{
+    int idx = rKey.lastIndexOf(QLatin1Char('\\'));
+    if (idx == -1)
+        return QString();
+    return rKey.left(idx + 1);
+}
+
+static QString keyName(const QString &rKey)
+{
+    int idx = rKey.lastIndexOf(QLatin1Char('\\'));
+    if (idx == -1)
+        return rKey;
+
+    QString res(rKey.mid(idx + 1));
+    if (res == "Default" || res == ".")
+        res = "";
+    return res;
+}
+
+static QString readRegistryKey(HKEY parentHandle, const QString &rSubkey)
+{
+
+    QString rSubkeyName = keyName(rSubkey);
+    QString rSubkeyPath = keyPath(rSubkey);
+
+    HKEY handle = 0;
+    LONG res;
+    QT_WA( {
+        res = RegOpenKeyExW(parentHandle, (WCHAR*)rSubkeyPath.utf16(),
+                            0, KEY_READ, &handle);
+    } , {
+        res = RegOpenKeyExA(parentHandle, rSubkeyPath.toLocal8Bit(),
+                            0, KEY_READ, &handle);
+    } );
+
+    if (res != ERROR_SUCCESS)
+        return QString();
+
+    // get the size and type of the value
+    DWORD dataType;
+    DWORD dataSize;
+    QT_WA( {
+        res = RegQueryValueExW(handle, (WCHAR*)rSubkeyName.utf16(), 0, &dataType, 0, &dataSize);
+    }, {
+        res = RegQueryValueExA(handle, rSubkeyName.toLocal8Bit(), 0, &dataType, 0, &dataSize);
+    } );
+    if (res != ERROR_SUCCESS) {
+        RegCloseKey(handle);
+        return QString();
+    }
+
+    // get the value
+    QByteArray data(dataSize, 0);
+    QT_WA( {
+        res = RegQueryValueExW(handle, (WCHAR*)rSubkeyName.utf16(), 0, 0,
+                               reinterpret_cast<unsigned char*>(data.data()), &dataSize);
+    }, {
+        res = RegQueryValueExA(handle, rSubkeyName.toLocal8Bit(), 0, 0,
+                               reinterpret_cast<unsigned char*>(data.data()), &dataSize);
+    } );
+    if (res != ERROR_SUCCESS) {
+        RegCloseKey(handle);
+        return QString();
+    }
+
+    QString result;
+    switch (dataType) {
+        case REG_EXPAND_SZ:
+        case REG_SZ: {
+            QT_WA( {
+                result = QString::fromUtf16(((const ushort*)data.constData()));
+            }, {
+                result = QString::fromLatin1(data.constData());
+            } );
+            break;
+        }
+
+        case REG_MULTI_SZ: {
+            QStringList l;
+            int i = 0;
+            for (;;) {
+                QString s;
+                QT_WA( {
+                    s = QString::fromUtf16((const ushort*)data.constData() + i);
+                }, {
+                    s = QString::fromLatin1(data.constData() + i);
+                } );
+                i += s.length() + 1;
+
+                if (s.isEmpty())
+                    break;
+                l.append(s);
+            }
+            result = l.join(", ");
+            break;
+        }
+
+        case REG_NONE:
+        case REG_BINARY: {
+            QT_WA( {
+                result = QString::fromUtf16((const ushort*)data.constData(), data.size()/2);
+            }, {
+                result = QString::fromLatin1(data.constData(), data.size());
+            } );
+            break;
+        }
+
+        case REG_DWORD_BIG_ENDIAN:
+        case REG_DWORD: {
+            Q_ASSERT(data.size() == sizeof(int));
+            int i;
+            memcpy((char*)&i, data.constData(), sizeof(int));
+            result = QString::number(i);
+            break;
+        }
+
+        default:
+            qWarning("QSettings: unknown data %d type in windows registry", dataType);
+            break;
+    }
+
+    RegCloseKey(handle);
+    return result;
+}
+QT_END_NAMESPACE
+#endif
+
+QT_BEGIN_NAMESPACE
+DotNET which_dotnet_version()
+{
+#ifndef Q_OS_WIN32
+    return NET2002; // Always generate 7.0 versions on other platforms
+#else
+    // Only search for the version once
+    static DotNET current_version = NETUnknown;
+    if(current_version != NETUnknown)
+        return current_version;
+
+    // Fallback to .NET 2002
+    current_version = NET2002;
+
+    QStringList warnPath;
+    int installed = 0;
+    int i = 0;
+    for(; dotNetCombo[i].version; ++i) {
+        QString path = readRegistryKey(HKEY_LOCAL_MACHINE, dotNetCombo[i].regKey);
+        if(!path.isEmpty()) {
+            ++installed;
+            current_version = dotNetCombo[i].version;
+                        warnPath += QString("%1").arg(dotNetCombo[i].versionStr);
+        }
+    }
+
+    if (installed < 2)
+        return current_version;
+
+    // More than one version installed, search directory path
+    QString paths = qgetenv("PATH");
+    QStringList pathlist = paths.toLower().split(";");
+
+    i = installed = 0;
+    for(; dotNetCombo[i].version; ++i) {
+        QString productPath = readRegistryKey(HKEY_LOCAL_MACHINE, dotNetCombo[i].regKey).toLower();
+                if (productPath.isEmpty())
+                        continue;
+        QStringList::iterator it;
+        for(it = pathlist.begin(); it != pathlist.end(); ++it) {
+            if((*it).contains(productPath)) {
+                ++installed;
+                current_version = dotNetCombo[i].version;
+                warnPath += QString("%1 in path").arg(dotNetCombo[i].versionStr);
+                                break;
+            }
+        }
+    }
+        switch(installed) {
+        case 1:
+                break;
+        case 0:
+                warn_msg(WarnLogic, "Generator: MSVC.NET: Found more than one version of Visual Studio, but"
+                                 " none in your path! Fallback to lowest version (%s)", warnPath.join(", ").toLatin1().data());
+                break;
+        default:
+                warn_msg(WarnLogic, "Generator: MSVC.NET: Found more than one version of Visual Studio in"
+                                 " your path! Fallback to lowest version (%s)", warnPath.join(", ").toLatin1().data());
+                break;
+        }
+
+    return current_version;
+#endif
+};
+
+// Flatfile Tags ----------------------------------------------------
+const char _slnHeader70[]       = "Microsoft Visual Studio Solution File, Format Version 7.00";
+const char _slnHeader71[]       = "Microsoft Visual Studio Solution File, Format Version 8.00";
+const char _slnHeader80[]       = "Microsoft Visual Studio Solution File, Format Version 9.00";
+const char _slnHeader90[]       = "Microsoft Visual Studio Solution File, Format Version 10.00";
+                                  // The following UUID _may_ change for later servicepacks...
+                                  // If so we need to search through the registry at
+                                  // HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\7.0\Projects
+                                  // to find the subkey that contains a "PossibleProjectExtension"
+                                  // containing "vcproj"...
+                                  // Use the hardcoded value for now so projects generated on other
+                                  // platforms are actually usable.
+const char _slnMSVCvcprojGUID[] = "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}";
+const char _slnProjectBeg[]     = "\nProject(\"";
+const char _slnProjectMid[]     = "\") = ";
+const char _slnProjectEnd[]     = "\nEndProject";
+const char _slnGlobalBeg[]      = "\nGlobal";
+const char _slnGlobalEnd[]      = "\nEndGlobal";
+const char _slnSolutionConf[]   = "\n\tGlobalSection(SolutionConfiguration) = preSolution"
+                                  "\n\t\tConfigName.0 = Debug|Win32"
+                                  "\n\t\tConfigName.1 = Release|Win32"
+                                  "\n\tEndGlobalSection";
+const char _slnProjDepBeg[]     = "\n\tGlobalSection(ProjectDependencies) = postSolution";
+const char _slnProjDepEnd[]     = "\n\tEndGlobalSection";
+const char _slnProjConfBeg[]    = "\n\tGlobalSection(ProjectConfiguration) = postSolution";
+const char _slnProjRelConfTag1[]= ".Release|%1.ActiveCfg = Release|";
+const char _slnProjRelConfTag2[]= ".Release|%1.Build.0 = Release|";
+const char _slnProjDbgConfTag1[]= ".Debug|%1.ActiveCfg = Debug|";
+const char _slnProjDbgConfTag2[]= ".Debug|%1.Build.0 = Debug|";
+const char _slnProjConfEnd[]    = "\n\tEndGlobalSection";
+const char _slnExtSections[]    = "\n\tGlobalSection(ExtensibilityGlobals) = postSolution"
+                                  "\n\tEndGlobalSection"
+                                  "\n\tGlobalSection(ExtensibilityAddIns) = postSolution"
+                                  "\n\tEndGlobalSection";
+// ------------------------------------------------------------------
+
+VcprojGenerator::VcprojGenerator() : Win32MakefileGenerator(), init_flag(false)
+{
+}
+bool VcprojGenerator::writeMakefile(QTextStream &t)
+{
+    initProject(); // Fills the whole project with proper data
+
+    // Generate solution file
+    if(project->first("TEMPLATE") == "vcsubdirs") {
+        if (!project->isActiveConfig("build_pass")) {
+            debug_msg(1, "Generator: MSVC.NET: Writing solution file");
+            writeSubDirs(t);
+        } else {
+            debug_msg(1, "Generator: MSVC.NET: Not writing solution file for build_pass configs");
+        }
+        return true;
+    } else
+    // Generate single configuration project file
+    if (project->first("TEMPLATE") == "vcapp" ||
+        project->first("TEMPLATE") == "vclib") {
+        if(!project->isActiveConfig("build_pass")) {
+            debug_msg(1, "Generator: MSVC.NET: Writing single configuration project file");
+            XmlOutput xmlOut(t);
+            xmlOut << vcProject;
+        }
+        return true;
+    }
+    return project->isActiveConfig("build_pass");
+}
+
+bool VcprojGenerator::writeProjectMakefile()
+{
+    usePlatformDir();
+    QTextStream t(&Option::output);
+
+    // Check if all requirements are fulfilled
+    if(!project->values("QMAKE_FAILED_REQUIREMENTS").isEmpty()) {
+        fprintf(stderr, "Project file not generated because all requirements not met:\n\t%s\n",
+                var("QMAKE_FAILED_REQUIREMENTS").toLatin1().constData());
+        return true;
+    }
+
+    // Generate project file
+    if(project->first("TEMPLATE") == "vcapp" ||
+       project->first("TEMPLATE") == "vclib") {
+        if (!mergedProjects.count()) {
+            warn_msg(WarnLogic, "Generator: MSVC.NET: no single configuration created, cannot output project!");
+            return false;
+        }
+
+        debug_msg(1, "Generator: MSVC.NET: Writing project file");
+        VCProject mergedProject;
+        for (int i = 0; i < mergedProjects.count(); ++i) {
+            VCProjectSingleConfig *singleProject = &(mergedProjects.at(i)->vcProject);
+            mergedProject.SingleProjects += *singleProject;
+            for (int j = 0; j < singleProject->ExtraCompilersFiles.count(); ++j) {
+                const QString &compilerName = singleProject->ExtraCompilersFiles.at(j).Name;
+                if (!mergedProject.ExtraCompilers.contains(compilerName))
+                    mergedProject.ExtraCompilers += compilerName;
+            }
+        }
+
+        if(mergedProjects.count() > 1 &&
+           mergedProjects.at(0)->vcProject.Name ==
+           mergedProjects.at(1)->vcProject.Name)
+            mergedProjects.at(0)->writePrlFile();
+        mergedProject.Name = unescapeFilePath(project->first("QMAKE_ORIG_TARGET"));
+        mergedProject.Version = mergedProjects.at(0)->vcProject.Version;
+        mergedProject.ProjectGUID = project->isEmpty("QMAKE_UUID") ? getProjectUUID().toString().toUpper() : project->first("QMAKE_UUID");
+        mergedProject.Keyword = project->first("VCPROJ_KEYWORD");
+        mergedProject.SccProjectName = mergedProjects.at(0)->vcProject.SccProjectName;
+        mergedProject.SccLocalPath = mergedProjects.at(0)->vcProject.SccLocalPath;
+        mergedProject.PlatformName = mergedProjects.at(0)->vcProject.PlatformName;
+
+        XmlOutput xmlOut(t);
+        xmlOut << mergedProject;
+        return true;
+    } else if(project->first("TEMPLATE") == "vcsubdirs") {
+        return writeMakefile(t);
+    }
+    return false;
+}
+
+struct VcsolutionDepend {
+    QString uuid;
+    QString vcprojFile, orig_target, target;
+    Target targetType;
+    QStringList dependencies;
+};
+
+QUuid VcprojGenerator::getProjectUUID(const QString &filename)
+{
+    bool validUUID = true;
+
+    // Read GUID from variable-space
+    QUuid uuid = project->first("GUID");
+
+    // If none, create one based on the MD5 of absolute project path
+    if(uuid.isNull() || !filename.isEmpty()) {
+        QString abspath = Option::fixPathToLocalOS(filename.isEmpty()?project->first("QMAKE_MAKEFILE"):filename);
+        QByteArray digest = QCryptographicHash::hash(abspath.toUtf8(), QCryptographicHash::Md5);
+        memcpy((unsigned char*)(&uuid), digest.constData(), sizeof(QUuid));
+        validUUID = !uuid.isNull();
+        uuid.data4[0] = (uuid.data4[0] & 0x3F) | 0x80; // UV_DCE variant
+        uuid.data3 = (uuid.data3 & 0x0FFF) | (QUuid::Name<<12);
+    }
+
+    // If still not valid, generate new one, and suggest adding to .pro
+    if(uuid.isNull() || !validUUID) {
+        uuid = QUuid::createUuid();
+        fprintf(stderr,
+                "qmake couldn't create a GUID based on filepath, and we couldn't\nfind a valid GUID in the .pro file (Consider adding\n'GUID = %s'  to the .pro file)\n",
+                uuid.toString().toUpper().toLatin1().constData());
+    }
+
+    // Store GUID in variable-space
+    project->values("GUID") = QStringList(uuid.toString().toUpper());
+    return uuid;
+}
+
+QUuid VcprojGenerator::increaseUUID(const QUuid &id)
+{
+    QUuid result(id);
+    qint64 dataFirst = (result.data4[0] << 24) +
+                       (result.data4[1] << 16) +
+                       (result.data4[2] << 8) +
+                        result.data4[3];
+    qint64 dataLast =  (result.data4[4] << 24) +
+                       (result.data4[5] << 16) +
+                       (result.data4[6] <<  8) +
+                        result.data4[7];
+
+    if(!(dataLast++))
+        dataFirst++;
+
+    result.data4[0] = uchar((dataFirst >> 24) & 0xff);
+    result.data4[1] = uchar((dataFirst >> 16) & 0xff);
+    result.data4[2] = uchar((dataFirst >>  8) & 0xff);
+    result.data4[3] = uchar(dataFirst         & 0xff);
+    result.data4[4] = uchar((dataLast  >> 24) & 0xff);
+    result.data4[5] = uchar((dataLast  >> 16) & 0xff);
+    result.data4[6] = uchar((dataLast  >>  8) & 0xff);
+    result.data4[7] = uchar(dataLast          & 0xff);
+    return result;
+}
+
+void VcprojGenerator::writeSubDirs(QTextStream &t)
+{
+    // Check if all requirements are fulfilled
+    if(!project->values("QMAKE_FAILED_REQUIREMENTS").isEmpty()) {
+        fprintf(stderr, "Project file not generated because all requirements not met:\n\t%s\n",
+                var("QMAKE_FAILED_REQUIREMENTS").toLatin1().constData());
+        return;
+    }
+
+    switch(which_dotnet_version()) {
+    case NET2008:
+        t << _slnHeader90;
+        break;
+    case NET2005:
+        t << _slnHeader80;
+        break;
+    case NET2003:
+        t << _slnHeader71;
+        break;
+    case NET2002:
+        t << _slnHeader70;
+        break;
+    default:
+        t << _slnHeader70;
+        warn_msg(WarnLogic, "Generator: MSVC.NET: Unknown version (%d) of MSVC detected for .sln", which_dotnet_version());
+        break;
+    }
+
+    QHash<QString, VcsolutionDepend*> solution_depends;
+    QList<VcsolutionDepend*> solution_cleanup;
+
+    QStringList subdirs = project->values("SUBDIRS");
+    QString oldpwd = qmake_getpwd();
+
+    // Make sure that all temp projects are configured
+    // for release so that the depends are created
+    // without the debug <lib>dxxx.lib name mangling
+    QStringList old_after_vars = Option::after_user_vars;
+    Option::after_user_vars.append("CONFIG+=release");
+
+    for(int i = 0; i < subdirs.size(); ++i) {
+        QString tmp = subdirs.at(i);
+        if(!project->isEmpty(tmp + ".file")) {
+            if(!project->isEmpty(tmp + ".subdir"))
+                warn_msg(WarnLogic, "Cannot assign both file and subdir for subdir %s",
+                         tmp.toLatin1().constData());
+            tmp = project->first(tmp + ".file");
+        } else if(!project->isEmpty(tmp + ".subdir")) {
+            tmp = project->first(tmp + ".subdir");
+        }
+        QFileInfo fi(fileInfo(Option::fixPathToLocalOS(tmp, true)));
+        if(fi.exists()) {
+            if(fi.isDir()) {
+                QString profile = tmp;
+                if(!profile.endsWith(Option::dir_sep))
+                    profile += Option::dir_sep;
+                profile += fi.baseName() + ".pro";
+                subdirs.append(profile);
+            } else {
+                QMakeProject tmp_proj;
+                QString dir = fi.path(), fn = fi.fileName();
+                if(!dir.isEmpty()) {
+                    if(!qmake_setpwd(dir))
+                        fprintf(stderr, "Cannot find directory: %s\n", dir.toLatin1().constData());
+                }
+                if(tmp_proj.read(fn)) {
+                    // Check if all requirements are fulfilled
+                    if(!tmp_proj.variables()["QMAKE_FAILED_REQUIREMENTS"].isEmpty()) {
+                        fprintf(stderr, "Project file(%s) not added to Solution because all requirements not met:\n\t%s\n",
+                                fn.toLatin1().constData(), tmp_proj.values("QMAKE_FAILED_REQUIREMENTS").join(" ").toLatin1().constData());
+                        continue;
+                    }
+                    if(tmp_proj.first("TEMPLATE") == "vcsubdirs") {
+                        QStringList tmp_proj_subdirs = tmp_proj.variables()["SUBDIRS"];
+                        for(int x = 0; x < tmp_proj_subdirs.size(); ++x) {
+                            QString tmpdir = tmp_proj_subdirs.at(x);
+                            if(!tmp_proj.isEmpty(tmpdir + ".file")) {
+                                if(!tmp_proj.isEmpty(tmpdir + ".subdir"))
+                                    warn_msg(WarnLogic, "Cannot assign both file and subdir for subdir %s",
+                                            tmpdir.toLatin1().constData());
+                                tmpdir = tmp_proj.first(tmpdir + ".file");
+                            } else if(!tmp_proj.isEmpty(tmpdir + ".subdir")) {
+                                tmpdir = tmp_proj.first(tmpdir + ".subdir");
+                            }
+                            subdirs += fileFixify(tmpdir);
+                        }
+                    } else if(tmp_proj.first("TEMPLATE") == "vcapp" || tmp_proj.first("TEMPLATE") == "vclib") {
+                        // Initialize a 'fake' project to get the correct variables
+                        // and to be able to extract all the dependencies
+                        Option::QMAKE_MODE old_mode = Option::qmake_mode;
+                        Option::qmake_mode = Option::QMAKE_GENERATE_NOTHING;
+                        VcprojGenerator tmp_vcproj;
+                        tmp_vcproj.setNoIO(true);
+                        tmp_vcproj.setProjectFile(&tmp_proj);
+                        Option::qmake_mode = old_mode;
+                        if(Option::debug_level) {
+                            QMap<QString, QStringList> &vars = tmp_proj.variables();
+                            for(QMap<QString, QStringList>::Iterator it = vars.begin();
+                                it != vars.end(); ++it) {
+                                if(it.key().left(1) != "." && !it.value().isEmpty())
+                                    debug_msg(1, "%s: %s === %s", fn.toLatin1().constData(), it.key().toLatin1().constData(),
+                                                it.value().join(" :: ").toLatin1().constData());
+                            }
+                        }
+
+                        // We assume project filename is [QMAKE_ORIG_TARGET].vcproj
+                        QString vcproj = unescapeFilePath(fixFilename(tmp_vcproj.project->first("QMAKE_ORIG_TARGET")) + project->first("VCPROJ_EXTENSION"));
+                        QString vcprojDir = qmake_getpwd();
+
+                        // If file doesn't exsist, then maybe the users configuration
+                        // doesn't allow it to be created. Skip to next...
+                        if(!exists(vcprojDir + Option::dir_sep + vcproj)) {
+
+                            // Try to find the directory which fits relative
+                            // to the output path, which represents the shadow
+                            // path in case we are shadow building
+                            QStringList list = fi.path().split(QLatin1Char('/'));
+                            QString tmpDir = QFileInfo(Option::output).path() + Option::dir_sep;
+                            bool found = false;
+                            for (int i = list.size() - 1; i >= 0; --i) {
+                                QString curr;
+                                for (int j = i; j < list.size(); ++j)
+                                    curr += list.at(j) + Option::dir_sep;
+                                if (exists(tmpDir + curr + vcproj)) {
+                                    vcprojDir = QDir::cleanPath(tmpDir + curr);
+                                    found = true;
+                                    break;
+                                }
+                            }
+                            if (!found) {
+                                warn_msg(WarnLogic, "Ignored (not found) '%s'", QString(vcprojDir + Option::dir_sep + vcproj).toLatin1().constData());
+                                goto nextfile; // # Dirty!
+                            }
+                        }
+
+                        VcsolutionDepend *newDep = new VcsolutionDepend;
+                        newDep->vcprojFile = vcprojDir + Option::dir_sep + vcproj;
+                        newDep->orig_target = unescapeFilePath(tmp_proj.first("QMAKE_ORIG_TARGET"));
+                        newDep->target = tmp_proj.first("MSVCPROJ_TARGET").section(Option::dir_sep, -1);
+                        newDep->targetType = tmp_vcproj.projectTarget;
+                        newDep->uuid = tmp_proj.isEmpty("QMAKE_UUID") ? getProjectUUID(Option::fixPathToLocalOS(vcprojDir + QDir::separator() + vcproj)).toString().toUpper(): tmp_proj.first("QMAKE_UUID");
+
+                        // We want to store it as the .lib name.
+                        if(newDep->target.endsWith(".dll"))
+                            newDep->target = newDep->target.left(newDep->target.length()-3) + "lib";
+
+                        // All ActiveQt Server projects are dependent on idc.exe
+                        if(tmp_proj.variables()["CONFIG"].contains("qaxserver"))
+                            newDep->dependencies << "idc.exe";
+
+                        // All extra compilers which has valid input are considered dependencies
+                        const QStringList &quc = tmp_proj.variables()["QMAKE_EXTRA_COMPILERS"];
+                        for(QStringList::ConstIterator it = quc.constBegin(); it != quc.constEnd(); ++it) {
+                            const QStringList &invar = tmp_proj.variables().value((*it) + ".input");
+                            for(QStringList::ConstIterator iit = invar.constBegin(); iit != invar.constEnd(); ++iit) {
+                                const QStringList fileList = tmp_proj.variables().value(*iit);
+                                if (!fileList.isEmpty()) {
+                                    const QStringList &cmdsParts = tmp_proj.variables().value((*it) + ".commands");
+                                    bool startOfLine = true;
+                                    foreach(QString cmd, cmdsParts) {
+                                        if (!startOfLine) {
+                                            if (cmd.contains("\r"))
+                                                startOfLine = true;
+                                            continue;
+                                        }
+                                        if (cmd.isEmpty())
+                                            continue;
+
+                                        startOfLine = false;
+                                        // Extra compiler commands might be defined in variables, so
+                                        // expand them (don't care about the in/out files)
+                                        cmd = tmp_vcproj.replaceExtraCompilerVariables(cmd, QStringList(), QStringList());
+                                        // Pull out command based on spaces and quoting, if the
+                                        // command starts with that
+                                        cmd = cmd.left(cmd.indexOf(cmd.at(0) == '"' ? '"' : ' ', 1));
+                                        QString dep = cmd.section('/', -1).section('\\', -1);
+                                        if (!newDep->dependencies.contains(dep))
+                                            newDep->dependencies << dep;
+                                    }
+                                }
+                            }
+                        }
+
+                        // Add all unknown libs to the deps
+                        QStringList where("QMAKE_LIBS");
+                        if(!tmp_proj.isEmpty("QMAKE_INTERNAL_PRL_LIBS"))
+                            where = tmp_proj.variables()["QMAKE_INTERNAL_PRL_LIBS"];
+                        for(QStringList::iterator wit = where.begin();
+                            wit != where.end(); ++wit) {
+                            QStringList &l = tmp_proj.variables()[(*wit)];
+                            for(QStringList::Iterator it = l.begin(); it != l.end(); ++it) {
+                                QString opt = (*it);
+                                if(!opt.startsWith("/") &&   // Not a switch
+                                    opt != newDep->target && // Not self
+                                    opt != "opengl32.lib" && // We don't care about these libs
+                                    opt != "glu32.lib" &&    // to make depgen alittle faster
+                                    opt != "kernel32.lib" &&
+                                    opt != "user32.lib" &&
+                                    opt != "gdi32.lib" &&
+                                    opt != "comdlg32.lib" &&
+                                    opt != "advapi32.lib" &&
+                                    opt != "shell32.lib" &&
+                                    opt != "ole32.lib" &&
+                                    opt != "oleaut32.lib" &&
+                                    opt != "uuid.lib" &&
+                                    opt != "imm32.lib" &&
+                                    opt != "winmm.lib" &&
+                                    opt != "wsock32.lib" &&
+                                    opt != "ws2_32.lib" &&
+                                    opt != "winspool.lib" &&
+                                    opt != "delayimp.lib")
+                                {
+                                    newDep->dependencies << opt.section(Option::dir_sep, -1);
+                                }
+                            }
+                        }
+#ifdef DEBUG_SOLUTION_GEN
+                        qDebug("Deps for %20s: [%s]", newDep->target.toLatin1().constData(), newDep->dependencies.join(" :: ").toLatin1().constData());
+#endif
+                        solution_cleanup.append(newDep);
+                        solution_depends.insert(newDep->target, newDep);
+                        t << _slnProjectBeg << _slnMSVCvcprojGUID << _slnProjectMid
+                            << "\"" << newDep->orig_target << "\", \"" << newDep->vcprojFile
+                            << "\", \"" << newDep->uuid << "\"";
+                        t << _slnProjectEnd;
+                    }
+                }
+nextfile:
+                qmake_setpwd(oldpwd);
+            }
+        }
+    }
+    t << _slnGlobalBeg;
+    if (!project->isEmpty("CE_SDK") && !project->isEmpty("CE_ARCH")) {
+        QString slnConfCE = _slnSolutionConf;
+        QString platform = QString("|") + project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")";
+        slnConfCE.replace(QString("|Win32"), platform);
+        t << slnConfCE;
+    } else {
+        t << _slnSolutionConf;
+    }
+    t << _slnProjDepBeg;
+
+    // Restore previous after_user_var options
+    Option::after_user_vars = old_after_vars;
+
+    // Figure out dependencies
+    for(QList<VcsolutionDepend*>::Iterator it = solution_cleanup.begin(); it != solution_cleanup.end(); ++it) {
+        int cnt = 0;
+        for(QStringList::iterator dit = (*it)->dependencies.begin();  dit != (*it)->dependencies.end(); ++dit) {
+            if(VcsolutionDepend *vc = solution_depends[*dit])
+                t << "\n\t\t" << (*it)->uuid << "." << cnt++ << " = " << vc->uuid;
+        }
+    }
+    t << _slnProjDepEnd;
+    t << _slnProjConfBeg;
+    for(QList<VcsolutionDepend*>::Iterator it = solution_cleanup.begin(); it != solution_cleanup.end(); ++it) {
+        QString platform = "Win32";
+        if (!project->isEmpty("CE_SDK") && !project->isEmpty("CE_ARCH"))
+            platform = project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")";
+        t << "\n\t\t" << (*it)->uuid << QString(_slnProjDbgConfTag1).arg(platform) << platform;
+        t << "\n\t\t" << (*it)->uuid << QString(_slnProjDbgConfTag2).arg(platform) << platform;
+        t << "\n\t\t" << (*it)->uuid << QString(_slnProjRelConfTag1).arg(platform) << platform;
+        t << "\n\t\t" << (*it)->uuid << QString(_slnProjRelConfTag2).arg(platform) << platform;
+    }
+    t << _slnProjConfEnd;
+    t << _slnExtSections;
+    t << _slnGlobalEnd;
+
+
+    while (!solution_cleanup.isEmpty())
+        delete solution_cleanup.takeFirst();
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+
+bool VcprojGenerator::hasBuiltinCompiler(const QString &file)
+{
+    // Source files
+    for (int i = 0; i < Option::cpp_ext.count(); ++i)
+        if (file.endsWith(Option::cpp_ext.at(i)))
+            return true;
+    for (int i = 0; i < Option::c_ext.count(); ++i)
+        if (file.endsWith(Option::c_ext.at(i)))
+            return true;
+    if (file.endsWith(".rc")
+        || file.endsWith(".idl"))
+        return true;
+    return false;
+}
+
+void VcprojGenerator::init()
+{
+    if(init_flag)
+        return;
+    if(project->first("TEMPLATE") == "vcsubdirs") { //too much work for subdirs
+        init_flag = true;
+        return;
+    }
+
+    debug_msg(1, "Generator: MSVC.NET: Initializing variables");
+
+    // this should probably not be here, but I'm using it to wrap the .t files
+    if (project->first("TEMPLATE") == "vcapp")
+        project->values("QMAKE_APP_FLAG").append("1");
+    else if (project->first("TEMPLATE") == "vclib")
+        project->values("QMAKE_LIB_FLAG").append("1");
+    if (project->values("QMAKESPEC").isEmpty())
+        project->values("QMAKESPEC").append(qgetenv("QMAKESPEC"));
+
+    processVars();
+    initOld();           // Currently calling old DSP code to set variables. CLEAN UP!
+
+    // Figure out what we're trying to build
+    if(project->first("TEMPLATE") == "vcapp") {
+        projectTarget = Application;
+    } else if(project->first("TEMPLATE") == "vclib") {
+        if(project->isActiveConfig("staticlib")) {
+            if (!project->values("RES_FILE").isEmpty())
+                project->values("MSVCPROJ_LIBS") += escapeFilePaths(project->values("RES_FILE"));
+            projectTarget = StaticLib;
+        } else
+            projectTarget = SharedLib;
+    }
+
+    // Setup PCH variables
+    precompH = project->first("PRECOMPILED_HEADER");
+    precompCPP = project->first("PRECOMPILED_SOURCE");
+    usePCH = !precompH.isEmpty() && project->isActiveConfig("precompile_header");
+    if (usePCH) {
+        precompHFilename = fileInfo(precompH).fileName();
+        // Created files
+        QString origTarget = unescapeFilePath(project->first("QMAKE_ORIG_TARGET"));
+        precompObj = origTarget + Option::obj_ext;
+        precompPch = origTarget + ".pch";
+        // Add PRECOMPILED_HEADER to HEADERS
+        if (!project->values("HEADERS").contains(precompH))
+            project->values("HEADERS") += precompH;
+        // Return to variable pool
+        project->values("PRECOMPILED_OBJECT") = QStringList(precompObj);
+        project->values("PRECOMPILED_PCH")    = QStringList(precompPch);
+
+        autogenPrecompCPP = precompCPP.isEmpty() && project->isActiveConfig("autogen_precompile_source");
+        if (autogenPrecompCPP) {
+            precompCPP = precompH
+                + (Option::cpp_ext.count() ? Option::cpp_ext.at(0) : QLatin1String(".cpp"));
+            project->values("GENERATED_SOURCES") += precompCPP;
+        } else if (!precompCPP.isEmpty()) {
+            project->values("SOURCES") += precompCPP;
+        }
+    }
+
+    // Add all input files for a custom compiler into a map for uniqueness,
+    // unless the compiler is configure as a combined stage, then use the first one
+    const QStringList &quc = project->values("QMAKE_EXTRA_COMPILERS");
+    for(QStringList::ConstIterator it = quc.constBegin(); it != quc.constEnd(); ++it) {
+        const QStringList &invar = project->variables().value((*it) + ".input");
+        const QString compiler_out = project->first((*it) + ".output");
+        for(QStringList::ConstIterator iit = invar.constBegin(); iit != invar.constEnd(); ++iit) {
+            QStringList fileList = project->variables().value(*iit);
+            if (!fileList.isEmpty()) {
+                if (project->values((*it) + ".CONFIG").indexOf("combine") != -1)
+                    fileList = QStringList(fileList.first());
+                for(QStringList::ConstIterator fit = fileList.constBegin(); fit != fileList.constEnd(); ++fit) {
+                    QString file = (*fit);
+                    if (verifyExtraCompiler((*it), file)) {
+                        if (!hasBuiltinCompiler(file)) {
+                            extraCompilerSources[file] += *it;
+                        } else {
+                            QString out = Option::fixPathToTargetOS(replaceExtraCompilerVariables(
+                                            compiler_out, file, QString()), false);
+                            extraCompilerSources[out] += *it;
+                            extraCompilerOutputs[out] = QStringList(file); // Can only have one
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+#if 0 // Debugging
+    Q_FOREACH(QString aKey, extraCompilerSources.keys()) {
+        qDebug("Extracompilers for %s are (%s)", aKey.toLatin1().constData(), extraCompilerSources.value(aKey).join(", ").toLatin1().constData());
+    }
+    Q_FOREACH(QString aKey, extraCompilerOutputs.keys()) {
+        qDebug("Object mapping for %s is (%s)", aKey.toLatin1().constData(), extraCompilerOutputs.value(aKey).join(", ").toLatin1().constData());
+    }
+    qDebug("");
+#endif
+}
+
+bool VcprojGenerator::mergeBuildProject(MakefileGenerator *other)
+{
+    VcprojGenerator *otherVC = static_cast<VcprojGenerator*>(other);
+    if (!otherVC) {
+        warn_msg(WarnLogic, "VcprojGenerator: Cannot merge other types of projects! (ignored)");
+        return false;
+    }
+    mergedProjects += otherVC;
+    return true;
+}
+
+void VcprojGenerator::initProject()
+{
+    // Initialize XML sub elements
+    // - Do this first since project elements may need
+    // - to know of certain configuration options
+    initConfiguration();
+    initRootFiles();
+    initSourceFiles();
+    initHeaderFiles();
+    initGeneratedFiles();
+    initLexYaccFiles();
+    initTranslationFiles();
+    initFormFiles();
+    initResourceFiles();
+    initExtraCompilerOutputs();
+
+    // Own elements -----------------------------
+    vcProject.Name = unescapeFilePath(project->first("QMAKE_ORIG_TARGET"));
+    switch(which_dotnet_version()) {
+    case NET2008:
+        vcProject.Version = "9,00";
+        break;
+    case NET2005:
+                //### using ',' because of a bug in 2005 B2
+                //### VS uses '.' or ',' depending on the regional settings! Using ',' always works.
+        vcProject.Version = "8,00";
+        break;
+    case NET2003:
+        vcProject.Version = "7.10";
+        break;
+    case NET2002:
+        vcProject.Version = "7.00";
+        break;
+    default:
+        vcProject.Version = "7.00";
+        warn_msg(WarnLogic, "Generator: MSVC.NET: Unknown version (%d) of MSVC detected for .vcproj", which_dotnet_version());
+        break;
+    }
+
+    vcProject.Keyword = project->first("VCPROJ_KEYWORD");
+    if (project->isEmpty("CE_SDK") || project->isEmpty("CE_ARCH")) {
+        vcProject.PlatformName = (vcProject.Configuration.idl.TargetEnvironment == midlTargetWin64 ? "Win64" : "Win32");
+    } else {
+        vcProject.PlatformName = project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")";
+    }
+    // These are not used by Qt, but may be used by customers
+    vcProject.SccProjectName = project->first("SCCPROJECTNAME");
+    vcProject.SccLocalPath = project->first("SCCLOCALPATH");
+    vcProject.flat_files = project->isActiveConfig("flat");
+}
+
+void VcprojGenerator::initConfiguration()
+{
+    // Initialize XML sub elements
+    // - Do this first since main configuration elements may need
+    // - to know of certain compiler/linker options
+    VCConfiguration &conf = vcProject.Configuration;
+    conf.CompilerVersion = which_dotnet_version();
+
+    initCompilerTool();
+
+    // Only on configuration per build
+    bool isDebug = project->isActiveConfig("debug");
+
+    if(projectTarget == StaticLib)
+        initLibrarianTool();
+    else {
+        conf.linker.GenerateDebugInformation = isDebug ? _True : _False;
+        initLinkerTool();
+    }
+    initResourceTool();
+    initIDLTool();
+
+    // Own elements -----------------------------
+    QString temp = project->first("BuildBrowserInformation");
+    switch (projectTarget) {
+    case SharedLib:
+        conf.ConfigurationType = typeDynamicLibrary;
+        break;
+    case StaticLib:
+        conf.ConfigurationType = typeStaticLibrary;
+        break;
+    case Application:
+    default:
+        conf.ConfigurationType = typeApplication;
+        break;
+    }
+
+    conf.Name = project->values("BUILD_NAME").join(" ");
+    if (conf.Name.isEmpty())
+        conf.Name = isDebug ? "Debug" : "Release";
+    if (project->isEmpty("CE_SDK") || project->isEmpty("CE_ARCH")) {
+        conf.Name += (conf.idl.TargetEnvironment == midlTargetWin64 ? "|Win64" : "|Win32");
+    } else {
+        conf.Name += "|" + project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")";
+    }
+    conf.ATLMinimizesCRunTimeLibraryUsage = (project->first("ATLMinimizesCRunTimeLibraryUsage").isEmpty() ? _False : _True);
+    conf.BuildBrowserInformation = triState(temp.isEmpty() ? (short)unset : temp.toShort());
+    temp = project->first("CharacterSet");
+    conf.CharacterSet = charSet(temp.isEmpty() ? (short)charSetNotSet : temp.toShort());
+    conf.DeleteExtensionsOnClean = project->first("DeleteExtensionsOnClean");
+    conf.ImportLibrary = conf.linker.ImportLibrary;
+    conf.IntermediateDirectory = project->first("OBJECTS_DIR");
+    conf.OutputDirectory = ".";
+    conf.PrimaryOutput = project->first("PrimaryOutput");
+    conf.WholeProgramOptimization = conf.compiler.WholeProgramOptimization;
+    temp = project->first("UseOfATL");
+    if(!temp.isEmpty())
+        conf.UseOfATL = useOfATL(temp.toShort());
+    temp = project->first("UseOfMfc");
+    if(!temp.isEmpty())
+        conf.UseOfMfc = useOfMfc(temp.toShort());
+
+    // Configuration does not need parameters from
+    // these sub XML items;
+    initCustomBuildTool();
+    initPreBuildEventTools();
+    initPostBuildEventTools();
+    // Only deploy for CE projects
+    if (!project->isEmpty("CE_SDK") && !project->isEmpty("CE_ARCH"))
+        initDeploymentTool();
+    initPreLinkEventTools();
+
+    // Set definite values in both configurations
+    if (isDebug) {
+        conf.compiler.PreprocessorDefinitions.removeAll("NDEBUG");
+    } else {
+        conf.compiler.PreprocessorDefinitions += "NDEBUG";
+    }
+
+}
+
+void VcprojGenerator::initCompilerTool()
+{
+    QString placement = project->first("OBJECTS_DIR");
+    if(placement.isEmpty())
+        placement = ".\\";
+
+    VCConfiguration &conf = vcProject.Configuration;
+    conf.compiler.AssemblerListingLocation = placement ;
+    conf.compiler.ProgramDataBaseFileName = ".\\" ;
+    conf.compiler.ObjectFile = placement ;
+    // PCH
+    if (usePCH) {
+        conf.compiler.UsePrecompiledHeader     = pchUseUsingSpecific;
+        conf.compiler.PrecompiledHeaderFile    = "$(IntDir)\\" + precompPch;
+        conf.compiler.PrecompiledHeaderThrough = project->first("PRECOMPILED_HEADER");
+        conf.compiler.ForcedIncludeFiles       = project->values("PRECOMPILED_HEADER");
+        // Minimal build option triggers an Internal Compiler Error
+        // when used in conjunction with /FI and /Yu, so remove it
+        project->values("QMAKE_CFLAGS_DEBUG").removeAll("-Gm");
+        project->values("QMAKE_CFLAGS_DEBUG").removeAll("/Gm");
+        project->values("QMAKE_CXXFLAGS_DEBUG").removeAll("-Gm");
+        project->values("QMAKE_CXXFLAGS_DEBUG").removeAll("/Gm");
+    }
+
+    conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS"));
+    if(project->isActiveConfig("debug")){
+        // Debug version
+        conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS"));
+        conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_DEBUG"));
+        if((projectTarget == Application) || (projectTarget == StaticLib))
+            conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_MT_DBG"));
+        else
+            conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_MT_DLLDBG"));
+    } else {
+        // Release version
+        conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS"));
+        conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_RELEASE"));
+        conf.compiler.PreprocessorDefinitions += "QT_NO_DEBUG";
+        conf.compiler.PreprocessorDefinitions += "NDEBUG";
+        if((projectTarget == Application) || (projectTarget == StaticLib))
+            conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_MT"));
+        else
+            conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_MT_DLL"));
+    }
+
+    // Common for both release and debug
+    if(project->isActiveConfig("warn_off"))
+        conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_WARN_OFF"));
+    else if(project->isActiveConfig("warn_on"))
+        conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_WARN_ON"));
+    if(project->isActiveConfig("windows"))
+        conf.compiler.PreprocessorDefinitions += project->values("MSVCPROJ_WINCONDEF");
+
+    // Can this be set for ALL configs?
+    // If so, use qmake.conf!
+    if(projectTarget == SharedLib)
+        conf.compiler.PreprocessorDefinitions += "_WINDOWS";
+
+    conf.compiler.PreprocessorDefinitions += project->values("DEFINES");
+    conf.compiler.PreprocessorDefinitions += project->values("PRL_EXPORT_DEFINES");
+    conf.compiler.parseOptions(project->values("MSVCPROJ_INCPATH"));
+}
+
+void VcprojGenerator::initLibrarianTool()
+{
+    VCConfiguration &conf = vcProject.Configuration;
+    conf.librarian.OutputFile = project->first("DESTDIR");
+    if(conf.librarian.OutputFile.isEmpty())
+        conf.librarian.OutputFile = ".\\";
+
+    if(!conf.librarian.OutputFile.endsWith("\\"))
+        conf.librarian.OutputFile += '\\';
+
+    conf.librarian.OutputFile += project->first("MSVCPROJ_TARGET");
+    conf.librarian.AdditionalOptions += project->values("QMAKE_LIBFLAGS");
+}
+
+void VcprojGenerator::initLinkerTool()
+{
+    findLibraries(); // Need to add the highest version of the libs
+    VCConfiguration &conf = vcProject.Configuration;
+    conf.linker.parseOptions(project->values("MSVCPROJ_LFLAGS"));
+
+    foreach(QString libs, project->values("MSVCPROJ_LIBS")) {
+        if (libs.left(9).toUpper() == "/LIBPATH:") {
+            QStringList l = QStringList(libs);
+            conf.linker.parseOptions(l);
+        } else {
+            conf.linker.AdditionalDependencies += libs;
+        }
+    }
+
+    switch (projectTarget) {
+    case Application:
+        conf.linker.OutputFile = project->first("DESTDIR");
+        break;
+    case SharedLib:
+        conf.linker.parseOptions(project->values("MSVCPROJ_LIBOPTIONS"));
+        conf.linker.OutputFile = project->first("DESTDIR");
+        break;
+    case StaticLib: //unhandled - added to remove warnings..
+        break;
+    }
+
+    if(conf.linker.OutputFile.isEmpty())
+        conf.linker.OutputFile = ".\\";
+
+    if(!conf.linker.OutputFile.endsWith("\\"))
+        conf.linker.OutputFile += '\\';
+
+    conf.linker.OutputFile += project->first("MSVCPROJ_TARGET");
+
+    if(project->isActiveConfig("debug")){
+        conf.linker.parseOptions(project->values("QMAKE_LFLAGS_DEBUG"));
+    } else {
+        conf.linker.parseOptions(project->values("QMAKE_LFLAGS_RELEASE"));
+    }
+
+    if(project->isActiveConfig("dll")){
+        conf.linker.parseOptions(project->values("QMAKE_LFLAGS_QT_DLL"));
+    }
+
+    if(project->isActiveConfig("console")){
+        conf.linker.parseOptions(project->values("QMAKE_LFLAGS_CONSOLE"));
+    } else {
+        conf.linker.parseOptions(project->values("QMAKE_LFLAGS_WINDOWS"));
+    }
+
+}
+
+void VcprojGenerator::initResourceTool()
+{
+    VCConfiguration &conf = vcProject.Configuration;
+    conf.resource.PreprocessorDefinitions = conf.compiler.PreprocessorDefinitions;
+
+    // We need to add _DEBUG for the debug version of the project, since the normal compiler defines
+    // do not contain it. (The compiler defines this symbol automatically, which is wy we don't need
+    // to add it for the compiler) However, the resource tool does not do this.
+    if(project->isActiveConfig("debug"))
+        conf.resource.PreprocessorDefinitions += "_DEBUG";
+    if(project->isActiveConfig("staticlib"))
+        conf.resource.ResourceOutputFileName = project->first("DESTDIR") + "/$(InputName).res";
+}
+
+
+void VcprojGenerator::initIDLTool()
+{
+}
+
+void VcprojGenerator::initCustomBuildTool()
+{
+}
+
+void VcprojGenerator::initPreBuildEventTools()
+{
+}
+
+QString VcprojGenerator::fixCommandLine(DotNET version, const QString &input) const
+{
+    QString result = input;
+
+    if (version >= NET2005)
+        result = result.replace(QLatin1Char('\n'), QLatin1String("&#x000D;&#x000A;"));
+
+    return result;
+}
+
+void VcprojGenerator::initPostBuildEventTools()
+{
+    VCConfiguration &conf = vcProject.Configuration;
+    if(!project->values("QMAKE_POST_LINK").isEmpty()) {
+        QString cmdline = fixCommandLine(conf.CompilerVersion, var("QMAKE_POST_LINK"));
+        conf.postBuild.CommandLine = cmdline;
+        if (conf.CompilerVersion < NET2005)
+            cmdline = cmdline.replace("\n", "&&");
+        conf.postBuild.Description = cmdline;
+    }
+
+    QString signature = !project->isEmpty("SIGNATURE_FILE") ? var("SIGNATURE_FILE") : var("DEFAULT_SIGNATURE");
+    bool useSignature = !signature.isEmpty() && !project->isActiveConfig("staticlib") &&
+                        !project->isEmpty("CE_SDK") && !project->isEmpty("CE_ARCH");
+    if(useSignature)
+        conf.postBuild.CommandLine.prepend(QLatin1String("signtool sign /F ") + signature + " \"$(TargetPath)\"\n" +
+            (!conf.postBuild.CommandLine.isEmpty() ? " && " : ""));
+
+    if(!project->values("MSVCPROJ_COPY_DLL").isEmpty()) {
+        if(!conf.postBuild.CommandLine.isEmpty())
+            conf.postBuild.CommandLine += " && ";
+        conf.postBuild.Description += var("MSVCPROJ_COPY_DLL_DESC");
+        conf.postBuild.CommandLine += var("MSVCPROJ_COPY_DLL");
+    }
+}
+
+void VcprojGenerator::initDeploymentTool()
+{
+    VCConfiguration &conf = vcProject.Configuration;
+    QString targetPath = project->values("deploy.path").join(" ");
+    if (targetPath.isEmpty())
+        targetPath = QString("%CSIDL_PROGRAM_FILES%\\") + project->first("TARGET");
+    if (targetPath.endsWith("/") || targetPath.endsWith("\\"))
+        targetPath = targetPath.mid(0,targetPath.size()-1);
+
+    // Only deploy Qt libs for shared build
+    if (!project->values("QMAKE_QT_DLL").isEmpty()) {
+        QStringList& arg = project->values("MSVCPROJ_LIBS");
+        for (QStringList::ConstIterator it = arg.constBegin(); it != arg.constEnd(); ++it) {
+            if (it->contains(project->first("QMAKE_LIBDIR"))) {
+                QString dllName = *it;
+
+                if (dllName.contains(QLatin1String("QAxContainer"))
+                    || dllName.contains(QLatin1String("qtmain"))
+                    || dllName.contains(QLatin1String("QtUiTools")))
+                    continue;
+                dllName.replace(QLatin1String(".lib") , QLatin1String(".dll"));
+                QFileInfo info(dllName);
+                conf.deployment.AdditionalFiles += info.fileName()
+                                                + "|" + QDir::toNativeSeparators(info.absolutePath())
+                                                + "|" + targetPath
+                                                + "|0;";
+            }
+        }
+    }
+
+    // C-runtime deployment
+    QString runtime = project->values("QT_CE_C_RUNTIME").join(QLatin1String(" "));
+    if (!runtime.isEmpty() && (runtime != QLatin1String("no"))) {
+        QString runtimeVersion = QLatin1String("msvcr");
+        QString mkspec = project->first("QMAKESPEC");
+        // If no .qmake.cache has been found, we fallback to the original mkspec
+        if (mkspec.isEmpty())
+            mkspec = project->first("QMAKESPEC_ORIGINAL");
+
+        if (!mkspec.isEmpty()) {
+            if (mkspec.endsWith("2008"))
+                runtimeVersion.append("90");
+            else
+                runtimeVersion.append("80");
+            if (project->isActiveConfig("debug"))
+                runtimeVersion.append("d");
+            runtimeVersion.append(".dll");
+
+            if (runtime == "yes") {
+                // Auto-find C-runtime
+                QString vcInstallDir = qgetenv("VCINSTALLDIR");
+                if (!vcInstallDir.isEmpty()) {
+                    vcInstallDir += "\\ce\\dll\\";
+                    vcInstallDir += project->values("CE_ARCH").join(QLatin1String(" "));
+                    if (!QFileInfo(vcInstallDir + QDir::separator() + runtimeVersion).exists())
+                        runtime.clear();
+                    else
+                        runtime = vcInstallDir;
+                }
+            }
+        }
+
+        if (!runtime.isEmpty() && runtime != QLatin1String("yes")) {
+            conf.deployment.AdditionalFiles += runtimeVersion
+                                            + "|" + QDir::toNativeSeparators(runtime)
+                                            + "|" + targetPath
+                                            + "|0;";
+        }
+    }
+
+    // foreach item in DEPLOYMENT
+    foreach(QString item, project->values("DEPLOYMENT")) {
+        // get item.path
+        QString devicePath = project->first(item + ".path");
+        // if the path does not exist, skip it
+        if (devicePath.isEmpty())
+            continue;
+        // check if item.path is relative (! either /,\ or %)
+        if (!(devicePath.at(0) == QLatin1Char('/')
+            || devicePath.at(0) == QLatin1Char('\\')
+            || devicePath.at(0) == QLatin1Char('%'))) {
+            // create output path
+            devicePath = Option::fixPathToLocalOS(QDir::cleanPath(targetPath + QLatin1Char('\\') + devicePath));
+        }
+        // foreach d in item.sources
+        foreach(QString source, project->values(item + ".sources")) {
+            QString itemDevicePath = devicePath;
+            source = Option::fixPathToLocalOS(source);
+            QString nameFilter;
+            QFileInfo info(source);
+            QString searchPath;
+            if (info.isDir()) {
+                nameFilter = QLatin1String("*");
+                itemDevicePath += "\\" + info.fileName();
+                searchPath = info.absoluteFilePath();
+            } else {
+                nameFilter = source.split('\\').last();
+                searchPath = info.absolutePath();
+            }
+
+            int pathSize = searchPath.size();
+            QDirIterator iterator(searchPath, QStringList() << nameFilter
+                                  , QDir::Files | QDir::NoDotAndDotDot | QDir::NoSymLinks
+                                  , QDirIterator::Subdirectories);
+            // foreach dirIterator-entry in d
+            while(iterator.hasNext()) {
+                iterator.next();
+                QString absoluteItemPath = Option::fixPathToLocalOS(QFileInfo(iterator.filePath()).absolutePath());
+                // Identify if it is just another subdir
+                int diffSize = absoluteItemPath.size() - pathSize;
+                // write out rules
+                conf.deployment.AdditionalFiles += iterator.fileName()
+                    + "|" + absoluteItemPath
+                    + "|" + itemDevicePath + (diffSize ? (absoluteItemPath.right(diffSize)) : QLatin1String(""))
+                    + "|0;";
+            }
+        }
+    }
+}
+
+void VcprojGenerator::initPreLinkEventTools()
+{
+    VCConfiguration &conf = vcProject.Configuration;
+    if(!project->values("QMAKE_PRE_LINK").isEmpty()) {
+        QString cmdline = fixCommandLine(conf.CompilerVersion, var("QMAKE_PRE_LINK"));
+        conf.preLink.Description = cmdline;
+        conf.preLink.CommandLine = cmdline;
+    }
+}
+
+void VcprojGenerator::initRootFiles()
+{
+    // Note: Root files do _not_ have any filter name, filter nor GUID!
+    vcProject.RootFiles.addFiles(project->values("RC_FILE"));
+
+    vcProject.RootFiles.Project = this;
+    vcProject.RootFiles.Config = &(vcProject.Configuration);
+    vcProject.RootFiles.CustomBuild = none;
+}
+
+void VcprojGenerator::initSourceFiles()
+{
+    vcProject.SourceFiles.Name = "Source Files";
+    vcProject.SourceFiles.Filter = "cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx";
+    vcProject.SourceFiles.Guid = _GUIDSourceFiles;
+
+    vcProject.SourceFiles.addFiles(project->values("SOURCES"));
+
+    vcProject.SourceFiles.Project = this;
+    vcProject.SourceFiles.Config = &(vcProject.Configuration);
+    vcProject.SourceFiles.CustomBuild = none;
+}
+
+void VcprojGenerator::initHeaderFiles()
+{
+    vcProject.HeaderFiles.Name = "Header Files";
+    vcProject.HeaderFiles.Filter = "h;hpp;hxx;hm;inl;inc;xsd";
+    vcProject.HeaderFiles.Guid = _GUIDHeaderFiles;
+
+    vcProject.HeaderFiles.addFiles(project->values("HEADERS"));
+    if (usePCH) // Generated PCH cpp file
+        vcProject.HeaderFiles.addFile(precompH);
+
+    vcProject.HeaderFiles.Project = this;
+    vcProject.HeaderFiles.Config = &(vcProject.Configuration);
+//    vcProject.HeaderFiles.CustomBuild = mocHdr;
+//    addMocArguments(vcProject.HeaderFiles);
+}
+
+void VcprojGenerator::initGeneratedFiles()
+{
+    vcProject.GeneratedFiles.Name = "Generated Files";
+    vcProject.GeneratedFiles.Filter = "cpp;c;cxx;moc;h;def;odl;idl;res;";
+    vcProject.GeneratedFiles.Guid = _GUIDGeneratedFiles;
+
+    // ### These cannot have CustomBuild (mocSrc)!!
+    vcProject.GeneratedFiles.addFiles(project->values("GENERATED_SOURCES"));
+    vcProject.GeneratedFiles.addFiles(project->values("GENERATED_FILES"));
+    vcProject.GeneratedFiles.addFiles(project->values("IDLSOURCES"));
+    vcProject.GeneratedFiles.addFiles(project->values("RES_FILE"));
+    vcProject.GeneratedFiles.addFiles(project->values("QMAKE_IMAGE_COLLECTION"));   // compat
+    if(!extraCompilerOutputs.isEmpty())
+        vcProject.GeneratedFiles.addFiles(extraCompilerOutputs.keys());
+
+    vcProject.GeneratedFiles.Project = this;
+    vcProject.GeneratedFiles.Config = &(vcProject.Configuration);
+//    vcProject.GeneratedFiles.CustomBuild = mocSrc;
+}
+
+void VcprojGenerator::initLexYaccFiles()
+{
+    vcProject.LexYaccFiles.Name = "Lex / Yacc Files";
+    vcProject.LexYaccFiles.ParseFiles = _False;
+    vcProject.LexYaccFiles.Filter = "l;y";
+    vcProject.LexYaccFiles.Guid = _GUIDLexYaccFiles;
+
+    vcProject.LexYaccFiles.addFiles(project->values("LEXSOURCES"));
+    vcProject.LexYaccFiles.addFiles(project->values("YACCSOURCES"));
+
+    vcProject.LexYaccFiles.Project = this;
+    vcProject.LexYaccFiles.Config = &(vcProject.Configuration);
+    vcProject.LexYaccFiles.CustomBuild = lexyacc;
+}
+
+void VcprojGenerator::initTranslationFiles()
+{
+    vcProject.TranslationFiles.Name = "Translation Files";
+    vcProject.TranslationFiles.ParseFiles = _False;
+    vcProject.TranslationFiles.Filter = "ts;xlf";
+    vcProject.TranslationFiles.Guid = _GUIDTranslationFiles;
+
+    vcProject.TranslationFiles.addFiles(project->values("TRANSLATIONS"));
+
+    vcProject.TranslationFiles.Project = this;
+    vcProject.TranslationFiles.Config = &(vcProject.Configuration);
+    vcProject.TranslationFiles.CustomBuild = none;
+}
+
+
+void VcprojGenerator::initFormFiles()
+{
+    vcProject.FormFiles.Name = "Form Files";
+    vcProject.FormFiles.ParseFiles = _False;
+    vcProject.FormFiles.Filter = "ui";
+    vcProject.FormFiles.Guid = _GUIDFormFiles;
+
+    vcProject.FormFiles.addFiles(project->values("FORMS"));
+    vcProject.FormFiles.addFiles(project->values("FORMS3"));
+
+    vcProject.FormFiles.Project = this;
+    vcProject.FormFiles.Config = &(vcProject.Configuration);
+    vcProject.FormFiles.CustomBuild = none;
+}
+
+
+void VcprojGenerator::initResourceFiles()
+{
+    vcProject.ResourceFiles.Name = "Resource Files";
+    vcProject.ResourceFiles.ParseFiles = _False;
+    vcProject.ResourceFiles.Filter = "qrc;*"; //"rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;ts;xlf;qrc";
+    vcProject.ResourceFiles.Guid = _GUIDResourceFiles;
+
+    // Bad hack, please look away -------------------------------------
+    QString rcc_dep_cmd = project->values("rcc.depend_command").join(" ");
+    if(!rcc_dep_cmd.isEmpty()) {
+        QStringList qrc_files = project->values("RESOURCES");
+        QStringList deps;
+        if(!qrc_files.isEmpty()) {
+            for (int i = 0; i < qrc_files.count(); ++i) {
+                char buff[256];
+                QString dep_cmd = replaceExtraCompilerVariables(rcc_dep_cmd, qrc_files.at(i),"");
+
+                dep_cmd = Option::fixPathToLocalOS(dep_cmd, true, false);
+                if(canExecute(dep_cmd)) {
+                    if(FILE *proc = QT_POPEN(dep_cmd.toLatin1().constData(), "r")) {
+                        QString indeps;
+                        while(!feof(proc)) {
+                            int read_in = (int)fread(buff, 1, 255, proc);
+                            if(!read_in)
+                                break;
+                            indeps += QByteArray(buff, read_in);
+                        }
+                        QT_PCLOSE(proc);
+                        if(!indeps.isEmpty())
+                            deps += fileFixify(indeps.replace('\n', ' ').simplified().split(' '));
+                    }
+                }
+            }
+            vcProject.ResourceFiles.addFiles(deps);
+        }
+    }
+    // You may look again --------------------------------------------
+
+    vcProject.ResourceFiles.addFiles(project->values("RESOURCES"));
+    vcProject.ResourceFiles.addFiles(project->values("IMAGES"));
+
+    vcProject.ResourceFiles.Project = this;
+    vcProject.ResourceFiles.Config = &(vcProject.Configuration);
+    vcProject.ResourceFiles.CustomBuild = none;
+}
+
+void VcprojGenerator::initExtraCompilerOutputs()
+{
+    QStringList otherFilters;
+    otherFilters << "FORMS"
+                 << "FORMS3"
+                 << "GENERATED_FILES"
+                 << "GENERATED_SOURCES"
+                 << "HEADERS"
+                 << "IDLSOURCES"
+                 << "IMAGES"
+                 << "LEXSOURCES"
+                 << "QMAKE_IMAGE_COLLECTION"
+                 << "RC_FILE"
+                 << "RESOURCES"
+                 << "RES_FILE"
+                 << "SOURCES"
+                 << "TRANSLATIONS"
+                 << "YACCSOURCES";
+    const QStringList &quc = project->values("QMAKE_EXTRA_COMPILERS");
+    for(QStringList::ConstIterator it = quc.begin(); it != quc.end(); ++it) {
+        QString extracompilerName = project->first((*it) + ".name");
+        if (extracompilerName.isEmpty())
+            extracompilerName = (*it);
+
+        // Create an extra compiler filter and add the files
+        VCFilter extraCompile;
+        extraCompile.Name = extracompilerName;
+        extraCompile.ParseFiles = _False;
+        extraCompile.Filter = "";
+        extraCompile.Guid = QString(_GUIDExtraCompilerFiles) + "-" + (*it);
+
+
+        // If the extra compiler has a variable_out set the output file
+        // is added to an other file list, and does not need its own..
+        bool addOnInput = hasBuiltinCompiler(project->first((*it) + ".output"));
+        QString tmp_other_out = project->first((*it) + ".variable_out");
+        if (!tmp_other_out.isEmpty() && !addOnInput)
+            continue;
+
+        if (!addOnInput) {
+            QString tmp_out = project->first((*it) + ".output");
+            if (project->values((*it) + ".CONFIG").indexOf("combine") != -1) {
+                // Combined output, only one file result
+                extraCompile.addFile(
+                    Option::fixPathToTargetOS(replaceExtraCompilerVariables(tmp_out, QString(), QString()), false));
+            } else {
+                // One output file per input
+                QStringList tmp_in = project->values(project->first((*it) + ".input"));
+                for (int i = 0; i < tmp_in.count(); ++i) {
+                    const QString &filename = tmp_in.at(i);
+                    if (extraCompilerSources.contains(filename))
+                        extraCompile.addFile(
+                            Option::fixPathToTargetOS(replaceExtraCompilerVariables(filename, tmp_out, QString()), false));
+                }
+            }
+        } else {
+            // In this case we the outputs have a built-in compiler, so we cannot add the custom
+            // build steps there. So, we turn it around and add it to the input files instead,
+            // provided that the input file variable is not handled already (those in otherFilters
+            // are handled, so we avoid them).
+            QStringList inputVars = project->values((*it) + ".input");
+            foreach(QString inputVar, inputVars) {
+                if (!otherFilters.contains(inputVar)) {
+                    QStringList tmp_in = project->values(inputVar);
+                    for (int i = 0; i < tmp_in.count(); ++i) {
+                        const QString &filename = tmp_in.at(i);
+                        if (extraCompilerSources.contains(filename))
+                            extraCompile.addFile(
+                                Option::fixPathToTargetOS(replaceExtraCompilerVariables(filename, QString(), QString()), false));
+                    }
+                }
+            }
+        }
+        extraCompile.Project = this;
+        extraCompile.Config = &(vcProject.Configuration);
+        extraCompile.CustomBuild = none;
+
+        vcProject.ExtraCompilersFiles.append(extraCompile);
+    }
+}
+
+/* \internal
+    Sets up all needed variables from the environment and all the different caches and .conf files
+*/
+
+void VcprojGenerator::initOld()
+{
+    if(init_flag)
+        return;
+
+    init_flag = true;
+    QStringList::Iterator it;
+
+    // Decode version, and add it to $$MSVCPROJ_VERSION --------------
+    if(!project->values("VERSION").isEmpty()) {
+        QString version = project->values("VERSION")[0];
+        int firstDot = version.indexOf(".");
+        QString major = version.left(firstDot);
+        QString minor = version.right(version.length() - firstDot - 1);
+        minor.replace(QRegExp("\\."), "");
+        project->values("MSVCPROJ_VERSION").append("/VERSION:" + major + "." + minor);
+        project->values("QMAKE_LFLAGS").append("/VERSION:" + major + "." + minor);
+    }
+
+    project->values("QMAKE_LIBS") += escapeFilePaths(project->values("LIBS"));
+
+     // Get filename w/o extension -----------------------------------
+    QString msvcproj_project = "";
+    QString targetfilename = "";
+    if(!project->isEmpty("TARGET")) {
+        project->values("TARGET") = unescapeFilePaths(project->values("TARGET"));
+        targetfilename = msvcproj_project = project->first("TARGET");
+    }
+
+    // Init base class too -------------------------------------------
+    MakefileGenerator::init();
+
+    if(msvcproj_project.isEmpty())
+        msvcproj_project = Option::output.fileName();
+
+    msvcproj_project = msvcproj_project.right(msvcproj_project.length() - msvcproj_project.lastIndexOf("\\") - 1);
+    msvcproj_project = msvcproj_project.left(msvcproj_project.lastIndexOf("."));
+    msvcproj_project.replace(QRegExp("-"), "");
+
+    project->values("MSVCPROJ_PROJECT").append(msvcproj_project);
+    QStringList &proj = project->values("MSVCPROJ_PROJECT");
+
+    for(it = proj.begin(); it != proj.end(); ++it)
+        (*it).replace(QRegExp("\\.[a-zA-Z0-9_]*$"), "");
+
+    // SUBSYSTEM -----------------------------------------------------
+    if(!project->values("QMAKE_APP_FLAG").isEmpty()) {
+            project->values("MSVCPROJ_TEMPLATE").append("win32app" + project->first("VCPROJ_EXTENSION"));
+            if(project->isActiveConfig("console")) {
+                project->values("MSVCPROJ_CONSOLE").append("CONSOLE");
+                project->values("MSVCPROJ_WINCONDEF").append("_CONSOLE");
+                project->values("MSVCPROJ_VCPROJTYPE").append("0x0103");
+                project->values("MSVCPROJ_SUBSYSTEM").append("CONSOLE");
+            } else {
+                project->values("MSVCPROJ_CONSOLE").clear();
+                project->values("MSVCPROJ_WINCONDEF").append("_WINDOWS");
+                project->values("MSVCPROJ_VCPROJTYPE").append("0x0101");
+                project->values("MSVCPROJ_SUBSYSTEM").append("WINDOWS");
+            }
+    }
+
+    // $$QMAKE.. -> $$MSVCPROJ.. -------------------------------------
+    project->values("MSVCPROJ_LIBS") += project->values("QMAKE_LIBS");
+    project->values("MSVCPROJ_LFLAGS") += project->values("QMAKE_LFLAGS");
+    if(!project->values("QMAKE_LIBDIR").isEmpty()) {
+        QStringList strl = project->values("QMAKE_LIBDIR");
+        QStringList::iterator stri;
+        for(stri = strl.begin(); stri != strl.end(); ++stri) {
+            if(!(*stri).startsWith("/LIBPATH:"))
+                (*stri).prepend("/LIBPATH:");
+        }
+        project->values("MSVCPROJ_LFLAGS") += strl;
+    }
+    project->values("MSVCPROJ_CXXFLAGS") += project->values("QMAKE_CXXFLAGS");
+    QStringList &incs = project->values("INCLUDEPATH");
+    for(QStringList::Iterator incit = incs.begin(); incit != incs.end(); ++incit) {
+        QString inc = (*incit);
+        if (!inc.startsWith('"') && !inc.endsWith('"'))
+            inc = QString("\"%1\"").arg(inc); // Quote all paths if not quoted already
+        project->values("MSVCPROJ_INCPATH").append("-I" + inc);
+    }
+    project->values("MSVCPROJ_INCPATH").append("-I" + specdir());
+
+    QString dest;
+    project->values("MSVCPROJ_TARGET") = QStringList(project->first("TARGET"));
+    Option::fixPathToTargetOS(project->first("TARGET"));
+    dest = project->first("TARGET") + project->first("TARGET_EXT");
+    project->values("MSVCPROJ_TARGET") = QStringList(dest);
+
+    // DLL COPY ------------------------------------------------------
+    if(project->isActiveConfig("dll") && !project->values("DLLDESTDIR").isEmpty()) {
+        QStringList dlldirs = project->values("DLLDESTDIR");
+        QString copydll("");
+        QStringList::Iterator dlldir;
+        for(dlldir = dlldirs.begin(); dlldir != dlldirs.end(); ++dlldir) {
+            if(!copydll.isEmpty())
+                copydll += " && ";
+            copydll += "copy  \"$(TargetPath)\" \"" + *dlldir + "\"";
+        }
+
+        QString deststr("Copy " + dest + " to ");
+        for(dlldir = dlldirs.begin(); dlldir != dlldirs.end();) {
+            deststr += *dlldir;
+            ++dlldir;
+            if(dlldir != dlldirs.end())
+                deststr += ", ";
+        }
+
+        project->values("MSVCPROJ_COPY_DLL").append(copydll);
+        project->values("MSVCPROJ_COPY_DLL_DESC").append(deststr);
+    }
+
+    if (!project->values("DEF_FILE").isEmpty())
+        project->values("MSVCPROJ_LFLAGS").append("/DEF:"+project->first("DEF_FILE"));
+
+    project->values("QMAKE_INTERNAL_PRL_LIBS") << "MSVCPROJ_LIBS";
+
+    // Verbose output if "-d -d"...
+    outputVariables();
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+
+QString VcprojGenerator::replaceExtraCompilerVariables(const QString &var, const QStringList &in, const QStringList &out)
+{
+    QString ret = MakefileGenerator::replaceExtraCompilerVariables(var, in, out);
+
+    QStringList &defines = project->values("VCPROJ_MAKEFILE_DEFINES");
+    if(defines.isEmpty())
+        defines.append(varGlue("PRL_EXPORT_DEFINES"," -D"," -D","") +
+                       varGlue("DEFINES"," -D"," -D",""));
+    ret.replace("$(DEFINES)", defines.first());
+
+    QStringList &incpath = project->values("VCPROJ_MAKEFILE_INCPATH");
+    if(incpath.isEmpty() && !this->var("MSVCPROJ_INCPATH").isEmpty())
+        incpath.append(this->var("MSVCPROJ_INCPATH"));
+    ret.replace("$(INCPATH)", incpath.join(" "));
+
+    return ret;
+}
+
+
+
+bool VcprojGenerator::openOutput(QFile &file, const QString &/*build*/) const
+{
+    QString outdir;
+    if(!file.fileName().isEmpty()) {
+        QFileInfo fi(fileInfo(file.fileName()));
+        if(fi.isDir())
+            outdir = file.fileName() + QDir::separator();
+    }
+    if(!outdir.isEmpty() || file.fileName().isEmpty()) {
+        QString ext = project->first("VCPROJ_EXTENSION");
+        if(project->first("TEMPLATE") == "vcsubdirs")
+            ext = project->first("VCSOLUTION_EXTENSION");
+        QString outputName = unescapeFilePath(project->first("TARGET"));
+        if (!project->first("MAKEFILE").isEmpty())
+            outputName = project->first("MAKEFILE");
+        file.setFileName(outdir + outputName + ext);
+    }
+    return Win32MakefileGenerator::openOutput(file, QString());
+}
+
+QString VcprojGenerator::fixFilename(QString ofile) const
+{
+    ofile = Option::fixPathToLocalOS(ofile);
+    int slashfind = ofile.lastIndexOf(Option::dir_sep);
+    if(slashfind == -1) {
+        ofile = ofile.replace('-', '_');
+    } else {
+        int hypenfind = ofile.indexOf('-', slashfind);
+        while (hypenfind != -1 && slashfind < hypenfind) {
+            ofile = ofile.replace(hypenfind, 1, '_');
+            hypenfind = ofile.indexOf('-', hypenfind + 1);
+        }
+    }
+    return ofile;
+}
+
+QString VcprojGenerator::findTemplate(QString file)
+{
+    QString ret;
+    if(!exists((ret = file)) &&
+       !exists((ret = QString(Option::mkfile::qmakespec + "/" + file))) &&
+       !exists((ret = QString(QLibraryInfo::location(QLibraryInfo::DataPath) + "/win32-msvc.net/" + file))) &&
+       !exists((ret = QString(QLibraryInfo::location(QLibraryInfo::DataPath) + "/win32-msvc2002/" + file))) &&
+       !exists((ret = QString(QLibraryInfo::location(QLibraryInfo::DataPath) + "/win32-msvc2003/" + file))) &&
+       !exists((ret = QString(QLibraryInfo::location(QLibraryInfo::DataPath) + "/win32-msvc2005/" + file))) &&
+       !exists((ret = QString(QLibraryInfo::location(QLibraryInfo::DataPath) + "/win32-msvc2008/" + file))) &&
+       !exists((ret = (QString(qgetenv("HOME")) + "/.tmake/" + file))))
+        return "";
+    debug_msg(1, "Generator: MSVC.NET: Found template \'%s\'", ret.toLatin1().constData());
+    return ret;
+}
+
+
+void VcprojGenerator::processPrlVariable(const QString &var, const QStringList &l)
+{
+    if(var == "QMAKE_PRL_DEFINES") {
+        QStringList &out = project->values("MSVCPROJ_DEFINES");
+        for(QStringList::ConstIterator it = l.begin(); it != l.end(); ++it) {
+            if(out.indexOf((*it)) == -1)
+                out.append((" /D " + *it));
+        }
+    } else {
+        MakefileGenerator::processPrlVariable(var, l);
+    }
+}
+
+void VcprojGenerator::outputVariables()
+{
+#if 0
+    qDebug("Generator: MSVC.NET: List of current variables:");
+    for(QMap<QString, QStringList>::ConstIterator it = project->variables().begin(); it != project->variables().end(); ++it)
+        qDebug("Generator: MSVC.NET: %s => %s", it.key().toLatin1().constData(), it.data().join(" | ").toLatin1().constData());
+#endif
+}
+
+QT_END_NAMESPACE
+