1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the qmake application of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "msvc_vcproj.h"

    43 #include "option.h"

    44 #include "xmloutput.h"

    45 #include <qdir.h>

    46 #include <qdiriterator.h>

    47 #include <qcryptographichash.h>

    48 #include <qregexp.h>

    49 #include <qhash.h>

    50 #include <quuid.h>

    51 #include <stdlib.h>

    52 

    53 //#define DEBUG_SOLUTION_GEN

    54 //#define DEBUG_PROJECT_GEN

    55 

    56 QT_BEGIN_NAMESPACE

    57 // Filter GUIDs (Do NOT change these!) ------------------------------

    58 const char _GUIDSourceFiles[]          = "{4FC737F1-C7A5-4376-A066-2A32D752A2FF}";

    59 const char _GUIDHeaderFiles[]          = "{93995380-89BD-4b04-88EB-625FBE52EBFB}";

    60 const char _GUIDGeneratedFiles[]       = "{71ED8ED8-ACB9-4CE9-BBE1-E00B30144E11}";

    61 const char _GUIDResourceFiles[]        = "{D9D6E242-F8AF-46E4-B9FD-80ECBC20BA3E}";

    62 const char _GUIDLexYaccFiles[]         = "{E12AE0D2-192F-4d59-BD23-7D3FA58D3183}";

    63 const char _GUIDTranslationFiles[]     = "{639EADAA-A684-42e4-A9AD-28FC9BCB8F7C}";

    64 const char _GUIDFormFiles[]            = "{99349809-55BA-4b9d-BF79-8FDBB0286EB3}";

    65 const char _GUIDExtraCompilerFiles[]   = "{E0D8C965-CC5F-43d7-AD63-FAEF0BBC0F85}";

    66 QT_END_NAMESPACE

    67 

    68 #ifdef Q_OS_WIN32

    69 #include <qt_windows.h>

    70 

    71 QT_BEGIN_NAMESPACE

    72 

    73 struct {

    74     DotNET version;

    75     const char *versionStr;

    76     const char *regKey;

    77 } dotNetCombo[] = {

    78 #ifdef Q_OS_WIN64

    79     {NET2008, "MSVC.NET 2008 (9.0)", "Software\\Wow6432Node\\Microsoft\\VisualStudio\\9.0\\Setup\\VC\\ProductDir"},

    80     {NET2008, "MSVC.NET 2008 Express Edition (9.0)", "Software\\Wow6432Node\\Microsoft\\VCExpress\\9.0\\Setup\\VC\\ProductDir"},

    81     {NET2005, "MSVC.NET 2005 (8.0)", "Software\\Wow6432Node\\Microsoft\\VisualStudio\\8.0\\Setup\\VC\\ProductDir"},

    82     {NET2005, "MSVC.NET 2005 Express Edition (8.0)", "Software\\Wow6432Node\\Microsoft\\VCExpress\\8.0\\Setup\\VC\\ProductDir"},

    83     {NET2003, "MSVC.NET 2003 (7.1)", "Software\\Wow6432Node\\Microsoft\\VisualStudio\\7.1\\Setup\\VC\\ProductDir"},

    84     {NET2002, "MSVC.NET 2002 (7.0)", "Software\\Wow6432Node\\Microsoft\\VisualStudio\\7.0\\Setup\\VC\\ProductDir"},

    85 #else

    86     {NET2008, "MSVC.NET 2008 (9.0)", "Software\\Microsoft\\VisualStudio\\9.0\\Setup\\VC\\ProductDir"},

    87     {NET2008, "MSVC.NET 2008 Express Edition (9.0)", "Software\\Microsoft\\VCExpress\\9.0\\Setup\\VC\\ProductDir"},

    88     {NET2005, "MSVC.NET 2005 (8.0)", "Software\\Microsoft\\VisualStudio\\8.0\\Setup\\VC\\ProductDir"},

    89     {NET2005, "MSVC.NET 2005 Express Edition (8.0)", "Software\\Microsoft\\VCExpress\\8.0\\Setup\\VC\\ProductDir"},

    90     {NET2003, "MSVC.NET 2003 (7.1)", "Software\\Microsoft\\VisualStudio\\7.1\\Setup\\VC\\ProductDir"},

    91     {NET2002, "MSVC.NET 2002 (7.0)", "Software\\Microsoft\\VisualStudio\\7.0\\Setup\\VC\\ProductDir"},

    92 #endif

    93     {NETUnknown, "", ""},

    94 };

    95 

    96 static QString keyPath(const QString &rKey)

    97 {

    98     int idx = rKey.lastIndexOf(QLatin1Char('\\'));

    99     if (idx == -1)

   100         return QString();

   101     return rKey.left(idx + 1);

   102 }

   103 

   104 static QString keyName(const QString &rKey)

   105 {

   106     int idx = rKey.lastIndexOf(QLatin1Char('\\'));

   107     if (idx == -1)

   108         return rKey;

   109 

   110     QString res(rKey.mid(idx + 1));

   111     if (res == "Default" || res == ".")

   112         res = "";

   113     return res;

   114 }

   115 

   116 static QString readRegistryKey(HKEY parentHandle, const QString &rSubkey)

   117 {

   118 

   119     QString rSubkeyName = keyName(rSubkey);

   120     QString rSubkeyPath = keyPath(rSubkey);

   121 

   122     HKEY handle = 0;

   123     LONG res = RegOpenKeyEx(parentHandle, (wchar_t*)rSubkeyPath.utf16(), 0, KEY_READ, &handle);

   124 

   125     if (res != ERROR_SUCCESS)

   126         return QString();

   127 

   128     // get the size and type of the value

   129     DWORD dataType;

   130     DWORD dataSize;

   131     res = RegQueryValueEx(handle, (wchar_t*)rSubkeyName.utf16(), 0, &dataType, 0, &dataSize);

   132     if (res != ERROR_SUCCESS) {

   133         RegCloseKey(handle);

   134         return QString();

   135     }

   136 

   137     // get the value

   138     QByteArray data(dataSize, 0);

   139     res = RegQueryValueEx(handle, (wchar_t*)rSubkeyName.utf16(), 0, 0,

   140                           reinterpret_cast<unsigned char*>(data.data()), &dataSize);

   141     if (res != ERROR_SUCCESS) {

   142         RegCloseKey(handle);

   143         return QString();

   144     }

   145 

   146     QString result;

   147     switch (dataType) {

   148         case REG_EXPAND_SZ:

   149         case REG_SZ: {

   150             result = QString::fromWCharArray(((const wchar_t *)data.constData()));

   151             break;

   152         }

   153 

   154         case REG_MULTI_SZ: {

   155             QStringList l;

   156             int i = 0;

   157             for (;;) {

   158                 QString s = QString::fromWCharArray((const wchar_t *)data.constData() + i);

   159                 i += s.length() + 1;

   160 

   161                 if (s.isEmpty())

   162                     break;

   163                 l.append(s);

   164             }

   165             result = l.join(", ");

   166             break;

   167         }

   168 

   169         case REG_NONE:

   170         case REG_BINARY: {

   171             result = QString::fromWCharArray((const wchar_t *)data.constData(), data.size() / 2);

   172             break;

   173         }

   174 

   175         case REG_DWORD_BIG_ENDIAN:

   176         case REG_DWORD: {

   177             Q_ASSERT(data.size() == sizeof(int));

   178             int i;

   179             memcpy((char*)&i, data.constData(), sizeof(int));

   180             result = QString::number(i);

   181             break;

   182         }

   183 

   184         default:

   185             qWarning("QSettings: unknown data %d type in windows registry", dataType);

   186             break;

   187     }

   188 

   189     RegCloseKey(handle);

   190     return result;

   191 }

   192 QT_END_NAMESPACE

   193 #endif

   194 

   195 QT_BEGIN_NAMESPACE

   196 DotNET which_dotnet_version()

   197 {

   198 #ifndef Q_OS_WIN32

   199     return NET2002; // Always generate 7.0 versions on other platforms

   200 #else

   201     // Only search for the version once

   202     static DotNET current_version = NETUnknown;

   203     if(current_version != NETUnknown)

   204         return current_version;

   205 

   206     // Fallback to .NET 2002

   207     current_version = NET2002;

   208 

   209     QStringList warnPath;

   210     int installed = 0;

   211     int i = 0;

   212     for(; dotNetCombo[i].version; ++i) {

   213         QString path = readRegistryKey(HKEY_LOCAL_MACHINE, dotNetCombo[i].regKey);

   214         if(!path.isEmpty()) {

   215             ++installed;

   216             current_version = dotNetCombo[i].version;

   217                         warnPath += QString("%1").arg(dotNetCombo[i].versionStr);

   218         }

   219     }

   220 

   221     if (installed < 2)

   222         return current_version;

   223 

   224     // More than one version installed, search directory path

   225     QString paths = qgetenv("PATH");

   226     QStringList pathlist = paths.toLower().split(";");

   227 

   228     i = installed = 0;

   229     for(; dotNetCombo[i].version; ++i) {

   230         QString productPath = readRegistryKey(HKEY_LOCAL_MACHINE, dotNetCombo[i].regKey).toLower();

   231                 if (productPath.isEmpty())

   232                         continue;

   233         QStringList::iterator it;

   234         for(it = pathlist.begin(); it != pathlist.end(); ++it) {

   235             if((*it).contains(productPath)) {

   236                 ++installed;

   237                 current_version = dotNetCombo[i].version;

   238                 warnPath += QString("%1 in path").arg(dotNetCombo[i].versionStr);

   239                                 break;

   240             }

   241         }

   242     }

   243         switch(installed) {

   244         case 1:

   245                 break;

   246         case 0:

   247                 warn_msg(WarnLogic, "Generator: MSVC.NET: Found more than one version of Visual Studio, but"

   248                                  " none in your path! Fallback to lowest version (%s)", warnPath.join(", ").toLatin1().data());

   249                 break;

   250         default:

   251                 warn_msg(WarnLogic, "Generator: MSVC.NET: Found more than one version of Visual Studio in"

   252                                  " your path! Fallback to lowest version (%s)", warnPath.join(", ").toLatin1().data());

   253                 break;

   254         }

   255 

   256     return current_version;

   257 #endif

   258 };

   259 

   260 // Flatfile Tags ----------------------------------------------------

   261 const char _slnHeader70[]       = "Microsoft Visual Studio Solution File, Format Version 7.00";

   262 const char _slnHeader71[]       = "Microsoft Visual Studio Solution File, Format Version 8.00";

   263 const char _slnHeader80[]       = "Microsoft Visual Studio Solution File, Format Version 9.00";

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

   265                                   // The following UUID _may_ change for later servicepacks...

   266                                   // If so we need to search through the registry at

   267                                   // HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\7.0\Projects

   268                                   // to find the subkey that contains a "PossibleProjectExtension"

   269                                   // containing "vcproj"...

   270                                   // Use the hardcoded value for now so projects generated on other

   271                                   // platforms are actually usable.

   272 const char _slnMSVCvcprojGUID[] = "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}";

   273 const char _slnProjectBeg[]     = "\nProject(\"";

   274 const char _slnProjectMid[]     = "\") = ";

   275 const char _slnProjectEnd[]     = "\nEndProject";

   276 const char _slnGlobalBeg[]      = "\nGlobal";

   277 const char _slnGlobalEnd[]      = "\nEndGlobal";

   278 const char _slnSolutionConf[]   = "\n\tGlobalSection(SolutionConfiguration) = preSolution"

   279                                   "\n\t\tConfigName.0 = Debug|Win32"

   280                                   "\n\t\tConfigName.1 = Release|Win32"

   281                                   "\n\tEndGlobalSection";

   282 const char _slnProjDepBeg[]     = "\n\tGlobalSection(ProjectDependencies) = postSolution";

   283 const char _slnProjDepEnd[]     = "\n\tEndGlobalSection";

   284 const char _slnProjConfBeg[]    = "\n\tGlobalSection(ProjectConfiguration) = postSolution";

   285 const char _slnProjRelConfTag1[]= ".Release|%1.ActiveCfg = Release|";

   286 const char _slnProjRelConfTag2[]= ".Release|%1.Build.0 = Release|";

   287 const char _slnProjDbgConfTag1[]= ".Debug|%1.ActiveCfg = Debug|";

   288 const char _slnProjDbgConfTag2[]= ".Debug|%1.Build.0 = Debug|";

   289 const char _slnProjConfEnd[]    = "\n\tEndGlobalSection";

   290 const char _slnExtSections[]    = "\n\tGlobalSection(ExtensibilityGlobals) = postSolution"

   291                                   "\n\tEndGlobalSection"

   292                                   "\n\tGlobalSection(ExtensibilityAddIns) = postSolution"

   293                                   "\n\tEndGlobalSection";

   294 // ------------------------------------------------------------------

   295 

   296 VcprojGenerator::VcprojGenerator() : Win32MakefileGenerator(), init_flag(false)

   297 {

   298 }

   299 bool VcprojGenerator::writeMakefile(QTextStream &t)

   300 {

   301     initProject(); // Fills the whole project with proper data

   302 

   303     // Generate solution file

   304     if(project->first("TEMPLATE") == "vcsubdirs") {

   305         if (!project->isActiveConfig("build_pass")) {

   306             debug_msg(1, "Generator: MSVC.NET: Writing solution file");

   307             writeSubDirs(t);

   308         } else {

   309             debug_msg(1, "Generator: MSVC.NET: Not writing solution file for build_pass configs");

   310         }

   311         return true;

   312     } else

   313     // Generate single configuration project file

   314     if (project->first("TEMPLATE") == "vcapp" ||

   315         project->first("TEMPLATE") == "vclib") {

   316         if(!project->isActiveConfig("build_pass")) {

   317             debug_msg(1, "Generator: MSVC.NET: Writing single configuration project file");

   318             XmlOutput xmlOut(t);

   319             xmlOut << vcProject;

   320         }

   321         return true;

   322     }

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

   324 }

   325 

   326 bool VcprojGenerator::writeProjectMakefile()

   327 {

   328     usePlatformDir();

   329     QTextStream t(&Option::output);

   330 

   331     // Check if all requirements are fulfilled

   332     if(!project->values("QMAKE_FAILED_REQUIREMENTS").isEmpty()) {

   333         fprintf(stderr, "Project file not generated because all requirements not met:\n\t%s\n",

   334                 var("QMAKE_FAILED_REQUIREMENTS").toLatin1().constData());

   335         return true;

   336     }

   337 

   338     // Generate project file

   339     if(project->first("TEMPLATE") == "vcapp" ||

   340        project->first("TEMPLATE") == "vclib") {

   341         if (!mergedProjects.count()) {

   342             warn_msg(WarnLogic, "Generator: MSVC.NET: no single configuration created, cannot output project!");

   343             return false;

   344         }

   345 

   346         debug_msg(1, "Generator: MSVC.NET: Writing project file");

   347         VCProject mergedProject;

   348         for (int i = 0; i < mergedProjects.count(); ++i) {

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

   350             mergedProject.SingleProjects += *singleProject;

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

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

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

   354                     mergedProject.ExtraCompilers += compilerName;

   355             }

   356         }

   357 

   358         if(mergedProjects.count() > 1 &&

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

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

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

   362         mergedProject.Name = unescapeFilePath(project->first("QMAKE_ORIG_TARGET"));

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

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

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

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

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

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

   369 

   370         XmlOutput xmlOut(t);

   371         xmlOut << mergedProject;

   372         return true;

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

   374         return writeMakefile(t);

   375     }

   376     return false;

   377 }

   378 

   379 struct VcsolutionDepend {

   380     QString uuid;

   381     QString vcprojFile, orig_target, target;

   382     Target targetType;

   383     QStringList dependencies;

   384 };

   385 

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

   387 {

   388     bool validUUID = true;

   389 

   390     // Read GUID from variable-space

   391     QUuid uuid = project->first("GUID");

   392 

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

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

   395         QString abspath = Option::fixPathToLocalOS(filename.isEmpty()?project->first("QMAKE_MAKEFILE"):filename);

   396         QByteArray digest = QCryptographicHash::hash(abspath.toUtf8(), QCryptographicHash::Md5);

   397         memcpy((unsigned char*)(&uuid), digest.constData(), sizeof(QUuid));

   398         validUUID = !uuid.isNull();

   399         uuid.data4[0] = (uuid.data4[0] & 0x3F) | 0x80; // UV_DCE variant

   400         uuid.data3 = (uuid.data3 & 0x0FFF) | (QUuid::Name<<12);

   401     }

   402 

   403     // If still not valid, generate new one, and suggest adding to .pro

   404     if(uuid.isNull() || !validUUID) {

   405         uuid = QUuid::createUuid();

   406         fprintf(stderr,

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

   408                 uuid.toString().toUpper().toLatin1().constData());

   409     }

   410 

   411     // Store GUID in variable-space

   412     project->values("GUID") = QStringList(uuid.toString().toUpper());

   413     return uuid;

   414 }

   415 

   416 QUuid VcprojGenerator::increaseUUID(const QUuid &id)

   417 {

   418     QUuid result(id);

   419     qint64 dataFirst = (result.data4[0] << 24) +

   420                        (result.data4[1] << 16) +

   421                        (result.data4[2] << 8) +

   422                         result.data4[3];

   423     qint64 dataLast =  (result.data4[4] << 24) +

   424                        (result.data4[5] << 16) +

   425                        (result.data4[6] <<  8) +

   426                         result.data4[7];

   427 

   428     if(!(dataLast++))

   429         dataFirst++;

   430 

   431     result.data4[0] = uchar((dataFirst >> 24) & 0xff);

   432     result.data4[1] = uchar((dataFirst >> 16) & 0xff);

   433     result.data4[2] = uchar((dataFirst >>  8) & 0xff);

   434     result.data4[3] = uchar(dataFirst         & 0xff);

   435     result.data4[4] = uchar((dataLast  >> 24) & 0xff);

   436     result.data4[5] = uchar((dataLast  >> 16) & 0xff);

   437     result.data4[6] = uchar((dataLast  >>  8) & 0xff);

   438     result.data4[7] = uchar(dataLast          & 0xff);

   439     return result;

   440 }

   441 

   442 void VcprojGenerator::writeSubDirs(QTextStream &t)

   443 {

   444     // Check if all requirements are fulfilled

   445     if(!project->values("QMAKE_FAILED_REQUIREMENTS").isEmpty()) {

   446         fprintf(stderr, "Project file not generated because all requirements not met:\n\t%s\n",

   447                 var("QMAKE_FAILED_REQUIREMENTS").toLatin1().constData());

   448         return;

   449     }

   450 

   451     switch(which_dotnet_version()) {

   452     case NET2008:

   453         t << _slnHeader90;

   454         break;

   455     case NET2005:

   456         t << _slnHeader80;

   457         break;

   458     case NET2003:

   459         t << _slnHeader71;

   460         break;

   461     case NET2002:

   462         t << _slnHeader70;

   463         break;

   464     default:

   465         t << _slnHeader70;

   466         warn_msg(WarnLogic, "Generator: MSVC.NET: Unknown version (%d) of MSVC detected for .sln", which_dotnet_version());

   467         break;

   468     }

   469 

   470     QHash<QString, VcsolutionDepend*> solution_depends;

   471     QList<VcsolutionDepend*> solution_cleanup;

   472 

   473     QStringList subdirs = project->values("SUBDIRS");

   474     QString oldpwd = qmake_getpwd();

   475 

   476     // Make sure that all temp projects are configured

   477     // for release so that the depends are created

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

   479     QStringList old_after_vars = Option::after_user_vars;

   480     Option::after_user_vars.append("CONFIG+=release");

   481 

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

   483         QString tmp = subdirs.at(i);

   484         if(!project->isEmpty(tmp + ".file")) {

   485             if(!project->isEmpty(tmp + ".subdir"))

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

   487                          tmp.toLatin1().constData());

   488             tmp = project->first(tmp + ".file");

   489         } else if(!project->isEmpty(tmp + ".subdir")) {

   490             tmp = project->first(tmp + ".subdir");

   491         }

   492         QFileInfo fi(fileInfo(Option::fixPathToLocalOS(tmp, true)));

   493         if(fi.exists()) {

   494             if(fi.isDir()) {

   495                 QString profile = tmp;

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

   497                     profile += Option::dir_sep;

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

   499                 subdirs.append(profile);

   500             } else {

   501                 QMakeProject tmp_proj;

   502                 QString dir = fi.path(), fn = fi.fileName();

   503                 if(!dir.isEmpty()) {

   504                     if(!qmake_setpwd(dir))

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

   506                 }

   507                 if(tmp_proj.read(fn)) {

   508                     // Check if all requirements are fulfilled

   509                     if(!tmp_proj.variables()["QMAKE_FAILED_REQUIREMENTS"].isEmpty()) {

   510                         fprintf(stderr, "Project file(%s) not added to Solution because all requirements not met:\n\t%s\n",

   511                                 fn.toLatin1().constData(), tmp_proj.values("QMAKE_FAILED_REQUIREMENTS").join(" ").toLatin1().constData());

   512                         continue;

   513                     }

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

   515                         QStringList tmp_proj_subdirs = tmp_proj.variables()["SUBDIRS"];

   516                         for(int x = 0; x < tmp_proj_subdirs.size(); ++x) {

   517                             QString tmpdir = tmp_proj_subdirs.at(x);

   518                             if(!tmp_proj.isEmpty(tmpdir + ".file")) {

   519                                 if(!tmp_proj.isEmpty(tmpdir + ".subdir"))

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

   521                                             tmpdir.toLatin1().constData());

   522                                 tmpdir = tmp_proj.first(tmpdir + ".file");

   523                             } else if(!tmp_proj.isEmpty(tmpdir + ".subdir")) {

   524                                 tmpdir = tmp_proj.first(tmpdir + ".subdir");

   525                             }

   526                             subdirs += fileFixify(tmpdir);

   527                         }

   528                     } else if(tmp_proj.first("TEMPLATE") == "vcapp" || tmp_proj.first("TEMPLATE") == "vclib") {

   529                         // Initialize a 'fake' project to get the correct variables

   530                         // and to be able to extract all the dependencies

   531                         Option::QMAKE_MODE old_mode = Option::qmake_mode;

   532                         Option::qmake_mode = Option::QMAKE_GENERATE_NOTHING;

   533                         VcprojGenerator tmp_vcproj;

   534                         tmp_vcproj.setNoIO(true);

   535                         tmp_vcproj.setProjectFile(&tmp_proj);

   536                         Option::qmake_mode = old_mode;

   537                         if(Option::debug_level) {

   538                             QMap<QString, QStringList> &vars = tmp_proj.variables();

   539                             for(QMap<QString, QStringList>::Iterator it = vars.begin();

   540                                 it != vars.end(); ++it) {

   541                                 if(it.key().left(1) != "." && !it.value().isEmpty())

   542                                     debug_msg(1, "%s: %s === %s", fn.toLatin1().constData(), it.key().toLatin1().constData(),

   543                                                 it.value().join(" :: ").toLatin1().constData());

   544                             }

   545                         }

   546 

   547                         // We assume project filename is [QMAKE_ORIG_TARGET].vcproj

   548                         QString vcproj = unescapeFilePath(tmp_vcproj.project->first("QMAKE_ORIG_TARGET") + project->first("VCPROJ_EXTENSION"));

   549                         QString vcprojDir = qmake_getpwd();

   550 

   551                         // If file doesn't exsist, then maybe the users configuration

   552                         // doesn't allow it to be created. Skip to next...

   553                         if(!exists(vcprojDir + Option::dir_sep + vcproj)) {

   554 

   555                             // Try to find the directory which fits relative

   556                             // to the output path, which represents the shadow

   557                             // path in case we are shadow building

   558                             QStringList list = fi.path().split(QLatin1Char('/'));

   559                             QString tmpDir = QFileInfo(Option::output).path() + Option::dir_sep;

   560                             bool found = false;

   561                             for (int i = list.size() - 1; i >= 0; --i) {

   562                                 QString curr;

   563                                 for (int j = i; j < list.size(); ++j)

   564                                     curr += list.at(j) + Option::dir_sep;

   565                                 if (exists(tmpDir + curr + vcproj)) {

   566                                     vcprojDir = QDir::cleanPath(tmpDir + curr);

   567                                     found = true;

   568                                     break;

   569                                 }

   570                             }

   571                             if (!found) {

   572                                 warn_msg(WarnLogic, "Ignored (not found) '%s'", QString(vcprojDir + Option::dir_sep + vcproj).toLatin1().constData());

   573                                 goto nextfile; // # Dirty!

   574                             }

   575                         }

   576 

   577                         VcsolutionDepend *newDep = new VcsolutionDepend;

   578                         newDep->vcprojFile = vcprojDir + Option::dir_sep + vcproj;

   579                         newDep->orig_target = unescapeFilePath(tmp_proj.first("QMAKE_ORIG_TARGET"));

   580                         newDep->target = tmp_proj.first("MSVCPROJ_TARGET").section(Option::dir_sep, -1);

   581                         newDep->targetType = tmp_vcproj.projectTarget;

   582                         newDep->uuid = tmp_proj.isEmpty("QMAKE_UUID") ? getProjectUUID(Option::fixPathToLocalOS(vcprojDir + QDir::separator() + vcproj)).toString().toUpper(): tmp_proj.first("QMAKE_UUID");

   583 

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

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

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

   587 

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

   589                         if(tmp_proj.variables()["CONFIG"].contains("qaxserver"))

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

   591 

   592                         // All extra compilers which has valid input are considered dependencies

   593                         const QStringList &quc = tmp_proj.variables()["QMAKE_EXTRA_COMPILERS"];

   594                         for(QStringList::ConstIterator it = quc.constBegin(); it != quc.constEnd(); ++it) {

   595                             const QStringList &invar = tmp_proj.variables().value((*it) + ".input");

   596                             for(QStringList::ConstIterator iit = invar.constBegin(); iit != invar.constEnd(); ++iit) {

   597                                 const QStringList fileList = tmp_proj.variables().value(*iit);

   598                                 if (!fileList.isEmpty()) {

   599                                     const QStringList &cmdsParts = tmp_proj.variables().value((*it) + ".commands");

   600                                     bool startOfLine = true;

   601                                     foreach(QString cmd, cmdsParts) {

   602                                         if (!startOfLine) {

   603                                             if (cmd.contains("\r"))

   604                                                 startOfLine = true;

   605                                             continue;

   606                                         }

   607                                         if (cmd.isEmpty())

   608                                             continue;

   609 

   610                                         startOfLine = false;

   611                                         // Extra compiler commands might be defined in variables, so

   612                                         // expand them (don't care about the in/out files)

   613                                         cmd = tmp_vcproj.replaceExtraCompilerVariables(cmd, QStringList(), QStringList());

   614                                         // Pull out command based on spaces and quoting, if the

   615                                         // command starts with that

   616                                         cmd = cmd.left(cmd.indexOf(cmd.at(0) == '"' ? '"' : ' ', 1));

   617                                         QString dep = cmd.section('/', -1).section('\\', -1);

   618                                         if (!newDep->dependencies.contains(dep))

   619                                             newDep->dependencies << dep;

   620                                     }

   621                                 }

   622                             }

   623                         }

   624 

   625                         // Add all unknown libs to the deps

   626                         QStringList where = QStringList() << "QMAKE_LIBS" << "QMAKE_LIBS_PRIVATE";

   627                         if(!tmp_proj.isEmpty("QMAKE_INTERNAL_PRL_LIBS"))

   628                             where = tmp_proj.variables()["QMAKE_INTERNAL_PRL_LIBS"];

   629                         for(QStringList::iterator wit = where.begin();

   630                             wit != where.end(); ++wit) {

   631                             QStringList &l = tmp_proj.variables()[(*wit)];

   632                             for(QStringList::Iterator it = l.begin(); it != l.end(); ++it) {

   633                                 QString opt = (*it);

   634                                 if(!opt.startsWith("/") &&   // Not a switch

   635                                     opt != newDep->target && // Not self

   636                                     opt != "opengl32.lib" && // We don't care about these libs

   637                                     opt != "glu32.lib" &&    // to make depgen alittle faster

   638                                     opt != "kernel32.lib" &&

   639                                     opt != "user32.lib" &&

   640                                     opt != "gdi32.lib" &&

   641                                     opt != "comdlg32.lib" &&

   642                                     opt != "advapi32.lib" &&

   643                                     opt != "shell32.lib" &&

   644                                     opt != "ole32.lib" &&

   645                                     opt != "oleaut32.lib" &&

   646                                     opt != "uuid.lib" &&

   647                                     opt != "imm32.lib" &&

   648                                     opt != "winmm.lib" &&

   649                                     opt != "wsock32.lib" &&

   650                                     opt != "ws2_32.lib" &&

   651                                     opt != "winspool.lib" &&

   652                                     opt != "delayimp.lib")

   653                                 {

   654                                     newDep->dependencies << opt.section(Option::dir_sep, -1);

   655                                 }

   656                             }

   657                         }

   658 #ifdef DEBUG_SOLUTION_GEN

   659                         qDebug("Deps for %20s: [%s]", newDep->target.toLatin1().constData(), newDep->dependencies.join(" :: ").toLatin1().constData());

   660 #endif

   661                         solution_cleanup.append(newDep);

   662                         solution_depends.insert(newDep->target, newDep);

   663                         t << _slnProjectBeg << _slnMSVCvcprojGUID << _slnProjectMid

   664                             << "\"" << newDep->orig_target << "\", \"" << newDep->vcprojFile

   665                             << "\", \"" << newDep->uuid << "\"";

   666                         t << _slnProjectEnd;

   667                     }

   668                 }

   669 nextfile:

   670                 qmake_setpwd(oldpwd);

   671             }

   672         }

   673     }

   674     t << _slnGlobalBeg;

   675     if (!project->isEmpty("CE_SDK") && !project->isEmpty("CE_ARCH")) {

   676         QString slnConfCE = _slnSolutionConf;

   677         QString platform = QString("|") + project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")";

   678         slnConfCE.replace(QString("|Win32"), platform);

   679         t << slnConfCE;

   680     } else {

   681         t << _slnSolutionConf;

   682     }

   683     t << _slnProjDepBeg;

   684 

   685     // Restore previous after_user_var options

   686     Option::after_user_vars = old_after_vars;

   687 

   688     // Figure out dependencies

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

   690         int cnt = 0;

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

   692             if(VcsolutionDepend *vc = solution_depends[*dit])

   693                 t << "\n\t\t" << (*it)->uuid << "." << cnt++ << " = " << vc->uuid;

   694         }

   695     }

   696     t << _slnProjDepEnd;

   697     t << _slnProjConfBeg;

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

   699         QString platform = "Win32";

   700         if (!project->isEmpty("CE_SDK") && !project->isEmpty("CE_ARCH"))

   701             platform = project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")";

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

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

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

   705         t << "\n\t\t" << (*it)->uuid << QString(_slnProjRelConfTag2).arg(platform) << platform;

   706     }

   707     t << _slnProjConfEnd;

   708     t << _slnExtSections;

   709     t << _slnGlobalEnd;

   710 

   711 

   712     while (!solution_cleanup.isEmpty())

   713         delete solution_cleanup.takeFirst();

   714 }

   715 

   716 // ------------------------------------------------------------------------------------------------

   717 // ------------------------------------------------------------------------------------------------

   718 

   719 bool VcprojGenerator::hasBuiltinCompiler(const QString &file)

   720 {

   721     // Source files

   722     for (int i = 0; i < Option::cpp_ext.count(); ++i)

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

   724             return true;

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

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

   727             return true;

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

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

   730         return true;

   731     return false;

   732 }

   733 

   734 void VcprojGenerator::init()

   735 {

   736     if(init_flag)

   737         return;

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

   739         init_flag = true;

   740         return;

   741     }

   742 

   743     debug_msg(1, "Generator: MSVC.NET: Initializing variables");

   744 

   745     // this should probably not be here, but I'm using it to wrap the .t files

   746     if (project->first("TEMPLATE") == "vcapp")

   747         project->values("QMAKE_APP_FLAG").append("1");

   748     else if (project->first("TEMPLATE") == "vclib")

   749         project->values("QMAKE_LIB_FLAG").append("1");

   750     if (project->values("QMAKESPEC").isEmpty())

   751         project->values("QMAKESPEC").append(qgetenv("QMAKESPEC"));

   752 

   753     processVars();

   754     initOld();           // Currently calling old DSP code to set variables. CLEAN UP!

   755 

   756     // Figure out what we're trying to build

   757     if(project->first("TEMPLATE") == "vcapp") {

   758         projectTarget = Application;

   759     } else if(project->first("TEMPLATE") == "vclib") {

   760         if(project->isActiveConfig("staticlib")) {

   761             if (!project->values("RES_FILE").isEmpty())

   762                 project->values("MSVCPROJ_LIBS") += escapeFilePaths(project->values("RES_FILE"));

   763             projectTarget = StaticLib;

   764         } else

   765             projectTarget = SharedLib;

   766     }

   767 

   768     // Setup PCH variables

   769     precompH = project->first("PRECOMPILED_HEADER");

   770     precompCPP = project->first("PRECOMPILED_SOURCE");

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

   772     if (usePCH) {

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

   774         // Created files

   775         QString origTarget = unescapeFilePath(project->first("QMAKE_ORIG_TARGET"));

   776         precompObj = origTarget + Option::obj_ext;

   777         precompPch = origTarget + ".pch";

   778         // Add PRECOMPILED_HEADER to HEADERS

   779         if (!project->values("HEADERS").contains(precompH))

   780             project->values("HEADERS") += precompH;

   781         // Return to variable pool

   782         project->values("PRECOMPILED_OBJECT") = QStringList(precompObj);

   783         project->values("PRECOMPILED_PCH")    = QStringList(precompPch);

   784 

   785         autogenPrecompCPP = precompCPP.isEmpty() && project->isActiveConfig("autogen_precompile_source");

   786         if (autogenPrecompCPP) {

   787             precompCPP = precompH

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

   789             project->values("GENERATED_SOURCES") += precompCPP;

   790         } else if (!precompCPP.isEmpty()) {

   791             project->values("SOURCES") += precompCPP;

   792         }

   793     }

   794 

   795     // Add all input files for a custom compiler into a map for uniqueness,

   796     // unless the compiler is configure as a combined stage, then use the first one

   797     const QStringList &quc = project->values("QMAKE_EXTRA_COMPILERS");

   798     for(QStringList::ConstIterator it = quc.constBegin(); it != quc.constEnd(); ++it) {

   799         const QStringList &invar = project->variables().value((*it) + ".input");

   800         const QString compiler_out = project->first((*it) + ".output");

   801         for(QStringList::ConstIterator iit = invar.constBegin(); iit != invar.constEnd(); ++iit) {

   802             QStringList fileList = project->variables().value(*iit);

   803             if (!fileList.isEmpty()) {

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

   805                     fileList = QStringList(fileList.first());

   806                 for(QStringList::ConstIterator fit = fileList.constBegin(); fit != fileList.constEnd(); ++fit) {

   807                     QString file = (*fit);

   808                     if (verifyExtraCompiler((*it), file)) {

   809                         if (!hasBuiltinCompiler(file)) {

   810                             extraCompilerSources[file] += *it;

   811                         } else {

   812                             QString out = Option::fixPathToTargetOS(replaceExtraCompilerVariables(

   813                                             compiler_out, file, QString()), false);

   814                             extraCompilerSources[out] += *it;

   815                             extraCompilerOutputs[out] = QStringList(file); // Can only have one

   816                         }

   817                     }

   818                 }

   819             }

   820         }

   821     }

   822 

   823 #if 0 // Debugging

   824     Q_FOREACH(QString aKey, extraCompilerSources.keys()) {

   825         qDebug("Extracompilers for %s are (%s)", aKey.toLatin1().constData(), extraCompilerSources.value(aKey).join(", ").toLatin1().constData());

   826     }

   827     Q_FOREACH(QString aKey, extraCompilerOutputs.keys()) {

   828         qDebug("Object mapping for %s is (%s)", aKey.toLatin1().constData(), extraCompilerOutputs.value(aKey).join(", ").toLatin1().constData());

   829     }

   830     qDebug("");

   831 #endif

   832 }

   833 

   834 bool VcprojGenerator::mergeBuildProject(MakefileGenerator *other)

   835 {

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

   837     if (!otherVC) {

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

   839         return false;

   840     }

   841     mergedProjects += otherVC;

   842     return true;

   843 }

   844 

   845 void VcprojGenerator::initProject()

   846 {

   847     // Initialize XML sub elements

   848     // - Do this first since project elements may need

   849     // - to know of certain configuration options

   850     initConfiguration();

   851     initRootFiles();

   852     initSourceFiles();

   853     initHeaderFiles();

   854     initGeneratedFiles();

   855     initLexYaccFiles();

   856     initTranslationFiles();

   857     initFormFiles();

   858     initResourceFiles();

   859     initExtraCompilerOutputs();

   860 

   861     // Own elements -----------------------------

   862     vcProject.Name = unescapeFilePath(project->first("QMAKE_ORIG_TARGET"));

   863     switch(which_dotnet_version()) {

   864     case NET2008:

   865         vcProject.Version = "9,00";

   866         break;

   867     case NET2005:

   868                 //### using ',' because of a bug in 2005 B2

   869                 //### VS uses '.' or ',' depending on the regional settings! Using ',' always works.

   870         vcProject.Version = "8,00";

   871         break;

   872     case NET2003:

   873         vcProject.Version = "7.10";

   874         break;

   875     case NET2002:

   876         vcProject.Version = "7.00";

   877         break;

   878     default:

   879         vcProject.Version = "7.00";

   880         warn_msg(WarnLogic, "Generator: MSVC.NET: Unknown version (%d) of MSVC detected for .vcproj", which_dotnet_version());

   881         break;

   882     }

   883 

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

   885     if (project->isEmpty("CE_SDK") || project->isEmpty("CE_ARCH")) {

   886         vcProject.PlatformName = (vcProject.Configuration.idl.TargetEnvironment == midlTargetWin64 ? "Win64" : "Win32");

   887     } else {

   888         vcProject.PlatformName = project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")";

   889     }

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

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

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

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

   894 }

   895 

   896 void VcprojGenerator::initConfiguration()

   897 {

   898     // Initialize XML sub elements

   899     // - Do this first since main configuration elements may need

   900     // - to know of certain compiler/linker options

   901     VCConfiguration &conf = vcProject.Configuration;

   902     conf.CompilerVersion = which_dotnet_version();

   903 

   904     initCompilerTool();

   905 

   906     // Only on configuration per build

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

   908 

   909     if(projectTarget == StaticLib)

   910         initLibrarianTool();

   911     else {

   912         conf.linker.GenerateDebugInformation = isDebug ? _True : _False;

   913         initLinkerTool();

   914     }

   915     initResourceTool();

   916     initIDLTool();

   917 

   918     // Own elements -----------------------------

   919     QString temp = project->first("BuildBrowserInformation");

   920     switch (projectTarget) {

   921     case SharedLib:

   922         conf.ConfigurationType = typeDynamicLibrary;

   923         break;

   924     case StaticLib:

   925         conf.ConfigurationType = typeStaticLibrary;

   926         break;

   927     case Application:

   928     default:

   929         conf.ConfigurationType = typeApplication;

   930         break;

   931     }

   932 

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

   934     if (conf.Name.isEmpty())

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

   936     if (project->isEmpty("CE_SDK") || project->isEmpty("CE_ARCH")) {

   937         conf.Name += (conf.idl.TargetEnvironment == midlTargetWin64 ? "|Win64" : "|Win32");

   938     } else {

   939         conf.Name += "|" + project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")";

   940     }

   941     conf.ATLMinimizesCRunTimeLibraryUsage = (project->first("ATLMinimizesCRunTimeLibraryUsage").isEmpty() ? _False : _True);

   942     conf.BuildBrowserInformation = triState(temp.isEmpty() ? (short)unset : temp.toShort());

   943     temp = project->first("CharacterSet");

   944     conf.CharacterSet = charSet(temp.isEmpty() ? (short)charSetNotSet : temp.toShort());

   945     conf.DeleteExtensionsOnClean = project->first("DeleteExtensionsOnClean");

   946     conf.ImportLibrary = conf.linker.ImportLibrary;

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

   948     conf.OutputDirectory = ".";

   949     conf.PrimaryOutput = project->first("PrimaryOutput");

   950     conf.WholeProgramOptimization = conf.compiler.WholeProgramOptimization;

   951     temp = project->first("UseOfATL");

   952     if(!temp.isEmpty())

   953         conf.UseOfATL = useOfATL(temp.toShort());

   954     temp = project->first("UseOfMfc");

   955     if(!temp.isEmpty())

   956         conf.UseOfMfc = useOfMfc(temp.toShort());

   957 

   958     // Configuration does not need parameters from

   959     // these sub XML items;

   960     initCustomBuildTool();

   961     initPreBuildEventTools();

   962     initPostBuildEventTools();

   963     // Only deploy for CE projects

   964     if (!project->isEmpty("CE_SDK") && !project->isEmpty("CE_ARCH"))

   965         initDeploymentTool();

   966     initPreLinkEventTools();

   967 

   968     // Set definite values in both configurations

   969     if (isDebug) {

   970         conf.compiler.PreprocessorDefinitions.removeAll("NDEBUG");

   971     } else {

   972         conf.compiler.PreprocessorDefinitions += "NDEBUG";

   973     }

   974 

   975 }

   976 

   977 void VcprojGenerator::initCompilerTool()

   978 {

   979     QString placement = project->first("OBJECTS_DIR");

   980     if(placement.isEmpty())

   981         placement = ".\\";

   982 

   983     VCConfiguration &conf = vcProject.Configuration;

   984     conf.compiler.AssemblerListingLocation = placement ;

   985     conf.compiler.ProgramDataBaseFileName = ".\\" ;

   986     conf.compiler.ObjectFile = placement ;

   987     // PCH

   988     if (usePCH) {

   989         conf.compiler.UsePrecompiledHeader     = pchUseUsingSpecific;

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

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

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

   993         // Minimal build option triggers an Internal Compiler Error

   994         // when used in conjunction with /FI and /Yu, so remove it

   995         project->values("QMAKE_CFLAGS_DEBUG").removeAll("-Gm");

   996         project->values("QMAKE_CFLAGS_DEBUG").removeAll("/Gm");

   997         project->values("QMAKE_CXXFLAGS_DEBUG").removeAll("-Gm");

   998         project->values("QMAKE_CXXFLAGS_DEBUG").removeAll("/Gm");

   999     }

  1000 

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

  1002     if(project->isActiveConfig("debug")){

  1003         // Debug version

  1004         conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_DEBUG"));

  1005         if((projectTarget == Application) || (projectTarget == StaticLib))

  1006             conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_MT_DBG"));

  1007         else

  1008             conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_MT_DLLDBG"));

  1009     } else {

  1010         // Release version

  1011         conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_RELEASE"));

  1012         conf.compiler.PreprocessorDefinitions += "QT_NO_DEBUG";

  1013         conf.compiler.PreprocessorDefinitions += "NDEBUG";

  1014         if((projectTarget == Application) || (projectTarget == StaticLib))

  1015             conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_MT"));

  1016         else

  1017             conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_MT_DLL"));

  1018     }

  1019 

  1020     // Common for both release and debug

  1021     if(project->isActiveConfig("warn_off"))

  1022         conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_WARN_OFF"));

  1023     else if(project->isActiveConfig("warn_on"))

  1024         conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_WARN_ON"));

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

  1026         conf.compiler.PreprocessorDefinitions += project->values("MSVCPROJ_WINCONDEF");

  1027 

  1028     // Can this be set for ALL configs?

  1029     // If so, use qmake.conf!

  1030     if(projectTarget == SharedLib)

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

  1032 

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

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

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

  1036 }

  1037 

  1038 void VcprojGenerator::initLibrarianTool()

  1039 {

  1040     VCConfiguration &conf = vcProject.Configuration;

  1041     conf.librarian.OutputFile = project->first("DESTDIR");

  1042     if(conf.librarian.OutputFile.isEmpty())

  1043         conf.librarian.OutputFile = ".\\";

  1044 

  1045     if(!conf.librarian.OutputFile.endsWith("\\"))

  1046         conf.librarian.OutputFile += '\\';

  1047 

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

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

  1050 }

  1051 

  1052 void VcprojGenerator::initLinkerTool()

  1053 {

  1054     findLibraries(); // Need to add the highest version of the libs

  1055     VCConfiguration &conf = vcProject.Configuration;

  1056     conf.linker.parseOptions(project->values("MSVCPROJ_LFLAGS"));

  1057 

  1058     foreach(QString libs, project->values("MSVCPROJ_LIBS")) {

  1059         if (libs.left(9).toUpper() == "/LIBPATH:") {

  1060             QStringList l = QStringList(libs);

  1061             conf.linker.parseOptions(l);

  1062         } else {

  1063             conf.linker.AdditionalDependencies += libs;

  1064         }

  1065     }

  1066 

  1067     switch (projectTarget) {

  1068     case Application:

  1069         conf.linker.OutputFile = project->first("DESTDIR");

  1070         break;

  1071     case SharedLib:

  1072         conf.linker.parseOptions(project->values("MSVCPROJ_LIBOPTIONS"));

  1073         conf.linker.OutputFile = project->first("DESTDIR");

  1074         break;

  1075     case StaticLib: //unhandled - added to remove warnings..

  1076         break;

  1077     }

  1078 

  1079     if(conf.linker.OutputFile.isEmpty())

  1080         conf.linker.OutputFile = ".\\";

  1081 

  1082     if(!conf.linker.OutputFile.endsWith("\\"))

  1083         conf.linker.OutputFile += '\\';

  1084 

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

  1086 

  1087     if(project->isActiveConfig("debug")){

  1088         conf.linker.parseOptions(project->values("QMAKE_LFLAGS_DEBUG"));

  1089     } else {

  1090         conf.linker.parseOptions(project->values("QMAKE_LFLAGS_RELEASE"));

  1091     }

  1092 

  1093     if(project->isActiveConfig("dll")){

  1094         conf.linker.parseOptions(project->values("QMAKE_LFLAGS_QT_DLL"));

  1095     }

  1096 

  1097     if(project->isActiveConfig("console")){

  1098         conf.linker.parseOptions(project->values("QMAKE_LFLAGS_CONSOLE"));

  1099     } else {

  1100         conf.linker.parseOptions(project->values("QMAKE_LFLAGS_WINDOWS"));

  1101     }

  1102 

  1103 }

  1104 

  1105 void VcprojGenerator::initResourceTool()

  1106 {

  1107     VCConfiguration &conf = vcProject.Configuration;

  1108     conf.resource.PreprocessorDefinitions = conf.compiler.PreprocessorDefinitions;

  1109 

  1110     // We need to add _DEBUG for the debug version of the project, since the normal compiler defines

  1111     // do not contain it. (The compiler defines this symbol automatically, which is wy we don't need

  1112     // to add it for the compiler) However, the resource tool does not do this.

  1113     if(project->isActiveConfig("debug"))

  1114         conf.resource.PreprocessorDefinitions += "_DEBUG";

  1115     if(project->isActiveConfig("staticlib"))

  1116         conf.resource.ResourceOutputFileName = project->first("DESTDIR") + "/$(InputName).res";

  1117 }

  1118 

  1119 

  1120 void VcprojGenerator::initIDLTool()

  1121 {

  1122 }

  1123 

  1124 void VcprojGenerator::initCustomBuildTool()

  1125 {

  1126 }

  1127 

  1128 void VcprojGenerator::initPreBuildEventTools()

  1129 {

  1130 }

  1131 

  1132 QString VcprojGenerator::fixCommandLine(DotNET version, const QString &input) const

  1133 {

  1134     QString result = input;