9d7ed92f6e
De-duplicate the code that calls the extra compiler's depend_command by using the central function callExtraCompilerDependCommand. This one actually tries to resolve dependencies unlike the removed code that blindly resolved relative paths to the build directory. This fixes dependencies reported by uic which need to be resolved against what is in DEPENDPATH. Fixes: QTBUG-80579 Change-Id: If482e50ff3eff716fefffee82004acc076b3a547 Reviewed-by: Kai Koehne <kai.koehne@qt.io>
3035 lines
117 KiB
C++
3035 lines
117 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the qmake application of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "msvc_objectmodel.h"
|
|
#include "msvc_vcproj.h"
|
|
#include "msvc_vcxproj.h"
|
|
|
|
#include <ioutils.h>
|
|
|
|
#include <qscopedpointer.h>
|
|
#include <qfileinfo.h>
|
|
#include <qregexp.h>
|
|
|
|
using namespace QMakeInternal;
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
static DotNET vsVersionFromString(const char *versionString)
|
|
{
|
|
struct VSVersionMapping
|
|
{
|
|
const char *str;
|
|
DotNET version;
|
|
};
|
|
static VSVersionMapping mapping[] = {
|
|
{ "7.0", NET2002 },
|
|
{ "7.1", NET2003 },
|
|
{ "8.0", NET2005 },
|
|
{ "9.0", NET2008 },
|
|
{ "10.0", NET2010 },
|
|
{ "11.0", NET2012 },
|
|
{ "12.0", NET2013 },
|
|
{ "14.0", NET2015 },
|
|
{ "15.0", NET2017 },
|
|
{ "16.0", NET2019 }
|
|
};
|
|
DotNET result = NETUnknown;
|
|
for (const auto entry : mapping) {
|
|
if (strcmp(entry.str, versionString) == 0)
|
|
return entry.version;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
DotNET vsVersionFromString(const ProString &versionString)
|
|
{
|
|
return vsVersionFromString(versionString.toLatin1().constData());
|
|
}
|
|
|
|
// XML Tags ---------------------------------------------------------
|
|
const char _Configuration[] = "Configuration";
|
|
const char _Configurations[] = "Configurations";
|
|
const char q_File[] = "File";
|
|
const char _FileConfiguration[] = "FileConfiguration";
|
|
const char q_Files[] = "Files";
|
|
const char _Filter[] = "Filter";
|
|
const char _Globals[] = "Globals";
|
|
const char _Platform[] = "Platform";
|
|
const char _Platforms[] = "Platforms";
|
|
const char _Tool[] = "Tool";
|
|
const char _VisualStudioProject[] = "VisualStudioProject";
|
|
|
|
// XML Properties ---------------------------------------------------
|
|
const char _AddModuleNamesToAssembly[] = "AddModuleNamesToAssembly";
|
|
const char _AdditionalDependencies[] = "AdditionalDependencies";
|
|
const char _AdditionalFiles[] = "AdditionalFiles";
|
|
const char _AdditionalIncludeDirectories[] = "AdditionalIncludeDirectories";
|
|
const char _AdditionalLibraryDirectories[] = "AdditionalLibraryDirectories";
|
|
const char _AdditionalOptions[] = "AdditionalOptions";
|
|
const char _AdditionalUsingDirectories[] = "AdditionalUsingDirectories";
|
|
const char _AssemblerListingLocation[] = "AssemblerListingLocation";
|
|
const char _AssemblerOutput[] = "AssemblerOutput";
|
|
const char _ATLMinimizesCRunTimeLibraryUsage[] = "ATLMinimizesCRunTimeLibraryUsage";
|
|
const char _BaseAddress[] = "BaseAddress";
|
|
const char _BasicRuntimeChecks[] = "BasicRuntimeChecks";
|
|
const char _BrowseInformation[] = "BrowseInformation";
|
|
const char _BrowseInformationFile[] = "BrowseInformationFile";
|
|
const char _BufferSecurityCheck[] = "BufferSecurityCheck";
|
|
const char _BuildBrowserInformation[] = "BuildBrowserInformation";
|
|
const char _CPreprocessOptions[] = "CPreprocessOptions";
|
|
const char _CallingConvention[] = "CallingConvention";
|
|
const char _CharacterSet[] = "CharacterSet";
|
|
const char _CommandLine[] = "CommandLine";
|
|
const char _CompileAs[] = "CompileAs";
|
|
const char _CompileAsManaged[] = "CompileAsManaged";
|
|
const char _CompileOnly[] = "CompileOnly";
|
|
const char _ConfigurationType[] = "ConfigurationType";
|
|
const char _Culture[] = "Culture";
|
|
const char _DLLDataFileName[] = "DLLDataFileName";
|
|
const char _DataExecutionPrevention[] = "DataExecutionPrevention";
|
|
const char _DebugInformationFormat[] = "DebugInformationFormat";
|
|
const char _DefaultCharType[] = "DefaultCharType";
|
|
const char _DelayLoadDLLs[] = "DelayLoadDLLs";
|
|
const char _DeleteExtensionsOnClean[] = "DeleteExtensionsOnClean";
|
|
const char _Description[] = "Description";
|
|
const char _Detect64BitPortabilityProblems[] = "Detect64BitPortabilityProblems";
|
|
const char _DisableLanguageExtensions[] = "DisableLanguageExtensions";
|
|
const char _DisableSpecificWarnings[] = "DisableSpecificWarnings";
|
|
const char _EmbedManifest[] = "EmbedManifest";
|
|
const char _EnableCOMDATFolding[] = "EnableCOMDATFolding";
|
|
const char _EnableErrorChecks[] = "EnableErrorChecks";
|
|
const char _EnableEnhancedInstructionSet[] = "EnableEnhancedInstructionSet";
|
|
const char _EnableFiberSafeOptimizations[] = "EnableFiberSafeOptimizations";
|
|
const char _EnableFunctionLevelLinking[] = "EnableFunctionLevelLinking";
|
|
const char _EnableIntrinsicFunctions[] = "EnableIntrinsicFunctions";
|
|
const char _EntryPointSymbol[] = "EntryPointSymbol";
|
|
const char _ErrorCheckAllocations[] = "ErrorCheckAllocations";
|
|
const char _ErrorCheckBounds[] = "ErrorCheckBounds";
|
|
const char _ErrorCheckEnumRange[] = "ErrorCheckEnumRange";
|
|
const char _ErrorCheckRefPointers[] = "ErrorCheckRefPointers";
|
|
const char _ErrorCheckStubData[] = "ErrorCheckStubData";
|
|
const char _ExceptionHandling[] = "ExceptionHandling";
|
|
const char _ExcludedFromBuild[] = "ExcludedFromBuild";
|
|
const char _ExpandAttributedSource[] = "ExpandAttributedSource";
|
|
const char _ExportNamedFunctions[] = "ExportNamedFunctions";
|
|
const char _FavorSizeOrSpeed[] = "FavorSizeOrSpeed";
|
|
const char _FloatingPointModel[] = "FloatingPointModel";
|
|
const char _FloatingPointExceptions[] = "FloatingPointExceptions";
|
|
const char _ForceConformanceInForLoopScope[] = "ForceConformanceInForLoopScope";
|
|
const char _ForceSymbolReferences[] = "ForceSymbolReferences";
|
|
const char _ForcedIncludeFiles[] = "ForcedIncludeFiles";
|
|
const char _ForcedUsingFiles[] = "ForcedUsingFiles";
|
|
const char _FullIncludePath[] = "FullIncludePath";
|
|
const char _FunctionOrder[] = "FunctionOrder";
|
|
const char _GenerateDebugInformation[] = "GenerateDebugInformation";
|
|
const char _GenerateMapFile[] = "GenerateMapFile";
|
|
const char _GeneratePreprocessedFile[] = "GeneratePreprocessedFile";
|
|
const char _GenerateStublessProxies[] = "GenerateStublessProxies";
|
|
const char _GenerateTypeLibrary[] = "GenerateTypeLibrary";
|
|
const char _GlobalOptimizations[] = "GlobalOptimizations";
|
|
const char _HeaderFileName[] = "HeaderFileName";
|
|
const char _HeapCommitSize[] = "HeapCommitSize";
|
|
const char _HeapReserveSize[] = "HeapReserveSize";
|
|
const char _IgnoreAllDefaultLibraries[] = "IgnoreAllDefaultLibraries";
|
|
const char _IgnoreDefaultLibraryNames[] = "IgnoreDefaultLibraryNames";
|
|
const char _IgnoreEmbeddedIDL[] = "IgnoreEmbeddedIDL";
|
|
const char _IgnoreImportLibrary[] = "IgnoreImportLibrary";
|
|
const char _IgnoreStandardIncludePath[] = "IgnoreStandardIncludePath";
|
|
const char _ImportLibrary[] = "ImportLibrary";
|
|
const char _ImproveFloatingPointConsistency[] = "ImproveFloatingPointConsistency";
|
|
const char _InlineFunctionExpansion[] = "InlineFunctionExpansion";
|
|
const char _InterfaceIdentifierFileName[] = "InterfaceIdentifierFileName";
|
|
const char _IntermediateDirectory[] = "IntermediateDirectory";
|
|
const char _KeepComments[] = "KeepComments";
|
|
const char _LargeAddressAware[] = "LargeAddressAware";
|
|
const char _LinkDLL[] = "LinkDLL";
|
|
const char _LinkIncremental[] = "LinkIncremental";
|
|
const char _LinkTimeCodeGeneration[] = "LinkTimeCodeGeneration";
|
|
const char _LinkToManagedResourceFile[] = "LinkToManagedResourceFile";
|
|
const char _MapExports[] = "MapExports";
|
|
const char _MapFileName[] = "MapFileName";
|
|
const char _MapLines[] = "MapLines ";
|
|
const char _MergeSections[] = "MergeSections";
|
|
const char _MergedIDLBaseFileName[] = "MergedIDLBaseFileName";
|
|
const char _MidlCommandFile[] = "MidlCommandFile";
|
|
const char _MinimalRebuild[] = "MinimalRebuild";
|
|
const char _MkTypLibCompatible[] = "MkTypLibCompatible";
|
|
const char _ModuleDefinitionFile[] = "ModuleDefinitionFile";
|
|
const char _Name[] = "Name";
|
|
const char _ObjectFile[] = "ObjectFile";
|
|
const char _OmitFramePointers[] = "OmitFramePointers";
|
|
const char _OpenMP[] = "OpenMP";
|
|
const char _Optimization[] = "Optimization ";
|
|
const char _OptimizeForProcessor[] = "OptimizeForProcessor";
|
|
const char _OptimizeForWindows98[] = "OptimizeForWindows98";
|
|
const char _OptimizeForWindowsApplication[] = "OptimizeForWindowsApplication";
|
|
const char _OptimizeReferences[] = "OptimizeReferences";
|
|
const char _OutputDirectory[] = "OutputDirectory";
|
|
const char _OutputFile[] = "OutputFile";
|
|
const char _Outputs[] = "Outputs";
|
|
const char _ParseFiles[] = "ParseFiles";
|
|
const char _PrecompiledHeaderFile[] = "PrecompiledHeaderFile";
|
|
const char _PrecompiledHeaderThrough[] = "PrecompiledHeaderThrough";
|
|
const char _PreprocessorDefinitions[] = "PreprocessorDefinitions";
|
|
const char _PrimaryOutput[] = "PrimaryOutput";
|
|
const char _ProjectGUID[] = "ProjectGUID";
|
|
const char _Keyword[] = "Keyword";
|
|
const char _ProjectType[] = "ProjectType";
|
|
const char _ProgramDatabase[] = "ProgramDatabase";
|
|
const char _ProgramDataBaseFileName[] = "ProgramDataBaseFileName";
|
|
const char _ProgramDatabaseFile[] = "ProgramDatabaseFile";
|
|
const char _ProxyFileName[] = "ProxyFileName";
|
|
const char _RandomizedBaseAddress[] = "RandomizedBaseAddress";
|
|
const char _RedirectOutputAndErrors[] = "RedirectOutputAndErrors";
|
|
const char _RegisterOutput[] = "RegisterOutput";
|
|
const char _RelativePath[] = "RelativePath";
|
|
const char _RemoteDirectory[] = "RemoteDirectory";
|
|
const char _ResourceOnlyDLL[] = "ResourceOnlyDLL";
|
|
const char _ResourceOutputFileName[] = "ResourceOutputFileName";
|
|
const char _RuntimeLibrary[] = "RuntimeLibrary";
|
|
const char _RuntimeTypeInfo[] = "RuntimeTypeInfo";
|
|
const char _SccProjectName[] = "SccProjectName";
|
|
const char _SccLocalPath[] = "SccLocalPath";
|
|
const char _SetChecksum[] = "SetChecksum";
|
|
const char _ShowIncludes[] = "ShowIncludes";
|
|
const char _ShowProgress[] = "ShowProgress";
|
|
const char _SmallerTypeCheck[] = "SmallerTypeCheck";
|
|
const char _StackCommitSize[] = "StackCommitSize";
|
|
const char _StackReserveSize[] = "StackReserveSize";
|
|
const char _StringPooling[] = "StringPooling";
|
|
const char _StripPrivateSymbols[] = "StripPrivateSymbols";
|
|
const char _StructMemberAlignment[] = "StructMemberAlignment";
|
|
const char _SubSystem[] = "SubSystem";
|
|
const char _SupportUnloadOfDelayLoadedDLL[] = "SupportUnloadOfDelayLoadedDLL";
|
|
const char _SuppressStartupBanner[] = "SuppressStartupBanner";
|
|
const char _SwapRunFromCD[] = "SwapRunFromCD";
|
|
const char _SwapRunFromNet[] = "SwapRunFromNet";
|
|
const char _TargetEnvironment[] = "TargetEnvironment";
|
|
const char _TargetMachine[] = "TargetMachine";
|
|
const char _TerminalServerAware[] = "TerminalServerAware";
|
|
const char _Path[] = "Path";
|
|
const char _TreatWChar_tAsBuiltInType[] = "TreatWChar_tAsBuiltInType";
|
|
const char _TurnOffAssemblyGeneration[] = "TurnOffAssemblyGeneration";
|
|
const char _TypeLibraryFile[] = "TypeLibraryFile";
|
|
const char _TypeLibraryName[] = "TypeLibraryName";
|
|
const char _TypeLibraryResourceID[] = "TypeLibraryResourceID";
|
|
const char _UndefineAllPreprocessorDefinitions[]= "UndefineAllPreprocessorDefinitions";
|
|
const char _UndefinePreprocessorDefinitions[] = "UndefinePreprocessorDefinitions";
|
|
const char _UniqueIdentifier[] = "UniqueIdentifier";
|
|
const char _UseOfATL[] = "UseOfATL";
|
|
const char _UseOfMfc[] = "UseOfMfc";
|
|
const char _UsePrecompiledHeader[] = "UsePrecompiledHeader";
|
|
const char _ValidateParameters[] = "ValidateParameters";
|
|
const char _VCCLCompilerTool[] = "VCCLCompilerTool";
|
|
const char _VCLibrarianTool[] = "VCLibrarianTool";
|
|
const char _VCLinkerTool[] = "VCLinkerTool";
|
|
const char _VCManifestTool[] = "VCManifestTool";
|
|
const char _VCCustomBuildTool[] = "VCCustomBuildTool";
|
|
const char _VCResourceCompilerTool[] = "VCResourceCompilerTool";
|
|
const char _VCMIDLTool[] = "VCMIDLTool";
|
|
const char _Version[] = "Version";
|
|
const char _WarnAsError[] = "WarnAsError";
|
|
const char _WarningLevel[] = "WarningLevel";
|
|
const char _WholeProgramOptimization[] = "WholeProgramOptimization";
|
|
const char _CompileForArchitecture[] = "CompileForArchitecture";
|
|
const char _InterworkCalls[] = "InterworkCalls";
|
|
const char _GenerateManifest[] = "GenerateManifest";
|
|
|
|
// XmlOutput stream functions ------------------------------
|
|
inline XmlOutput::xml_output attrT(const char *name, const triState v)
|
|
{
|
|
if(v == unset)
|
|
return noxml();
|
|
return attr(name, (v == _True ? "true" : "false"));
|
|
}
|
|
|
|
inline XmlOutput::xml_output attrE(const char *name, int v)
|
|
{
|
|
return attr(name, QString::number(v));
|
|
}
|
|
|
|
/*ifNot version*/
|
|
inline XmlOutput::xml_output attrE(const char *name, int v, int ifn)
|
|
{
|
|
if (v == ifn)
|
|
return noxml();
|
|
return attr(name, QString::number(v));
|
|
}
|
|
|
|
inline XmlOutput::xml_output attrL(const char *name, qint64 v)
|
|
{
|
|
return attr(name, QString::number(v));
|
|
}
|
|
|
|
/*ifNot version*/
|
|
inline XmlOutput::xml_output attrL(const char *name, qint64 v, qint64 ifn)
|
|
{
|
|
if (v == ifn)
|
|
return noxml();
|
|
return attr(name, QString::number(v));
|
|
}
|
|
|
|
inline XmlOutput::xml_output attrS(const char *name, const QString &v)
|
|
{
|
|
if(v.isEmpty())
|
|
return noxml();
|
|
return attr(name, v);
|
|
}
|
|
|
|
inline XmlOutput::xml_output attrX(const char *name, const QStringList &v, const char *s = ",")
|
|
{
|
|
if(v.isEmpty())
|
|
return noxml();
|
|
return attr(name, v.join(s));
|
|
}
|
|
|
|
triState operator!(const triState &rhs)
|
|
{
|
|
if (rhs == unset)
|
|
return rhs;
|
|
triState lhs = (rhs == _True ? _False : _True);
|
|
return lhs;
|
|
}
|
|
|
|
// VCToolBase -------------------------------------------------
|
|
QStringList VCToolBase::fixCommandLine(const QString &input)
|
|
{
|
|
// The splitting regexp is a bit bizarre for backwards compat reasons (why else ...).
|
|
return input.split(QRegExp(QLatin1String("(\n\t|\r\\\\h|\r\n)\\s*")));
|
|
}
|
|
|
|
static QString vcCommandSeparator()
|
|
{
|
|
// MSVC transforms the build tree into a single batch file, simply pasting the contents
|
|
// of the custom commands into it, and putting an "if errorlevel goto" statement behind it.
|
|
// As we want every sub-command to be error-checked (as is done by makefile-based
|
|
// backends), we insert the checks ourselves, using the undocumented jump target.
|
|
static QString cmdSep =
|
|
QLatin1String("
if errorlevel 1 goto VCReportError
");
|
|
return cmdSep;
|
|
}
|
|
|
|
static void unknownOptionWarning(const char *tool, const char *option)
|
|
{
|
|
static bool firstCall = true;
|
|
warn_msg(WarnLogic, "Could not parse %s option '%s'; added to AdditionalOptions.", tool, option);
|
|
if (firstCall) {
|
|
firstCall = false;
|
|
warn_msg(WarnLogic,
|
|
"You can suppress these warnings with CONFIG+=suppress_vcproj_warnings.");
|
|
}
|
|
}
|
|
|
|
|
|
// VCCLCompilerTool -------------------------------------------------
|
|
VCCLCompilerTool::VCCLCompilerTool()
|
|
: AssemblerOutput(asmListingNone),
|
|
BasicRuntimeChecks(runtimeBasicCheckNone),
|
|
BrowseInformation(brInfoNone),
|
|
BufferSecurityCheck(unset),
|
|
CallingConvention(callConventionDefault),
|
|
CompileAs(compileAsDefault),
|
|
CompileAsManaged(managedDefault),
|
|
CompileAsWinRT(unset),
|
|
CompileOnly(unset),
|
|
DebugInformationFormat(debugDisabled),
|
|
Detect64BitPortabilityProblems(unset),
|
|
DisableLanguageExtensions(unset),
|
|
EnableEnhancedInstructionSet(archNotSet),
|
|
EnableFiberSafeOptimizations(unset),
|
|
EnableFunctionLevelLinking(unset),
|
|
EnableIntrinsicFunctions(unset),
|
|
ExceptionHandling(ehDefault),
|
|
ExpandAttributedSource(unset),
|
|
FavorSizeOrSpeed(favorNone),
|
|
FloatingPointModel(floatingPointNotSet),
|
|
FloatingPointExceptions(unset),
|
|
ForceConformanceInForLoopScope(unset),
|
|
GeneratePreprocessedFile(preprocessNo),
|
|
PreprocessSuppressLineNumbers(unset),
|
|
GlobalOptimizations(unset),
|
|
IgnoreStandardIncludePath(unset),
|
|
ImproveFloatingPointConsistency(unset),
|
|
InlineFunctionExpansion(expandDefault),
|
|
KeepComments(unset),
|
|
MinimalRebuild(unset),
|
|
OmitDefaultLibName(unset),
|
|
OmitFramePointers(unset),
|
|
OpenMP(unset),
|
|
Optimization(optimizeCustom),
|
|
OptimizeForProcessor(procOptimizeBlended),
|
|
OptimizeForWindowsApplication(unset),
|
|
ProgramDataBaseFileName(""),
|
|
RuntimeLibrary(rtMultiThreaded),
|
|
RuntimeTypeInfo(unset),
|
|
ShowIncludes(unset),
|
|
SmallerTypeCheck(unset),
|
|
StringPooling(unset),
|
|
StructMemberAlignment(alignNotSet),
|
|
SuppressStartupBanner(unset),
|
|
TreatWChar_tAsBuiltInType(unset),
|
|
TurnOffAssemblyGeneration(unset),
|
|
UndefineAllPreprocessorDefinitions(unset),
|
|
UsePrecompiledHeader(pchUnset),
|
|
UseUnicodeForAssemblerListing(unset),
|
|
WarnAsError(unset),
|
|
WarningLevel(warningLevel_0),
|
|
WholeProgramOptimization(unset),
|
|
CompileForArchitecture(archUnknown),
|
|
InterworkCalls(unset),
|
|
EnablePREfast(unset),
|
|
DisplayFullPaths(unset),
|
|
MultiProcessorCompilation(unset),
|
|
GenerateXMLDocumentationFiles(unset),
|
|
CreateHotpatchableImage(unset)
|
|
{
|
|
}
|
|
|
|
/*
|
|
* Some values for the attribute UsePrecompiledHeader have changed from VS 2003 to VS 2005,
|
|
* see the following chart, so we need a function that transforms those values if we are
|
|
* using NET2005:
|
|
*
|
|
* Meaning 2003 2005
|
|
* -----------------------------------------
|
|
* Don't use PCH 0 0
|
|
* Create PCH (/Yc) 1 1
|
|
* Automatically generate (/YX) 2 (seems that it was removed)
|
|
* Use specific PCH (/Yu) 3 2
|
|
*
|
|
*/
|
|
inline XmlOutput::xml_output xformUsePrecompiledHeaderForNET2005(pchOption whatPch, DotNET compilerVersion)
|
|
{
|
|
if (compilerVersion >= NET2005) {
|
|
if (whatPch == pchGenerateAuto) whatPch = (pchOption)0;
|
|
if (whatPch == pchUseUsingSpecific) whatPch = (pchOption)2;
|
|
}
|
|
return attrE(_UsePrecompiledHeader, whatPch, /*ifNot*/ pchUnset);
|
|
}
|
|
|
|
inline XmlOutput::xml_output xformExceptionHandlingNET2005(exceptionHandling eh, DotNET compilerVersion)
|
|
{
|
|
if (eh == ehDefault)
|
|
return noxml();
|
|
|
|
if (compilerVersion >= NET2005)
|
|
return attrE(_ExceptionHandling, eh);
|
|
|
|
return attrS(_ExceptionHandling, (eh == ehNoSEH ? "true" : "false"));
|
|
}
|
|
|
|
bool VCCLCompilerTool::parseOption(const char* option)
|
|
{
|
|
// skip index 0 ('/' or '-')
|
|
char first = option[1];
|
|
char second = option[2];
|
|
char third = option[3];
|
|
char fourth = option[4];
|
|
bool found = true;
|
|
|
|
switch (first) {
|
|
case '?':
|
|
case 'h':
|
|
if(second == 'o' && third == 't' && fourth == 'p') {
|
|
CreateHotpatchableImage = _True;
|
|
break;
|
|
}
|
|
qWarning("Generator: Option '/?', '/help': MSVC.NET projects do not support outputting help info");
|
|
found = false;
|
|
break;
|
|
case '@':
|
|
qWarning("Generator: Option '/@': MSVC.NET projects do not support the use of a response file");
|
|
found = false;
|
|
break;
|
|
case 'l':
|
|
qWarning("Generator: Option '/link': qmake generator does not support passing link options through the compiler tool");
|
|
found = false;
|
|
break;
|
|
case 'A':
|
|
if(second != 'I') {
|
|
found = false; break;
|
|
}
|
|
AdditionalUsingDirectories += option+3;
|
|
break;
|
|
case 'C':
|
|
KeepComments = _True;
|
|
break;
|
|
case 'D':
|
|
PreprocessorDefinitions += option+2;
|
|
break;
|
|
case 'E':
|
|
if(second == 'H') {
|
|
QByteArray opt(option + 2);
|
|
if (opt.contains('a') && !opt.contains('s') && !opt.contains('c'))
|
|
ExceptionHandling = ehSEH;
|
|
else if (!opt.contains('a') && opt.contains("s-") && opt.contains("c-"))
|
|
ExceptionHandling = ehNone;
|
|
else if (!opt.contains('a') && opt.contains('s') && opt.contains('c'))
|
|
ExceptionHandling = ehNoSEH;
|
|
else {
|
|
// ExceptionHandling must be false, or it will override
|
|
// with an /EHsc option
|
|
ExceptionHandling = ehNone;
|
|
AdditionalOptions += option;
|
|
}
|
|
if (config->CompilerVersion < NET2005
|
|
&& ExceptionHandling == ehSEH) {
|
|
ExceptionHandling = ehNone;
|
|
AdditionalOptions += option;
|
|
}
|
|
break;
|
|
} else if (second == 'P') {
|
|
PreprocessSuppressLineNumbers = _True;
|
|
}
|
|
GeneratePreprocessedFile = preprocessYes;
|
|
break;
|
|
case 'F':
|
|
if(second <= '9' && second >= '0') {
|
|
AdditionalOptions += option;
|
|
break;
|
|
} else {
|
|
switch (second) {
|
|
case 'A':
|
|
if(third == 'c') {
|
|
AssemblerOutput = asmListingAsmMachine;
|
|
if(fourth == 's')
|
|
AssemblerOutput = asmListingAsmMachineSrc;
|
|
} else if(third == 's') {
|
|
AssemblerOutput = asmListingAsmSrc;
|
|
} else if (third == 'u') {
|
|
UseUnicodeForAssemblerListing = _True;
|
|
} else {
|
|
AssemblerOutput = asmListingAssemblyOnly;
|
|
}
|
|
break;
|
|
case 'C':
|
|
DisplayFullPaths = _True;
|
|
break;
|
|
case 'a':
|
|
AssemblerListingLocation = option+3;
|
|
break;
|
|
case 'I':
|
|
ForcedIncludeFiles += option+3;
|
|
break;
|
|
case 'i':
|
|
PreprocessOutputPath += option+3;
|
|
break;
|
|
case 'R':
|
|
BrowseInformation = brAllInfo;
|
|
BrowseInformationFile = option+3;
|
|
break;
|
|
case 'S':
|
|
if (config->CompilerVersion < NET2013)
|
|
found = false;
|
|
// Ignore this flag. Visual Studio 2013 takes care of this setting.
|
|
break;
|
|
case 'r':
|
|
BrowseInformation = brNoLocalSymbols;
|
|
BrowseInformationFile = option+3;
|
|
break;
|
|
case 'U':
|
|
ForcedUsingFiles += option+3;
|
|
break;
|
|
case 'd':
|
|
ProgramDataBaseFileName = option+3;
|
|
break;
|
|
case 'e':
|
|
OutputFile = option+3;
|
|
break;
|
|
case 'm':
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 'o':
|
|
ObjectFile = option+3;
|
|
break;
|
|
case 'p':
|
|
PrecompiledHeaderFile = option+3;
|
|
break;
|
|
case 'x':
|
|
ExpandAttributedSource = _True;
|
|
break;
|
|
default:
|
|
found = false; break;
|
|
}
|
|
}
|
|
break;
|
|
case 'G':
|
|
switch (second) {
|
|
case '3':
|
|
case '4':
|
|
qWarning("Option '/G3' and '/G4' were phased out in Visual C++ 5.0");
|
|
found = false; break;
|
|
case '5':
|
|
OptimizeForProcessor = procOptimizePentium;
|
|
break;
|
|
case '6':
|
|
case 'B':
|
|
OptimizeForProcessor = procOptimizePentiumProAndAbove;
|
|
break;
|
|
case '7':
|
|
OptimizeForProcessor = procOptimizePentium4AndAbove;
|
|
break;
|
|
case 'A':
|
|
OptimizeForWindowsApplication = _True;
|
|
break;
|
|
case 'F':
|
|
StringPooling = _True;
|
|
break;
|
|
case 'H':
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 'L':
|
|
WholeProgramOptimization = _True;
|
|
if(third == '-')
|
|
WholeProgramOptimization = _False;
|
|
break;
|
|
case 'R':
|
|
RuntimeTypeInfo = _True;
|
|
if(third == '-')
|
|
RuntimeTypeInfo = _False;
|
|
break;
|
|
case 'S':
|
|
BufferSecurityCheck = _True;
|
|
if(third == '-')
|
|
BufferSecurityCheck = _False;
|
|
break;
|
|
case 'T':
|
|
EnableFiberSafeOptimizations = _True;
|
|
break;
|
|
case 'X':
|
|
// Same as the /EHsc option, which is Exception Handling without SEH
|
|
ExceptionHandling = ehNoSEH;
|
|
if (third == '-')
|
|
ExceptionHandling = ehNone;
|
|
break;
|
|
case 'Z':
|
|
case 'e':
|
|
case 'h':
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 'd':
|
|
CallingConvention = callConventionCDecl;
|
|
break;
|
|
case 'f':
|
|
StringPooling = _True;
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 'm':
|
|
MinimalRebuild = _True;
|
|
if(third == '-')
|
|
MinimalRebuild = _False;
|
|
break;
|
|
case 'r':
|
|
CallingConvention = callConventionFastCall;
|
|
break;
|
|
case 's':
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 'y':
|
|
EnableFunctionLevelLinking = _True;
|
|
break;
|
|
case 'z':
|
|
CallingConvention = callConventionStdCall;
|
|
break;
|
|
default:
|
|
found = false; break;
|
|
}
|
|
break;
|
|
case 'H':
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 'I':
|
|
AdditionalIncludeDirectories += option+2;
|
|
break;
|
|
case 'J':
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 'L':
|
|
if(second == 'D') {
|
|
AdditionalOptions += option;
|
|
break;
|
|
}
|
|
found = false; break;
|
|
case 'M':
|
|
if(second == 'D') {
|
|
RuntimeLibrary = rtMultiThreadedDLL;
|
|
if(third == 'd')
|
|
RuntimeLibrary = rtMultiThreadedDebugDLL;
|
|
break;
|
|
} else if(second == 'L') {
|
|
RuntimeLibrary = rtSingleThreaded;
|
|
if(third == 'd')
|
|
RuntimeLibrary = rtSingleThreadedDebug;
|
|
break;
|
|
} else if(second == 'T') {
|
|
RuntimeLibrary = rtMultiThreaded;
|
|
if(third == 'd')
|
|
RuntimeLibrary = rtMultiThreadedDebug;
|
|
break;
|
|
} else if (second == 'P') {
|
|
if (config->CompilerVersion >= NET2010) {
|
|
MultiProcessorCompilation = _True;
|
|
MultiProcessorCompilationProcessorCount = option+3;
|
|
} else if (config->CompilerVersion >= NET2005) {
|
|
AdditionalOptions += option;
|
|
} else {
|
|
warn_msg(WarnLogic, "/MP option is not supported in Visual C++ < 2005, ignoring.");
|
|
}
|
|
break;
|
|
}
|
|
found = false; break;
|
|
case 'O':
|
|
switch (second) {
|
|
case '1':
|
|
Optimization = optimizeMinSpace;
|
|
break;
|
|
case '2':
|
|
Optimization = optimizeMaxSpeed;
|
|
break;
|
|
case 'a':
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 'b':
|
|
if(third == '0')
|
|
InlineFunctionExpansion = expandDisable;
|
|
else if(third == '1')
|
|
InlineFunctionExpansion = expandOnlyInline;
|
|
else if(third == '2')
|
|
InlineFunctionExpansion = expandAnySuitable;
|
|
else
|
|
found = false;
|
|
break;
|
|
case 'd':
|
|
Optimization = optimizeDisabled;
|
|
break;
|
|
case 'g':
|
|
GlobalOptimizations = _True;
|
|
break;
|
|
case 'i':
|
|
EnableIntrinsicFunctions = _True;
|
|
break;
|
|
case 'p':
|
|
ImproveFloatingPointConsistency = _True;
|
|
if(third == '-')
|
|
ImproveFloatingPointConsistency = _False;
|
|
break;
|
|
case 's':
|
|
FavorSizeOrSpeed = favorSize;
|
|
break;
|
|
case 't':
|
|
FavorSizeOrSpeed = favorSpeed;
|
|
break;
|
|
case 'w':
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 'x':
|
|
Optimization = optimizeFull;
|
|
break;
|
|
case 'y':
|
|
OmitFramePointers = _True;
|
|
if(third == '-')
|
|
OmitFramePointers = _False;
|
|
break;
|
|
default:
|
|
found = false; break;
|
|
}
|
|
break;
|
|
case 'P':
|
|
GeneratePreprocessedFile = preprocessYes;
|
|
break;
|
|
case 'Q':
|
|
if(second == 'I') {
|
|
AdditionalOptions += option;
|
|
break;
|
|
} else if (second == 'R') {
|
|
QString opt = option + 3;
|
|
if (opt == "interwork-return") {
|
|
InterworkCalls = _True;
|
|
break;
|
|
} else if (opt == "arch4") {
|
|
CompileForArchitecture = archArmv4;
|
|
break;
|
|
} else if (opt == "arch5") {
|
|
CompileForArchitecture = archArmv5;
|
|
break;
|
|
} else if (opt == "arch4T") {
|
|
CompileForArchitecture = archArmv4T;
|
|
break;
|
|
} else if (opt == "arch5T") {
|
|
CompileForArchitecture = archArmv5T;
|
|
break;
|
|
}
|
|
} else if (second == 'M') {
|
|
QString opt = option + 3;
|
|
if (opt == "mips1") {
|
|
CompileForArchitecture = archMips1;
|
|
break;
|
|
}
|
|
else if (opt == "mips2") {
|
|
CompileForArchitecture = archMips2;
|
|
break;
|
|
}
|
|
else if (opt == "mips3") {
|
|
CompileForArchitecture = archMips3;
|
|
break;
|
|
}
|
|
else if (opt == "mips4") {
|
|
CompileForArchitecture = archMips4;
|
|
break;
|
|
}
|
|
else if (opt == "mips5") {
|
|
CompileForArchitecture = archMips5;
|
|
break;
|
|
}
|
|
else if (opt == "mips16") {
|
|
CompileForArchitecture = archMips16;
|
|
break;
|
|
}
|
|
else if (opt == "mips32") {
|
|
CompileForArchitecture = archMips32;
|
|
break;
|
|
}
|
|
else if (opt == "mips64") {
|
|
CompileForArchitecture = archMips64;
|
|
break;
|
|
}
|
|
}
|
|
found = false; break;
|
|
case 'R':
|
|
if(second == 'T' && third == 'C') {
|
|
int rtc = BasicRuntimeChecks;
|
|
for (size_t i = 4; option[i]; ++i) {
|
|
if (!parseRuntimeCheckOption(option[i], &rtc)) {
|
|
found = false;
|
|
break;
|
|
}
|
|
}
|
|
BasicRuntimeChecks = static_cast<basicRuntimeCheckOption>(rtc);
|
|
}
|
|
break;
|
|
case 'T':
|
|
if(second == 'C') {
|
|
CompileAs = compileAsC;
|
|
} else if(second == 'P') {
|
|
CompileAs = compileAsCPlusPlus;
|
|
} else {
|
|
qWarning("Generator: Options '/Tp<filename>' and '/Tc<filename>' are not supported by qmake");
|
|
found = false; break;
|
|
}
|
|
break;
|
|
case 'U':
|
|
UndefinePreprocessorDefinitions += option+2;
|
|
break;
|
|
case 'V':
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 'W':
|
|
switch (second) {
|
|
case 'a':
|
|
case '4':
|
|
WarningLevel = warningLevel_4;
|
|
break;
|
|
case '3':
|
|
WarningLevel = warningLevel_3;
|
|
break;
|
|
case '2':
|
|
WarningLevel = warningLevel_2;
|
|
break;
|
|
case '1':
|
|
WarningLevel = warningLevel_1;
|
|
break;
|
|
case '0':
|
|
WarningLevel = warningLevel_0;
|
|
break;
|
|
case 'L':
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 'X':
|
|
WarnAsError = _True;
|
|
break;
|
|
case 'p':
|
|
if(third == '6' && fourth == '4') {
|
|
if (config->CompilerVersion >= NET2010) {
|
|
// Deprecated for VS2010 but can be used under Additional Options.
|
|
AdditionalOptions += option;
|
|
} else {
|
|
Detect64BitPortabilityProblems = _True;
|
|
}
|
|
break;
|
|
}
|
|
// Fallthrough
|
|
default:
|
|
found = false; break;
|
|
}
|
|
break;
|
|
case 'X':
|
|
IgnoreStandardIncludePath = _True;
|
|
break;
|
|
case 'Y':
|
|
switch (second) {
|
|
case '\0':
|
|
case '-':
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 'X':
|
|
UsePrecompiledHeader = pchGenerateAuto;
|
|
PrecompiledHeaderThrough = option+3;
|
|
break;
|
|
case 'c':
|
|
UsePrecompiledHeader = pchCreateUsingSpecific;
|
|
PrecompiledHeaderThrough = option+3;
|
|
break;
|
|
case 'd':
|
|
case 'l':
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 'u':
|
|
UsePrecompiledHeader = pchUseUsingSpecific;
|
|
PrecompiledHeaderThrough = option+3;
|
|
break;
|
|
default:
|
|
found = false; break;
|
|
}
|
|
break;
|
|
case 'Z':
|
|
switch (second) {
|
|
case '7':
|
|
DebugInformationFormat = debugOldStyleInfo;
|
|
break;
|
|
case 'I':
|
|
DebugInformationFormat = debugEditAndContinue;
|
|
break;
|
|
case 'd':
|
|
DebugInformationFormat = debugLineInfoOnly;
|
|
break;
|
|
case 'i':
|
|
DebugInformationFormat = debugEnabled;
|
|
break;
|
|
case 'l':
|
|
OmitDefaultLibName = _True;
|
|
break;
|
|
case 'a':
|
|
DisableLanguageExtensions = _True;
|
|
break;
|
|
case 'e':
|
|
DisableLanguageExtensions = _False;
|
|
break;
|
|
case 'c':
|
|
if(third == ':') {
|
|
const char *c = option + 4;
|
|
// Go to the end of the option
|
|
while ( *c != '\0' && *c != ' ' && *c != '-')
|
|
++c;
|
|
if(fourth == 'f')
|
|
ForceConformanceInForLoopScope = ((*c) == '-' ? _False : _True);
|
|
else if(fourth == 'w')
|
|
TreatWChar_tAsBuiltInType = ((*c) == '-' ? _False : _True);
|
|
else
|
|
AdditionalOptions += option;
|
|
} else {
|
|
found = false; break;
|
|
}
|
|
break;
|
|
case 'g':
|
|
case 'm':
|
|
case 's':
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 'p':
|
|
switch (third)
|
|
{
|
|
case '\0':
|
|
case '1':
|
|
StructMemberAlignment = alignSingleByte;
|
|
if(fourth == '6')
|
|
StructMemberAlignment = alignSixteenBytes;
|
|
break;
|
|
case '2':
|
|
StructMemberAlignment = alignTwoBytes;
|
|
break;
|
|
case '4':
|
|
StructMemberAlignment = alignFourBytes;
|
|
break;
|
|
case '8':
|
|
StructMemberAlignment = alignEightBytes;
|
|
break;
|
|
default:
|
|
found = false; break;
|
|
}
|
|
break;
|
|
case 'W':
|
|
if (third == '-')
|
|
CompileAsWinRT = _False;
|
|
else
|
|
CompileAsWinRT = _True;
|
|
break;
|
|
default:
|
|
found = false; break;
|
|
}
|
|
break;
|
|
case 'a':
|
|
if (second == 'r' && third == 'c' && fourth == 'h') {
|
|
if (option[5] == ':') {
|
|
const char *o = option;
|
|
if (o[6] == 'S' && o[7] == 'S' && o[8] == 'E') {
|
|
EnableEnhancedInstructionSet = o[9] == '2' ? archSSE2 : archSSE;
|
|
break;
|
|
}
|
|
}
|
|
} else if (second == 'n' && third == 'a' && fourth == 'l') {
|
|
EnablePREfast = _True;
|
|
break;
|
|
}
|
|
found = false;
|
|
break;
|
|
case 'b': // see http://msdn2.microsoft.com/en-us/library/ms173499.aspx
|
|
if (second == 'i' && third == 'g' && fourth == 'o') {
|
|
const char *o = option;
|
|
if (o[5] == 'b' && o[6] == 'j') {
|
|
AdditionalOptions += option;
|
|
break;
|
|
}
|
|
}
|
|
found = false;
|
|
break;
|
|
case 'c':
|
|
if(second == '\0') {
|
|
CompileOnly = _True;
|
|
} else if(second == 'l') {
|
|
if (config->CompilerVersion < NET2005) {
|
|
if(*(option+5) == 'n') {
|
|
CompileAsManaged = managedAssemblyPure;
|
|
TurnOffAssemblyGeneration = _True;
|
|
} else if(*(option+5) == 'p') {
|
|
CompileAsManaged = managedAssemblyPure;
|
|
warn_msg(WarnLogic, "/clr:pure option only for .NET >= 2005, using /clr");
|
|
} else if(*(option+5) == 's') {
|
|
CompileAsManaged = managedAssemblyPure;
|
|
warn_msg(WarnLogic, "/clr:safe option only for .NET >= 2005, using /clr");
|
|
} else if(*(option+5) == 'o') {
|
|
CompileAsManaged = managedAssemblyPure;
|
|
warn_msg(WarnLogic, "/clr:oldSyntax option only for .NET >= 2005, using /clr");
|
|
} else if(*(option+5) == 'i') {
|
|
CompileAsManaged = managedAssemblyPure;
|
|
warn_msg(WarnLogic, "initialAppDomain enum value unknown, using /crl");
|
|
} else {
|
|
CompileAsManaged = managedAssemblyPure;
|
|
}
|
|
} else {
|
|
if(*(option+5) == 'n') {
|
|
CompileAsManaged = managedAssembly;
|
|
TurnOffAssemblyGeneration = _True;
|
|
} else if(*(option+5) == 'p') {
|
|
CompileAsManaged = managedAssemblyPure;
|
|
} else if(*(option+5) == 's') {
|
|
CompileAsManaged = managedAssemblySafe;
|
|
} else if(*(option+5) == 'o') {
|
|
CompileAsManaged = managedAssemblyOldSyntax;
|
|
} else if(*(option+5) == 'i') {
|
|
CompileAsManaged = managedAssembly;
|
|
warn_msg(WarnLogic, "initialAppDomain enum value unknown, using /crl default");
|
|
} else {
|
|
CompileAsManaged = managedAssembly;
|
|
}
|
|
}
|
|
} else {
|
|
found = false; break;
|
|
}
|
|
break;
|
|
case 'd':
|
|
if (second == 'r') {
|
|
CompileAsManaged = managedAssembly;
|
|
break;
|
|
} else if (second != 'o' && third == 'c') {
|
|
GenerateXMLDocumentationFiles = _True;
|
|
XMLDocumentationFileName += option+4;
|
|
break;
|
|
}
|
|
found = false;
|
|
break;
|
|
case 'e':
|
|
if (second == 'r' && third == 'r' && fourth == 'o') {
|
|
if (option[12] == ':') {
|
|
if ( option[13] == 'n') {
|
|
ErrorReporting = "None";
|
|
} else if (option[13] == 'p') {
|
|
ErrorReporting = "Prompt";
|
|
} else if (option[13] == 'q') {
|
|
ErrorReporting = "Queue";
|
|
} else if (option[13] == 's') {
|
|
ErrorReporting = "Send";
|
|
} else {
|
|
found = false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
found = false;
|
|
break;
|
|
case 'f':
|
|
if(second == 'p' && third == ':') {
|
|
// Go to the end of the option
|
|
const char *c = option + 4;
|
|
while (*c != '\0' && *c != ' ' && *c != '-')
|
|
++c;
|
|
switch (fourth) {
|
|
case 'e':
|
|
FloatingPointExceptions = ((*c) == '-' ? _False : _True);
|
|
break;
|
|
case 'f':
|
|
FloatingPointModel = floatingPointFast;
|
|
break;
|
|
case 'p':
|
|
FloatingPointModel = floatingPointPrecise;
|
|
break;
|
|
case 's':
|
|
FloatingPointModel = floatingPointStrict;
|
|
break;
|
|
default:
|
|
found = false;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 'n':
|
|
if(second == 'o' && third == 'B' && fourth == 'o') {
|
|
AdditionalOptions += "/noBool";
|
|
break;
|
|
}
|
|
if(second == 'o' && third == 'l' && fourth == 'o') {
|
|
SuppressStartupBanner = _True;
|
|
break;
|
|
}
|
|
found = false; break;
|
|
case 'o':
|
|
{
|
|
const char *str = option + 2;
|
|
const size_t len = strlen(str);
|
|
if (len >= 5 && len <= 6 && strncmp(str, "penmp", 5) == 0) {
|
|
if (len == 5) {
|
|
OpenMP = _True;
|
|
break;
|
|
} else if (str[5] == '-') {
|
|
OpenMP = _False;
|
|
break;
|
|
}
|
|
}
|
|
found = false; break;
|
|
}
|
|
case 's':
|
|
if(second == 'h' && third == 'o' && fourth == 'w') {
|
|
ShowIncludes = _True;
|
|
break;
|
|
}
|
|
if (strlen(option) > 8 && second == 't' && third == 'd') {
|
|
const QString version = option + 8;
|
|
static const QStringList knownVersions = { "14", "17", "latest" };
|
|
if (knownVersions.contains(version)) {
|
|
LanguageStandard = "stdcpp" + version;
|
|
break;
|
|
}
|
|
}
|
|
found = false; break;
|
|
case 'u':
|
|
if (!second)
|
|
UndefineAllPreprocessorDefinitions = _True;
|
|
else if (strcmp(option + 2, "tf-8") == 0)
|
|
AdditionalOptions += option;
|
|
else
|
|
found = false;
|
|
break;
|
|
case 'v':
|
|
if(second == 'd' || second == 'm') {
|
|
AdditionalOptions += option;
|
|
break;
|
|
}
|
|
found = false; break;
|
|
case 'w':
|
|
switch (second) {
|
|
case '\0':
|
|
WarningLevel = warningLevel_0;
|
|
break;
|
|
case 'd':
|
|
DisableSpecificWarnings += option+3;
|
|
break;
|
|
case 'e':
|
|
if (config->CompilerVersion <= NET2008)
|
|
AdditionalOptions += option;
|
|
else
|
|
TreatSpecificWarningsAsErrors += option + 3;
|
|
break;
|
|
default:
|
|
AdditionalOptions += option;
|
|
}
|
|
break;
|
|
default:
|
|
AdditionalOptions += option;
|
|
break;
|
|
}
|
|
if(!found) {
|
|
if (!config->suppressUnknownOptionWarnings)
|
|
unknownOptionWarning("Compiler", option);
|
|
AdditionalOptions += option;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool VCCLCompilerTool::parseRuntimeCheckOption(char c, int *rtc)
|
|
{
|
|
if (c == '1')
|
|
*rtc = runtimeBasicCheckAll;
|
|
else if (c == 'c')
|
|
SmallerTypeCheck = _True;
|
|
else if (c == 's')
|
|
*rtc |= runtimeCheckStackFrame;
|
|
else if (c == 'u')
|
|
*rtc |= runtimeCheckUninitVariables;
|
|
else
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
// VCLinkerTool -----------------------------------------------------
|
|
VCLinkerTool::VCLinkerTool()
|
|
: DataExecutionPrevention(unset),
|
|
EnableCOMDATFolding(optFoldingDefault),
|
|
GenerateDebugInformation(unset),
|
|
DebugInfoOption(linkerDebugOptionNone),
|
|
GenerateMapFile(unset),
|
|
HeapCommitSize(-1),
|
|
HeapReserveSize(-1),
|
|
IgnoreAllDefaultLibraries(unset),
|
|
IgnoreEmbeddedIDL(unset),
|
|
IgnoreImportLibrary(_True),
|
|
ImageHasSafeExceptionHandlers(unset),
|
|
LargeAddressAware(addrAwareDefault),
|
|
LinkDLL(unset),
|
|
LinkIncremental(linkIncrementalDefault),
|
|
LinkTimeCodeGeneration(optLTCGDefault),
|
|
MapExports(unset),
|
|
MapLines(unset),
|
|
OptimizeForWindows98(optWin98Default),
|
|
OptimizeReferences(optReferencesDefault),
|
|
RandomizedBaseAddress(unset),
|
|
RegisterOutput(unset),
|
|
ResourceOnlyDLL(unset),
|
|
SetChecksum(unset),
|
|
ShowProgress(linkProgressNotSet),
|
|
StackCommitSize(-1),
|
|
StackReserveSize(-1),
|
|
SubSystem(subSystemNotSet),
|
|
SupportUnloadOfDelayLoadedDLL(unset),
|
|
SuppressStartupBanner(unset),
|
|
SwapRunFromCD(unset),
|
|
SwapRunFromNet(unset),
|
|
TargetMachine(machineNotSet),
|
|
TerminalServerAware(termSvrAwareDefault),
|
|
TreatWarningsAsErrors(unset),
|
|
TurnOffAssemblyGeneration(unset),
|
|
TypeLibraryResourceID(0),
|
|
GenerateManifest(unset),
|
|
EnableUAC(unset),
|
|
UACUIAccess(unset),
|
|
SectionAlignment(-1),
|
|
PreventDllBinding(unset),
|
|
AllowIsolation(unset),
|
|
AssemblyDebug(unset),
|
|
CLRUnmanagedCodeCheck(unset),
|
|
DelaySign(unset),
|
|
GenerateWindowsMetadata(unset)
|
|
{
|
|
}
|
|
|
|
// Hashing routine to do fast option lookups ----
|
|
// Slightly rewritten to stop on ':' ',' and '\0'
|
|
// Original routine in qtranslator.cpp ----------
|
|
static uint elfHash(const char* name)
|
|
{
|
|
const uchar *k;
|
|
uint h = 0;
|
|
uint g;
|
|
|
|
if(name) {
|
|
k = (const uchar *) name;
|
|
while((*k) &&
|
|
(*k)!= ':' &&
|
|
(*k)!=',' &&
|
|
(*k)!=' ') {
|
|
h = (h << 4) + *k++;
|
|
if((g = (h & 0xf0000000)) != 0)
|
|
h ^= g >> 24;
|
|
h &= ~g;
|
|
}
|
|
}
|
|
if(!h)
|
|
h = 1;
|
|
return h;
|
|
}
|
|
|
|
//#define USE_DISPLAY_HASH
|
|
#ifdef USE_DISPLAY_HASH
|
|
static void displayHash(const char* str)
|
|
{
|
|
printf("case 0x%07x: // %s\n break;\n", elfHash(str), str);
|
|
}
|
|
#endif
|
|
|
|
bool VCLinkerTool::parseOption(const char* option)
|
|
{
|
|
#ifdef USE_DISPLAY_HASH
|
|
// Main options
|
|
displayHash("/ALIGN"); displayHash("/ALLOWBIND"); displayHash("/ASSEMBLYMODULE");
|
|
displayHash("/ASSEMBLYRESOURCE"); displayHash("/BASE"); displayHash("/DEBUG");
|
|
displayHash("/DEF"); displayHash("/DEFAULTLIB"); displayHash("/DELAY");
|
|
displayHash("/DELAYLOAD"); displayHash("/DLL"); displayHash("/DRIVER");
|
|
displayHash("/ENTRY"); displayHash("/EXETYPE"); displayHash("/EXPORT");
|
|
displayHash("/FIXED"); displayHash("/FORCE"); displayHash("/HEAP");
|
|
displayHash("/IDLOUT"); displayHash("/IGNORE"); displayHash("/IGNOREIDL"); displayHash("/IMPLIB");
|
|
displayHash("/INCLUDE"); displayHash("/INCREMENTAL"); displayHash("/LARGEADDRESSAWARE");
|
|
displayHash("/LIBPATH"); displayHash("/LTCG"); displayHash("/MACHINE");
|
|
displayHash("/MAP"); displayHash("/MAPINFO"); displayHash("/MERGE");
|
|
displayHash("/MIDL"); displayHash("/NOASSEMBLY"); displayHash("/NODEFAULTLIB");
|
|
displayHash("/NOENTRY"); displayHash("/NOLOGO"); displayHash("/OPT");
|
|
displayHash("/ORDER"); displayHash("/OUT"); displayHash("/PDB");
|
|
displayHash("/PDBSTRIPPED"); displayHash("/RELEASE"); displayHash("/SECTION");
|
|
displayHash("/STACK"); displayHash("/STUB"); displayHash("/SUBSYSTEM");
|
|
displayHash("/SWAPRUN"); displayHash("/TLBID"); displayHash("/TLBOUT");
|
|
displayHash("/TSAWARE"); displayHash("/VERBOSE"); displayHash("/VERSION");
|
|
displayHash("/VXD"); displayHash("/WS "); displayHash("/libpath");
|
|
displayHash("/WINMD"); displayHash("/WINMDFILE:");
|
|
|
|
#endif
|
|
#ifdef USE_DISPLAY_HASH
|
|
// Sub options
|
|
displayHash("UNLOAD"); displayHash("NOBIND"); displayHash("no"); displayHash("NOSTATUS"); displayHash("STATUS");
|
|
displayHash("AM33"); displayHash("ARM"); displayHash("CEE"); displayHash("EBC"); displayHash("IA64"); displayHash("X86"); displayHash("X64"); displayHash("M32R");
|
|
displayHash("MIPS"); displayHash("MIPS16"); displayHash("MIPSFPU"); displayHash("MIPSFPU16"); displayHash("MIPSR41XX"); displayHash("PPC");
|
|
displayHash("SH3"); displayHash("SH3DSP"); displayHash("SH4"); displayHash("SH5"); displayHash("THUMB"); displayHash("TRICORE"); displayHash("EXPORTS");
|
|
displayHash("LINES"); displayHash("REF"); displayHash("NOREF"); displayHash("ICF"); displayHash("WIN98"); displayHash("NOWIN98");
|
|
displayHash("CONSOLE"); displayHash("EFI_APPLICATION"); displayHash("EFI_BOOT_SERVICE_DRIVER"); displayHash("EFI_ROM"); displayHash("EFI_RUNTIME_DRIVER"); displayHash("NATIVE");
|
|
displayHash("POSIX"); displayHash("WINDOWS"); displayHash("WINDOWSCE"); displayHash("NET"); displayHash("CD"); displayHash("NO");
|
|
#endif
|
|
bool found = true;
|
|
const uint optionHash = elfHash(option);
|
|
if (config->CompilerVersion < NET2010) {
|
|
switch (optionHash) {
|
|
case 0x3360dbe: // /ALIGN[:number]
|
|
case 0x1485c34: // /ALLOWBIND[:NO]
|
|
case 0x33aec94: // /FIXED[:NO]
|
|
case 0x7988f7e: // /SECTION:name,[E][R][W][S][D][K][L][P][X][,ALIGN=#]
|
|
case 0x0348992: // /STUB:filename
|
|
AdditionalOptions += option;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
switch (optionHash) {
|
|
case 0x6b21972: // /DEFAULTLIB:library
|
|
case 0x396ea92: // /DRIVER[:UPONLY | :WDM]
|
|
case 0xaca9d75: // /EXETYPE[:DYNAMIC | :DEV386]
|
|
case 0x3ad5444: // /EXPORT:entryname[,@ordinal[,NONAME]][,DATA]
|
|
case 0x33b4675: // /FORCE:[MULTIPLE|UNRESOLVED]
|
|
case 0x3dc3455: // /IGNORE:number,number,number,number ### NOTE: This one is undocumented, but it is even used by Microsoft.
|
|
// In recent versions of the Microsoft linker they have disabled this undocumented feature.
|
|
case 0x0034bc4: // /VXD
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 0x3360dbe: // /ALIGN[:number]
|
|
SectionAlignment = QString(option+7).toLongLong();
|
|
break;
|
|
case 0x1485c34: // /ALLOWBIND[:NO]
|
|
if(*(option+10) == ':' && (*(option+11) == 'n' || *(option+11) == 'N'))
|
|
PreventDllBinding = _False;
|
|
else
|
|
PreventDllBinding = _True;
|
|
break;
|
|
case 0x312011e: // /ALLOWISOLATION[:NO]
|
|
if(*(option+15) == ':' && (*(option+16) == 'n' || *(option+16) == 'N'))
|
|
AllowIsolation = _False;
|
|
else
|
|
AllowIsolation = _True;
|
|
break;
|
|
case 0x679c075: // /ASSEMBLYMODULE:filename
|
|
AddModuleNamesToAssembly += option+15;
|
|
break;
|
|
case 0x75f35f7: // /ASSEMBLYDEBUG[:DISABLE]
|
|
if(*(option+14) == ':' && (*(option+15) == 'D'))
|
|
AssemblyDebug = _False;
|
|
else
|
|
AssemblyDebug = _True;
|
|
break;
|
|
case 0x43294a5: // /ASSEMBLYLINKRESOURCE:filename
|
|
AssemblyLinkResource += option+22;
|
|
break;
|
|
case 0x062d065: // /ASSEMBLYRESOURCE:filename
|
|
LinkToManagedResourceFile = option+18;
|
|
break;
|
|
case 0x0336675: // /BASE:{address | @filename,key}
|
|
// Do we need to do a manual lookup when '@filename,key'?
|
|
// Seems BaseAddress only can contain the location...
|
|
// We don't use it in Qt, so keep it simple for now
|
|
BaseAddress = option+6;
|
|
break;
|
|
case 0x63bf065: // /CLRIMAGETYPE:{IJW|PURE|SAFE}
|
|
if(*(option+14) == 'I')
|
|
CLRImageType = "ForceIJWImage";
|
|
else if(*(option+14) == 'P')
|
|
CLRImageType = "ForcePureILImage";
|
|
else if(*(option+14) == 'S')
|
|
CLRImageType = "ForceSafeILImage";
|
|
break;
|
|
case 0x5f2a6a2: // /CLRSUPPORTLASTERROR{:NO | SYSTEMDLL}
|
|
if(*(option+20) == ':') {
|
|
if(*(option+21) == 'N') {
|
|
CLRSupportLastError = "Disabled";
|
|
} else if(*(option+21) == 'S') {
|
|
CLRSupportLastError = "SystemDlls";
|
|
}
|
|
} else {
|
|
CLRSupportLastError = "Enabled";
|
|
}
|
|
break;
|
|
case 0xc7984f5: // /CLRTHREADATTRIBUTE:{STA|MTA|NONE}
|
|
if(*(option+20) == 'N')
|
|
CLRThreadAttribute = "DefaultThreadingAttribute";
|
|
else if(*(option+20) == 'M')
|
|
CLRThreadAttribute = "MTAThreadingAttribute";
|
|
else if(*(option+20) == 'S')
|
|
CLRThreadAttribute = "STAThreadingAttribute";
|
|
break;
|
|
case 0xa8c637b: // /CLRUNMANAGEDCODECHECK[:NO]
|
|
if(*(option+23) == 'N')
|
|
CLRUnmanagedCodeCheck = _False;
|
|
else
|
|
CLRUnmanagedCodeCheck = _True;
|
|
break;
|
|
case 0x62d9e94: // /MANIFEST[:NO]
|
|
if ((*(option+9) == ':' && (*(option+10) == 'N' || *(option+10) == 'n')))
|
|
GenerateManifest = _False;
|
|
else
|
|
GenerateManifest = _True;
|
|
break;
|
|
case 0x34be314: // /WINMD[:NO]
|
|
if ((*(option+6) == ':' && (*(option+7) == 'N' || *(option+7) == 'n')))
|
|
GenerateWindowsMetadata = _False;
|
|
else
|
|
GenerateWindowsMetadata = _True;
|
|
break;
|
|
case 0x31be7e5: // /WINMDFILE:filename
|
|
WindowsMetadataFile = option+11;
|
|
break;
|
|
case 0x8b64559: // /MANIFESTDEPENDENCY:manifest_dependency
|
|
AdditionalManifestDependencies += option+20;
|
|
break;
|
|
case 0xe9e8195: // /MANIFESTFILE:filename
|
|
ManifestFile = option+14;
|
|
break;
|
|
case 0x9e9fb83: // /MANIFESTUAC http://msdn.microsoft.com/en-us/library/bb384691%28VS.100%29.aspx
|
|
if ((*(option+12) == ':' && (*(option+13) == 'N' || *(option+13) == 'n')))
|
|
EnableUAC = _False;
|
|
else if((*(option+12) == ':' && (*(option+13) == 'l' || *(option+14) == 'e'))) { // level
|
|
if(*(option+20) == 'a')
|
|
UACExecutionLevel = "AsInvoker";
|
|
else if(*(option+20) == 'h')
|
|
UACExecutionLevel = "HighestAvailable";
|
|
else if(*(option+20) == 'r')
|
|
UACExecutionLevel = "RequireAdministrator";
|
|
} else if((*(option+12) == ':' && (*(option+13) == 'u' || *(option+14) == 'i'))) { // uiAccess
|
|
if(*(option+22) == 't')
|
|
UACUIAccess = _True;
|
|
else
|
|
UACUIAccess = _False;
|
|
} else if((*(option+12) == ':' && (*(option+13) == 'f' || *(option+14) == 'r'))) { // fragment
|
|
AdditionalOptions += option;
|
|
}else
|
|
EnableUAC = _True;
|
|
break;
|
|
case 0x3389797: // /DEBUG[:FASTLINK]
|
|
GenerateDebugInformation = _True;
|
|
if (config->CompilerVersion >= NET2015 && strcmp(option + 7, "FASTLINK") == 0)
|
|
DebugInfoOption = linkerDebugOptionFastLink;
|
|
break;
|
|
case 0x0033896: // /DEF:filename
|
|
ModuleDefinitionFile = option+5;
|
|
break;
|
|
case 0x338a069: // /DELAY:{UNLOAD | NOBIND}
|
|
// MS documentation does not specify what to do with
|
|
// this option, so we'll put it in AdditionalOptions
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 0x06f4bf4: // /DELAYLOAD:dllname
|
|
DelayLoadDLLs += option+11;
|
|
break;
|
|
case 0x06d451e: // /DELAYSIGN[:NO]
|
|
if(*(option+10) == ':' && (*(option+11) == 'n' || *(option+11) == 'N'))
|
|
DelaySign = _False;
|
|
else
|
|
DelaySign = _True;
|
|
break;
|
|
case 0x003390c: // /DLL
|
|
// This option is not used for vcproj files
|
|
break;
|
|
case 0x2ee8415: // /DYNAMICBASE[:NO]
|
|
if(*(option+12) == ':' && (*(option+13) == 'n' || *(option+13) == 'N'))
|
|
RandomizedBaseAddress = _False;
|
|
else
|
|
RandomizedBaseAddress = _True;
|
|
break;
|
|
case 0x33a3979: // /ENTRY:function
|
|
EntryPointSymbol = option+7;
|
|
break;
|
|
case 0x4504334: // /ERRORREPORT:[ NONE | PROMPT | QUEUE | SEND ]
|
|
if(*(option+12) == ':' ) {
|
|
if(*(option+13) == 'N')
|
|
LinkErrorReporting = "NoErrorReport";
|
|
else if(*(option+13) == 'P')
|
|
LinkErrorReporting = "PromptImmediately";
|
|
else if(*(option+13) == 'Q')
|
|
LinkErrorReporting = "QueueForNextLogin";
|
|
else if(*(option+13) == 'S')
|
|
LinkErrorReporting = "SendErrorReport";
|
|
}
|
|
break;
|
|
case 0x033c960: // /HEAP:reserve[,commit]
|
|
{
|
|
QStringList both = QString(option+6).split(",");
|
|
HeapReserveSize = both[0].toLongLong();
|
|
if(both.count() == 2)
|
|
HeapCommitSize = both[1].toLongLong();
|
|
}
|
|
break;
|
|
case 0x3d91494: // /IDLOUT:[path\]filename
|
|
MergedIDLBaseFileName = option+8;
|
|
break;
|
|
case 0x345a04c: // /IGNOREIDL
|
|
IgnoreEmbeddedIDL = _True;
|
|
break;
|
|
case 0x3e250e2: // /IMPLIB:filename
|
|
ImportLibrary = option+8;
|
|
break;
|
|
case 0xe281ab5: // /INCLUDE:symbol
|
|
ForceSymbolReferences += option+9;
|
|
break;
|
|
case 0xb28103c: // /INCREMENTAL[:no]
|
|
if(*(option+12) == ':' &&
|
|
(*(option+13) == 'n' || *(option+13) == 'N'))
|
|
LinkIncremental = linkIncrementalNo;
|
|
else
|
|
LinkIncremental = linkIncrementalYes;
|
|
break;
|
|
case 0x07f1ab2: // /KEYCONTAINER:name
|
|
KeyContainer = option+14;
|
|
break;
|
|
case 0xfadaf35: // /KEYFILE:filename
|
|
KeyFile = option+9;
|
|
break;
|
|
case 0x26e4675: // /LARGEADDRESSAWARE[:no]
|
|
if(*(option+18) == ':' &&
|
|
*(option+19) == 'n')
|
|
LargeAddressAware = addrAwareNoLarge;
|
|
else
|
|
LargeAddressAware = addrAwareLarge;
|
|
break;
|
|
case 0x2f96bc8: // /libpath:dir
|
|
case 0x0d745c8: // /LIBPATH:dir
|
|
AdditionalLibraryDirectories += option+9;
|
|
break;
|
|
case 0x0341877: // /LTCG[:NOSTATUS|:STATUS]
|
|
config->WholeProgramOptimization = _True;
|
|
if (config->CompilerVersion >= NET2005) {
|
|
LinkTimeCodeGeneration = optLTCGEnabled;
|
|
if(*(option+5) == ':') {
|
|
const char* str = option+6;
|
|
if (*str == 'S')
|
|
ShowProgress = linkProgressAll;
|
|
else if (qstricmp(str, "pginstrument") == 0)
|
|
LinkTimeCodeGeneration = optLTCGInstrument;
|
|
else if (qstricmp(str, "pgoptimize") == 0)
|
|
LinkTimeCodeGeneration = optLTCGOptimize;
|
|
else if (qstricmp(str, "pgupdate") == 0)
|
|
LinkTimeCodeGeneration = optLTCGUpdate;
|
|
}
|
|
} else {
|
|
AdditionalOptions.append(option);
|
|
}
|
|
break;
|
|
case 0x379ED25:
|
|
case 0x157cf65: // /MACHINE:{AM33|ARM|CEE|IA64|X86|M32R|MIPS|MIPS16|MIPSFPU|MIPSFPU16|MIPSR41XX|PPC|SH3|SH4|SH5|THUMB|TRICORE}
|
|
switch (elfHash(option+9)) {
|
|
// Very limited documentation on all options but X86,
|
|
case 0x0005bb6: // X86
|
|
TargetMachine = machineX86;
|
|
break;
|
|
case 0x0005b94: // X64
|
|
TargetMachine = machineX64;
|
|
break;
|
|
// so we put the others in AdditionalOptions...
|
|
case 0x0046063: // AM33
|
|
case 0x000466d: // ARM
|
|
case 0x0004795: // CEE
|
|
case 0x0004963: // EBC
|
|
case 0x004d494: // IA64
|
|
case 0x0050672: // M32R
|
|
case 0x0051e53: // MIPS
|
|
case 0x51e5646: // MIPS16
|
|
case 0x1e57b05: // MIPSFPU
|
|
case 0x57b09a6: // MIPSFPU16
|
|
case 0x5852738: // MIPSR41XX
|
|
case 0x0005543: // PPC
|
|
case 0x00057b3: // SH3
|
|
case 0x57b7980: // SH3DSP
|
|
case 0x00057b4: // SH4
|
|
case 0x00057b5: // SH5
|
|
case 0x058da12: // THUMB
|
|
case 0x96d8435: // TRICORE
|
|
default:
|
|
AdditionalOptions += option;
|
|
break;
|
|
}
|
|
break;
|
|
case 0x0034160: // /MAP[:filename]
|
|
GenerateMapFile = _True;
|
|
if (option[4] == ':')
|
|
MapFileName = option+5;
|
|
break;
|
|
case 0x164e1ef: // /MAPINFO:{EXPORTS|LINES}
|
|
if(*(option+9) == 'E')
|
|
MapExports = _True;
|
|
else if(*(option+9) == 'L')
|
|
MapLines = _True;
|
|
break;
|
|
case 0x341a6b5: // /MERGE:from=to
|
|
MergeSections = option+7;
|
|
break;
|
|
case 0x0341d8c: // /MIDL:@file
|
|
MidlCommandFile = option+7;
|
|
break;
|
|
case 0x84e2679: // /NOASSEMBLY
|
|
TurnOffAssemblyGeneration = _True;
|
|
break;
|
|
case 0x2b21942: // /NODEFAULTLIB[:library]
|
|
if(*(option+13) == '\0')
|
|
IgnoreAllDefaultLibraries = _True;
|
|
else
|
|
IgnoreDefaultLibraryNames += option+14;
|
|
break;
|
|
case 0x33a3a39: // /NOENTRY
|
|
ResourceOnlyDLL = _True;
|
|
break;
|
|
case 0x434138f: // /NOLOGO
|
|
SuppressStartupBanner = _True;
|
|
break;
|
|
case 0xc841054: // /NXCOMPAT[:NO]
|
|
if ((*(option+9) == ':' && (*(option+10) == 'N' || *(option+10) == 'n')))
|
|
DataExecutionPrevention = _False;
|
|
else
|
|
DataExecutionPrevention = _True;
|
|
break;
|
|
case 0x0034454: // /OPT:{REF | NOREF | ICF[=iterations] | NOICF | WIN98 | NOWIN98}
|
|
{
|
|
char third = *(option+7);
|
|
switch (third) {
|
|
case 'F': // REF
|
|
if(*(option+5) == 'R') {
|
|
OptimizeReferences = optReferences;
|
|
} else { // ICF[=iterations]
|
|
EnableCOMDATFolding = optFolding;
|
|
// [=iterations] case is not documented
|
|
}
|
|
break;
|
|
case 'R': // NOREF
|
|
OptimizeReferences = optNoReferences;
|
|
break;
|
|
case 'I': // NOICF
|
|
EnableCOMDATFolding = optNoFolding;
|
|
break;
|
|
case 'N': // WIN98
|
|
OptimizeForWindows98 = optWin98Yes;
|
|
break;
|
|
case 'W': // NOWIN98
|
|
OptimizeForWindows98 = optWin98No;
|
|
break;
|
|
default:
|
|
found = false;
|
|
}
|
|
}
|
|
break;
|
|
case 0x34468a2: // /ORDER:@filename
|
|
FunctionOrder = option+8;
|
|
break;
|
|
case 0x00344a4: // /OUT:filename
|
|
OutputFile = option+5;
|
|
break;
|
|
case 0x0034482: // /PDB:filename
|
|
ProgramDatabaseFile = option+5;
|
|
break;
|
|
case 0xa2ad314: // /PDBSTRIPPED:pdb_file_name
|
|
StripPrivateSymbols = option+13;
|
|
break;
|
|
case 0x6a09535: // /RELEASE
|
|
SetChecksum = _True;
|
|
break;
|
|
case 0x348857b: // /STACK:reserve[,commit]
|
|
{
|
|
QStringList both = QString(option+7).split(",");
|
|
StackReserveSize = both[0].toLongLong();
|
|
if(both.count() == 2)
|
|
StackCommitSize = both[1].toLongLong();
|
|
}
|
|
break;
|
|
case 0x75AA4D8: // /SAFESEH:{NO}
|
|
if (config->CompilerVersion >= NET2010)
|
|
ImageHasSafeExceptionHandlers = (option[8] == ':') ? _False : _True;
|
|
else
|
|
AdditionalOptions += option;
|
|
break;
|
|
case 0x9B3C00D:
|
|
case 0x78dc00d: // /SUBSYSTEM:{CONSOLE|EFI_APPLICATION|EFI_BOOT_SERVICE_DRIVER|EFI_ROM|EFI_RUNTIME_DRIVER|NATIVE|POSIX|WINDOWS|WINDOWSCE}[,major[.minor]]
|
|
{
|
|
// Split up in subsystem, and version number
|
|
QStringList both = QString(option+11).split(",");
|
|
switch (elfHash(both[0].toLatin1().constData())) {
|
|
case 0x8438445: // CONSOLE
|
|
SubSystem = subSystemConsole;
|
|
break;
|
|
case 0xbe29493: // WINDOWS
|
|
SubSystem = subSystemWindows;
|
|
break;
|
|
// The following are undocumented, so add them to AdditionalOptions
|
|
case 0x240949e: // EFI_APPLICATION
|
|
case 0xe617652: // EFI_BOOT_SERVICE_DRIVER
|
|
case 0x9af477d: // EFI_ROM
|
|
case 0xd34df42: // EFI_RUNTIME_DRIVER
|
|
case 0x5268ea5: // NATIVE
|
|
case 0x05547e8: // POSIX
|
|
case 0x2949c95: // WINDOWSCE
|
|
case 0x4B69795: // windowsce
|
|
AdditionalOptions += option;
|
|
break;
|
|
default:
|
|
found = false;
|
|
}
|
|
}
|
|
break;
|
|
case 0x8b654de: // /SWAPRUN:{NET | CD}
|
|
if(*(option+9) == 'N')
|
|
SwapRunFromNet = _True;
|
|
else if(*(option+9) == 'C')
|
|
SwapRunFromCD = _True;
|
|
else
|
|
found = false;
|
|
break;
|
|
case 0x34906d4: // /TLBID:id
|
|
TypeLibraryResourceID = QString(option+7).toLongLong();
|
|
break;
|
|
case 0x4907494: // /TLBOUT:[path\]filename
|
|
TypeLibraryFile = option+8;
|
|
break;
|
|
case 0x976b525: // /TSAWARE[:NO]
|
|
if(*(option+8) == ':')
|
|
TerminalServerAware = termSvrAwareNo;
|
|
else
|
|
TerminalServerAware = termSvrAwareYes;
|
|
break;
|
|
case 0xaa67735: // /VERBOSE[:lib]
|
|
if(*(option+9) == ':') {
|
|
ShowProgress = linkProgressLibs;
|
|
AdditionalOptions += option;
|
|
} else {
|
|
ShowProgress = linkProgressAll;
|
|
}
|
|
break;
|
|
case 0xaa77f7e: // /VERSION:major[.minor]
|
|
Version = option+9;
|
|
break;
|
|
case 0x0034c50: // /WS[:NO]
|
|
if (config->CompilerVersion >= NET2010) {
|
|
if(*(option+3) == ':')
|
|
TreatWarningsAsErrors = _False;
|
|
else
|
|
TreatWarningsAsErrors = _True;
|
|
} else {
|
|
AdditionalOptions += option;
|
|
}
|
|
break;
|
|
default:
|
|
AdditionalOptions += option;
|
|
break;
|
|
}
|
|
if(!found) {
|
|
if (!config->suppressUnknownOptionWarnings)
|
|
unknownOptionWarning("Linker", option);
|
|
AdditionalOptions += option;
|
|
}
|
|
return found;
|
|
}
|
|
|
|
// VCManifestTool ---------------------------------------------------
|
|
VCManifestTool::VCManifestTool()
|
|
: EmbedManifest(unset)
|
|
{
|
|
}
|
|
|
|
bool VCManifestTool::parseOption(const char *option)
|
|
{
|
|
Q_UNUSED(option);
|
|
// ### implement if we introduce QMAKE_MT_FLAGS
|
|
return false;
|
|
}
|
|
|
|
// VCMIDLTool -------------------------------------------------------
|
|
VCMIDLTool::VCMIDLTool()
|
|
: DefaultCharType(midlCharUnsigned),
|
|
EnableErrorChecks(midlDisableAll),
|
|
ErrorCheckAllocations(unset),
|
|
ErrorCheckBounds(unset),
|
|
ErrorCheckEnumRange(unset),
|
|
ErrorCheckRefPointers(unset),
|
|
ErrorCheckStubData(unset),
|
|
GenerateStublessProxies(unset),
|
|
GenerateTypeLibrary(unset),
|
|
IgnoreStandardIncludePath(unset),
|
|
MkTypLibCompatible(unset),
|
|
StructMemberAlignment(midlAlignNotSet),
|
|
SuppressStartupBanner(unset),
|
|
TargetEnvironment(midlTargetNotSet),
|
|
ValidateParameters(unset),
|
|
WarnAsError(unset),
|
|
WarningLevel(midlWarningLevel_0),
|
|
ApplicationConfigurationMode(unset),
|
|
ValidateAllParameters(unset),
|
|
SuppressCompilerWarnings(unset),
|
|
LocaleID(-1)
|
|
{
|
|
}
|
|
|
|
bool VCMIDLTool::parseOption(const char* option)
|
|
{
|
|
#ifdef USE_DISPLAY_HASH
|
|
displayHash("/D name[=def]"); displayHash("/I directory-list"); displayHash("/Oi");
|
|
displayHash("/Oic"); displayHash("/Oicf"); displayHash("/Oif"); displayHash("/Os");
|
|
displayHash("/U name"); displayHash("/WX"); displayHash("/W{0|1|2|3|4}");
|
|
displayHash("/Zp {N}"); displayHash("/Zs"); displayHash("/acf filename");
|
|
displayHash("/align {N}"); displayHash("/app_config"); displayHash("/c_ext");
|
|
displayHash("/char ascii7"); displayHash("/char signed"); displayHash("/char unsigned");
|
|
displayHash("/client none"); displayHash("/client stub"); displayHash("/confirm");
|
|
displayHash("/cpp_cmd cmd_line"); displayHash("/cpp_opt options");
|
|
displayHash("/cstub filename"); displayHash("/dlldata filename"); displayHash("/env win32");
|
|
displayHash("/env win64"); displayHash("/error all"); displayHash("/error allocation");
|
|
displayHash("/error bounds_check"); displayHash("/error enum"); displayHash("/error none");
|
|
displayHash("/error ref"); displayHash("/error stub_data"); displayHash("/h filename");
|
|
displayHash("/header filename"); displayHash("/iid filename"); displayHash("/lcid");
|
|
displayHash("/mktyplib203"); displayHash("/ms_ext"); displayHash("/ms_union");
|
|
displayHash("/msc_ver <nnnn>"); displayHash("/newtlb"); displayHash("/no_cpp");
|
|
displayHash("/no_def_idir"); displayHash("/no_default_epv"); displayHash("/no_format_opt");
|
|
displayHash("/no_warn"); displayHash("/nocpp"); displayHash("/nologo"); displayHash("/notlb");
|
|
displayHash("/o filename"); displayHash("/oldnames"); displayHash("/oldtlb");
|
|
displayHash("/osf"); displayHash("/out directory"); displayHash("/pack {N}");
|
|
displayHash("/prefix all"); displayHash("/prefix client"); displayHash("/prefix server");
|
|
displayHash("/prefix switch"); displayHash("/protocol all"); displayHash("/protocol dce");
|
|
displayHash("/protocol ndr64"); displayHash("/proxy filename"); displayHash("/robust");
|
|
displayHash("/rpcss"); displayHash("/savePP"); displayHash("/server none");
|
|
displayHash("/server stub"); displayHash("/sstub filename"); displayHash("/syntax_check");
|
|
displayHash("/target {system}"); displayHash("/tlb filename"); displayHash("/use_epv");
|
|
displayHash("/win32"); displayHash("/win64");
|
|
#endif
|
|
bool found = true;
|
|
int offset = 0;
|
|
|
|
const uint optionHash = elfHash(option);
|
|
|
|
if (config->CompilerVersion < NET2010) {
|
|
switch (optionHash) {
|
|
case 0x5b1cb97: // /app_config
|
|
case 0x5a2fc64: // /client {none|stub}
|
|
case 0x35aabb2: // /cstub filename
|
|
case 0x64ceb12: // /newtlb
|
|
case 0x556dbee: // /no_warn
|
|
case 0x662bb12: // /oldtlb
|
|
case 0x69c9cf2: // /server {none|stub}
|
|
case 0x36aabb2: // /sstub filename
|
|
AdditionalOptions += option;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
switch(optionHash) {
|
|
case 0x0000334: // /D name[=def]
|
|
PreprocessorDefinitions += option+3;
|
|
break;
|
|
case 0x0000339: // /I directory-list
|
|
AdditionalIncludeDirectories += option+3;
|
|
break;
|
|
case 0x0345f96: // /Oicf
|
|
case 0x00345f6: // /Oif
|
|
GenerateStublessProxies = _True;
|
|
break;
|
|
case 0x0000345: // /U name
|
|
UndefinePreprocessorDefinitions += option+3;
|
|
break;
|
|
case 0x00034c8: // /WX
|
|
WarnAsError = _True;
|
|
break;
|
|
case 0x3582fde: // /align {N}
|
|
offset = 3; // Fallthrough
|
|
case 0x0003510: // /Zp {N}
|
|
switch (*(option+offset+4)) {
|
|
case '1':
|
|
StructMemberAlignment = (*(option+offset+5) == '\0') ? midlAlignSingleByte : midlAlignSixteenBytes;
|
|
break;
|
|
case '2':
|
|
StructMemberAlignment = midlAlignTwoBytes;
|
|
break;
|
|
case '4':
|
|
StructMemberAlignment = midlAlignFourBytes;
|
|
break;
|
|
case '8':
|
|
StructMemberAlignment = midlAlignEightBytes;
|
|
break;
|
|
default:
|
|
found = false;
|
|
}
|
|
break;
|
|
case 0x5b1cb97: // /app_config
|
|
ApplicationConfigurationMode = _True;
|
|
break;
|
|
case 0x0359e82: // /char {ascii7|signed|unsigned}
|
|
switch(*(option+6)) {
|
|
case 'a':
|
|
DefaultCharType = midlCharAscii7;
|
|
break;
|
|
case 's':
|
|
DefaultCharType = midlCharSigned;
|
|
break;
|
|
case 'u':
|
|
DefaultCharType = midlCharUnsigned;
|
|
break;
|
|
default:
|
|
found = false;
|
|
}
|
|
break;
|
|
case 0x5a2fc64: // /client {none|stub}
|
|
if(*(option+8) == 's')
|
|
GenerateClientFiles = "Stub";
|
|
else
|
|
GenerateClientFiles = "None";
|
|
break;
|
|
case 0xa766524: // /cpp_opt options
|
|
CPreprocessOptions += option+9;
|
|
break;
|
|
case 0x35aabb2: // /cstub filename
|
|
ClientStubFile = option+7;
|
|
break;
|
|
case 0xb32abf1: // /dlldata filename
|
|
DLLDataFileName = option + 9;
|
|
break;
|
|
case 0x0035c56: // /env {win32|win64}
|
|
TargetEnvironment = (*(option+8) == '6') ? midlTargetWin64 : midlTargetWin32;
|
|
break;
|
|
case 0x35c9962: // /error {all|allocation|bounds_check|enum|none|ref|stub_data}
|
|
EnableErrorChecks = midlEnableCustom;
|
|
switch (*(option+7)) {
|
|
case 'a':
|
|
if(*(option+10) == '\0')
|
|
EnableErrorChecks = midlEnableAll;
|
|
else
|
|
ErrorCheckAllocations = _True;
|
|
break;
|
|
case 'b':
|
|
ErrorCheckBounds = _True;
|
|
break;
|
|
case 'e':
|
|
ErrorCheckEnumRange = _True;
|
|
break;
|
|
case 'n':
|
|
EnableErrorChecks = midlDisableAll;
|
|
break;
|
|
case 'r':
|
|
ErrorCheckRefPointers = _True;
|
|
break;
|
|
case 's':
|
|
ErrorCheckStubData = _True;
|
|
break;
|
|
default:
|
|
found = false;
|
|
}
|
|
break;
|
|
case 0x5eb7af2: // /header filename
|
|
offset = 5;
|
|
Q_FALLTHROUGH();
|
|
case 0x0000358: // /h filename
|
|
HeaderFileName = option + offset + 3;
|
|
break;
|
|
case 0x0035ff4: // /iid filename
|
|
InterfaceIdentifierFileName = option+5;
|
|
break;
|
|
case 0x64b7933: // /mktyplib203
|
|
MkTypLibCompatible = _True;
|
|
break;
|
|
case 0x64ceb12: // /newtlb
|
|
TypeLibFormat = "NewFormat";
|
|
break;
|
|
case 0x8e0b0a2: // /no_def_idir
|
|
IgnoreStandardIncludePath = _True;
|
|
break;
|
|
case 0x65635ef: // /nologo
|
|
SuppressStartupBanner = _True;
|
|
break;
|
|
case 0x695e9f4: // /no_robust
|
|
ValidateAllParameters = _False;
|
|
break;
|
|
case 0x3656b22: // /notlb
|
|
GenerateTypeLibrary = _True;
|
|
break;
|
|
case 0x556dbee: // /no_warn
|
|
SuppressCompilerWarnings = _True;
|
|
break;
|
|
case 0x000035f: // /o filename
|
|
RedirectOutputAndErrors = option+3;
|
|
break;
|
|
case 0x662bb12: // /oldtlb
|
|
TypeLibFormat = "OldFormat";
|
|
break;
|
|
case 0x00366c4: // /out directory
|
|
OutputDirectory = option+5;
|
|
break;
|
|
case 0x36796f9: // /proxy filename
|
|
ProxyFileName = option+7;
|
|
break;
|
|
case 0x6959c94: // /robust
|
|
ValidateParameters = _True;
|
|
break;
|
|
case 0x6a88df4: // /target {system}
|
|
if(*(option+11) == '6')
|
|
TargetEnvironment = midlTargetWin64;
|
|
else
|
|
TargetEnvironment = midlTargetWin32;
|
|
break;
|
|
case 0x69c9cf2: // /server {none|stub}
|
|
if(*(option+8) == 's')
|
|
GenerateServerFiles = "Stub";
|
|
else
|
|
GenerateServerFiles = "None";
|
|
break;
|
|
case 0x36aabb2: // /sstub filename
|
|
ServerStubFile = option+7;
|
|
break;
|
|
case 0x0036b22: // /tlb filename
|
|
TypeLibraryName = option+5;
|
|
break;
|
|
case 0x36e0162: // /win32
|
|
TargetEnvironment = midlTargetWin32;
|
|
break;
|
|
case 0x36e0194: // /win64
|
|
TargetEnvironment = midlTargetWin64;
|
|
break;
|
|
case 0x0003459: // /Oi
|
|
case 0x00345f3: // /Oic
|
|
case 0x0003463: // /Os
|
|
case 0x0003513: // /Zs
|
|
case 0x0035796: // /acf filename
|
|
case 0x3595cf4: // /c_ext
|
|
case 0xa64d3dd: // /confirm
|
|
case 0xa765b64: // /cpp_cmd cmd_line
|
|
case 0x03629f4: // /lcid
|
|
case 0x6495cc4: // /ms_ext
|
|
case 0x96c7a1e: // /ms_union
|
|
case 0x4996fa2: // /msc_ver <nnnn>
|
|
case 0x6555a40: // /no_cpp
|
|
case 0xf64d6a6: // /no_default_epv
|
|
case 0x6dd9384: // /no_format_opt
|
|
case 0x3655a70: // /nocpp
|
|
case 0x2b455a3: // /oldnames
|
|
case 0x0036696: // /osf
|
|
case 0x036679b: // /pack {N}
|
|
case 0x678bd38: // /prefix {all|client|server|switch}
|
|
case 0x96b702c: // /protocol {all|dce|ndr64}
|
|
case 0x3696aa3: // /rpcss
|
|
case 0x698ca60: // /savePP
|
|
case 0xce9b12b: // /syntax_check
|
|
case 0xc9b5f16: // /use_epv
|
|
AdditionalOptions += option;
|
|
break;
|
|
default:
|
|
// /W{0|1|2|3|4} case
|
|
if(*(option+1) == 'W') {
|
|
switch (*(option+2)) {
|
|
case '0':
|
|
WarningLevel = midlWarningLevel_0;
|
|
break;
|
|
case '1':
|
|
WarningLevel = midlWarningLevel_1;
|
|
break;
|
|
case '2':
|
|
WarningLevel = midlWarningLevel_2;
|
|
break;
|
|
case '3':
|
|
WarningLevel = midlWarningLevel_3;
|
|
break;
|
|
case '4':
|
|
WarningLevel = midlWarningLevel_4;
|
|
break;
|
|
default:
|
|
found = false;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(!found)
|
|
warn_msg(WarnLogic, "Could not parse MIDL option: %s", option);
|
|
return true;
|
|
}
|
|
|
|
// VCLibrarianTool --------------------------------------------------
|
|
VCLibrarianTool::VCLibrarianTool()
|
|
: IgnoreAllDefaultLibraries(unset),
|
|
SuppressStartupBanner(_True)
|
|
{
|
|
}
|
|
|
|
// VCCustomBuildTool ------------------------------------------------
|
|
VCCustomBuildTool::VCCustomBuildTool()
|
|
{
|
|
ToolName = "VCCustomBuildTool";
|
|
}
|
|
|
|
// VCResourceCompilerTool -------------------------------------------
|
|
VCResourceCompilerTool::VCResourceCompilerTool()
|
|
: Culture(rcUseDefault),
|
|
IgnoreStandardIncludePath(unset),
|
|
ShowProgress(linkProgressNotSet),
|
|
SuppressStartupBanner(unset)
|
|
{
|
|
}
|
|
|
|
// VCDeploymentTool --------------------------------------------
|
|
VCDeploymentTool::VCDeploymentTool()
|
|
: RegisterOutput(registerNo)
|
|
{
|
|
DeploymentTag = "DeploymentTool";
|
|
RemoteDirectory = "";
|
|
}
|
|
|
|
VCEventTool::VCEventTool(const QString &eventName)
|
|
: ExcludedFromBuild(unset)
|
|
{
|
|
EventName = eventName;
|
|
ToolName = "VC";
|
|
ToolName += eventName;
|
|
ToolName += "Tool";
|
|
}
|
|
|
|
// VCPostBuildEventTool ---------------------------------------------
|
|
VCPostBuildEventTool::VCPostBuildEventTool()
|
|
: VCEventTool("PostBuildEvent")
|
|
{
|
|
}
|
|
|
|
// VCPreBuildEventTool ----------------------------------------------
|
|
VCPreBuildEventTool::VCPreBuildEventTool()
|
|
: VCEventTool("PreBuildEvent")
|
|
{
|
|
}
|
|
|
|
// VCPreLinkEventTool -----------------------------------------------
|
|
VCPreLinkEventTool::VCPreLinkEventTool()
|
|
: VCEventTool("PreLinkEvent")
|
|
{
|
|
}
|
|
|
|
// VCConfiguration --------------------------------------------------
|
|
|
|
VCConfiguration::VCConfiguration()
|
|
: WinRT(false),
|
|
ATLMinimizesCRunTimeLibraryUsage(unset),
|
|
BuildBrowserInformation(unset),
|
|
CharacterSet(charSetNotSet),
|
|
ConfigurationType(typeApplication),
|
|
RegisterOutput(unset),
|
|
UseOfATL(useATLNotSet),
|
|
UseOfMfc(useMfcStdWin),
|
|
WholeProgramOptimization(unset)
|
|
{
|
|
compiler.config = this;
|
|
linker.config = this;
|
|
idl.config = this;
|
|
}
|
|
|
|
// VCFilter ---------------------------------------------------------
|
|
VCFilter::VCFilter()
|
|
: ParseFiles(unset),
|
|
Config(nullptr)
|
|
{
|
|
useCustomBuildTool = false;
|
|
useCompilerTool = false;
|
|
}
|
|
|
|
void VCFilter::addFile(const QString& filename)
|
|
{
|
|
Files += VCFilterFile(filename);
|
|
}
|
|
|
|
void VCFilter::addFile(const VCFilterFile& fileInfo)
|
|
{
|
|
Files += VCFilterFile(fileInfo);
|
|
}
|
|
|
|
void VCFilter::addFiles(const QStringList& fileList)
|
|
{
|
|
for (int i = 0; i < fileList.count(); ++i)
|
|
addFile(fileList.at(i));
|
|
}
|
|
|
|
void VCFilter::addFiles(const ProStringList& fileList)
|
|
{
|
|
for (int i = 0; i < fileList.count(); ++i)
|
|
addFile(fileList.at(i).toQString());
|
|
}
|
|
|
|
void VCFilter::modifyPCHstage(QString str)
|
|
{
|
|
const bool isHFile = (str == Project->precompH);
|
|
const bool pchThroughSourceFile = !Project->precompSource.isEmpty();
|
|
if (isHFile && pchThroughSourceFile && Project->autogenPrecompSource) {
|
|
useCustomBuildTool = true;
|
|
QString toFile(Project->precompSource);
|
|
CustomBuildTool.Description = "Generating precompiled header source file '" + toFile + "' ...";
|
|
CustomBuildTool.Outputs += toFile;
|
|
|
|
QStringList lines;
|
|
CustomBuildTool.CommandLine +=
|
|
"echo /*-------------------------------------------------------------------- >" + toFile;
|
|
lines << "* Precompiled header source file used by Visual Studio.NET to generate";
|
|
lines << "* the .pch file.";
|
|
lines << "*";
|
|
lines << "* Due to issues with the dependencies checker within the IDE, it";
|
|
lines << "* sometimes fails to recompile the PCH file, if we force the IDE to";
|
|
lines << "* create the PCH file directly from the header file.";
|
|
lines << "*";
|
|
lines << "* This file is auto-generated by qmake since no PRECOMPILED_SOURCE was";
|
|
lines << "* specified, and is used as the common stdafx.cpp. The file is only";
|
|
lines << QLatin1String("* generated when creating ")
|
|
+ (Config->CompilerVersion < NET2010 ? ".vcproj" : ".vcxproj")
|
|
+ " project files, and is not used for";
|
|
lines << "* command line compilations by nmake.";
|
|
lines << "*";
|
|
lines << "* WARNING: All changes made in this file will be lost.";
|
|
lines << "--------------------------------------------------------------------*/";
|
|
lines << "#include \"" + Project->precompHFilename + "\"";
|
|
for (const QString &line : qAsConst(lines))
|
|
CustomBuildTool.CommandLine += "echo " + line + ">>" + toFile;
|
|
return;
|
|
}
|
|
|
|
useCompilerTool = true;
|
|
const bool isPrecompSource = pchThroughSourceFile && (str == Project->precompSource);
|
|
if (isPrecompSource) {
|
|
CompilerTool.UsePrecompiledHeader = pchCreateUsingSpecific;
|
|
if (Project->autogenPrecompSource)
|
|
CompilerTool.PrecompiledHeaderThrough = Project->precompHFilename;
|
|
CompilerTool.ForcedIncludeFiles = QStringList("$(NOINHERIT)");
|
|
return;
|
|
}
|
|
|
|
bool isCFile = false;
|
|
for (QStringList::Iterator it = Option::c_ext.begin(); it != Option::c_ext.end(); ++it) {
|
|
if (str.endsWith(*it)) {
|
|
isCFile = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool pchCompatible = (isCFile == Project->pchIsCFile);
|
|
if (!pchCompatible) {
|
|
CompilerTool.UsePrecompiledHeader = pchNone;
|
|
CompilerTool.PrecompiledHeaderThrough = QLatin1String("$(NOINHERIT)");
|
|
CompilerTool.ForcedIncludeFiles = QStringList("$(NOINHERIT)");
|
|
}
|
|
}
|
|
|
|
VCFilterFile VCFilter::findFile(const QString &filePath, bool *found) const
|
|
{
|
|
for (int i = 0; i < Files.count(); ++i) {
|
|
const VCFilterFile &f = Files.at(i);
|
|
if (f.file == filePath) {
|
|
*found = true;
|
|
return f;
|
|
}
|
|
}
|
|
*found = false;
|
|
return VCFilterFile();
|
|
}
|
|
|
|
bool VCFilter::addExtraCompiler(const VCFilterFile &info)
|
|
{
|
|
const QStringList &extraCompilers = Project->extraCompilerSources.value(info.file);
|
|
if (extraCompilers.isEmpty())
|
|
return false;
|
|
|
|
QString inFile = info.file;
|
|
|
|
// is the extracompiler rule on a file with a built in compiler?
|
|
const QString objectMappedFile = Project->extraCompilerOutputs.value(inFile);
|
|
bool hasBuiltIn = false;
|
|
if (!objectMappedFile.isEmpty()) {
|
|
hasBuiltIn = Project->hasBuiltinCompiler(objectMappedFile);
|
|
|
|
// Remove the fake file suffix we've added initially to generate correct command lines.
|
|
inFile.chop(Project->customBuildToolFilterFileSuffix.length());
|
|
|
|
// qDebug("*** Extra compiler file has object mapped file '%s' => '%s'", qPrintable(inFile), qPrintable(objectMappedFile.join(' ')));
|
|
}
|
|
|
|
CustomBuildTool.AdditionalDependencies.clear();
|
|
CustomBuildTool.CommandLine.clear();
|
|
CustomBuildTool.Description.clear();
|
|
CustomBuildTool.Outputs.clear();
|
|
CustomBuildTool.ToolPath.clear();
|
|
CustomBuildTool.ToolName = QLatin1String(_VCCustomBuildTool);
|
|
|
|
for (int x = 0; x < extraCompilers.count(); ++x) {
|
|
const QString &extraCompilerName = extraCompilers.at(x);
|
|
|
|
if (!Project->verifyExtraCompiler(extraCompilerName, inFile) && !hasBuiltIn)
|
|
continue;
|
|
|
|
// All information about the extra compiler
|
|
QString tmp_out = Project->project->first(ProKey(extraCompilerName + ".output")).toQString();
|
|
QString tmp_cmd = Project->project->values(ProKey(extraCompilerName + ".commands")).join(' ');
|
|
QString tmp_cmd_name = Project->project->values(ProKey(extraCompilerName + ".name")).join(' ');
|
|
QStringList tmp_dep = Project->project->values(ProKey(extraCompilerName + ".depends")).toQStringList();
|
|
QString tmp_dep_cmd = Project->project->values(ProKey(extraCompilerName + ".depend_command")).join(' ');
|
|
const ProStringList &configs = Project->project->values(ProKey(extraCompilerName + ".CONFIG"));
|
|
bool combined = configs.indexOf("combine") != -1;
|
|
|
|
QString cmd, cmd_name, out;
|
|
QStringList deps, inputs;
|
|
// Variabel replacement of output name
|
|
out = Option::fixPathToTargetOS(Project->replaceExtraCompilerVariables(
|
|
tmp_out, inFile, QString(), MakefileGenerator::NoShell), false);
|
|
|
|
// If file has built-in compiler, we've swapped the input and output of
|
|
// the command, as we in Visual Studio cannot have a Custom Buildstep on
|
|
// a file which uses a built-in compiler. We would in this case only get
|
|
// the result from the extra compiler. If 'hasBuiltIn' is true, we know
|
|
// that we're actually on the _output_file_ of the result, and we
|
|
// therefore swap inFile and out below, since the extra-compiler still
|
|
// must see it as the original way. If the result also has a built-in
|
|
// compiler, too bad..
|
|
if (hasBuiltIn) {
|
|
out = inFile;
|
|
inFile = objectMappedFile;
|
|
}
|
|
|
|
// Dependency for the output
|
|
if (!tmp_dep.isEmpty())
|
|
deps = tmp_dep;
|
|
if (!tmp_dep_cmd.isEmpty()) {
|
|
const QString dep_cd_cmd = QLatin1String("cd ")
|
|
+ IoUtils::shellQuote(Option::fixPathToLocalOS(Option::output_dir, false))
|
|
+ QLatin1String(" && ");
|
|
Project->callExtraCompilerDependCommand(extraCompilerName, dep_cd_cmd, tmp_dep_cmd,
|
|
inFile, out,
|
|
true, // dep_lines
|
|
&deps,
|
|
configs.contains("dep_existing_only"),
|
|
true /* checkCommandAvailability */);
|
|
}
|
|
for (int i = 0; i < deps.count(); ++i)
|
|
deps[i] = Option::fixPathToTargetOS(
|
|
Project->replaceExtraCompilerVariables(
|
|
deps.at(i), inFile, out, MakefileGenerator::NoShell),
|
|
false);
|
|
// Command for file
|
|
if (combined) {
|
|
// Add dependencies for each file
|
|
const ProStringList &tmp_in = Project->project->values(ProKey(extraCompilerName + ".input"));
|
|
for (int a = 0; a < tmp_in.count(); ++a) {
|
|
const ProStringList &files = Project->project->values(tmp_in.at(a).toKey());
|
|
for (int b = 0; b < files.count(); ++b) {
|
|
QString file = files.at(b).toQString();
|
|
deps += Project->findDependencies(file);
|
|
inputs += Option::fixPathToTargetOS(file, false);
|
|
}
|
|
}
|
|
deps = inputs + deps; // input files themselves too..
|
|
|
|
// Replace variables for command w/all input files
|
|
cmd = Project->replaceExtraCompilerVariables(tmp_cmd,
|
|
inputs,
|
|
QStringList(out),
|
|
MakefileGenerator::TargetShell);
|
|
} else {
|
|
deps.prepend(inFile); // input file itself too..
|
|
cmd = Project->replaceExtraCompilerVariables(tmp_cmd,
|
|
inFile,
|
|
out,
|
|
MakefileGenerator::TargetShell);
|
|
}
|
|
// Name for command
|
|
if (!tmp_cmd_name.isEmpty()) {
|
|
cmd_name = Project->replaceExtraCompilerVariables(
|
|
tmp_cmd_name, inFile, out, MakefileGenerator::NoShell);
|
|
} else {
|
|
int space = cmd.indexOf(' ');
|
|
if (space != -1)
|
|
cmd_name = cmd.left(space);
|
|
else
|
|
cmd_name = cmd;
|
|
}
|
|
|
|
// Fixify paths
|
|
for (int i = 0; i < deps.count(); ++i)
|
|
deps[i] = Option::fixPathToTargetOS(deps[i], false);
|
|
|
|
|
|
// Output in info.additionalFile -----------
|
|
if (!CustomBuildTool.Description.isEmpty())
|
|
CustomBuildTool.Description += ", ";
|
|
CustomBuildTool.Description += cmd_name;
|
|
CustomBuildTool.CommandLine += VCToolBase::fixCommandLine(cmd.trimmed());
|
|
int space = cmd.indexOf(' ');
|
|
QFileInfo finf(cmd.left(space));
|
|
if (CustomBuildTool.ToolPath.isEmpty())
|
|
CustomBuildTool.ToolPath += Option::fixPathToTargetOS(finf.path());
|
|
CustomBuildTool.Outputs += out;
|
|
|
|
deps += CustomBuildTool.AdditionalDependencies;
|
|
// Make sure that all deps are only once
|
|
QStringList uniqDeps;
|
|
for (int c = 0; c < deps.count(); ++c) {
|
|
QString aDep = deps.at(c);
|
|
if (!aDep.isEmpty())
|
|
uniqDeps << aDep;
|
|
}
|
|
uniqDeps.removeDuplicates();
|
|
CustomBuildTool.AdditionalDependencies = uniqDeps;
|
|
}
|
|
|
|
// Ensure that none of the output files are also dependencies. Or else, the custom buildstep
|
|
// will be rebuild every time, even if nothing has changed.
|
|
for (const QString &output : qAsConst(CustomBuildTool.Outputs))
|
|
CustomBuildTool.AdditionalDependencies.removeAll(output);
|
|
|
|
useCustomBuildTool = !CustomBuildTool.CommandLine.isEmpty();
|
|
return useCustomBuildTool;
|
|
}
|
|
|
|
// VCProjectSingleConfig --------------------------------------------
|
|
const VCFilter &VCProjectSingleConfig::filterByName(const QString &name) const
|
|
{
|
|
if (name == "Root Files")
|
|
return RootFiles;
|
|
if (name == "Source Files")
|
|
return SourceFiles;
|
|
if (name == "Header Files")
|
|
return HeaderFiles;
|
|
if (name == "Generated Files")
|
|
return GeneratedFiles;
|
|
if (name == "LexYacc Files")
|
|
return LexYaccFiles;
|
|
if (name == "Translation Files")
|
|
return TranslationFiles;
|
|
if (name == "Form Files")
|
|
return FormFiles;
|
|
if (name == "Resource Files")
|
|
return ResourceFiles;
|
|
if (name == "Deployment Files")
|
|
return DeploymentFiles;
|
|
if (name == "Distribution Files")
|
|
return DistributionFiles;
|
|
return filterForExtraCompiler(name);
|
|
}
|
|
|
|
const VCFilter &VCProjectSingleConfig::filterForExtraCompiler(const QString &compilerName) const
|
|
{
|
|
for (int i = 0; i < ExtraCompilersFiles.count(); ++i)
|
|
if (ExtraCompilersFiles.at(i).Name == compilerName)
|
|
return ExtraCompilersFiles.at(i);
|
|
|
|
static VCFilter nullFilter;
|
|
return nullFilter;
|
|
}
|
|
|
|
// Tree file generation ---------------------------------------------
|
|
void TreeNode::generateXML(XmlOutput &xml, const QString &tagName, VCProject &tool, const QString &filter) {
|
|
if (children.size()) {
|
|
// Filter
|
|
ChildrenMap::ConstIterator it, end = children.constEnd();
|
|
if (!tagName.isEmpty()) {
|
|
xml << tag("Filter")
|
|
<< attr("Name", tagName)
|
|
<< attr("Filter", "");
|
|
}
|
|
// First round, do nested filters
|
|
for (it = children.constBegin(); it != end; ++it)
|
|
if ((*it)->children.size())
|
|
(*it)->generateXML(xml, it.key(), tool, filter);
|
|
// Second round, do leafs
|
|
for (it = children.constBegin(); it != end; ++it)
|
|
if (!(*it)->children.size())
|
|
(*it)->generateXML(xml, it.key(), tool, filter);
|
|
|
|
if (!tagName.isEmpty())
|
|
xml << closetag("Filter");
|
|
} else {
|
|
// Leaf
|
|
VCProjectWriter::outputFileConfigs(tool, xml, info, filter);
|
|
}
|
|
}
|
|
|
|
// Flat file generation ---------------------------------------------
|
|
void FlatNode::generateXML(XmlOutput &xml, const QString &/*tagName*/, VCProject &tool, const QString &filter) {
|
|
if (children.size()) {
|
|
ChildrenMapFlat::ConstIterator it = children.constBegin();
|
|
ChildrenMapFlat::ConstIterator end = children.constEnd();
|
|
for (; it != end; ++it) {
|
|
VCProjectWriter::outputFileConfigs(tool, xml, (*it), filter);
|
|
}
|
|
}
|
|
}
|
|
|
|
void VCProjectWriter::write(XmlOutput &xml, VCProjectSingleConfig &tool)
|
|
{
|
|
xml << decl("1.0", "Windows-1252")
|
|
<< tag(_VisualStudioProject)
|
|
<< attrS(_ProjectType, "Visual C++")
|
|
<< attrS(_Version, tool.Version)
|
|
<< attrS(_Name, tool.Name)
|
|
<< attrS(_ProjectGUID, tool.ProjectGUID)
|
|
<< attrS(_Keyword, tool.Keyword)
|
|
<< attrS(_SccProjectName, tool.SccProjectName)
|
|
<< attrS(_SccLocalPath, tool.SccLocalPath)
|
|
<< tag(_Platforms)
|
|
<< tag(_Platform)
|
|
<< attrS(_Name, tool.PlatformName)
|
|
<< closetag(_Platforms)
|
|
<< tag(_Configurations);
|
|
write(xml, tool.Configuration);
|
|
xml << closetag(_Configurations)
|
|
<< tag(q_Files);
|
|
// Add this configuration into a multi-config project, since that's where we have the flat/tree
|
|
// XML output functionality
|
|
VCProject tempProj;
|
|
tempProj.SingleProjects += tool;
|
|
outputFilter(tempProj, xml, "Source Files");
|
|
outputFilter(tempProj, xml, "Header Files");
|
|
outputFilter(tempProj, xml, "Generated Files");
|
|
outputFilter(tempProj, xml, "LexYacc Files");
|
|
outputFilter(tempProj, xml, "Translation Files");
|
|
outputFilter(tempProj, xml, "Form Files");
|
|
outputFilter(tempProj, xml, "Resource Files");
|
|
outputFilter(tempProj, xml, "Deployment Files");
|
|
outputFilter(tempProj, xml, "Distribution Files");
|
|
|
|
QSet<QString> extraCompilersInProject;
|
|
for (int i = 0; i < tool.ExtraCompilersFiles.count(); ++i) {
|
|
const QString &compilerName = tool.ExtraCompilersFiles.at(i).Name;
|
|
if (!extraCompilersInProject.contains(compilerName)) {
|
|
extraCompilersInProject += compilerName;
|
|
tempProj.ExtraCompilers += compilerName;
|
|
}
|
|
}
|
|
|
|
for (int x = 0; x < tempProj.ExtraCompilers.count(); ++x) {
|
|
outputFilter(tempProj, xml, tempProj.ExtraCompilers.at(x));
|
|
}
|
|
outputFilter(tempProj, xml, "Root Files");
|
|
xml << closetag(q_Files)
|
|
<< tag(_Globals)
|
|
<< data(); // No "/>" end tag
|
|
}
|
|
|
|
void VCProjectWriter::write(XmlOutput &xml, VCProject &tool)
|
|
{
|
|
if (tool.SingleProjects.count() == 0) {
|
|
warn_msg(WarnLogic, "Generator: .NET: no single project in merge project, no output");
|
|
return;
|
|
}
|
|
|
|
xml << decl("1.0", "Windows-1252")
|
|
<< tag(_VisualStudioProject)
|
|
<< attrS(_ProjectType, "Visual C++")
|
|
<< attrS(_Version, tool.Version)
|
|
<< attrS(_Name, tool.Name)
|
|
<< attrS(_ProjectGUID, tool.ProjectGUID)
|
|
<< attrS(_Keyword, tool.Keyword)
|
|
<< attrS(_SccProjectName, tool.SccProjectName)
|
|
<< attrS(_SccLocalPath, tool.SccLocalPath)
|
|
<< tag(_Platforms)
|
|
<< tag(_Platform)
|
|
<< attrS(_Name, tool.PlatformName)
|
|
<< closetag(_Platforms)
|
|
<< tag(_Configurations);
|
|
// Output each configuration
|
|
for (int i = 0; i < tool.SingleProjects.count(); ++i)
|
|
write(xml, tool.SingleProjects.at(i).Configuration);
|
|
xml << closetag(_Configurations)
|
|
<< tag(q_Files);
|
|
outputFilter(tool, xml, "Source Files");
|
|
outputFilter(tool, xml, "Header Files");
|
|
outputFilter(tool, xml, "Generated Files");
|
|
outputFilter(tool, xml, "LexYacc Files");
|
|
outputFilter(tool, xml, "Translation Files");
|
|
outputFilter(tool, xml, "Form Files");
|
|
outputFilter(tool, xml, "Resource Files");
|
|
outputFilter(tool, xml, "Deployment Files");
|
|
outputFilter(tool, xml, "Distribution Files");
|
|
for (int x = 0; x < tool.ExtraCompilers.count(); ++x) {
|
|
outputFilter(tool, xml, tool.ExtraCompilers.at(x));
|
|
}
|
|
outputFilter(tool, xml, "Root Files");
|
|
xml << closetag(q_Files)
|
|
<< tag(_Globals)
|
|
<< data(); // No "/>" end tag
|
|
}
|
|
|
|
void VCProjectWriter::write(XmlOutput &xml, const VCCLCompilerTool &tool)
|
|
{
|
|
xml << tag(_Tool)
|
|
<< attrS(_Name, _VCCLCompilerTool)
|
|
<< attrX(_AdditionalIncludeDirectories, tool.AdditionalIncludeDirectories)
|
|
<< attrX(_AdditionalOptions, tool.AdditionalOptions, " ")
|
|
<< attrX(_AdditionalUsingDirectories, tool.AdditionalUsingDirectories)
|
|
<< attrS(_AssemblerListingLocation, tool.AssemblerListingLocation)
|
|
<< attrE(_AssemblerOutput, tool.AssemblerOutput, /*ifNot*/ asmListingNone)
|
|
<< attrE(_BasicRuntimeChecks, tool.BasicRuntimeChecks, /*ifNot*/ runtimeBasicCheckNone)
|
|
<< attrE(_BrowseInformation, tool.BrowseInformation, /*ifNot*/ brInfoNone)
|
|
<< attrS(_BrowseInformationFile, tool.BrowseInformationFile)
|
|
<< attrT(_BufferSecurityCheck, tool.BufferSecurityCheck)
|
|
<< attrE(_CallingConvention, tool.CallingConvention, /*ifNot*/ callConventionDefault)
|
|
<< attrE(_CompileAs, tool.CompileAs, compileAsDefault)
|
|
<< attrE(_CompileAsManaged, tool.CompileAsManaged, /*ifNot*/ managedDefault)
|
|
<< attrT(_CompileOnly, tool.CompileOnly)
|
|
<< attrE(_DebugInformationFormat, tool.DebugInformationFormat, /*ifNot*/ debugUnknown)
|
|
<< attrT(_Detect64BitPortabilityProblems, tool.Detect64BitPortabilityProblems)
|
|
<< attrT(_DisableLanguageExtensions, tool.DisableLanguageExtensions)
|
|
<< attrX(_DisableSpecificWarnings, tool.DisableSpecificWarnings)
|
|
<< attrE(_EnableEnhancedInstructionSet, tool.EnableEnhancedInstructionSet, /*ifnot*/ archNotSet)
|
|
<< attrT(_EnableFiberSafeOptimizations, tool.EnableFiberSafeOptimizations)
|
|
<< attrT(_EnableFunctionLevelLinking, tool.EnableFunctionLevelLinking)
|
|
<< attrT(_EnableIntrinsicFunctions, tool.EnableIntrinsicFunctions)
|
|
<< xformExceptionHandlingNET2005(tool.ExceptionHandling, tool.config->CompilerVersion)
|
|
<< attrT(_ExpandAttributedSource, tool.ExpandAttributedSource)
|
|
<< attrE(_FavorSizeOrSpeed, tool.FavorSizeOrSpeed, /*ifNot*/ favorNone)
|
|
|
|
<< attrE(_FloatingPointModel, tool.FloatingPointModel, /*ifNot*/ floatingPointNotSet)
|
|
<< attrT(_FloatingPointExceptions, tool.FloatingPointExceptions)
|
|
|
|
<< attrT(_ForceConformanceInForLoopScope, tool.ForceConformanceInForLoopScope)
|
|
<< attrX(_ForcedIncludeFiles, tool.ForcedIncludeFiles)
|
|
<< attrX(_ForcedUsingFiles, tool.ForcedUsingFiles)
|
|
<< attrE(_GeneratePreprocessedFile, tool.GeneratePreprocessedFile, /*ifNot*/ preprocessUnknown)
|
|
<< attrT(_GlobalOptimizations, tool.GlobalOptimizations)
|
|
<< attrT(_IgnoreStandardIncludePath, tool.IgnoreStandardIncludePath)
|
|
<< attrT(_ImproveFloatingPointConsistency, tool.ImproveFloatingPointConsistency)
|
|
<< attrE(_InlineFunctionExpansion, tool.InlineFunctionExpansion, /*ifNot*/ expandDefault)
|
|
<< attrT(_KeepComments, tool.KeepComments)
|
|
<< attrT(_MinimalRebuild, tool.MinimalRebuild)
|
|
<< attrS(_ObjectFile, tool.ObjectFile)
|
|
<< attrT(_OmitFramePointers, tool.OmitFramePointers)
|
|
<< attrT(_OpenMP, tool.OpenMP)
|
|
<< attrE(_Optimization, tool.Optimization, /*ifNot*/ optimizeDefault)
|
|
<< attrE(_OptimizeForProcessor, tool.OptimizeForProcessor, /*ifNot*/ procOptimizeBlended)
|
|
<< attrT(_OptimizeForWindowsApplication, tool.OptimizeForWindowsApplication)
|
|
<< attrS(_OutputFile, tool.OutputFile)
|
|
<< attrS(_PrecompiledHeaderFile, tool.PrecompiledHeaderFile)
|
|
<< attrS(_PrecompiledHeaderThrough, tool.PrecompiledHeaderThrough)
|
|
<< attrX(_PreprocessorDefinitions, tool.PreprocessorDefinitions)
|
|
<< (tool.ProgramDataBaseFileName.isNull() ? noxml() : attr(_ProgramDataBaseFileName, tool.ProgramDataBaseFileName))
|
|
<< attrE(_RuntimeLibrary, tool.RuntimeLibrary, /*ifNot*/ rtUnknown)
|
|
<< attrT(_RuntimeTypeInfo, tool.RuntimeTypeInfo)
|
|
<< attrT(_ShowIncludes, tool.ShowIncludes)
|
|
<< attrT(_SmallerTypeCheck, tool.SmallerTypeCheck)
|
|
<< attrT(_StringPooling, tool.StringPooling)
|
|
<< attrE(_StructMemberAlignment, tool.StructMemberAlignment, /*ifNot*/ alignNotSet)
|
|
<< attrT(_SuppressStartupBanner, tool.SuppressStartupBanner)
|
|
<< attrT(_TreatWChar_tAsBuiltInType, tool.TreatWChar_tAsBuiltInType)
|
|
<< attrT(_TurnOffAssemblyGeneration, tool.TurnOffAssemblyGeneration)
|
|
<< attrT(_UndefineAllPreprocessorDefinitions, tool.UndefineAllPreprocessorDefinitions)
|
|
<< attrX(_UndefinePreprocessorDefinitions, tool.UndefinePreprocessorDefinitions)
|
|
<< xformUsePrecompiledHeaderForNET2005(tool.UsePrecompiledHeader, tool.config->CompilerVersion)
|
|
<< attrT(_WarnAsError, tool.WarnAsError)
|
|
<< attrE(_WarningLevel, tool.WarningLevel, /*ifNot*/ warningLevelUnknown)
|
|
<< attrT(_WholeProgramOptimization, tool.WholeProgramOptimization)
|
|
<< attrE(_CompileForArchitecture, tool.CompileForArchitecture, /*ifNot*/ archUnknown)
|
|
<< attrT(_InterworkCalls, tool.InterworkCalls)
|
|
|
|
<< closetag(_Tool);
|
|
}
|
|
|
|
void VCProjectWriter::write(XmlOutput &xml, const VCLinkerTool &tool)
|
|
{
|
|
xml << tag(_Tool)
|
|
<< attrS(_Name, _VCLinkerTool)
|
|
<< attrX(_AdditionalDependencies, tool.AdditionalDependencies, " ")
|
|
<< attrX(_AdditionalLibraryDirectories, tool.AdditionalLibraryDirectories)
|
|
<< attrX(_AdditionalOptions, tool.AdditionalOptions, " ")
|
|
<< attrX(_AddModuleNamesToAssembly, tool.AddModuleNamesToAssembly)
|
|
<< attrS(_BaseAddress, tool.BaseAddress)
|
|
<< attrT(_DataExecutionPrevention, tool.DataExecutionPrevention)
|
|
<< attrX(_DelayLoadDLLs, tool.DelayLoadDLLs)
|
|
<< attrE(_EnableCOMDATFolding, tool.EnableCOMDATFolding, /*ifNot*/ optFoldingDefault)
|
|
<< attrS(_EntryPointSymbol, tool.EntryPointSymbol)
|
|
<< attrX(_ForceSymbolReferences, tool.ForceSymbolReferences)
|
|
<< attrS(_FunctionOrder, tool.FunctionOrder)
|
|
<< attrT(_GenerateDebugInformation, tool.GenerateDebugInformation)
|
|
<< attrT(_GenerateMapFile, tool.GenerateMapFile)
|
|
<< attrL(_HeapCommitSize, tool.HeapCommitSize, /*ifNot*/ -1)
|
|
<< attrL(_HeapReserveSize, tool.HeapReserveSize, /*ifNot*/ -1)
|
|
<< attrT(_IgnoreAllDefaultLibraries, tool.IgnoreAllDefaultLibraries)
|
|
<< attrX(_IgnoreDefaultLibraryNames, tool.IgnoreDefaultLibraryNames)
|
|
<< attrT(_IgnoreEmbeddedIDL, tool.IgnoreEmbeddedIDL)
|
|
<< attrT(_IgnoreImportLibrary, tool.IgnoreImportLibrary)
|
|
<< attrS(_ImportLibrary, tool.ImportLibrary)
|
|
<< attrE(_LargeAddressAware, tool.LargeAddressAware, /*ifNot*/ addrAwareDefault)
|
|
<< attrT(_LinkDLL, tool.LinkDLL)
|
|
<< attrE(_LinkIncremental, tool.LinkIncremental, /*ifNot*/ linkIncrementalDefault)
|
|
<< attrE(_LinkTimeCodeGeneration, tool.LinkTimeCodeGeneration)
|
|
<< attrS(_LinkToManagedResourceFile, tool.LinkToManagedResourceFile)
|
|
<< attrT(_MapExports, tool.MapExports)
|
|
<< attrS(_MapFileName, tool.MapFileName)
|
|
<< attrT(_MapLines, tool.MapLines)
|
|
<< attrS(_MergedIDLBaseFileName, tool.MergedIDLBaseFileName)
|
|
<< attrS(_MergeSections, tool.MergeSections)
|
|
<< attrS(_MidlCommandFile, tool.MidlCommandFile)
|
|
<< attrS(_ModuleDefinitionFile, tool.ModuleDefinitionFile)
|
|
<< attrE(_OptimizeForWindows98, tool.OptimizeForWindows98, /*ifNot*/ optWin98Default)
|
|
<< attrE(_OptimizeReferences, tool.OptimizeReferences, /*ifNot*/ optReferencesDefault)
|
|
<< attrS(_OutputFile, tool.OutputFile)
|
|
<< attr(_ProgramDatabaseFile, tool.ProgramDatabaseFile)
|
|
<< attrT(_RandomizedBaseAddress, tool.RandomizedBaseAddress)
|
|
<< attrT(_RegisterOutput, tool.RegisterOutput)
|
|
<< attrT(_ResourceOnlyDLL, tool.ResourceOnlyDLL)
|
|
<< attrT(_SetChecksum, tool.SetChecksum)
|
|
<< attrE(_ShowProgress, tool.ShowProgress, /*ifNot*/ linkProgressNotSet)
|
|
<< attrL(_StackCommitSize, tool.StackCommitSize, /*ifNot*/ -1)
|
|
<< attrL(_StackReserveSize, tool.StackReserveSize, /*ifNot*/ -1)
|
|
<< attrS(_StripPrivateSymbols, tool.StripPrivateSymbols)
|
|
<< attrE(_SubSystem, tool.SubSystem)
|
|
<< attrT(_SupportUnloadOfDelayLoadedDLL, tool.SupportUnloadOfDelayLoadedDLL)
|
|
<< attrT(_SuppressStartupBanner, tool.SuppressStartupBanner)
|
|
<< attrT(_SwapRunFromCD, tool.SwapRunFromCD)
|
|
<< attrT(_SwapRunFromNet, tool.SwapRunFromNet)
|
|
<< attrE(_TargetMachine, tool.TargetMachine, /*ifNot*/ machineNotSet)
|
|
<< attrE(_TerminalServerAware, tool.TerminalServerAware, /*ifNot*/ termSvrAwareDefault)
|
|
<< attrT(_TurnOffAssemblyGeneration, tool.TurnOffAssemblyGeneration)
|
|
<< attrS(_TypeLibraryFile, tool.TypeLibraryFile)
|
|
<< attrL(_TypeLibraryResourceID, tool.TypeLibraryResourceID, /*ifNot*/ rcUseDefault)
|
|
<< attrS(_Version, tool.Version)
|
|
<< attrT(_GenerateManifest, tool.GenerateManifest)
|
|
<< closetag(_Tool);
|
|
}
|
|
|
|
void VCProjectWriter::write(XmlOutput &xml, const VCManifestTool &tool)
|
|
{
|
|
xml << tag(_Tool)
|
|
<< attrS(_Name, _VCManifestTool)
|
|
<< attrT(_EmbedManifest, tool.EmbedManifest)
|
|
<< closetag(_Tool);
|
|
}
|
|
|
|
void VCProjectWriter::write(XmlOutput &xml, const VCMIDLTool &tool)
|
|
{
|
|
xml << tag(_Tool)
|
|
<< attrS(_Name, _VCMIDLTool)
|
|
<< attrX(_AdditionalIncludeDirectories, tool.AdditionalIncludeDirectories)
|
|
<< attrX(_AdditionalOptions, tool.AdditionalOptions, " ")
|
|
<< attrX(_CPreprocessOptions, tool.CPreprocessOptions)
|
|
<< attrE(_DefaultCharType, tool.DefaultCharType)
|
|
<< attrS(_DLLDataFileName, tool.DLLDataFileName)
|
|
<< attrE(_EnableErrorChecks, tool.EnableErrorChecks)
|
|
<< attrT(_ErrorCheckAllocations, tool.ErrorCheckAllocations)
|
|
<< attrT(_ErrorCheckBounds, tool.ErrorCheckBounds)
|
|
<< attrT(_ErrorCheckEnumRange, tool.ErrorCheckEnumRange)
|
|
<< attrT(_ErrorCheckRefPointers, tool.ErrorCheckRefPointers)
|
|
<< attrT(_ErrorCheckStubData, tool.ErrorCheckStubData)
|
|
<< attrX(_FullIncludePath, tool.FullIncludePath)
|
|
<< attrT(_GenerateStublessProxies, tool.GenerateStublessProxies)
|
|
<< attrT(_GenerateTypeLibrary, tool.GenerateTypeLibrary)
|
|
<< attrS(_HeaderFileName, tool.HeaderFileName)
|
|
<< attrT(_IgnoreStandardIncludePath, tool.IgnoreStandardIncludePath)
|
|
<< attrS(_InterfaceIdentifierFileName, tool.InterfaceIdentifierFileName)
|
|
<< attrT(_MkTypLibCompatible, tool.MkTypLibCompatible)
|
|
<< attrS(_OutputDirectory, tool.OutputDirectory)
|
|
<< attrX(_PreprocessorDefinitions, tool.PreprocessorDefinitions)
|
|
<< attrS(_ProxyFileName, tool.ProxyFileName)
|
|
<< attrS(_RedirectOutputAndErrors, tool.RedirectOutputAndErrors)
|
|
<< attrE(_StructMemberAlignment, tool.StructMemberAlignment, /*ifNot*/ midlAlignNotSet)
|
|
<< attrT(_SuppressStartupBanner, tool.SuppressStartupBanner)
|
|
<< attrE(_TargetEnvironment, tool.TargetEnvironment, /*ifNot*/ midlTargetNotSet)
|
|
<< attrS(_TypeLibraryName, tool.TypeLibraryName)
|
|
<< attrX(_UndefinePreprocessorDefinitions, tool.UndefinePreprocessorDefinitions)
|
|
<< attrT(_ValidateParameters, tool.ValidateParameters)
|
|
<< attrT(_WarnAsError, tool.WarnAsError)
|
|
<< attrE(_WarningLevel, tool.WarningLevel)
|
|
<< closetag(_Tool);
|
|
}
|
|
|
|
void VCProjectWriter::write(XmlOutput &xml, const VCCustomBuildTool &tool)
|
|
{
|
|
xml << tag(_Tool)
|
|
<< attrS(_Name, tool.ToolName)
|
|
<< attrX(_AdditionalDependencies, tool.AdditionalDependencies, ";")
|
|
<< attrS(_CommandLine, tool.CommandLine.join(vcCommandSeparator()))
|
|
<< attrS(_Description, tool.Description)
|
|
<< attrX(_Outputs, tool.Outputs, ";")
|
|
<< attrS(_Path, tool.ToolPath)
|
|
<< closetag(_Tool);
|
|
}
|
|
|
|
void VCProjectWriter::write(XmlOutput &xml, const VCLibrarianTool &tool)
|
|
{
|
|
xml
|
|
<< tag(_Tool)
|
|
<< attrS(_Name, _VCLibrarianTool)
|
|
<< attrX(_AdditionalDependencies, tool.AdditionalDependencies)
|
|
<< attrX(_AdditionalLibraryDirectories, tool.AdditionalLibraryDirectories)
|
|
<< attrX(_AdditionalOptions, tool.AdditionalOptions, " ")
|
|
<< attrX(_ExportNamedFunctions, tool.ExportNamedFunctions)
|
|
<< attrX(_ForceSymbolReferences, tool.ForceSymbolReferences)
|
|
<< attrT(_IgnoreAllDefaultLibraries, tool.IgnoreAllDefaultLibraries)
|
|
<< attrX(_IgnoreDefaultLibraryNames, tool.IgnoreDefaultLibraryNames)
|
|
<< attrS(_ModuleDefinitionFile, tool.ModuleDefinitionFile)
|
|
<< attrS(_OutputFile, tool.OutputFile)
|
|
<< attrT(_SuppressStartupBanner, tool.SuppressStartupBanner)
|
|
<< closetag(_Tool);
|
|
}
|
|
|
|
void VCProjectWriter::write(XmlOutput &xml, const VCResourceCompilerTool &tool)
|
|
{
|
|
xml
|
|
<< tag(_Tool)
|
|
<< attrS(_Name, _VCResourceCompilerTool)
|
|
<< attrS(_Path, tool.ToolPath)
|
|
<< attrX(_AdditionalIncludeDirectories, tool.AdditionalIncludeDirectories)
|
|
<< attrX(_AdditionalOptions, tool.AdditionalOptions, " ")
|
|
<< attrE(_Culture, tool.Culture, /*ifNot*/ rcUseDefault)
|
|
<< attrX(_FullIncludePath, tool.FullIncludePath)
|
|
<< attrT(_IgnoreStandardIncludePath, tool.IgnoreStandardIncludePath)
|
|
<< attrX(_PreprocessorDefinitions, tool.PreprocessorDefinitions)
|
|
<< attrS(_ResourceOutputFileName, tool.ResourceOutputFileName)
|
|
<< attrE(_ShowProgress, tool.ShowProgress, /*ifNot*/ linkProgressNotSet)
|
|
<< closetag(_Tool);
|
|
}
|
|
|
|
void VCProjectWriter::write(XmlOutput &xml, const VCEventTool &tool)
|
|
{
|
|
xml
|
|
<< tag(_Tool)
|
|
<< attrS(_Name, tool.ToolName)
|
|
<< attrS(_Path, tool.ToolPath)
|
|
<< attrS(_CommandLine, tool.CommandLine.join(vcCommandSeparator()))
|
|
<< attrS(_Description, tool.Description)
|
|
<< attrT(_ExcludedFromBuild, tool.ExcludedFromBuild)
|
|
<< closetag(_Tool);
|
|
}
|
|
|
|
void VCProjectWriter::write(XmlOutput &xml, const VCDeploymentTool &tool)
|
|
{
|
|
if (tool.AdditionalFiles.isEmpty())
|
|
return;
|
|
xml << tag(tool.DeploymentTag)
|
|
<< attrS(_RemoteDirectory, tool.RemoteDirectory)
|
|
<< attrE(_RegisterOutput, tool.RegisterOutput)
|
|
<< attrS(_AdditionalFiles, tool.AdditionalFiles)
|
|
<< closetag(tool.DeploymentTag);
|
|
}
|
|
|
|
void VCProjectWriter::write(XmlOutput &xml, const VCWinDeployQtTool &tool)
|
|
{
|
|
Q_UNUSED(xml);
|
|
Q_UNUSED(tool);
|
|
}
|
|
|
|
void VCProjectWriter::write(XmlOutput &xml, const VCConfiguration &tool)
|
|
{
|
|
xml << tag(_Configuration)
|
|
<< attrS(_Name, tool.Name)
|
|
<< attrS(_OutputDirectory, tool.OutputDirectory)
|
|
<< attrT(_ATLMinimizesCRunTimeLibraryUsage, tool.ATLMinimizesCRunTimeLibraryUsage)
|
|
<< attrT(_BuildBrowserInformation, tool.BuildBrowserInformation)
|
|
<< attrE(_CharacterSet, tool.CharacterSet, /*ifNot*/ charSetNotSet)
|
|
<< attrE(_ConfigurationType, tool.ConfigurationType)
|
|
<< attrS(_DeleteExtensionsOnClean, tool.DeleteExtensionsOnClean)
|
|
<< attrS(_ImportLibrary, tool.ImportLibrary)
|
|
<< attrS(_IntermediateDirectory, tool.IntermediateDirectory)
|
|
<< attrS(_PrimaryOutput, tool.PrimaryOutput)
|
|
<< attrS(_ProgramDatabase, tool.ProgramDatabase)
|
|
<< attrT(_RegisterOutput, tool.RegisterOutput)
|
|
<< attrE(_UseOfATL, tool.UseOfATL, /*ifNot*/ useATLNotSet)
|
|
<< attrE(_UseOfMfc, tool.UseOfMfc)
|
|
<< attrT(_WholeProgramOptimization, tool.WholeProgramOptimization);
|
|
write(xml, tool.compiler);
|
|
if (tool.ConfigurationType == typeStaticLibrary)
|
|
write(xml, tool.librarian);
|
|
else
|
|
write(xml, tool.linker);
|
|
write(xml, tool.manifestTool);
|
|
write(xml, tool.idl);
|
|
write(xml, tool.postBuild);
|
|
write(xml, tool.preBuild);
|
|
write(xml, tool.preLink);
|
|
write(xml, tool.resource);
|
|
write(xml, tool.deployment);
|
|
xml << closetag(_Configuration);
|
|
}
|
|
|
|
void VCProjectWriter::write(XmlOutput &xml, VCFilter &tool)
|
|
{
|
|
if(!tool.Files.count())
|
|
return;
|
|
|
|
if (!tool.Name.isEmpty()) {
|
|
xml << tag(_Filter)
|
|
<< attrS(_Name, tool.Name)
|
|
<< attrS(_Filter, tool.Filter)
|
|
<< attrS(_UniqueIdentifier, tool.Guid)
|
|
<< attrT(_ParseFiles, tool.ParseFiles);
|
|
}
|
|
for (int i = 0; i < tool.Files.count(); ++i) {
|
|
const VCFilterFile &info = tool.Files.at(i);
|
|
xml << tag(q_File)
|
|
<< attrS(_RelativePath, Option::fixPathToTargetOS(info.file))
|
|
<< data(); // In case no custom builds, to avoid "/>" endings
|
|
outputFileConfig(tool, xml, tool.Files.at(i).file);
|
|
xml << closetag(q_File);
|
|
}
|
|
if (!tool.Name.isEmpty())
|
|
xml << closetag(_Filter);
|
|
}
|
|
|
|
// outputs a given filter for all existing configurations of a project
|
|
void VCProjectWriter::outputFilter(VCProject &project, XmlOutput &xml, const QString &filtername)
|
|
{
|
|
QScopedPointer<Node> root;
|
|
if (project.SingleProjects.at(0).flat_files)
|
|
root.reset(new FlatNode);
|
|
else
|
|
root.reset(new TreeNode);
|
|
|
|
QString name, extfilter, guid;
|
|
triState parse = unset;
|
|
|
|
for (int i = 0; i < project.SingleProjects.count(); ++i) {
|
|
const VCFilter filter = project.SingleProjects.at(i).filterByName(filtername);
|
|
|
|
// Merge all files in this filter to root tree
|
|
for (int x = 0; x < filter.Files.count(); ++x)
|
|
root->addElement(filter.Files.at(x));
|
|
|
|
// Save filter setting from first filter. Next filters
|
|
// may differ but we cannot handle that. (ex. extfilter)
|
|
if (name.isEmpty()) {
|
|
name = filter.Name;
|
|
extfilter = filter.Filter;
|
|
parse = filter.ParseFiles;
|
|
guid = filter.Guid;
|
|
}
|
|
}
|
|
|
|
if (!root->hasElements())
|
|
return;
|
|
|
|
// Actual XML output ----------------------------------
|
|
if (!name.isEmpty()) {
|
|
xml << tag(_Filter)
|
|
<< attrS(_Name, name)
|
|
<< attrS(_Filter, extfilter)
|
|
<< attrS(_UniqueIdentifier, guid)
|
|
<< attrT(_ParseFiles, parse);
|
|
}
|
|
root->generateXML(xml, "", project, filtername); // output root tree
|
|
if (!name.isEmpty())
|
|
xml << closetag(_Filter);
|
|
}
|
|
|
|
// Output all configurations (by filtername) for a file (by info)
|
|
// A filters config output is in VCFilter.outputFileConfig()
|
|
void VCProjectWriter::outputFileConfigs(VCProject &project, XmlOutput &xml, const VCFilterFile &info, const QString &filtername)
|
|
{
|
|
xml << tag(q_File)
|
|
<< attrS(_RelativePath, Option::fixPathToTargetOS(info.file));
|
|
for (int i = 0; i < project.SingleProjects.count(); ++i) {
|
|
VCFilter filter = project.SingleProjects.at(i).filterByName(filtername);
|
|
if (filter.Config) // only if the filter is not empty
|
|
outputFileConfig(filter, xml, info.file);
|
|
}
|
|
xml << closetag(q_File);
|
|
}
|
|
|
|
void VCProjectWriter::outputFileConfig(VCFilter &filter, XmlOutput &xml, const QString &filename)
|
|
{
|
|
// Clearing each filter tool
|
|
filter.useCustomBuildTool = false;
|
|
filter.useCompilerTool = false;
|
|
filter.CustomBuildTool = VCCustomBuildTool();
|
|
filter.CompilerTool = VCCLCompilerTool();
|
|
|
|
// Unset some default options
|
|
filter.CustomBuildTool.config = filter.Config;
|
|
filter.CompilerTool.BufferSecurityCheck = unset;
|
|
filter.CompilerTool.DebugInformationFormat = debugUnknown;
|
|
filter.CompilerTool.ExceptionHandling = ehDefault;
|
|
filter.CompilerTool.GeneratePreprocessedFile = preprocessUnknown;
|
|
filter.CompilerTool.Optimization = optimizeDefault;
|
|
filter.CompilerTool.ProgramDataBaseFileName.clear();
|
|
filter.CompilerTool.RuntimeLibrary = rtUnknown;
|
|
filter.CompilerTool.WarningLevel = warningLevelUnknown;
|
|
filter.CompilerTool.config = filter.Config;
|
|
|
|
bool inBuild;
|
|
VCFilterFile info = filter.findFile(filename, &inBuild);
|
|
inBuild &= !info.excludeFromBuild;
|
|
|
|
if (inBuild) {
|
|
filter.addExtraCompiler(info);
|
|
if(filter.Project->usePCH)
|
|
filter.modifyPCHstage(info.file);
|
|
} else {
|
|
// Excluded files uses an empty compiler stage
|
|
if(info.excludeFromBuild)
|
|
filter.useCompilerTool = true;
|
|
}
|
|
|
|
// Actual XML output ----------------------------------
|
|
if (filter.useCustomBuildTool || filter.useCompilerTool || !inBuild) {
|
|
xml << tag(_FileConfiguration)
|
|
<< attr(_Name, filter.Config->Name)
|
|
<< (!inBuild ? attrS(_ExcludedFromBuild, "true") : noxml());
|
|
if (filter.useCustomBuildTool)
|
|
filter.Project->projectWriter->write(xml, filter.CustomBuildTool);
|
|
if (filter.useCompilerTool)
|
|
filter.Project->projectWriter->write(xml, filter.CompilerTool);
|
|
xml << closetag(_FileConfiguration);
|
|
}
|
|
}
|
|
|
|
QT_END_NAMESPACE
|