msvc_vcproj.cpp - mozsearch

++ // Copyright (C) 2016 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

++

++ #include "msvc_vcproj.h"

++ #include "option.h"

++ #include "xmloutput.h"

++

++ #include <ioutils.h>

++

++ #include <qdir.h>

++ #include <qdirlisting.h>

++ #include <qcryptographichash.h>

++ #include <qhash.h>

++ #include <quuid.h>

++ #include <qregularexpression.h>

++

++ #include <stdlib.h>

++ #include <tuple>

++ #include <utility>

++

++ //#define DEBUG_SOLUTION_GEN

++

++ using namespace QMakeInternal;

++ using namespace Qt::StringLiterals;

++

++ 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}";

++ const char _GUIDDistributionFiles[]    = "{B83CAF91-C7BF-462F-B76C-EA11631F866C}";

++

++ // 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"

++                                   "\n# Visual Studio 2005";

++ const char _slnHeader90[]       = "Microsoft Visual Studio Solution File, Format Version 10.00"

++                                   "\n# Visual Studio 2008";

++ const char _slnHeader100[]      = "Microsoft Visual Studio Solution File, Format Version 11.00"

++                                   "\n# Visual Studio 2010";

++ const char _slnHeader110[]      = "Microsoft Visual Studio Solution File, Format Version 12.00"

++                                   "\n# Visual Studio 2012";

++ const char _slnHeader120[]      = "Microsoft Visual Studio Solution File, Format Version 12.00"

++                                   "\n# Visual Studio 2013";

++ const char _slnHeader140[]      = "Microsoft Visual Studio Solution File, Format Version 12.00"

++                                   "\n# Visual Studio 2015";

++ const char _slnHeader141[]      = "Microsoft Visual Studio Solution File, Format Version 12.00"

++                                   "\n# Visual Studio 15";

++ const char _slnHeader142[]      = "Microsoft Visual Studio Solution File, Format Version 12.00"

++                                   "\n# Visual Studio Version 16";

++ const char _slnHeader143[]      = "Microsoft Visual Studio Solution File, Format Version 12.00"

++                                   "\n# Visual Studio Version 17";

++ const char _slnHeader145[]      = "Microsoft Visual Studio Solution File, Format Version 12.00"

++                                   "\n# Visual Studio Version 18";

++                                   // 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(SolutionConfigurationPlatforms) = preSolution"

++                                   "\n\t\tDebug|Win32 = Debug|Win32"

++                                   "\n\t\tRelease|Win32 = Release|Win32"

++                                   "\n\tEndGlobalSection";

++

++ const char _slnProjDepBeg[]     = "\n\tProjectSection(ProjectDependencies) = postProject";

++ const char _slnProjDepEnd[]     = "\n\tEndProjectSection";

++ const char _slnProjConfBeg[]    = "\n\tGlobalSection(ProjectConfigurationPlatforms) = 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(),

++       is64Bit(false),

++       customBuildToolFilterFileSuffix(QStringLiteral(".cbt")),

++       projectWriter(nullptr)

++ {

++ }

++

++ VcprojGenerator::~VcprojGenerator()

++ {

++     delete projectWriter;

++ }

++

++ 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);

++             projectWriter->write(xmlOut, vcProject);

++         }

++         return true;

++     }

++     return project->isActiveConfig("build_pass");

++ }

++

++ bool VcprojGenerator::writeProjectMakefile()

++ {

++     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.size()) {

++             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.size(); ++i) {

++             VCProjectSingleConfig *singleProject = &(mergedProjects.at(i)->vcProject);

++             mergedProject.SingleProjects += *singleProject;

++             for (int j = 0; j < singleProject->ExtraCompilersFiles.size(); ++j) {

++                 const QString &compilerName = singleProject->ExtraCompilersFiles.at(j).Name;

++                 if (!mergedProject.ExtraCompilers.contains(compilerName))

++                     mergedProject.ExtraCompilers += compilerName;

++             }

++         }

++

++         if(mergedProjects.size() > 1 &&

++            mergedProjects.at(0)->vcProject.Name ==

++            mergedProjects.at(1)->vcProject.Name)

++             mergedProjects.at(0)->writePrlFile();

++         mergedProject.Name = project->first("QMAKE_PROJECT_NAME").toQString();

++         mergedProject.Version = mergedProjects.at(0)->vcProject.Version;

++         mergedProject.SdkVersion = mergedProjects.at(0)->vcProject.SdkVersion;

++         mergedProject.ProjectGUID = project->isEmpty("QMAKE_UUID") ? getProjectUUID().toString().toUpper() : project->first("QMAKE_UUID").toQString();

++         mergedProject.Keyword = project->first("VCPROJ_KEYWORD").toQString();

++         mergedProject.SccProjectName = mergedProjects.at(0)->vcProject.SccProjectName;

++         mergedProject.SccLocalPath = mergedProjects.at(0)->vcProject.SccLocalPath;

++         mergedProject.PlatformName = mergedProjects.at(0)->vcProject.PlatformName;

++         mergedProject.WindowsTargetPlatformVersion =

++                 project->first("WINDOWS_TARGET_PLATFORM_VERSION").toQString();

++         mergedProject.WindowsTargetPlatformMinVersion =

++                 project->first("WINDOWS_TARGET_PLATFORM_MIN_VERSION").toQString();

++

++         XmlOutput xmlOut(t);

++         projectWriter->write(xmlOut, mergedProject);

++         return true;

++     } else if(project->first("TEMPLATE") == "vcsubdirs") {

++         return writeMakefile(t);

++     }

++     return false;

++ }

++

++ struct VcsolutionDepend {

++     QString uuid;

++     QString vcprojFile;

++     QString projectName;

++     QString target;

++     Target targetType;

++     QStringList dependencies;

++ };

++

++ /* Disable optimization in getProjectUUID() due to a compiler

++  * bug in MSVC 2015 that causes ASSERT: "&other != this" in the QString

++  * copy constructor for non-empty file names at:

++  * filename.isEmpty()?project->first("QMAKE_MAKEFILE"):filename */

++

++ #if defined(Q_CC_MSVC) && !defined(Q_CC_CLANG)

++ #   pragma optimize( "g", off )

++ #   pragma warning ( disable : 4748 )

++ #endif

++

++ QUuid VcprojGenerator::getProjectUUID(const QString &filename)

++ {

++     bool validUUID = true;

++

++     // Read GUID from variable-space

++     auto uuid = QUuid::fromString(project->first("GUID").toQStringView());

++

++     // If none, create one based on the MD5 of absolute project path

++     if(uuid.isNull() || !filename.isEmpty()) {

++         QString abspath = Option::fixPathToTargetOS(

++                     filename.isEmpty() ? project->first("QMAKE_MAKEFILE").toQString() : filename);

++         QByteArray digest = QCryptographicHash::hash(abspath.toUtf8(), QCryptographicHash::Sha1);

++         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") = ProStringList(uuid.toString().toUpper());

++     return uuid;

++ }

++

++ #if defined(Q_CC_MSVC) && !defined(Q_CC_CLANG)

++ #   pragma optimize( "g", on )

++ #endif

++

++ 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;

++ }

++

++ QString VcprojGenerator::retrievePlatformToolSet() const

