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

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** 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 "msbuild_objectmodel.h"

#include "msvc_vcproj.h"

#include "msvc_vcxproj.h"

#include <qstringlist.h>

#include <qfileinfo.h>

QT_BEGIN_NAMESPACE

// XML Tags ---------------------------------------------------------

const char _CLCompile[]                         = "ClCompile";

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 _ItemGroup[]                         = "ItemGroup";

const char _Link[]                              = "Link";

const char _Midl[]                              = "Midl";

const char _Platform[]                          = "Platform";

const char _Platforms[]                         = "Platforms";

const char _ResourceCompile[]                   = "ResourceCompile";

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 _AdditionalManifestDependencies[]    = "AdditionalManifestDependencies";

const char _AdditionalOptions[]                 = "AdditionalOptions";

const char _AdditionalUsingDirectories[]        = "AdditionalUsingDirectories";

const char _AllowIsolation[]                    = "AllowIsolation";

const char _AlwaysAppend[]                      = "AlwaysAppend";

const char _ApplicationConfigurationMode[]      = "ApplicationConfigurationMode";

const char _AssemblerListingLocation[]          = "AssemblerListingLocation";

const char _AssemblerOutput[]                   = "AssemblerOutput";

const char _AssemblyDebug[]                     = "AssemblyDebug";

const char _AssemblyLinkResource[]              = "AssemblyLinkResource";

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 _CallingConvention[]                 = "CallingConvention";

const char _CharacterSet[]                      = "CharacterSet";

const char _ClientStubFile[]                    = "ClientStubFile";

const char _CLRImageType[]                      = "CLRImageType";

const char _CLRSupportLastError[]               = "CLRSupportLastError";

const char _CLRThreadAttribute[]                = "CLRThreadAttribute";

const char _CLRUnmanagedCodeCheck[]             = "CLRUnmanagedCodeCheck";

const char _Command[]                           = "Command";

const char _CommandLine[]                       = "CommandLine";

const char _CompileAs[]                         = "CompileAs";

const char _CompileAsManaged[]                  = "CompileAsManaged";

const char _CompileForArchitecture[]            = "CompileForArchitecture";

const char _CompileOnly[]                       = "CompileOnly";

const char _ConfigurationType[]                 = "ConfigurationType";

const char _CPreprocessOptions[]                = "CPreprocessOptions";

const char _CreateHotpatchableImage[]           = "CreateHotpatchableImage";

const char _CreateHotPatchableImage[]           = "CreateHotPatchableImage";

const char _Culture[]                           = "Culture";

const char _DataExecutionPrevention[]           = "DataExecutionPrevention";

const char _DebugInformationFormat[]            = "DebugInformationFormat";

const char _DefaultCharIsUnsigned[]             = "DefaultCharIsUnsigned";

const char _DefaultCharType[]                   = "DefaultCharType";

const char _DelayLoadDLLs[]                     = "DelayLoadDLLs";

const char _DelaySign[]                         = "DelaySign";

const char _DeleteExtensionsOnClean[]           = "DeleteExtensionsOnClean";

const char _Description[]                       = "Description";

const char _Detect64BitPortabilityProblems[]    = "Detect64BitPortabilityProblems";

const char _DisableLanguageExtensions[]         = "DisableLanguageExtensions";

const char _DisableSpecificWarnings[]           = "DisableSpecificWarnings";

const char _DisplayLibrary[]                    = "DisplayLibrary";

const char _DLLDataFileName[]                   = "DLLDataFileName";

const char _Driver[]                            = "Driver";

const char _EmbedManagedResourceFile[]          = "EmbedManagedResourceFile";

const char _EnableCOMDATFolding[]               = "EnableCOMDATFolding";

const char _EnableUAC[]                         = "EnableUAC";

const char _EnableErrorChecks[]                 = "EnableErrorChecks";

const char _EnableEnhancedInstructionSet[]      = "EnableEnhancedInstructionSet";

const char _EnableFiberSafeOptimizations[]      = "EnableFiberSafeOptimizations";

const char _EnableFunctionLevelLinking[]        = "EnableFunctionLevelLinking";

const char _EnableIntrinsicFunctions[]          = "EnableIntrinsicFunctions";

const char _EnablePREfast[]                     = "EnablePREfast";

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 _ErrorReporting[]                    = "ErrorReporting";

const char _ExceptionHandling[]                 = "ExceptionHandling";

const char _ExcludedFromBuild[]                 = "ExcludedFromBuild";

const char _ExpandAttributedSource[]            = "ExpandAttributedSource";

const char _ExportNamedFunctions[]              = "ExportNamedFunctions";

