/**************************************************************************** | |
** | |
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). | |
** All rights reserved. | |
** Contact: Nokia Corporation (qt-info@nokia.com) | |
** | |
** This file is part of the qmake application of the Qt Toolkit. | |
** | |
** $QT_BEGIN_LICENSE:LGPL$ | |
** GNU Lesser General Public License Usage | |
** This file may be used under the terms of the GNU Lesser General Public | |
** License version 2.1 as published by the Free Software Foundation and | |
** appearing in the file LICENSE.LGPL included in the packaging of this | |
** file. Please review the following information to ensure the GNU Lesser | |
** General Public License version 2.1 requirements will be met: | |
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. | |
** | |
** In addition, as a special exception, Nokia gives you certain additional | |
** rights. These rights are described in the Nokia Qt LGPL Exception | |
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. | |
** | |
** GNU General Public License Usage | |
** Alternatively, this file may be used under the terms of the GNU General | |
** Public License version 3.0 as published by the Free Software Foundation | |
** and appearing in the file LICENSE.GPL included in the packaging of this | |
** file. Please review the following information to ensure the GNU General | |
** Public License version 3.0 requirements will be met: | |
** http://www.gnu.org/copyleft/gpl.html. | |
** | |
** Other Usage | |
** Alternatively, this file may be used in accordance with the terms and | |
** conditions contained in a signed written agreement between you and Nokia. | |
** | |
** | |
** | |
** | |
** | |
** $QT_END_LICENSE$ | |
** | |
****************************************************************************/ | |
#include "msvc_vcxproj.h" | |
#include "msbuild_objectmodel.h" | |
#include <qdir.h> | |
#include <qdiriterator.h> | |
#include <quuid.h> | |
QT_BEGIN_NAMESPACE | |
// Filter GUIDs (Do NOT change these!) ------------------------------ | |
const char _GUIDSourceFiles[] = "{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"; | |
const char _GUIDHeaderFiles[] = "{93995380-89BD-4b04-88EB-625FBE52EBFB}"; | |
const char _GUIDGeneratedFiles[] = "{71ED8ED8-ACB9-4CE9-BBE1-E00B30144E11}"; | |
const char _GUIDResourceFiles[] = "{D9D6E242-F8AF-46E4-B9FD-80ECBC20BA3E}"; | |
const char _GUIDLexYaccFiles[] = "{E12AE0D2-192F-4d59-BD23-7D3FA58D3183}"; | |
const char _GUIDTranslationFiles[] = "{639EADAA-A684-42e4-A9AD-28FC9BCB8F7C}"; | |
const char _GUIDFormFiles[] = "{99349809-55BA-4b9d-BF79-8FDBB0286EB3}"; | |
const char _GUIDExtraCompilerFiles[] = "{E0D8C965-CC5F-43d7-AD63-FAEF0BBC0F85}"; | |
QT_END_NAMESPACE | |
QT_BEGIN_NAMESPACE | |
VcxprojGenerator::VcxprojGenerator() : VcprojGenerator() | |
{ | |
} | |
bool VcxprojGenerator::writeMakefile(QTextStream &t) | |
{ | |
initProject(); // Fills the whole project with proper data | |
// Generate solution file | |
if(project->first("TEMPLATE") == "vcsubdirs") { | |
if (!project->isActiveConfig("build_pass")) { | |
debug_msg(1, "Generator: MSVC.NET: Writing solution file"); | |
writeSubDirs(t); | |
} else { | |
debug_msg(1, "Generator: MSVC.NET: Not writing solution file for build_pass configs"); | |
} | |
return true; | |
} else | |
// Generate single configuration project file | |
if (project->first("TEMPLATE") == "vcapp" || | |
project->first("TEMPLATE") == "vclib") { | |
if(!project->isActiveConfig("build_pass")) { | |
debug_msg(1, "Generator: MSVC.NET: Writing single configuration project file"); | |
XmlOutput xmlOut(t); | |
xmlOut << vcxProject; | |
} | |
return true; | |
} | |
return project->isActiveConfig("build_pass"); | |
} | |
void VcxprojGenerator::initProject() | |
{ | |
// Initialize XML sub elements | |
// - Do this first since project elements may need | |
// - to know of certain configuration options | |
initConfiguration(); | |
initRootFiles(); | |
initSourceFiles(); | |
initHeaderFiles(); | |
initGeneratedFiles(); | |
initLexYaccFiles(); | |
initTranslationFiles(); | |
initFormFiles(); | |
initResourceFiles(); | |
initExtraCompilerOutputs(); | |
// Own elements ----------------------------- | |
vcxProject.Name = unescapeFilePath(project->first("QMAKE_ORIG_TARGET")); | |
vcxProject.Keyword = project->first("VCPROJ_KEYWORD"); | |
if (project->isEmpty("CE_SDK") || project->isEmpty("CE_ARCH")) { | |
vcxProject.PlatformName = vcxProject.Configuration.idl.TargetEnvironment; | |
if ( vcxProject.Configuration.idl.TargetEnvironment.isEmpty() ) | |
vcxProject.PlatformName = "Win32"; | |
} else { | |
vcxProject.PlatformName = project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")"; | |
} | |
// These are not used by Qt, but may be used by customers | |
vcxProject.SccProjectName = project->first("SCCPROJECTNAME"); | |
vcxProject.SccLocalPath = project->first("SCCLOCALPATH"); | |
vcxProject.flat_files = project->isActiveConfig("flat"); | |
} | |
void VcxprojGenerator::initConfiguration() | |
{ | |
// Initialize XML sub elements | |
// - Do this first since main configuration elements may need | |
// - to know of certain compiler/linker options | |
VCXConfiguration &conf = vcxProject.Configuration; | |
initCompilerTool(); | |
// Only on configuration per build | |
bool isDebug = project->isActiveConfig("debug"); | |
if(projectTarget == StaticLib) | |
initLibrarianTool(); | |
else { | |
conf.linker.GenerateDebugInformation = isDebug ? _True : _False; | |
initLinkerTool(); | |
} | |
initResourceTool(); | |
initIDLTool(); | |
// Own elements ----------------------------- | |
QString temp = project->first("BuildBrowserInformation"); | |
switch (projectTarget) { | |
case SharedLib: | |
conf.ConfigurationType = "DynamicLibrary"; | |
break; | |
case StaticLib: | |
conf.ConfigurationType = "StaticLibrary"; | |
break; | |
case Application: | |
default: | |
conf.ConfigurationType = "Application"; | |
break; | |
} | |
conf.OutputDirectory = project->first("DESTDIR"); | |
if(conf.OutputDirectory.isEmpty()) | |
conf.OutputDirectory = ".\\"; | |
if(!conf.OutputDirectory.endsWith("\\")) | |
conf.OutputDirectory += '\\'; | |
// The target name could have been changed. | |
conf.TargetName = project->first("TARGET"); | |
if ( !conf.TargetName.isEmpty() && !project->first("TARGET_VERSION_EXT").isEmpty() && project->isActiveConfig("shared")) | |
conf.TargetName.append(project->first("TARGET_VERSION_EXT")); | |
conf.Name = project->values("BUILD_NAME").join(" "); | |
if (conf.Name.isEmpty()) | |
conf.Name = isDebug ? "Debug" : "Release"; | |
conf.ConfigurationName = conf.Name; | |
if (project->isEmpty("CE_SDK") || project->isEmpty("CE_ARCH")) { | |
conf.Name += (conf.idl.TargetEnvironment == "Win64" ? "|Win64" : "|Win32"); | |
} else { | |
conf.Name += "|" + project->values("CE_SDK").join(" ") + " (" + project->first("CE_ARCH") + ")"; | |
} | |
conf.ATLMinimizesCRunTimeLibraryUsage = (project->first("ATLMinimizesCRunTimeLibraryUsage").isEmpty() ? _False : _True); | |
conf.BuildBrowserInformation = triState(temp.isEmpty() ? (short)unset : temp.toShort()); | |
temp = project->first("CharacterSet"); | |
if (!temp.isEmpty()) | |
{ | |
switch (charSet(temp.toShort())) { | |
case charSetMBCS: | |
conf.CharacterSet = "MultiByte"; | |
break; | |
case charSetUnicode: | |
conf.CharacterSet = "Unicode"; | |
break; | |
case charSetNotSet: | |
default: | |
conf.CharacterSet = "NotSet"; | |
break; | |
} | |
} | |
conf.DeleteExtensionsOnClean = project->first("DeleteExtensionsOnClean"); | |
conf.ImportLibrary = conf.linker.ImportLibrary; | |
conf.IntermediateDirectory = project->first("OBJECTS_DIR"); | |
//conf.OutputDirectory = "."; | |
conf.PrimaryOutput = project->first("PrimaryOutput"); | |
conf.WholeProgramOptimization = conf.compiler.WholeProgramOptimization; | |
temp = project->first("UseOfATL"); | |
if(!temp.isEmpty()) | |
{ | |
switch (useOfATL(temp.toShort())) { | |
case useATLStatic: | |
conf.UseOfATL = "Static"; | |
break; | |
case useATLDynamic: | |
conf.UseOfATL = "Dynamic"; | |
break; | |
case useATLNotSet: | |
default: | |
conf.UseOfATL = "false"; | |
break; | |
} | |
} | |
temp = project->first("UseOfMfc"); | |
if(!temp.isEmpty()) | |
{ | |
switch (useOfMfc(temp.toShort())) { | |
case useMfcStatic: | |
conf.UseOfMfc = "Static"; | |
break; | |
case useMfcDynamic: | |
conf.UseOfMfc = "Dynamic"; | |
break; | |
case useMfcStdWin: | |
default: | |
conf.UseOfMfc = "false"; | |
break; | |
} | |
} | |
// Configuration does not need parameters from | |
// these sub XML items; | |
initCustomBuildTool(); | |
initPreBuildEventTools(); | |
initPostBuildEventTools(); | |
// Only deploy for CE projects | |
if (!project->isEmpty("CE_SDK") && !project->isEmpty("CE_ARCH")) | |
initDeploymentTool(); | |
initPreLinkEventTools(); | |
// Set definite values in both configurations | |
if (isDebug) { | |
conf.compiler.PreprocessorDefinitions.removeAll("NDEBUG"); | |
} else { | |
conf.compiler.PreprocessorDefinitions += "NDEBUG"; | |
} | |
} | |
void VcxprojGenerator::initCompilerTool() | |
{ | |
QString placement = project->first("OBJECTS_DIR"); | |
if(placement.isEmpty()) | |
placement = ".\\"; | |
VCXConfiguration &conf = vcxProject.Configuration; | |
conf.compiler.AssemblerListingLocation = placement ; | |
conf.compiler.ProgramDataBaseFileName = ".\\" ; | |
conf.compiler.ObjectFileName = placement ; | |
conf.compiler.ExceptionHandling = "false"; | |
// PCH | |
if (usePCH) { | |
conf.compiler.PrecompiledHeader = "Use"; | |
conf.compiler.PrecompiledHeaderOutputFile = "$(IntDir)\\" + precompPch; | |
conf.compiler.PrecompiledHeaderFile = project->first("PRECOMPILED_HEADER"); | |
conf.compiler.ForcedIncludeFiles = project->values("PRECOMPILED_HEADER"); | |
conf.compiler.PreprocessToFile = _False; | |
conf.compiler.PreprocessSuppressLineNumbers = _False; | |
// Minimal build option triggers an Internal Compiler Error | |
// when used in conjunction with /FI and /Yu, so remove it | |
project->values("QMAKE_CFLAGS_DEBUG").removeAll("-Gm"); | |
project->values("QMAKE_CFLAGS_DEBUG").removeAll("/Gm"); | |
project->values("QMAKE_CXXFLAGS_DEBUG").removeAll("-Gm"); | |
project->values("QMAKE_CXXFLAGS_DEBUG").removeAll("/Gm"); | |
} | |
conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS")); | |
if(project->isActiveConfig("debug")){ | |
// Debug version | |
if((projectTarget == Application) || (projectTarget == StaticLib)) | |
conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_MT_DBG")); | |
else | |
conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_MT_DLLDBG")); | |
} else { | |
// Release version | |
conf.compiler.PreprocessorDefinitions += "QT_NO_DEBUG"; | |
conf.compiler.PreprocessorDefinitions += "NDEBUG"; | |
if((projectTarget == Application) || (projectTarget == StaticLib)) | |
conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_MT")); | |
else | |
conf.compiler.parseOptions(project->values("QMAKE_CXXFLAGS_MT_DLL")); | |
} | |
// Common for both release and debug | |
if(project->isActiveConfig("windows")) | |
conf.compiler.PreprocessorDefinitions += project->values("MSVCPROJ_WINCONDEF"); | |
// Can this be set for ALL configs? | |
// If so, use qmake.conf! | |
if(projectTarget == SharedLib) | |
conf.compiler.PreprocessorDefinitions += "_WINDOWS"; | |
conf.compiler.PreprocessorDefinitions += project->values("DEFINES"); | |
conf.compiler.PreprocessorDefinitions += project->values("PRL_EXPORT_DEFINES"); | |
conf.compiler.parseOptions(project->values("MSVCPROJ_INCPATH")); | |
} | |
void VcxprojGenerator::initLinkerTool() | |
{ | |
findLibraries(); // Need to add the highest version of the libs | |
VCXConfiguration &conf = vcxProject.Configuration; | |
conf.linker.parseOptions(project->values("MSVCPROJ_LFLAGS")); | |
foreach(QString libs, project->values("MSVCPROJ_LIBS")) { | |
if (libs.left(9).toUpper() == "/LIBPATH:") { | |
QStringList l = QStringList(libs); | |
conf.linker.parseOptions(l); | |
} else { | |
conf.linker.AdditionalDependencies += libs; | |
} | |
} | |
switch (projectTarget) { | |
case Application: | |
conf.linker.OutputFile = project->first("DESTDIR"); | |
break; | |
case SharedLib: | |
conf.linker.parseOptions(project->values("MSVCPROJ_LIBOPTIONS")); | |
conf.linker.OutputFile = project->first("DESTDIR"); | |
break; | |
case StaticLib: //unhandled - added to remove warnings.. | |
break; | |
} | |
if(conf.linker.OutputFile.isEmpty()) | |
conf.linker.OutputFile = ".\\"; | |
if(!conf.linker.OutputFile.endsWith("\\")) | |
conf.linker.OutputFile += '\\'; | |
conf.linker.OutputFile += project->first("MSVCPROJ_TARGET"); | |
if(project->isActiveConfig("dll")){ | |
conf.linker.parseOptions(project->values("QMAKE_LFLAGS_QT_DLL")); | |
} | |
} | |
void VcxprojGenerator::initResourceTool() | |
{ | |
VCXConfiguration &conf = vcxProject.Configuration; | |
conf.resource.PreprocessorDefinitions = conf.compiler.PreprocessorDefinitions; | |
// We need to add _DEBUG for the debug version of the project, since the normal compiler defines | |
// do not contain it. (The compiler defines this symbol automatically, which is wy we don't need | |
// to add it for the compiler) However, the resource tool does not do this. | |
if(project->isActiveConfig("debug")) | |
conf.resource.PreprocessorDefinitions += "_DEBUG"; | |
if(project->isActiveConfig("staticlib")) | |
conf.resource.ResourceOutputFileName = project->first("DESTDIR") + "/$(InputName).res"; | |
} | |
void VcxprojGenerator::initPostBuildEventTools() | |
{ | |
VCXConfiguration &conf = vcxProject.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.UseInBuild = _True; | |
} | |
QString signature = !project->isEmpty("SIGNATURE_FILE") ? var("SIGNATURE_FILE") : var("DEFAULT_SIGNATURE"); | |
bool useSignature = !signature.isEmpty() && !project->isActiveConfig("staticlib") && | |
!project->isEmpty("CE_SDK") && !project->isEmpty("CE_ARCH"); | |
if(useSignature) { | |
conf.postBuild.CommandLine.prepend( | |
QLatin1String("signtool sign /F ") + signature + QLatin1String(" \"$(TargetPath)\"")); | |
conf.postBuild.UseInBuild = _True; | |
} | |
if(!project->values("MSVCPROJ_COPY_DLL").isEmpty()) { | |
conf.postBuild.Description += var("MSVCPROJ_COPY_DLL_DESC"); | |
conf.postBuild.CommandLine += var("MSVCPROJ_COPY_DLL"); | |
conf.postBuild.UseInBuild = _True; | |
} | |
} | |
void VcxprojGenerator::initDeploymentTool() | |
{ | |
VCXConfiguration &conf = vcxProject.Configuration; | |
QString targetPath = project->values("deploy.path").join(" "); | |
if (targetPath.isEmpty()) | |
targetPath = QString("%CSIDL_PROGRAM_FILES%\\") + project->first("TARGET"); | |
if (targetPath.endsWith("/") || targetPath.endsWith("\\")) | |
targetPath.chop(1); | |
// Only deploy Qt libs for shared build | |
if (!project->values("QMAKE_QT_DLL").isEmpty()) { | |
QStringList& arg = project->values("MSVCPROJ_LIBS"); | |
for (QStringList::ConstIterator it = arg.constBegin(); it != arg.constEnd(); ++it) { | |
if (it->contains(project->first("QMAKE_LIBDIR"))) { | |
QString dllName = *it; | |
if (dllName.contains(QLatin1String("QAxContainer")) | |
|| dllName.contains(QLatin1String("qtmain")) | |
|| dllName.contains(QLatin1String("QtUiTools"))) | |
continue; | |
dllName.replace(QLatin1String(".lib") , QLatin1String(".dll")); | |
QFileInfo info(dllName); | |
conf.deployment.AdditionalFiles += info.fileName() | |
+ "|" + QDir::toNativeSeparators(info.absolutePath()) | |
+ "|" + targetPath | |
+ "|0;"; | |
} | |
} | |
} | |
// C-runtime deployment | |
QString runtime = project->values("QT_CE_C_RUNTIME").join(QLatin1String(" ")); | |
if (!runtime.isEmpty() && (runtime != QLatin1String("no"))) { | |
QString runtimeVersion = QLatin1String("msvcr"); | |
QString mkspec = project->first("QMAKESPEC"); | |
// If no .qmake.cache has been found, we fallback to the original mkspec | |
if (mkspec.isEmpty()) | |
mkspec = project->first("QMAKESPEC_ORIGINAL"); | |
if (!mkspec.isEmpty()) { | |
if (mkspec.endsWith("2010")) | |
runtimeVersion.append("100"); | |
else if (mkspec.endsWith("2008")) | |
runtimeVersion.append("90"); | |
else | |
runtimeVersion.append("80"); | |
if (project->isActiveConfig("debug")) | |
runtimeVersion.append("d"); | |
runtimeVersion.append(".dll"); | |
if (runtime == "yes") { | |
// Auto-find C-runtime | |
QString vcInstallDir = qgetenv("VCINSTALLDIR"); | |
if (!vcInstallDir.isEmpty()) { | |
vcInstallDir += "\\ce\\dll\\"; | |
vcInstallDir += project->values("CE_ARCH").join(QLatin1String(" ")); | |
if (!QFileInfo(vcInstallDir + QDir::separator() + runtimeVersion).exists()) | |
runtime.clear(); | |
else | |
runtime = vcInstallDir; | |
} | |
} | |
} | |
if (!runtime.isEmpty() && runtime != QLatin1String("yes")) { | |
conf.deployment.AdditionalFiles += runtimeVersion | |
+ "|" + QDir::toNativeSeparators(runtime) | |
+ "|" + targetPath | |
+ "|0;"; | |
} | |
} | |
// foreach item in DEPLOYMENT | |
foreach(QString item, project->values("DEPLOYMENT")) { | |
// get item.path | |
QString devicePath = project->first(item + ".path"); | |
if (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::fixPathToLocalOS(QDir::cleanPath(targetPath + QLatin1Char('\\') + devicePath)); | |
} | |
// foreach d in item.sources | |
foreach(QString source, project->values(item + ".sources")) { | |
QString itemDevicePath = devicePath; | |
source = Option::fixPathToLocalOS(source); | |
QString nameFilter; | |
QFileInfo info(source); | |
QString searchPath; | |
if (info.isDir()) { | |
nameFilter = QLatin1String("*"); | |
itemDevicePath += "\\" + info.fileName(); | |
searchPath = info.absoluteFilePath(); | |
} else { | |
nameFilter = source.split('\\').last(); | |
searchPath = info.absolutePath(); | |
} | |
int pathSize = searchPath.size(); | |
QDirIterator iterator(searchPath, QStringList() << nameFilter | |
, QDir::Files | QDir::NoDotAndDotDot | QDir::NoSymLinks | |
, QDirIterator::Subdirectories); | |
// foreach dirIterator-entry in d | |
while(iterator.hasNext()) { | |
iterator.next(); | |
QString absoluteItemPath = Option::fixPathToLocalOS(QFileInfo(iterator.filePath()).absolutePath()); | |
// Identify if it is just another subdir | |
int diffSize = absoluteItemPath.size() - pathSize; | |
// write out rules | |
conf.deployment.AdditionalFiles += iterator.fileName() | |
+ "|" + absoluteItemPath | |
+ "|" + itemDevicePath + (diffSize ? (absoluteItemPath.right(diffSize)) : QLatin1String("")) | |
+ "|0;"; | |
} | |
} | |
} | |
} | |
void VcxprojGenerator::initPreLinkEventTools() | |
{ | |
VCXConfiguration &conf = vcxProject.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.UseInBuild = _True; | |
} | |
} | |
void VcxprojGenerator::initRootFiles() | |
{ | |
vcxProject.RootFiles.addFiles(project->values("RC_FILE")); | |
vcxProject.RootFiles.Project = this; | |
vcxProject.RootFiles.Config = &(vcxProject.Configuration); | |
vcxProject.RootFiles.CustomBuild = none; | |
} | |
void VcxprojGenerator::initSourceFiles() | |
{ | |
vcxProject.SourceFiles.Name = "Source Files"; | |
vcxProject.SourceFiles.Filter = "cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"; | |
vcxProject.SourceFiles.Guid = _GUIDSourceFiles; | |
vcxProject.SourceFiles.addFiles(project->values("SOURCES")); | |
vcxProject.SourceFiles.Project = this; | |
vcxProject.SourceFiles.Config = &(vcxProject.Configuration); | |
vcxProject.SourceFiles.CustomBuild = none; | |
} | |
void VcxprojGenerator::initHeaderFiles() | |
{ | |
vcxProject.HeaderFiles.Name = "Header Files"; | |
vcxProject.HeaderFiles.Filter = "h;hpp;hxx;hm;inl;inc;xsd"; | |
vcxProject.HeaderFiles.Guid = _GUIDHeaderFiles; | |
vcxProject.HeaderFiles.addFiles(project->values("HEADERS")); | |
if (usePCH) // Generated PCH cpp file | |
vcxProject.HeaderFiles.addFile(precompH); | |
vcxProject.HeaderFiles.Project = this; | |
vcxProject.HeaderFiles.Config = &(vcxProject.Configuration); | |
} | |
void VcxprojGenerator::initGeneratedFiles() | |
{ | |
vcxProject.GeneratedFiles.Name = "Generated Files"; | |
vcxProject.GeneratedFiles.Filter = "cpp;c;cxx;moc;h;def;odl;idl;res"; | |
vcxProject.GeneratedFiles.Guid = _GUIDGeneratedFiles; | |
// ### These cannot have CustomBuild (mocSrc)!! | |
vcxProject.GeneratedFiles.addFiles(project->values("GENERATED_SOURCES")); | |
vcxProject.GeneratedFiles.addFiles(project->values("GENERATED_FILES")); | |
vcxProject.GeneratedFiles.addFiles(project->values("IDLSOURCES")); | |
vcxProject.GeneratedFiles.addFiles(project->values("RES_FILE")); | |
vcxProject.GeneratedFiles.addFiles(project->values("QMAKE_IMAGE_COLLECTION")); // compat | |
if(!extraCompilerOutputs.isEmpty()) | |
vcxProject.GeneratedFiles.addFiles(extraCompilerOutputs.keys()); | |
vcxProject.GeneratedFiles.Project = this; | |
vcxProject.GeneratedFiles.Config = &(vcxProject.Configuration); | |
} | |
void VcxprojGenerator::initLexYaccFiles() | |
{ | |
vcxProject.LexYaccFiles.Name = "Lex / Yacc Files"; | |
vcxProject.LexYaccFiles.ParseFiles = _False; | |
vcxProject.LexYaccFiles.Filter = "l;y"; | |
vcxProject.LexYaccFiles.Guid = _GUIDLexYaccFiles; | |
vcxProject.LexYaccFiles.addFiles(project->values("LEXSOURCES")); | |
vcxProject.LexYaccFiles.addFiles(project->values("YACCSOURCES")); | |
vcxProject.LexYaccFiles.Project = this; | |
vcxProject.LexYaccFiles.Config = &(vcxProject.Configuration); | |
vcxProject.LexYaccFiles.CustomBuild = lexyacc; | |
} | |
void VcxprojGenerator::initTranslationFiles() | |
{ | |
vcxProject.TranslationFiles.Name = "Translation Files"; | |
vcxProject.TranslationFiles.ParseFiles = _False; | |
vcxProject.TranslationFiles.Filter = "ts;xlf"; | |
vcxProject.TranslationFiles.Guid = _GUIDTranslationFiles; | |
vcxProject.TranslationFiles.addFiles(project->values("TRANSLATIONS")); | |
vcxProject.TranslationFiles.Project = this; | |
vcxProject.TranslationFiles.Config = &(vcxProject.Configuration); | |
vcxProject.TranslationFiles.CustomBuild = none; | |
} | |
void VcxprojGenerator::initFormFiles() | |
{ | |
vcxProject.FormFiles.Name = "Form Files"; | |
vcxProject.FormFiles.ParseFiles = _False; | |
vcxProject.FormFiles.Filter = "ui"; | |
vcxProject.FormFiles.Guid = _GUIDFormFiles; | |
vcxProject.FormFiles.addFiles(project->values("FORMS")); | |
vcxProject.FormFiles.addFiles(project->values("FORMS3")); | |
vcxProject.FormFiles.Project = this; | |
vcxProject.FormFiles.Config = &(vcxProject.Configuration); | |
vcxProject.FormFiles.CustomBuild = none; | |
} | |
void VcxprojGenerator::initResourceFiles() | |
{ | |
vcxProject.ResourceFiles.Name = "Resource Files"; | |
vcxProject.ResourceFiles.ParseFiles = _False; | |
vcxProject.ResourceFiles.Filter = "qrc;*"; //"rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;ts;xlf;qrc"; | |
vcxProject.ResourceFiles.Guid = _GUIDResourceFiles; | |
// Bad hack, please look away ------------------------------------- | |
QString rcc_dep_cmd = project->values("rcc.depend_command").join(" "); | |
if(!rcc_dep_cmd.isEmpty()) { | |
QStringList qrc_files = project->values("RESOURCES"); | |
QStringList deps; | |
if(!qrc_files.isEmpty()) { | |
for (int i = 0; i < qrc_files.count(); ++i) { | |
char buff[256]; | |
QString dep_cmd = replaceExtraCompilerVariables(rcc_dep_cmd, qrc_files.at(i),""); | |
dep_cmd = Option::fixPathToLocalOS(dep_cmd, true, false); | |
if(canExecute(dep_cmd)) { | |
dep_cmd.prepend(QLatin1String("cd ") | |
+ escapeFilePath(Option::fixPathToLocalOS(Option::output_dir, false)) | |
+ QLatin1String(" && ")); | |
if(FILE *proc = QT_POPEN(dep_cmd.toLatin1().constData(), "r")) { | |
QString indeps; | |
while(!feof(proc)) { | |
int read_in = (int)fread(buff, 1, 255, proc); | |
if(!read_in) | |
break; | |
indeps += QByteArray(buff, read_in); | |
} | |
QT_PCLOSE(proc); | |
if(!indeps.isEmpty()) | |
deps += fileFixify(indeps.replace('\n', ' ').simplified().split(' '), | |
QString(), Option::output_dir); | |
} | |
} | |
} | |
vcxProject.ResourceFiles.addFiles(deps); | |
} | |
} | |
// You may look again -------------------------------------------- | |
vcxProject.ResourceFiles.addFiles(project->values("RESOURCES")); | |
vcxProject.ResourceFiles.addFiles(project->values("IMAGES")); | |
vcxProject.ResourceFiles.Project = this; | |
vcxProject.ResourceFiles.Config = &(vcxProject.Configuration); | |
vcxProject.ResourceFiles.CustomBuild = none; | |
} | |
void VcxprojGenerator::initExtraCompilerOutputs() | |
{ | |
QStringList otherFilters; | |
otherFilters << "FORMS" | |
<< "FORMS3" | |
<< "GENERATED_FILES" | |
<< "GENERATED_SOURCES" | |
<< "HEADERS" | |
<< "IDLSOURCES" | |
<< "IMAGES" | |
<< "LEXSOURCES" | |
<< "QMAKE_IMAGE_COLLECTION" | |
<< "RC_FILE" | |
<< "RESOURCES" | |
<< "RES_FILE" | |
<< "SOURCES" | |
<< "TRANSLATIONS" | |
<< "YACCSOURCES"; | |
const QStringList &quc = project->values("QMAKE_EXTRA_COMPILERS"); | |
for(QStringList::ConstIterator it = quc.begin(); it != quc.end(); ++it) { | |
QString extracompilerName = project->first((*it) + ".name"); | |
if (extracompilerName.isEmpty()) | |
extracompilerName = (*it); | |
// Create an extra compiler filter and add the files | |
VCXFilter extraCompile; | |
extraCompile.Name = extracompilerName; | |
extraCompile.ParseFiles = _False; | |
extraCompile.Filter = ""; | |
extraCompile.Guid = QString(_GUIDExtraCompilerFiles) + "-" + (*it); | |
// If the extra compiler has a variable_out set the output file | |
// is added to an other file list, and does not need its own.. | |
bool addOnInput = hasBuiltinCompiler(project->first((*it) + ".output")); | |
QString tmp_other_out = project->first((*it) + ".variable_out"); | |
if (!tmp_other_out.isEmpty() && !addOnInput) | |
continue; | |
if (!addOnInput) { | |
QString tmp_out = project->first((*it) + ".output"); | |
if (project->values((*it) + ".CONFIG").indexOf("combine") != -1) { | |
// Combined output, only one file result | |
extraCompile.addFile( | |
Option::fixPathToTargetOS(replaceExtraCompilerVariables(tmp_out, QString(), QString()), false)); | |
} else { | |
// One output file per input | |
QStringList tmp_in = project->values(project->first((*it) + ".input")); | |
for (int i = 0; i < tmp_in.count(); ++i) { | |
const QString &filename = tmp_in.at(i); | |
if (extraCompilerSources.contains(filename)) | |
extraCompile.addFile( | |
Option::fixPathToTargetOS(replaceExtraCompilerVariables(filename, tmp_out, QString()), false)); | |
} | |
} | |
} else { | |
// In this case we the outputs have a built-in compiler, so we cannot add the custom | |
// build steps there. So, we turn it around and add it to the input files instead, | |
// provided that the input file variable is not handled already (those in otherFilters | |
// are handled, so we avoid them). | |
QStringList inputVars = project->values((*it) + ".input"); | |
foreach(QString inputVar, inputVars) { | |
if (!otherFilters.contains(inputVar)) { | |
QStringList tmp_in = project->values(inputVar); | |
for (int i = 0; i < tmp_in.count(); ++i) { | |
const QString &filename = tmp_in.at(i); | |
if (extraCompilerSources.contains(filename)) | |
extraCompile.addFile( | |
Option::fixPathToTargetOS(replaceExtraCompilerVariables(filename, QString(), QString()), false)); | |
} | |
} | |
} | |
} | |
extraCompile.Project = this; | |
extraCompile.Config = &(vcxProject.Configuration); | |
extraCompile.CustomBuild = none; | |
vcxProject.ExtraCompilersFiles.append(extraCompile); | |
} | |
} | |
bool VcxprojGenerator::writeProjectMakefile() | |
{ | |
usePlatformDir(); | |
QTextStream t(&Option::output); | |
// Check if all requirements are fulfilled | |
if(!project->values("QMAKE_FAILED_REQUIREMENTS").isEmpty()) { | |
fprintf(stderr, "Project file not generated because all requirements not met:\n\t%s\n", | |
var("QMAKE_FAILED_REQUIREMENTS").toLatin1().constData()); | |
return true; | |
} | |
// Generate project file | |
if(project->first("TEMPLATE") == "vcapp" || | |
project->first("TEMPLATE") == "vclib") { | |
if (!mergedProjects.count()) { | |
warn_msg(WarnLogic, "Generator: MSVC.NET: no single configuration created, cannot output project!"); | |
return false; | |
} | |
debug_msg(1, "Generator: MSVC.NET: Writing project file"); | |
VCXProject mergedProject; | |
for (int i = 0; i < mergedProjects.count(); ++i) { | |
VCXProjectSingleConfig *singleProject = &(mergedProjects.at(i)->vcxProject); | |
mergedProject.SingleProjects += *singleProject; | |
for (int j = 0; j < singleProject->ExtraCompilersFiles.count(); ++j) { | |
const QString &compilerName = singleProject->ExtraCompilersFiles.at(j).Name; | |
if (!mergedProject.ExtraCompilers.contains(compilerName)) | |
mergedProject.ExtraCompilers += compilerName; | |
} | |
} | |
if(mergedProjects.count() > 1 && | |
mergedProjects.at(0)->vcxProject.Name == | |
mergedProjects.at(1)->vcxProject.Name) | |
mergedProjects.at(0)->writePrlFile(); | |
mergedProject.Name = unescapeFilePath(project->first("QMAKE_ORIG_TARGET")); | |
mergedProject.Version = mergedProjects.at(0)->vcxProject.Version; | |
mergedProject.ProjectGUID = project->isEmpty("QMAKE_UUID") ? getProjectUUID().toString().toUpper() : project->first("QMAKE_UUID"); | |
mergedProject.Keyword = project->first("VCPROJ_KEYWORD"); | |
mergedProject.SccProjectName = mergedProjects.at(0)->vcxProject.SccProjectName; | |
mergedProject.SccLocalPath = mergedProjects.at(0)->vcxProject.SccLocalPath; | |
mergedProject.PlatformName = mergedProjects.at(0)->vcxProject.PlatformName; | |
XmlOutput xmlOut(t); | |
xmlOut << mergedProject; | |
return true; | |
} else if(project->first("TEMPLATE") == "vcsubdirs") { | |
return writeMakefile(t); | |
} | |
return false; | |
} | |
bool VcxprojGenerator::mergeBuildProject(MakefileGenerator *other) | |
{ | |
VcxprojGenerator *otherVC = static_cast<VcxprojGenerator*>(other); | |
if (!otherVC) { | |
warn_msg(WarnLogic, "VcxprojGenerator: Cannot merge other types of projects! (ignored)"); | |
return false; | |
} | |
mergedProjects += otherVC; | |
return true; | |
} | |
QT_END_NAMESPACE | |