++ {

++     // The PlatformToolset string corresponds to the name of a directory in

++     // $(VCTargetsPath)\Platforms\{Win32,x64,...}\PlatformToolsets

++     // e.g. v90, v100, v110, v110_xp, v120_CTP_Nov, v120, or WindowsSDK7.1

++

++     // This environment variable may be set by a commandline build

++     // environment such as the Windows SDK command prompt

++     QByteArray envVar = qgetenv("PlatformToolset");

++     if (!envVar.isEmpty())

++         return envVar;

++

++     return u"v"_s + project->first("MSVC_TOOLSET_VER");

++ }

++

++ bool VcprojGenerator::isStandardSuffix(const QString &suffix) const

++ {

++     if (!project->values("QMAKE_APP_FLAG").isEmpty()) {

++         if (suffix.compare("exe", Qt::CaseInsensitive) == 0)

++             return true;

++     } else if (project->isActiveConfig("shared")) {

++         if (suffix.compare("dll", Qt::CaseInsensitive) == 0)

++             return true;

++     } else {

++         if (suffix.compare("lib", Qt::CaseInsensitive) == 0)

++             return true;

++     }

++     return false;

++ }

++

++ ProString VcprojGenerator::firstInputFileName(const ProString &extraCompilerName) const

++ {

++     for (const ProString &var : project->values(ProKey(extraCompilerName + ".input"))) {

++         const ProStringList &files = project->values(var.toKey());

++         if (!files.isEmpty())

++             return files.first();

++     }

++     return ProString();

++ }

++

++ QString VcprojGenerator::firstExpandedOutputFileName(const ProString &extraCompilerName)

++ {

++     const ProString firstOutput = project->first(ProKey(extraCompilerName + ".output"));

++     return replaceExtraCompilerVariables(firstOutput.toQString(),

++                                          firstInputFileName(extraCompilerName).toQString(),

++                                          QString(), NoShell);

++ }

++

++ ProStringList VcprojGenerator::collectDependencies(QMakeProject *proj, QHash<QString, QString> &projLookup,

++                                                    QHash<QString, QString> &projGuids,

++                                                    QHash<VcsolutionDepend *, QStringList> &extraSubdirs,

++                                                    QHash<QString, VcsolutionDepend*> &solution_depends,

++                                                    QList<VcsolutionDepend*> &solution_cleanup,

++                                                    QTextStream &t,

++                                                    QHash<QString, ProStringList> &subdirProjectLookup,

++                                                    const ProStringList &allDependencies)

++ {

++     QList<QPair<QString, ProStringList>> collectedSubdirs;

++     ProStringList tmp_proj_subdirs = proj->values("SUBDIRS");

++     ProStringList projectsInProject;

++     const int numSubdirs = tmp_proj_subdirs.size();

++     collectedSubdirs.reserve(numSubdirs);

++     for (int x = 0; x < numSubdirs; ++x) {

++         ProString tmpdir = tmp_proj_subdirs.at(x);

++         const ProKey tmpdirConfig(tmpdir + ".CONFIG");

++         if (!proj->isEmpty(tmpdirConfig)) {

++             const ProStringList config = proj->values(tmpdirConfig);

++             if (config.contains(QStringLiteral("no_default_target")))

++                 continue; // Ignore this sub-dir

++         }

++         const ProKey fkey(tmpdir + ".file");

++         const ProKey skey(tmpdir + ".subdir");

++         if (!proj->isEmpty(fkey)) {

++             if (!proj->isEmpty(skey))

++                 warn_msg(WarnLogic, "Cannot assign both file and subdir for subdir %s",

++                          tmpdir.toLatin1().constData());

++             tmpdir = proj->first(fkey);

++         } else if (!proj->isEmpty(skey)) {

++             tmpdir = proj->first(skey);

++         }

++         projectsInProject.append(tmpdir);

++         collectedSubdirs.append(qMakePair(tmpdir.toQString(), proj->values(ProKey(tmp_proj_subdirs.at(x) + ".depends"))));

++         projLookup.insert(tmp_proj_subdirs.at(x).toQString(), tmpdir.toQString());

++     }

++     for (const auto &subdir : std::as_const(collectedSubdirs)) {

++         QString profile = subdir.first;

++         QFileInfo fi(fileInfo(Option::normalizePath(profile)));

++         if (fi.exists()) {

++             if (fi.isDir()) {

++                 if (!profile.endsWith(Option::dir_sep))

++                     profile += Option::dir_sep;

++                 profile += fi.baseName() + Option::pro_ext;

++                 QString profileKey = fi.absoluteFilePath();

++                 fi = QFileInfo(fileInfo(Option::normalizePath(profile)));

++                 if (!fi.exists())

++                     continue;

++                 projLookup.insert(profileKey, fi.absoluteFilePath());

++             }

++             QString oldpwd = qmake_getpwd();

++             QString oldoutpwd = Option::output_dir;

++             QMakeProject tmp_proj;

++             QString dir = fi.absolutePath(), fn = fi.fileName();

++             if (!dir.isEmpty()) {

++                 if (!qmake_setpwd(dir))

++                     fprintf(stderr, "Cannot find directory: %s", dir.toLatin1().constData());

++             }

++             Option::output_dir = Option::globals->shadowedPath(QDir::cleanPath(dir));

++             if (tmp_proj.read(fn)) {

++                 // Check if all requirements are fulfilled

++                 if (!tmp_proj.isEmpty("QMAKE_FAILED_REQUIREMENTS")) {

++                     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());

++                     qmake_setpwd(oldpwd);

++                     Option::output_dir = oldoutpwd;

++                     continue;

++                 }

++                 if (tmp_proj.first("TEMPLATE") == "vcsubdirs") {

++                     ProStringList tmpList = collectDependencies(&tmp_proj, projLookup, projGuids, extraSubdirs, solution_depends, solution_cleanup, t, subdirProjectLookup, subdir.second);

++                     subdirProjectLookup.insert(subdir.first, tmpList);

++                 } else {

++                     ProStringList tmpList;

++                     tmpList += subdir.second;

++                     tmpList += allDependencies;

++                     // 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;

++

++                     // We assume project filename is [QMAKE_PROJECT_NAME].vcproj

++                     const ProString projectName = tmp_vcproj.project->first("QMAKE_PROJECT_NAME");

++                     const QString vcproj = projectName + project->first("VCPROJ_EXTENSION");

++                     QString vcprojDir = Option::output_dir;

++

++                     // 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)) {

++                         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->projectName = projectName.toQString();

++                     newDep->target = tmp_proj.first("MSVCPROJ_TARGET").toQString().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").toQString();

++                     // We want to store it as the .lib name.

++                     if (newDep->target.endsWith(".dll"))

++                         newDep->target = newDep->target.left(newDep->target.size()-3) + "lib";

++                     projGuids.insert(newDep->projectName, newDep->target);

++

++                     if (tmpList.size()) {

++                         const ProStringList depends = tmpList;

++                         for (const ProString &dep : depends) {

++                             QString depend = dep.toQString();

++                             if (!projGuids[depend].isEmpty()) {

++                                 newDep->dependencies << projGuids[depend];

++                             } else if (subdirProjectLookup[projLookup[depend]].size() > 0) {

++                                 const ProStringList tmpLst = subdirProjectLookup[projLookup[depend]];

++                                 for (const ProString &tDep : tmpLst) {

++                                     QString tmpDep = tDep.toQString();

++                                     newDep->dependencies << projGuids[projLookup[tmpDep]];

++                                 }

++                             } else {

++                                 extraSubdirs.insert(newDep, tmpList.toQStringList());

++                                 newDep->dependencies.clear();

++                                 break;

++                             }

++                         }

++                     }

++

++                     // All ActiveQt Server projects are dependent on idc.exe

++                     if (tmp_proj.values("CONFIG").contains("qaxserver"))

++                         newDep->dependencies << "idc.exe";

++

++                     // Add all unknown libs to the deps

++                     QStringList where = QStringList() << "LIBS" << "LIBS_PRIVATE"

++                                                       << "QMAKE_LIBS" << "QMAKE_LIBS_PRIVATE";

++                     for (QStringList::ConstIterator wit = where.cbegin();

++                         wit != where.cend(); ++wit) {

++                             const ProStringList &l = tmp_proj.values(ProKey(*wit));

++                             for (ProStringList::ConstIterator it = l.begin(); it != l.end(); ++it) {

++                                 const QString opt = fixLibFlag(*it).toQString();

++                                 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);

++                 }

++ nextfile:

++                 qmake_setpwd(oldpwd);

++                 Option::output_dir = oldoutpwd;

++             }

++         }

++     }

++     return projectsInProject;

++ }

