/****************************************************************************

**

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "msvc_objectmodel.h"

#include "msvc_vcproj.h"

#include <qstringlist.h>

#include <qfileinfo.h>

QT_BEGIN_NAMESPACE

// 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 _DebugInformationFormat[]            = "DebugInformationFormat";

const char _DefaultCharIsUnsigned[]             = "DefaultCharIsUnsigned";

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 _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 _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 _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";

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

}

// VCCLCompilerTool -------------------------------------------------

VCCLCompilerTool::VCCLCompilerTool()

    :        AssemblerOutput(asmListingNone),

        BasicRuntimeChecks(runtimeBasicCheckNone),

        BrowseInformation(brInfoNone),

        BufferSecurityCheck(_False),

        CallingConvention(callConventionDefault),

        CompileAs(compileAsDefault),

        CompileAsManaged(managedDefault),

        CompileOnly(unset),

        DebugInformationFormat(debugDisabled),

        DefaultCharIsUnsigned(unset),

        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),

        GlobalOptimizations(unset),

        IgnoreStandardIncludePath(unset),

        ImproveFloatingPointConsistency(unset),

        InlineFunctionExpansion(expandDefault),

        KeepComments(unset),

        MinimalRebuild(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(pchNone),

        WarnAsError(unset),

        WarningLevel(warningLevel_0),

        WholeProgramOptimization(unset),

        CompileForArchitecture(archUnknown),

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

}

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

}

XmlOutput &operator<<(XmlOutput &xml, const VCCLCompilerTool &tool)

{

    return 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(_DefaultCharIsUnsigned, tool.DefaultCharIsUnsigned)

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

            << (!tool.PrecompiledHeaderFile.isEmpty() || !tool.PrecompiledHeaderThrough.isEmpty() ? xformUsePrecompiledHeaderForNET2005(tool.UsePrecompiledHeader, tool.config->CompilerVersion) : noxml())

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

}

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':

        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') {

            QString opt(option);

            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;

        }

        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 {

                    AssemblerOutput = asmListingAssemblyOnly;

                }

                break;

            case 'a':

                AssemblerListingLocation = option+3;

                break;

            case 'I':

                ForcedIncludeFiles += option+3;

                break;