const char _FavorSizeOrSpeed[]                  = "FavorSizeOrSpeed";

const char _FixedBaseAddress[]                  = "FixedBaseAddress";

const char _FloatingPointModel[]                = "FloatingPointModel";

const char _FloatingPointExceptions[]           = "FloatingPointExceptions";

const char _ForceConformanceInForLoopScope[]    = "ForceConformanceInForLoopScope";

const char _ForceFileOutput[]                   = "ForceFileOutput";

const char _ForceSymbolReferences[]             = "ForceSymbolReferences";

const char _ForcedIncludeFiles[]                = "ForcedIncludeFiles";

const char _ForcedUsingFiles[]                  = "ForcedUsingFiles";

const char _FullIncludePath[]                   = "FullIncludePath";

const char _FunctionLevelLinking[]              = "FunctionLevelLinking";

const char _FunctionOrder[]                     = "FunctionOrder";

const char _GenerateClientFiles[]               = "GenerateClientFiles";

const char _GenerateDebugInformation[]          = "GenerateDebugInformation";

const char _GenerateManifest[]                  = "GenerateManifest";

const char _GenerateMapFile[]                   = "GenerateMapFile";

const char _GeneratePreprocessedFile[]          = "GeneratePreprocessedFile";

const char _GenerateServerFiles[]               = "GenerateServerFiles";

const char _GenerateStublessProxies[]           = "GenerateStublessProxies";

const char _GenerateTypeLibrary[]               = "GenerateTypeLibrary";

const char _GenerateXMLDocumentationFiles[]     = "GenerateXMLDocumentationFiles";

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 _IgnoreSpecificDefaultLibraries[]    = "IgnoreSpecificDefaultLibraries";

const char _IgnoreStandardIncludePath[]         = "IgnoreStandardIncludePath";

const char _ImageHasSafeExceptionHandlers[]     = "ImageHasSafeExceptionHandlers";

const char _ImportLibrary[]                     = "ImportLibrary";

const char _ImproveFloatingPointConsistency[]   = "ImproveFloatingPointConsistency";

const char _InlineFunctionExpansion[]           = "InlineFunctionExpansion";

const char _IntrinsicFunctions[]                = "IntrinsicFunctions";

const char _InterfaceIdentifierFileName[]       = "InterfaceIdentifierFileName";

const char _IntermediateDirectory[]             = "IntermediateDirectory";

const char _InterworkCalls[]                    = "InterworkCalls";

const char _KeyContainer[]                      = "KeyContainer";

const char _KeyFile[]                           = "KeyFile";

const char _Keyword[]                           = "Keyword";

const char _KeepComments[]                      = "KeepComments";

const char _LargeAddressAware[]                 = "LargeAddressAware";

const char _LinkDLL[]                           = "LinkDLL";

const char _LinkErrorReporting[]                = "LinkErrorReporting";

const char _LinkIncremental[]                   = "LinkIncremental";

const char _LinkStatus[]                        = "LinkStatus";

const char _LinkTimeCodeGeneration[]            = "LinkTimeCodeGeneration";

const char _LinkToManagedResourceFile[]         = "LinkToManagedResourceFile";

const char _LocaleID[]                          = "LocaleID";

const char _ManifestFile[]                      = "ManifestFile";

const char _MapExports[]                        = "MapExports";

const char _MapFileName[]                       = "MapFileName";

const char _MapLines[]                          = "MapLines ";

const char _MergedIDLBaseFileName[]             = "MergedIDLBaseFileName";

const char _MergeSections[]                     = "MergeSections";

const char _Message[]                           = "Message";

const char _MidlCommandFile[]                   = "MidlCommandFile";

const char _MinimalRebuild[]                    = "MinimalRebuild";

const char _MkTypLibCompatible[]                = "MkTypLibCompatible";

const char _ModuleDefinitionFile[]              = "ModuleDefinitionFile";

const char _MSDOSStubFileName[]                 = "MSDOSStubFileName";

const char _MultiProcessorCompilation[]         = "MultiProcessorCompilation";

const char _Name[]                              = "Name";

const char _NoEntryPoint[]                      = "NoEntryPoint";

const char _NullTerminateStrings[]              = "NullTerminateStrings";

const char _ObjectFile[]                        = "ObjectFile";

const char _ObjectFiles[]                       = "ObjectFiles";

const char _ObjectFileName[]                    = "ObjectFileName";

const char _OmitDefaultLibName[]                = "OmitDefaultLibName";

const char _OmitFramePointers[]                 = "OmitFramePointers";

const char _OpenMP[]                            = "OpenMP";