++

++ 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 (vcProject.Configuration.CompilerVersion) {

++     case NET2026:

++         t << _slnHeader145;

++         break;

++     case NET2022:

++         t << _slnHeader143;

++         break;

++     case NET2019:

++         t << _slnHeader142;

++         break;

++     case NET2017:

++         t << _slnHeader141;

++         break;

++     case NET2015:

++         t << _slnHeader140;

++         break;

++     case NET2013:

++         t << _slnHeader120;

++         break;

++     case NET2012:

++         t << _slnHeader110;

++         break;

++     case NET2010:

++         t << _slnHeader100;

++         break;

++     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",

++                  vcProject.Configuration.CompilerVersion);

++         break;

++     }

++

++     QHash<QString, VcsolutionDepend*> solution_depends;

++     QList<VcsolutionDepend*> solution_cleanup;

++

++     // Make sure that all temp projects are configured

++     // for release so that the depends are created

++     // without the debug <lib>dxxx.lib name mangling

++     QString old_after_vars = Option::globals->extra_cmds[QMakeEvalAfter];

++     Option::globals->extra_cmds[QMakeEvalAfter].append("\nCONFIG+=release");

++

++     QHash<QString, QString> profileLookup;

++     QHash<QString, QString> projGuids;

++     QHash<VcsolutionDepend *, QStringList> extraSubdirs;

++     QHash<QString, ProStringList> subdirProjectLookup;

++     collectDependencies(project, profileLookup, projGuids, extraSubdirs, solution_depends, solution_cleanup, t, subdirProjectLookup);

++

++     // write out projects

++     for (QList<VcsolutionDepend*>::Iterator it = solution_cleanup.begin(); it != solution_cleanup.end(); ++it) {

++         // ### quoting rules?

++         t << _slnProjectBeg << _slnMSVCvcprojGUID << _slnProjectMid

++             << "\"" << (*it)->projectName << "\", \"" << (*it)->vcprojFile

++             << "\", \"" << (*it)->uuid << "\"";

++

++         debug_msg(1, "Project %s has dependencies: %s", (*it)->target.toLatin1().constData(), (*it)->dependencies.join(" ").toLatin1().constData());

++

++         bool hasDependency = false;

++         for (QStringList::iterator dit = (*it)->dependencies.begin();  dit != (*it)->dependencies.end(); ++dit) {

++             if (VcsolutionDepend *vc = solution_depends[*dit]) {

++                 if (!hasDependency) {

++                     hasDependency = true;

++                     t << _slnProjDepBeg;

++                 }

++                 t << "\n\t\t" << vc->uuid << " = " << vc->uuid;

++             }

++         }

++         if (hasDependency)

++             t << _slnProjDepEnd;

++

++         t << _slnProjectEnd;

++     }

++

++     t << _slnGlobalBeg;

++

++     for (auto extraIt = extraSubdirs.cbegin(), end = extraSubdirs.cend(); extraIt != end; ++extraIt) {

++         for (const QString &depend : extraIt.value()) {

++             if (!projGuids[depend].isEmpty()) {

++                 extraIt.key()->dependencies << projGuids[depend];

++             } else if (!profileLookup[depend].isEmpty()) {

++                 if (!projGuids[profileLookup[depend]].isEmpty())

++                     extraIt.key()->dependencies << projGuids[profileLookup[depend]];

++             }

++         }

++     }

++     QString slnConf = _slnSolutionConf;

++     if (!project->isEmpty("VCPROJ_ARCH")) {

++         slnConf.replace(QLatin1String("|Win32"), "|" + project->first("VCPROJ_ARCH"));

++     } else if (is64Bit) {

++         slnConf.replace(QLatin1String("|Win32"), QLatin1String("|x64"));

++     }

++     t << slnConf;

++

++     // Restore previous after_user_var options

++     Option::globals->extra_cmds[QMakeEvalAfter] = old_after_vars;

++

++     t << _slnProjConfBeg;

++     for(QList<VcsolutionDepend*>::Iterator it = solution_cleanup.begin(); it != solution_cleanup.end(); ++it) {

++         QString platform = is64Bit ? "x64" : "Win32";

++         QString xplatform = platform;

++         if (!project->isEmpty("VCPROJ_ARCH")) {

++             xplatform = project->first("VCPROJ_ARCH").toQString();

++         }

++         if (!project->isHostBuild())

++             platform = xplatform;

++         t << "\n\t\t" << (*it)->uuid << QString(_slnProjDbgConfTag1).arg(xplatform) << platform;

++         t << "\n\t\t" << (*it)->uuid << QString(_slnProjDbgConfTag2).arg(xplatform) << platform;

++         t << "\n\t\t" << (*it)->uuid << QString(_slnProjRelConfTag1).arg(xplatform) << platform;

++         t << "\n\t\t" << (*it)->uuid << QString(_slnProjRelConfTag2).arg(xplatform) << 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.size(); ++i)

++         if (file.endsWith(Option::cpp_ext.at(i)))

++             return true;

++     for (int i = 0; i < Option::c_ext.size(); ++i)

++         if (file.endsWith(Option::c_ext.at(i)))

++             return true;

++     if (file.endsWith(".rc")

++         || file.endsWith(".idl"))

++         return true;

++     return false;

++ }

++

++ void VcprojGenerator::createCustomBuildToolFakeFile(const QString &cbtFilePath,

++                                                     const QString &realOutFilePath)

++ {

++     QFile file(fileFixify(cbtFilePath, FileFixifyFromOutdir | FileFixifyAbsolute));

++     if (file.exists())

++         return;

++     if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {

++         warn_msg(WarnLogic, "Cannot create '%s'.", qPrintable(file.fileName()));

++         return;

++     }

++     file.write("This is a dummy file needed to create ");

++     file.write(qPrintable(realOutFilePath));

++     file.write("\n");

++ }

++

++ void VcprojGenerator::init()

++ {

++     is64Bit = (project->first("QMAKE_TARGET.arch") == "x86_64");

++     projectWriter = createProjectWriter();

++

++     if(project->first("TEMPLATE") == "vcsubdirs") //too much work for subdirs

++         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");

++

++     processVars();

++

++     // set /VERSION for EXE/DLL header

++     ProString major_minor = project->first("VERSION_PE_HEADER");

++     if (major_minor.isEmpty()) {

++         ProString version = project->first("VERSION");

++         if (!version.isEmpty()) {

++             int firstDot = version.indexOf(".");

++             int secondDot = version.indexOf(".", firstDot + 1);

++             major_minor = version.left(secondDot);

++         }

++     }

++     if (!major_minor.isEmpty())

++         project->values("QMAKE_LFLAGS").append("/VERSION:" + major_minor);

++

++     MakefileGenerator::init();

++

++     // $$QMAKE.. -> $$MSVCPROJ.. -------------------------------------

++     const ProStringList &incs = project->values("INCLUDEPATH");

++     for (ProStringList::ConstIterator incit = incs.begin(); incit != incs.end(); ++incit) {

++         QString inc = (*incit).toQString();

++         project->values("MSVCPROJ_INCPATH").append("-I" + escapeFilePath(inc));

++     }

++

++     QString dest = Option::fixPathToTargetOS(project->first("TARGET").toQString()) + project->first("TARGET_EXT");

++     project->values("MSVCPROJ_TARGET") = ProStringList(dest);

++

++     // DLL COPY ------------------------------------------------------

++     if (project->isActiveConfig("dll") && !project->values("DLLDESTDIR").isEmpty()) {

++         const ProStringList &dlldirs = project->values("DLLDESTDIR");

++         QString copydll("");

++         ProStringList::ConstIterator dlldir;

++         for (dlldir = dlldirs.begin(); dlldir != dlldirs.end(); ++dlldir) {

++             if (!copydll.isEmpty())

++                 copydll += " && ";

++             copydll += "copy \"$(TargetPath)\" " + escapeFilePath(*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 0

++     // Verbose output if "-d -d"...

++     qDebug("Generator: MSVC.NET: List of current variables:");

++     for (ProValueMap::ConstIterator it = project->variables().begin(); it != project->variables().end(); ++it)

++         qDebug("Generator: MSVC.NET: %s => %s", qPrintable(it.key().toQString()), qPrintable(it.value().join(" | ")));

++ #endif

++

++     // 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")) {

++             project->values("LIBS") += project->values("RES_FILE");

++             projectTarget = StaticLib;

++         } else

++             projectTarget = SharedLib;

++     }

++

++     // Setup PCH variables

++     precompH = project->first("PRECOMPILED_HEADER").toQString();

++     precompSource = project->first("PRECOMPILED_SOURCE").toQString();

++     pchIsCFile = project->isActiveConfig("precompile_header_c");

++     usePCH = !precompH.isEmpty() && (pchIsCFile || project->isActiveConfig("precompile_header"));

++     if (usePCH) {

++         precompHFilename = fileInfo(precompH).fileName();

++         // Created files

++         QString origTarget = project->first("QMAKE_ORIG_TARGET").toQString();

++         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") = ProStringList(precompObj);

++         project->values("PRECOMPILED_PCH")    = ProStringList(precompPch);

++

++         autogenPrecompSource = precompSource.isEmpty() && project->isActiveConfig("autogen_precompile_source");

++         if (autogenPrecompSource) {

++             precompSource = precompH

++                     + (pchIsCFile

++                        ? (Option::c_ext.size() ? Option::c_ext.at(0) : QLatin1String(".c"))

++                        : (Option::cpp_ext.size() ? Option::cpp_ext.at(0) : QLatin1String(".cpp")));

++             project->values("GENERATED_SOURCES") += precompSource;

++         } else if (!precompSource.isEmpty()) {

++             project->values("SOURCES") += precompSource;

++         }

++     }

++

++     // Helper function to create a fake file foo.cbt for the project view.

++     //

++     // This prevents VS from complaining about a circular dependency from "foo -> foo".

++     //

++     // The .cbt file is added as "source" of the Custom Build Tool.  This means, in the project

++     // view, this is the file the Custom Build Tool property page is attached to.

++     //

++     // This function returns a pair with

++     //   - the fully resolved output file path

++     //   - the file path of the .cbt file

++     auto addExtraCompilerSourceWithCustomBuildToolFakeFile

++         = [this](const QString &compilerOutput, const ProString &extraCompiler,

++                  const QStringList &inputs) -> std::pair<QString, QString>

++     {

++         QString realOut = replaceExtraCompilerVariables(compilerOutput, inputs, {}, NoShell);

++         QString out = realOut + customBuildToolFilterFileSuffix;

++         createCustomBuildToolFakeFile(out, realOut);

++         out = Option::fixPathToTargetOS(out, false);

++         extraCompilerSources[out] += extraCompiler.toQString();

++         return { realOut, out };

++     };

++

++     // Add all input files for a custom compiler into a map for uniqueness.

++     //

++     // Use .cbt files for the following cases:

++     //   - CONFIG += combine

++     //   - the input has a built-in compiler (e.g. C++ source file)

++     for (const ProString &quc : project->values("QMAKE_EXTRA_COMPILERS")) {

++         const ProStringList &invar = project->values(ProKey(quc + ".input"));

++         const QString compiler_out = project->first(ProKey(quc + ".output")).toQString();

++

++         QStringList inputFiles;

++         for (auto it = invar.begin(); it != invar.end(); ++it)

++             inputFiles += project->values(it->toKey()).toQStringList();

++

++         if (project->values(ProKey(quc + ".CONFIG")).contains("combine")) {

++             // Handle "CONFIG += combine" extra compilers.

++             QString realOut;

++             QString out;

++             std::tie(realOut, out)

++                 = addExtraCompilerSourceWithCustomBuildToolFakeFile(compiler_out, quc, inputFiles);

++             if (hasBuiltinCompiler(realOut))

++                 extraCompilerOutputs[out] = realOut;

++         } else {

++             // Handle regular 1-to-1 extra compilers.

++             for (const QString &file : inputFiles) {

++                 if (verifyExtraCompiler(quc, file)) {

++                     if (!hasBuiltinCompiler(file)) {

++                         extraCompilerSources[file] += quc.toQString();

++                     } else {

++                         QString out;

++                         std::tie(std::ignore, out)

++                             = addExtraCompilerSourceWithCustomBuildToolFakeFile(compiler_out,

++                                                                                 quc,

++                                                                                 QStringList(file));

++                         extraCompilerOutputs[out] = file;

++                     }

++                 }

++             }

++         }

++     }

++

++ #if 0 // Debugging

++     for (auto it = extraCompilerSources.cbegin(), end = extraCompilerSources.cend(); it != end; ++it)

++         qDebug("Extracompilers for %s are (%s)", it.key().toLatin1().constData(), it.value().join(", ").toLatin1().constData());

++     for (auto it = extraCompilerOutputs.cbegin(), end = extraCompilerOutputs.cend(); it != end; ++it)

++         qDebug("Object mapping for %s is (%s)", qPrintable(it.key()), qPrintable(it.value()));

++     qDebug("");

++ #endif

++ }

++

++ bool VcprojGenerator::mergeBuildProject(MakefileGenerator *other)

++ {

++     if (!other || !other->projectFile()) {

++         warn_msg(WarnLogic, "VcprojGenerator: Cannot merge null project.");

++         return false;

++     }

++     if (other->projectFile()->first("MAKEFILE_GENERATOR") != project->first("MAKEFILE_GENERATOR")) {

++         warn_msg(WarnLogic, "VcprojGenerator: Cannot merge other types of projects! (ignored)");

++         return false;

++     }

++

++     VcprojGenerator *otherVC = static_cast<VcprojGenerator*>(other);

++     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();

++     initDistributionFiles();

++     initExtraCompilerOutputs();

++

++     // Own elements -----------------------------

++     vcProject.Name = project->first("QMAKE_ORIG_TARGET").toQString();

++     switch (vcProject.Configuration.CompilerVersion) {

++     case NET2026:

++         vcProject.Version = "18.00";

++         break;

++     case NET2022:

++         vcProject.Version = "17.00";

++         break;

++     case NET2019:

++         vcProject.Version = "16.00";

++         break;

++     case NET2017:

++         vcProject.Version = "15.00";

++         break;

++     case NET2015:

++         vcProject.Version = "14.00";

++         break;

++     case NET2013:

++         vcProject.Version = "12.00";

++         break;

++     case NET2012:

++         vcProject.Version = "11.00";

++         break;

++     case NET2010:

++         vcProject.Version = "10.00";

++         break;

++     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", vcProject.Configuration.CompilerVersion);

++         break;

++     }

++

++     vcProject.Keyword = project->first("VCPROJ_KEYWORD").toQString();

++     if (!project->isEmpty("VCPROJ_ARCH")) {

++         vcProject.PlatformName = project->first("VCPROJ_ARCH").toQString();

++     } else {

++         vcProject.PlatformName = (is64Bit ? "x64" : "Win32");

++     }

++     vcProject.SdkVersion = project->first("WINSDK_VER").toQString();

++     // These are not used by Qt, but may be used by customers

++     vcProject.SccProjectName = project->first("SCCPROJECTNAME").toQString();

++     vcProject.SccLocalPath = project->first("SCCLOCALPATH").toQString();

++     vcProject.flat_files = project->isActiveConfig("flat");

++

++     // Set up the full target path for target conflict checking.

++     const QChar slash = QLatin1Char('/');

++     QString destdir = QDir::fromNativeSeparators(var("DESTDIR"));

++     if (!destdir.endsWith(slash))

++         destdir.append(slash);

++     project->values("DEST_TARGET") = ProStringList(destdir

++                                                    + project->first("TARGET")

++                                                    + project->first("TARGET_EXT"));

++ }

++

++ 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.suppressUnknownOptionWarnings = project->isActiveConfig("suppress_vcproj_warnings");

++     conf.CompilerVersion = vsVersionFromString(project->first("MSVC_VER"));

++

++     initCompilerTool();

++

++     // Only on configuration per build

++     bool isDebug = project->isActiveConfig("debug");

++

++     if(projectTarget == StaticLib)

++         initLibrarianTool();

++     else {

++         conf.linker.GenerateDebugInformation = project->isActiveConfig("debug_info") ? _True : _False;

++         initLinkerTool();

++     }

++     initManifestTool();

++     initResourceTool();

++     initIDLTool();

++

++     // Own elements -----------------------------

++     ProString 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.OutputDirectory = project->first("DESTDIR").toQString();

++     if (conf.OutputDirectory.isEmpty())

++         conf.OutputDirectory = ".\\";

++     if (!conf.OutputDirectory.endsWith("\\"))

++         conf.OutputDirectory += '\\';

++     if (conf.CompilerVersion >= NET2010) {

++         conf.PlatformToolSet = retrievePlatformToolSet();

++

++         const QFileInfo targetInfo = fileInfo(project->first("MSVCPROJ_TARGET").toQString());

++         conf.PrimaryOutput = targetInfo.completeBaseName();

++

++         const QString targetSuffix = targetInfo.suffix();

++         if (!isStandardSuffix(targetSuffix))

++             conf.PrimaryOutputExtension = '.' + targetSuffix;

++     }

++

++     conf.Name = project->values("BUILD_NAME").join(' ');

++     if (conf.Name.isEmpty())

++         conf.Name = isDebug ? "Debug" : "Release";

++     conf.ConfigurationName = conf.Name;

++     if (!project->isEmpty("VCPROJ_ARCH")) {

++         conf.Name += "|" + project->first("VCPROJ_ARCH");

++     } else {

++         conf.Name += (is64Bit ? "|x64" : "|Win32");

++     }

++     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").toQString();

++     conf.ImportLibrary = conf.linker.ImportLibrary;

++     conf.IntermediateDirectory = project->first("OBJECTS_DIR").toQString();

++     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 crosscompiled projects

++     if (!project->isHostBuild())

++         initDeploymentTool();

++     initWinDeployQtTool();

++     initPreLinkEventTools();

++ }