const char _OpenMPSupport[]                     = "OpenMPSupport";

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 _Path[]                              = "Path";

const char _PrecompiledHeader[]                 = "PrecompiledHeader";

const char _PrecompiledHeaderFile[]             = "PrecompiledHeaderFile";

const char _PrecompiledHeaderOutputFile[]       = "PrecompiledHeaderOutputFile";

const char _PrecompiledHeaderThrough[]          = "PrecompiledHeaderThrough";

const char _PreprocessorDefinitions[]           = "PreprocessorDefinitions";

const char _PreprocessKeepComments[]            = "PreprocessKeepComments";

const char _PreprocessOutputPath[]              = "PreprocessOutputPath";

const char _PreprocessSuppressLineNumbers[]     = "PreprocessSuppressLineNumbers";

const char _PreprocessToFile[]                  = "PreprocessToFile";

const char _PreventDllBinding[]                 = "PreventDllBinding";

const char _PrimaryOutput[]                     = "PrimaryOutput";

const char _Profile[]                           = "Profile";

const char _ProfileGuidedDatabase[]             = "ProfileGuidedDatabase";

const char _ProjectGUID[]                       = "ProjectGUID";

const char _ProcessorNumber[]                   = "ProcessorNumber";

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 _RemoveObjects[]                     = "RemoveObjects";

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 _SectionAlignment[]                  = "SectionAlignment";

const char _ServerStubFile[]                    = "ServerStubFile";

const char _SetChecksum[]                       = "SetChecksum";

const char _ShowIncludes[]                      = "ShowIncludes";

const char _ShowProgress[]                      = "ShowProgress";

const char _SmallerTypeCheck[]                  = "SmallerTypeCheck";

const char _SpecifySectionAttributes[]          = "SpecifySectionAttributes";

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 _SupportNobindOfDelayLoadedDLL[]     = "SupportNobindOfDelayLoadedDLL";

const char _SupportUnloadOfDelayLoadedDLL[]     = "SupportUnloadOfDelayLoadedDLL";

const char _SuppressCompilerWarnings[]          = "SuppressCompilerWarnings";

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 _TrackerLogDirectory[]               = "TrackerLogDirectory";

const char _TreatLibWarningAsErrors[]           = "TreatLibWarningAsErrors";

const char _TreatLinkerWarningAsErrors[]        = "TreatLinkerWarningAsErrors";

const char _TreatSpecificWarningsAsErrors[]     = "TreatSpecificWarningsAsErrors";

const char _TreatWarningAsError[]               = "TreatWarningAsError";

const char _TreatWChar_tAsBuiltInType[]         = "TreatWChar_tAsBuiltInType";

const char _TurnOffAssemblyGeneration[]         = "TurnOffAssemblyGeneration";

const char _TypeLibFormat[]                     = "TypeLibFormat";

const char _TypeLibraryFile[]                   = "TypeLibraryFile";

const char _TypeLibraryName[]                   = "TypeLibraryName";

const char _TypeLibraryResourceID[]             = "TypeLibraryResourceID";

const char _UACExecutionLevel[]                 = "UACExecutionLevel";

const char _UACUIAccess[]                       = "UACUIAccess";

const char _UndefineAllPreprocessorDefinitions[]= "UndefineAllPreprocessorDefinitions";

const char _UndefinePreprocessorDefinitions[]   = "UndefinePreprocessorDefinitions";

const char _UniqueIdentifier[]                  = "UniqueIdentifier";

const char _UseFullPaths[]                      = "UseFullPaths";

const char _UseOfATL[]                          = "UseOfATL";

const char _UseOfMfc[]                          = "UseOfMfc";

const char _UsePrecompiledHeader[]              = "UsePrecompiledHeader";

const char _UseUnicodeForAssemblerListing[]     = "UseUnicodeForAssemblerListing";

const char _ValidateAllParameters[]             = "ValidateAllParameters";

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 _Verbose[]                           = "Verbose";

const char _Version[]                           = "Version";

const char _WarnAsError[]                       = "WarnAsError";

const char _WarningLevel[]                      = "WarningLevel";

const char _WholeProgramOptimization[]          = "WholeProgramOptimization";

const char _XMLDocumentationFileName[]          = "XMLDocumentationFileName";

// XmlOutput stream functions ------------------------------

inline XmlOutput::xml_output attrTagT(const char *name, const triState v)

{

    if(v == unset)

        return noxml();

    return tagValue(name, (v == _True ? "true" : "false"));

}

inline XmlOutput::xml_output attrTagL(const char *name, qint64 v)

{

    return tagValue(name, QString::number(v));

}

/*ifNot version*/