++

++ // Filter from the given QMAKE_CFLAGS the options that are relevant

++ // for the vcxproj-global VCCLCompilerTool.

++ static ProStringList relevantCFlags(const ProStringList &flags)

++ {

++     ProStringList result;

++     static const QRegularExpression rex("^[/-]std:");

++     for (const ProString &flag : flags) {

++         if (rex.match(flag.toQString()).hasMatch()) {

++             result.append(flag);

++         }

++     }

++     return result;

++ }

++

++ void VcprojGenerator::initCompilerTool()

++ {

++     QString placement = project->first("OBJECTS_DIR").toQString();

++     if(placement.isEmpty())

++         placement = ".\\";

++

++     VCConfiguration &conf = vcProject.Configuration;

++     if (conf.CompilerVersion >= NET2010) {

++         // adjust compiler tool defaults for VS 2010 and above

++         conf.compiler.Optimization = optimizeDisabled;

++     }

++     conf.compiler.AssemblerListingLocation = placement ;

++     conf.compiler.ObjectFile = placement ;

++     conf.compiler.ExceptionHandling = ehNone;

++     // PCH

++     if (usePCH) {

++         conf.compiler.UsePrecompiledHeader     = pchUseUsingSpecific;

++         conf.compiler.PrecompiledHeaderFile    = "$(IntDir)\\" + precompPch;

++         conf.compiler.PrecompiledHeaderThrough = project->first("PRECOMPILED_HEADER").toQString();

++         conf.compiler.ForcedIncludeFiles       = project->values("PRECOMPILED_HEADER").toQStringList();

++     }

++

++     conf.compiler.parseOptions(relevantCFlags(project->values("QMAKE_CFLAGS")));

++     conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS"));

++

++     if (project->isActiveConfig("windows"))

++         conf.compiler.PreprocessorDefinitions += "_WINDOWS";

++     else if (project->isActiveConfig("console"))

++         conf.compiler.PreprocessorDefinitions += "_CONSOLE";

++

++     conf.compiler.PreprocessorDefinitions += project->values("DEFINES").toQStringList();

++     conf.compiler.PreprocessorDefinitions += project->values("PRL_EXPORT_DEFINES").toQStringList();

++     conf.compiler.parseOptions(project->values("MSVCPROJ_INCPATH"));

++ }

++

++ void VcprojGenerator::initLibrarianTool()

++ {

++     VCConfiguration &conf = vcProject.Configuration;

++     conf.librarian.OutputFile = "$(OutDir)\\";

++     conf.librarian.OutputFile += project->first("MSVCPROJ_TARGET").toQString();

++     conf.librarian.AdditionalOptions += project->values("QMAKE_LIBFLAGS").toQStringList();

++ }

++

++ void VcprojGenerator::initManifestTool()

++ {

++     VCManifestTool &tool = vcProject.Configuration.manifestTool;

++     const ProString tmplt = project->first("TEMPLATE");

++     if ((tmplt == "vclib"

++          && !project->isActiveConfig("embed_manifest_dll")

++          && !project->isActiveConfig("static"))

++         || (tmplt == "vcapp"

++             && !project->isActiveConfig("embed_manifest_exe"))) {

++         tool.EmbedManifest = _False;

++     }

++ }

++

++ void VcprojGenerator::initLinkerTool()

++ {

++     VCConfiguration &conf = vcProject.Configuration;

++     conf.linker.parseOptions(project->values("QMAKE_LFLAGS"));

++

++     if (!project->values("DEF_FILE").isEmpty())

++         conf.linker.ModuleDefinitionFile = project->first("DEF_FILE").toQString();

++

++     static const char * const lflags[] = { "LIBS", "LIBS_PRIVATE",

++                                            "QMAKE_LIBS", "QMAKE_LIBS_PRIVATE", nullptr };

++     for (int i = 0; lflags[i]; i++) {

++         const auto libs = fixLibFlags(lflags[i]);

++         for (const ProString &lib : libs) {

++             if (lib.startsWith("/LIBPATH:"))

++                 conf.linker.AdditionalLibraryDirectories << lib.mid(9).toQString();

++             else

++                 conf.linker.AdditionalDependencies << lib.toQString();

++         }

++     }

++

++     conf.linker.OutputFile = "$(OutDir)\\";

++     conf.linker.OutputFile += project->first("MSVCPROJ_TARGET").toQString();

++ }

++

++ void VcprojGenerator::initResourceTool()

++ {

++     VCConfiguration &conf = vcProject.Configuration;

++

++     ProStringList rcDefines = project->values("RC_DEFINES");

++     if (rcDefines.size() > 0)

++         conf.resource.PreprocessorDefinitions = rcDefines.toQStringList();

++     else

++         conf.resource.PreprocessorDefinitions = conf.compiler.PreprocessorDefinitions;

++

++     for (const ProString &path : project->values("RC_INCLUDEPATH")) {

++         QString fixedPath = fileFixify(path.toQString());

++         if (fileInfo(fixedPath).isRelative()) {

++             if (fixedPath == QLatin1String("."))

++                 fixedPath = QStringLiteral("$(ProjectDir)");

++             else

++                 fixedPath.prepend(QStringLiteral("$(ProjectDir)\\"));

++         }

++         conf.resource.AdditionalIncludeDirectories << escapeFilePath(fixedPath);

++     }

++

++     // 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 (conf.CompilerVersion < NET2010 && project->isActiveConfig("staticlib"))

++         conf.resource.ResourceOutputFileName = "$(OutDir)\\$(InputName).res";

++ }

++

++ void VcprojGenerator::initIDLTool()

++ {

++ }

++

++ void VcprojGenerator::initCustomBuildTool()

++ {

++ }

++

++ void VcprojGenerator::initPreBuildEventTools()

++ {

++ }

++

++ void VcprojGenerator::initPostBuildEventTools()

++ {

++     VCConfiguration &conf = vcProject.Configuration;

++     if (!project->values("QMAKE_POST_LINK").isEmpty()) {

++         QStringList cmdline = VCToolBase::fixCommandLine(var("QMAKE_POST_LINK"));

++         conf.postBuild.CommandLine = cmdline;

++         conf.postBuild.Description = cmdline.join(QLatin1String("\r\n"));

++         conf.postBuild.ExcludedFromBuild = _False;

++     }

++     if (!project->values("MSVCPROJ_COPY_DLL").isEmpty()) {

++         conf.postBuild.Description += var("MSVCPROJ_COPY_DLL_DESC");

++         conf.postBuild.CommandLine += var("MSVCPROJ_COPY_DLL");

++         conf.postBuild.ExcludedFromBuild = _False;

++     }

++ }

++

++ void VcprojGenerator::initDeploymentTool()

++ {

++     VCConfiguration &conf = vcProject.Configuration;

++     QString targetPath;

++     targetPath = project->values("deploy.path").join(' ');

++     if (targetPath.isEmpty())

++         targetPath = QString("%CSIDL_PROGRAM_FILES%\\") + project->first("TARGET");

++     if (targetPath.endsWith("/") || targetPath.endsWith("\\"))

++         targetPath.chop(1);

++     conf.deployment.RemoteDirectory = targetPath;

++     const ProStringList dllPaths = project->values("QMAKE_DLL_PATHS");

++     // Only deploy Qt libs for shared build

++     if (!dllPaths.isEmpty()) {

++         // FIXME: This code should actually resolve the libraries from all Qt modules.

++         ProStringList arg = project->values("LIBS") + project->values("LIBS_PRIVATE")

++                 + project->values("QMAKE_LIBS") + project->values("QMAKE_LIBS_PRIVATE");

++         bool qpaPluginDeployed = false;

++         for (ProStringList::ConstIterator it = arg.constBegin(); it != arg.constEnd(); ++it) {

++             QString dllName = (*it).toQString();

++             dllName.replace(QLatin1Char('\\'), QLatin1Char('/'));

++             // LIBPATH isn't relevant for deployment

++             if (dllName.startsWith(QLatin1String("/LIBPATH:")))

++                 continue;

++             // We want to deploy .dlls not .libs

++             if (dllName.endsWith(QLatin1String(".lib")))

++                 dllName.replace(dllName.size() - 3, 3, QLatin1String("dll"));

++             // Use only the file name and check in Qt's install path and LIBPATHs to check for existence

++             dllName.remove(0, dllName.lastIndexOf(QLatin1Char('/')) + 1);

++             QFileInfo info;

++             for (const ProString &dllPath : dllPaths) {

++                 QString absoluteDllFilePath = dllPath.toQString();

++                 if (!absoluteDllFilePath.endsWith(QLatin1Char('/')))

++                     absoluteDllFilePath += QLatin1Char('/');

++                 absoluteDllFilePath += dllName;

++                 info = QFileInfo(absoluteDllFilePath);

++                 if (info.exists())

++                     break;

++             }

++

++             if (!info.exists())

++                 continue;

++

++             conf.deployment.AdditionalFiles += info.fileName()

++                     + "|" + QDir::toNativeSeparators(info.absolutePath())

++                     + "|" + targetPath

++                     + "|0;";

++             if (!qpaPluginDeployed) {

++                 QString debugInfix;

++                 bool foundGuid = dllName.contains(QLatin1String("Guid"));

++                 if (foundGuid)

++                     debugInfix = QLatin1Char('d');

++

++                 if (foundGuid || dllName.contains(QLatin1String("Gui"))) {

++                     QFileInfo info2;

++                     for (const ProString &dllPath : dllPaths) {

++                         QString absoluteDllFilePath = dllPath.toQString();

++                         if (!absoluteDllFilePath.endsWith(QLatin1Char('/')))

++                             absoluteDllFilePath += QLatin1Char('/');

++                         absoluteDllFilePath += QLatin1String("../plugins/platforms/qwindows")

++                                 + debugInfix + QLatin1String(".dll");

++                         info2 = QFileInfo(absoluteDllFilePath);

++                         if (info2.exists())

++                             break;

++                     }

++                     if (info2.exists()) {

++                         conf.deployment.AdditionalFiles += QLatin1String("qwindows") + debugInfix + QLatin1String(".dll")

++                                                     + QLatin1Char('|') + QDir::toNativeSeparators(info2.absolutePath())

++                                                     + QLatin1Char('|') + targetPath + QLatin1String("\\platforms")

++                                                     + QLatin1String("|0;");

++                         qpaPluginDeployed = true;

++                     }

++                 }

++             }

++         }

++     }

++

++     for (const ProString &item : project->values("INSTALLS")) {

++         // get item.path

++         QString devicePath = project->first(ProKey(item + ".path")).toQString();

++         if (devicePath.isEmpty())

++             devicePath = targetPath;

++         // 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::fixPathToTargetOS(targetPath + QLatin1Char('\\') + devicePath);

++         }

++         // foreach d in item.files

++         for (const ProString &src : project->values(ProKey(item + ".files"))) {

++             QString itemDevicePath = devicePath;

++             QString source = Option::normalizePath(src.toQString());

++             QString nameFilter;

++             QFileInfo info(source);

++             QString searchPath;

++             if (info.isDir()) {

++                 nameFilter = QLatin1String("*");

++                 itemDevicePath += "\\" + info.fileName();

++                 searchPath = info.absoluteFilePath();

++             } else {

++                 nameFilter = info.fileName();

++                 searchPath = info.absolutePath();

++             }

++

++             int pathSize = searchPath.size();

++             using F = QDirListing::IteratorFlag;

++             QDirListing dirList(searchPath, QStringList{nameFilter}, F::FilesOnly | F::ResolveSymlinks | F::Recursive);

++             // foreach dirIterator-entry in d

++             for (const auto &dirEntry : dirList) {

++                 const QString absoluteItemPath = Option::fixPathToTargetOS(dirEntry.absolutePath());

++                 // Identify if it is just another subdir

++                 int diffSize = absoluteItemPath.size() - pathSize;

++                 // write out rules

++                 conf.deployment.AdditionalFiles += dirEntry.fileName()

++                         + "|" + absoluteItemPath

++                         + "|" + itemDevicePath + (diffSize ? (absoluteItemPath.right(diffSize)) : QLatin1String(""))

++                         + "|0;";

++             }

++         }

++     }