inline XmlOutput::xml_output attrTagL(const char *name, qint64 v, qint64 ifn)

{

    if (v == ifn)

        return noxml();

    return tagValue(name, QString::number(v));

}

inline XmlOutput::xml_output attrTagS(const char *name, const QString &v)

{

    if(v.isEmpty())

        return noxml();

    return tagValue(name, v);

}

inline XmlOutput::xml_output attrTagX(const char *name, const QStringList &v, const char *s = ",")

{

    if(v.isEmpty())

        return noxml();

    QStringList temp = v;

    temp.append(QString("%(%1)").arg(name));

    return tagValue(name, temp.join(s));

}

inline XmlOutput::xml_output valueTagX(const QStringList &v, const char *s = " ")

{

    if(v.isEmpty())

        return noxml();

    return valueTag(v.join(s));

}

inline XmlOutput::xml_output valueTagDefX(const QStringList &v, const QString &tagName, const char *s = " ")

{

    if(v.isEmpty())

        return noxml();

    QStringList temp = v;

    temp.append(QString("%(%1)").arg(tagName));

    return valueTag(temp.join(s));

}

inline XmlOutput::xml_output valueTagT( const triState v)

{

    if(v == unset)

        return noxml();

    return valueTag(v == _True ? "true" : "false");

}

// VCXCLCompilerTool -------------------------------------------------

VCXCLCompilerTool::VCXCLCompilerTool()

    :   BrowseInformation(_False),

        BufferSecurityCheck(_False),

        CreateHotpatchableImage(unset),

        DisableLanguageExtensions(unset),

        EnableFiberSafeOptimizations(unset),

        EnablePREfast(unset),

        ExpandAttributedSource(unset),

        FloatingPointExceptions(unset),

        ForceConformanceInForLoopScope(unset),

        FunctionLevelLinking(unset),

        GenerateXMLDocumentationFiles(unset),

        IgnoreStandardIncludePath(unset),

        IntrinsicFunctions(unset),

        MinimalRebuild(unset),

        MultiProcessorCompilation(unset),

        OmitDefaultLibName(unset),

        OmitFramePointers(unset),

        Optimization("Disabled"),

        OpenMPSupport(unset),

        PreprocessKeepComments(unset),

        PreprocessSuppressLineNumbers(unset),

        RuntimeTypeInfo(unset),

        ShowIncludes(unset),

        SmallerTypeCheck(unset),

        StringPooling(unset),

        SuppressStartupBanner(unset),

        TreatWarningAsError(unset),

        TreatWChar_tAsBuiltInType(unset),

        UndefineAllPreprocessorDefinitions(unset),

        UseFullPaths(unset),

        UseUnicodeForAssemblerListing(unset),

        WholeProgramOptimization(unset)

{

}

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