++ }

++

++ void VcprojGenerator::initWinDeployQtTool()

++ {

++     VCConfiguration &conf = vcProject.Configuration;

++     conf.windeployqt.ExcludedFromBuild = true;

++     if (project->isActiveConfig("windeployqt")) {

++         conf.windeployqt.Record = QStringLiteral("$(TargetName).windeployqt.$(Platform).$(Configuration)");

++         const QString commandLine = MakefileGenerator::shellQuote(QDir::toNativeSeparators(project->first("QMAKE_WINDEPLOYQT").toQString()))

++                 + QLatin1Char(' ') + project->values("WINDEPLOYQT_OPTIONS").join(QLatin1Char(' '));

++

++         //  Visual Studio copies all files to be deployed into the MSIL directory

++         //  and then invokes MDILXapCompile on it, which checks for managed code and

++         //  translates it into native code. The problem is that all entries of the

++         //  package will be copied into the MSIL directly, losing the subdirectory

++         //  structure (for instance for plugins). However, the MDILXapCompile call

++         //  itself contains the original subdirectories as parameters and hence the

++         //  call fails.

++         //  Hence the only way to get a build done is to recreate the directory

++         //  structure manually by invoking windeployqt a second time, so that

++         //  the MDILXapCompile call succeeds and deployment continues.

++         conf.windeployqt.CommandLine += commandLine

++                 + QStringLiteral(" -list relative -dir \"$(MSBuildProjectDirectory)\" \"$(OutDir)\\$(TargetFileName)\" > ")

++                 + MakefileGenerator::shellQuote(conf.windeployqt.Record);

++         conf.windeployqt.config = &vcProject.Configuration;

++         conf.windeployqt.ExcludedFromBuild = false;

++     }

++ }

++

++ void VcprojGenerator::initPreLinkEventTools()

++ {

++     VCConfiguration &conf = vcProject.Configuration;

++     if(!project->values("QMAKE_PRE_LINK").isEmpty()) {

++         QStringList cmdline = VCToolBase::fixCommandLine(var("QMAKE_PRE_LINK"));

++         conf.preLink.CommandLine = cmdline;

++         conf.preLink.Description = cmdline.join(QLatin1String("\r\n"));

++         conf.preLink.ExcludedFromBuild = _False;

++     }

++ }

++

++ 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);

++ }

++

++ 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);

++ }

++

++ 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"));

++     if (project->values("RC_FILE").isEmpty())

++         vcProject.GeneratedFiles.addFiles(project->values("RES_FILE"));

++     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);

++ }

++

++ 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.addFiles(project->values("EXTRA_TRANSLATIONS"));

++

++     vcProject.TranslationFiles.Project = this;

++     vcProject.TranslationFiles.Config = &(vcProject.Configuration);

++ }

++

++ 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.Project = this;

++     vcProject.FormFiles.Config = &(vcProject.Configuration);

++ }

++

++ 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()) {

++         const QStringList qrc_files = project->values("RESOURCES").toQStringList();

++         QStringList deps;

++         for (const QString &qrc_file : qrc_files) {

++             callExtraCompilerDependCommand("rcc",

++                                            rcc_dep_cmd,

++                                            qrc_file,

++                                            QString(),

++                                            true,  // dep_lines

++                                            &deps,

++                                            false, // existingDepsOnly

++                                            true   // checkCommandavailability

++                                           );

++         }

++         // A file that is also a source, header etc. would get a second, conflicting project item.

++         for (const QString &dep : std::as_const(deps)) {

++             if (!otherFiltersContain(dep))

++                 vcProject.ResourceFiles.addFile(dep);

++         }

++     }

++     // You may look again --------------------------------------------

++

++     vcProject.ResourceFiles.addFiles(project->values("RESOURCES"));

++

++     vcProject.ResourceFiles.Project = this;

++     vcProject.ResourceFiles.Config = &(vcProject.Configuration);

++ }

++

++ void VcprojGenerator::initDistributionFiles()

++ {

++     vcProject.DistributionFiles.Name = "Distribution Files";

++     vcProject.DistributionFiles.ParseFiles = _False;

++     vcProject.DistributionFiles.Filter = "*";

++     vcProject.DistributionFiles.Guid = _GUIDDistributionFiles;

++     vcProject.DistributionFiles.addFiles(project->values("DISTFILES"));

++     vcProject.DistributionFiles.Project = this;

++     vcProject.DistributionFiles.Config = &(vcProject.Configuration);

++ }

++

++ QString VcprojGenerator::extraCompilerName(const ProString &extraCompiler,

++                                              const QStringList &inputs,

++                                              const QStringList &outputs)

++ {

++     QString name = project->values(ProKey(extraCompiler + ".name")).join(' ');

++     if (name.isEmpty())

++         name = extraCompiler.toQString();

++     else

++         name = replaceExtraCompilerVariables(name, inputs, outputs, NoShell);

++     return name;

++ }

++

++ void VcprojGenerator::initExtraCompilerOutputs()