{

    return xml

        << tag(_CLCompile)

            << attrTagX(_AdditionalIncludeDirectories, tool.AdditionalIncludeDirectories, ";")

            << attrTagX(_AdditionalOptions, tool.AdditionalOptions, " ")

            << attrTagX(_AdditionalUsingDirectories, tool.AdditionalUsingDirectories, ";")

            << attrTagS(_AlwaysAppend, tool.AlwaysAppend)

            << attrTagS(_AssemblerListingLocation, tool.AssemblerListingLocation)

            << attrTagS(_AssemblerOutput, tool.AssemblerOutput)

            << attrTagS(_BasicRuntimeChecks, tool.BasicRuntimeChecks)

            << attrTagT(_BrowseInformation, tool.BrowseInformation)

            << attrTagS(_BrowseInformationFile, tool.BrowseInformationFile)

            << attrTagT(_BufferSecurityCheck, tool.BufferSecurityCheck)

            << attrTagS(_CallingConvention, tool.CallingConvention)

            << attrTagS(_CompileAs, tool.CompileAs)

            << attrTagS(_CompileAsManaged, tool.CompileAsManaged)

            << attrTagT(_CreateHotpatchableImage, tool.CreateHotpatchableImage)

            << attrTagS(_DebugInformationFormat, tool.DebugInformationFormat)

            << attrTagT(_DisableLanguageExtensions, tool.DisableLanguageExtensions)

            << attrTagX(_DisableSpecificWarnings, tool.DisableSpecificWarnings, ";")

            << attrTagS(_EnableEnhancedInstructionSet, tool.EnableEnhancedInstructionSet)

            << attrTagT(_EnableFiberSafeOptimizations, tool.EnableFiberSafeOptimizations)

            << attrTagT(_EnablePREfast, tool.EnablePREfast)

            << attrTagS(_ErrorReporting, tool.ErrorReporting)

            << attrTagS(_ExceptionHandling, tool.ExceptionHandling)

            << attrTagT(_ExpandAttributedSource, tool.ExpandAttributedSource)

            << attrTagS(_FavorSizeOrSpeed, tool.FavorSizeOrSpeed)

            << attrTagT(_FloatingPointExceptions, tool.FloatingPointExceptions)

            << attrTagS(_FloatingPointModel, tool.FloatingPointModel)

            << attrTagT(_ForceConformanceInForLoopScope, tool.ForceConformanceInForLoopScope)

            << attrTagX(_ForcedIncludeFiles, tool.ForcedIncludeFiles, ";")

            << attrTagX(_ForcedUsingFiles, tool.ForcedUsingFiles, ";")

            << attrTagT(_FunctionLevelLinking, tool.FunctionLevelLinking)

            << attrTagT(_GenerateXMLDocumentationFiles, tool.GenerateXMLDocumentationFiles)

            << attrTagT(_IgnoreStandardIncludePath, tool.IgnoreStandardIncludePath)

            << attrTagS(_InlineFunctionExpansion, tool.InlineFunctionExpansion)

            << attrTagT(_IntrinsicFunctions, tool.IntrinsicFunctions)

            << attrTagT(_MinimalRebuild, tool.MinimalRebuild)

            << attrTagT(_MultiProcessorCompilation, tool.MultiProcessorCompilation)

            << attrTagS(_ObjectFileName, tool.ObjectFileName)

            << attrTagX(_ObjectFiles, tool.ObjectFiles, ";")

            << attrTagT(_OmitDefaultLibName, tool.OmitDefaultLibName)

            << attrTagT(_OmitFramePointers, tool.OmitFramePointers)

            << attrTagT(_OpenMPSupport, tool.OpenMPSupport)

            << attrTagS(_Optimization, tool.Optimization)

            << attrTagS(_PrecompiledHeader, tool.PrecompiledHeader)

            << attrTagS(_PrecompiledHeaderFile, tool.PrecompiledHeaderFile)

            << attrTagS(_PrecompiledHeaderOutputFile, tool.PrecompiledHeaderOutputFile)

            << attrTagT(_PreprocessKeepComments, tool.PreprocessKeepComments)

            << attrTagX(_PreprocessorDefinitions, tool.PreprocessorDefinitions, ";")

            << attrTagS(_PreprocessOutputPath, tool.PreprocessOutputPath)

            << attrTagT(_PreprocessSuppressLineNumbers, tool.PreprocessSuppressLineNumbers)

            << attrTagT(_PreprocessToFile, tool.PreprocessToFile)

            << attrTagS(_ProgramDataBaseFileName, tool.ProgramDataBaseFileName)

            << attrTagS(_ProcessorNumber, tool.ProcessorNumber)

            << attrTagS(_RuntimeLibrary, tool.RuntimeLibrary)

            << attrTagT(_RuntimeTypeInfo, tool.RuntimeTypeInfo)

            << attrTagT(_ShowIncludes, tool.ShowIncludes)

            << attrTagT(_SmallerTypeCheck, tool.SmallerTypeCheck)

            << attrTagT(_StringPooling, tool.StringPooling)

            << attrTagS(_StructMemberAlignment, tool.StructMemberAlignment)

            << attrTagT(_SuppressStartupBanner, tool.SuppressStartupBanner)

            << attrTagS(_TreatSpecificWarningsAsErrors, tool.TreatSpecificWarningsAsErrors)

            << attrTagT(_TreatWarningAsError, tool.TreatWarningAsError)

            << attrTagT(_TreatWChar_tAsBuiltInType, tool.TreatWChar_tAsBuiltInType)

            << attrTagT(_UndefineAllPreprocessorDefinitions, tool.UndefineAllPreprocessorDefinitions)

            << attrTagX(_UndefinePreprocessorDefinitions, tool.UndefinePreprocessorDefinitions, ";")

            << attrTagT(_UseFullPaths, tool.UseFullPaths)

            << attrTagT(_UseUnicodeForAssemblerListing, tool.UseUnicodeForAssemblerListing)

            << attrTagS(_WarningLevel, tool.WarningLevel)

            << attrTagT(_WholeProgramOptimization, tool.WholeProgramOptimization)

            << attrTagS(_XMLDocumentationFileName, tool.XMLDocumentationFileName)

        << closetag(_CLCompile);

}

bool VCXCLCompilerTool::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 '?':

        qWarning("Generator: Option '/?' : 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':

        PreprocessKeepComments = _True;

        break;

    case 'D':

        PreprocessorDefinitions += option+2;

        break;

    case 'E':