++ {

++     ProStringList otherFilters;

++     otherFilters << "FORMS"

++                  << "GENERATED_FILES"

++                  << "GENERATED_SOURCES"

++                  << "HEADERS"

++                  << "IDLSOURCES"

++                  << "LEXSOURCES"

++                  << "RC_FILE"

++                  << "RESOURCES"

++                  << "RES_FILE"

++                  << "SOURCES"

++                  << "TRANSLATIONS"

++                  << "YACCSOURCES";

++     const ProStringList &quc = project->values("QMAKE_EXTRA_COMPILERS");

++     for (ProStringList::ConstIterator it = quc.begin(); it != quc.end(); ++it) {

++         const ProStringList &inputVars = project->values(ProKey(*it + ".input"));

++         ProStringList inputFiles;

++         for (auto var : inputVars)

++             inputFiles.append(project->values(var.toKey()));

++         const ProStringList &outputs = project->values(ProKey(*it + ".output"));

++

++         // Create an extra compiler filter and add the files

++         VCFilter extraCompile;

++         extraCompile.Name = extraCompilerName(it->toQString(), inputFiles.toQStringList(),

++                                               outputs.toQStringList());

++         extraCompile.ParseFiles = _False;

++         extraCompile.Filter = "";

++         extraCompile.Guid = QString(_GUIDExtraCompilerFiles) + "-" + (*it);

++

++         // VCFilter::addExtraCompiler() merges all extra compilers of an input file into one

++         // custom build step, so each file may be listed only once across the compilers.

++         auto listedByOtherCompiler = [this](const QString &file) {

++             for (const VCFilter &filter : std::as_const(vcProject.ExtraCompilersFiles)) {

++                 for (const VCFilterFile &ff : filter.Files) {

++                     if (ff.file == file)

++                         return true;

++                 }

++             }

++             return false;

++         };

++

++         bool addOnInput = hasBuiltinCompiler(firstExpandedOutputFileName(*it));

++         if (!addOnInput) {

++             // If the extra compiler has a variable_out set that is already handled

++             // some other place, ignore it.

++             const ProString &outputVar = project->first(ProKey(*it + ".variable_out"));

++             if (!outputVar.isEmpty() && otherFilters.contains(outputVar))

++                 continue;

++

++             QString tmp_out;

++             if (!outputs.isEmpty())

++                 tmp_out = outputs.first().toQString();

++             if (project->values(ProKey(*it + ".CONFIG")).indexOf("combine") != -1) {

++                 // Combined output, only one file result. Use .cbt file.

++                 extraCompile.addFile(Option::fixPathToTargetOS(

++                         replaceExtraCompilerVariables(tmp_out + customBuildToolFilterFileSuffix,

++                                                       QString(), QString(), NoShell), false));

++             } else if (!inputVars.isEmpty()) {

++                 // One output file per input

++                 const ProStringList &tmp_in = project->values(inputVars.first().toKey());

++                 for (int i = 0; i < tmp_in.size(); ++i) {

++                     const QString &filename = tmp_in.at(i).toQString();

++                     if (!extraCompilerSources.contains(filename) || otherFiltersContain(filename))

++                         continue;

++                     const QString file = Option::fixPathToTargetOS(

++                             replaceExtraCompilerVariables(filename, tmp_out, QString(), NoShell),

++                             false);

++                     if (!listedByOtherCompiler(file))

++                         extraCompile.addFile(file);

++                 }

++             }

++         } 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).

++             for (const ProString &inputVar : inputVars) {

++                 if (!otherFilters.contains(inputVar)) {

++                     const ProStringList &tmp_in = project->values(inputVar.toKey());

++                     for (int i = 0; i < tmp_in.size(); ++i) {

++                         const QString &filename = tmp_in.at(i).toQString();

++                         if (!extraCompilerSources.contains(filename)

++                             || otherFiltersContain(filename))

++                             continue;

++                         const QString file = Option::fixPathToTargetOS(

++                                 replaceExtraCompilerVariables(filename, QString(), QString(),

++                                                               NoShell),

++                                 false);

++                         if (!listedByOtherCompiler(file))

++                             extraCompile.addFile(file);

++                     }

++                 }

++             }

++         }

++         extraCompile.Project = this;

++         extraCompile.Config = &(vcProject.Configuration);

++

++         vcProject.ExtraCompilersFiles.append(extraCompile);

++     }

++ }

++

++ bool VcprojGenerator::otherFiltersContain(const QString &fileName) const

++ {

++     auto filterFileMatches = [&fileName](const VCFilterFile &ff) {

++         // MSBuild compares item paths case-insensitively.

++         return ff.file.compare(fileName, Qt::CaseInsensitive) == 0;

++     };

++     for (const VCFilter *filter : { &vcProject.RootFiles,

++                                     &vcProject.SourceFiles,

++                                     &vcProject.HeaderFiles,

++                                     &vcProject.GeneratedFiles,

++                                     &vcProject.LexYaccFiles,

++                                     &vcProject.TranslationFiles,

++                                     &vcProject.FormFiles,

++                                     &vcProject.ResourceFiles,

++                                     &vcProject.DeploymentFiles,

++                                     &vcProject.DistributionFiles}) {

++         if (std::any_of(filter->Files.cbegin(), filter->Files.cend(), filterFileMatches))

++             return true;

++     }

++     return false;

++ }

++

++ // ------------------------------------------------------------------------------------------------

++ // ------------------------------------------------------------------------------------------------

++

++ VCProjectWriter *VcprojGenerator::createProjectWriter()

++ {

++     return new VCProjectWriter;

++ }

++

++ QString VcprojGenerator::replaceExtraCompilerVariables(

++         const QString &var, const QStringList &in, const QStringList &out, ReplaceFor forShell)

++ {

++     QString ret = MakefileGenerator::replaceExtraCompilerVariables(var, in, out, forShell);

++

++     ProStringList &defines = project->values("VCPROJ_MAKEFILE_DEFINES");

++     if(defines.isEmpty())

++         defines.append(varGlue("PRL_EXPORT_DEFINES"," -D"," -D","") +

++                        varGlue("DEFINES"," -D"," -D",""));

++     ret.replace(QLatin1String("$(DEFINES)"), defines.first().toQString());

++

++     ProStringList &incpath = project->values("VCPROJ_MAKEFILE_INCPATH");

++     if(incpath.isEmpty() && !this->var("MSVCPROJ_INCPATH").isEmpty())

++         incpath.append(this->var("MSVCPROJ_INCPATH"));

++     ret.replace(QLatin1String("$(INCPATH)"), incpath.join(' '));

++

++     return ret;

++ }

++

++ bool VcprojGenerator::openOutput(QFile &file, const QString &/*build*/) const

++ {

++     ProString fileName = file.fileName();

++     ProString extension = project->first("TEMPLATE") == "vcsubdirs"

++             ? project->first("VCSOLUTION_EXTENSION") : project->first("VCPROJ_EXTENSION");

++     if (!fileName.endsWith(extension)) {

++         if (fileName.isEmpty()) {

++             fileName = !project->first("MAKEFILE").isEmpty()

++                     ? project->first("MAKEFILE") : project->first("TARGET");

++         }

++         file.setFileName(fileName + extension);

++     }

++     return Win32MakefileGenerator::openOutput(file, QString());

++ }

++

++ QT_END_NAMESPACE

Revision control