fsharp 3.1.1.26+dfsg2-3 / usr / lib / cli / fsharp / Microsoft.FSharp.Targets

<!-- Copyright (c) Microsoft Open Technologies, Inc.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information. -->

<!--
***********************************************************************************************
Microsoft.FSharp.Targets

WARNING:  DO NOT MODIFY this file unless you are knowledgeable about MSBuild and have
          created a backup copy.  Incorrect changes to this file will make it
          impossible to load or build your projects from the command-line or the IDE.

This file defines the steps in the standard build process specific for F# .NET projects.
For example, it contains the step that actually calls the F# compiler.  The remainder
of the build process is defined in Microsoft.Common.targets, which is imported by 
this file.

Copyright (C) Microsoft Corporation. Apache 2.0 License.
***********************************************************************************************
-->

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">


  <UsingTask TaskName="Fsc" AssemblyFile="FSharp.Build.dll"  />
  <UsingTask TaskName="CreateFSharpManifestResourceName" AssemblyFile="FSharp.Build.dll"  />

  <PropertyGroup>
    <ImportByWildcardBeforeMicrosoftFSharpTargets Condition="'$(ImportByWildcardBeforeMicrosoftFSharpTargets)' == ''">true</ImportByWildcardBeforeMicrosoftFSharpTargets>
    <ImportByWildcardAfterMicrosoftFSharpTargets Condition="'$(ImportByWildcardAfterMicrosoftFSharpTargets)' == ''">true</ImportByWildcardAfterMicrosoftFSharpTargets>
  </PropertyGroup>

  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\$(MSBuildThisFile)\ImportBefore\*" Condition="'$(ImportByWildcardBeforeMicrosoftFSharpTargets)' == 'true' and exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\$(MSBuildThisFile)\ImportBefore')"/>

  <PropertyGroup>
    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
    <DefaultLanguageSourceExtension>.fs</DefaultLanguageSourceExtension>
    <Language>F#</Language>
    <TargetRuntime>Managed</TargetRuntime>
    <Tailcalls Condition="'$(Tailcalls)'==''">$(Optimize)</Tailcalls>
    <FrameworkRegistryBase Condition="'$(TargetFrameworkIdentifier)'=='Silverlight'">Software\Microsoft\Microsoft SDKs\$(TargetFrameworkIdentifier)</FrameworkRegistryBase>
    <!-- Visual studio requires a non-empty RootNamespace value for "Add New Item" to work. -->
    <RootNamespace Condition="'$(RootNamespace)'==''">RootNamespace</RootNamespace>
    <Actual32Bit Condition="'$(TargetFrameworkVersion)'=='v2.0' or '$(TargetFrameworkVersion)'=='v3.0' or '$(TargetFrameworkVersion)'=='v3.5' or '$(TargetFrameworkVersion)'=='v4.0'">false</Actual32Bit>
    <Actual32Bit Condition="!('$(TargetFrameworkVersion)'=='v2.0' or '$(TargetFrameworkVersion)'=='v3.0' or '$(TargetFrameworkVersion)'=='v3.5' or '$(TargetFrameworkVersion)'=='v4.0')">$(Prefer32Bit)</Actual32Bit>
  </PropertyGroup>

  <!--
      The CreateManifestResourceNames target create the manifest resource names from the .RESX
      files.
      
          [IN]
          @(EmbeddedResource) - The list of EmbeddedResource items that have been pre-processed to add metadata about resource type
                                Expected Metadata "Type" can either be "Resx" or "Non-Resx"

          [OUT]
          @(EmbeddedResource) - EmbeddedResource items with metadata         
          
      For F# applications the transformation is like:

          Resources1.resx => Resources1 => Build into main assembly
          SubFolder\Resources1.resx => SubFolder.Resources1 => Build into main assembly
          Resources1.fr.resx => Resources1.fr => Build into satellite assembly
          Resources1.notaculture.resx => Resources1.notaculture => Build into main assembly

      For other project systems, this transformation may be different.
      -->
  <PropertyGroup>
    <CreateManifestResourceNamesDependsOn></CreateManifestResourceNamesDependsOn>
  </PropertyGroup>

  <PropertyGroup>
    <UsingXBuild>false</UsingXBuild>
    <UsingXBuild Condition="Exists('$(MSBuildExtensionsPath32)\..\4.0\Mono.Posix.dll')">true</UsingXBuild>
  </PropertyGroup>

  
  <Target
    Name="CreateManifestResourceNames"
    Condition="'@(EmbeddedResource)' != ''"
    DependsOnTargets="$(CreateManifestResourceNamesDependsOn)"
    >
    <ItemGroup>
      <_Temporary Remove="@(_Temporary)" />
    </ItemGroup>

  <!-- START XBUILD -->

  <!-- This is the implementation of CreateManifestResourceNames which is compatible with the way -->
  <!-- xbuild processes resource names -->

    <CreateFSharpManifestResourceName 
         Condition="'@(ResxWithNoCulture)' != '' AND '$(UsingXBuild)' == 'true'"
	 ResourceFiles="@(ResxWithNoCulture)" RootNamespace="$(RootNamespace)">
      <Output TaskParameter = "ManifestResourceNames" ItemName = "ManifestResourceWithNoCultureName" />
    </CreateFSharpManifestResourceName>

    <CreateFSharpManifestResourceName 
         Condition="'@(NonResxWithNoCulture)' != '' AND '$(UsingXBuild)' == 'true'"
	 ResourceFiles="@(NonResxWithNoCulture)" RootNamespace="$(RootNamespace)">
      <Output TaskParameter = "ManifestResourceNames" ItemName = "ManifestNonResxWithNoCulture" />
    </CreateFSharpManifestResourceName>

    <CreateFSharpManifestResourceName 
         Condition="'@(ResxWithCulture)' != '' AND '$(UsingXBuild)' == 'true'"
         ResourceFiles="@(ResxWithCulture)" RootNamespace="$(RootNamespace)">
      <Output TaskParameter = "ManifestResourceNames" ItemName = "ManifestResourceWithCultureName" />
    </CreateFSharpManifestResourceName>

    <CreateFSharpManifestResourceName 
         Condition="'@(NonResxWithCulture)' != '' AND '$(UsingXBuild)' == 'true'"
         ResourceFiles="@(NonResxWithCulture)" RootNamespace="$(RootNamespace)">
      <Output TaskParameter = "ManifestResourceNames" ItemName = "ManifestNonResxWithCulture" />
    </CreateFSharpManifestResourceName>

  <!-- END XBUILD -->


  <!-- START MSBUILD -->

  <!-- This is the implementation of CreateManifestResourceNames which is compatible with the way -->
  <!-- msbuild processes resource names -->

    <CreateFSharpManifestResourceName
          ResourceFiles="@(EmbeddedResource)"
          RootNamespace="$(RootNamespace)"
          Condition="'%(EmbeddedResource.ManifestResourceName)' == '' and ('%(EmbeddedResource.WithCulture)' == 'false' or '%(EmbeddedResource.Type)' == 'Resx') AND '$(UsingXBuild)' == 'false'">

      <Output TaskParameter="ResourceFilesWithManifestResourceNames" ItemName="_Temporary" />

    </CreateFSharpManifestResourceName>

    <CreateFSharpManifestResourceName
          ResourceFiles="@(EmbeddedResource)"
          RootNamespace="$(RootNamespace)"
          PrependCultureAsDirectory="false"
          Condition="'%(EmbeddedResource.ManifestResourceName)' == '' and '%(EmbeddedResource.WithCulture)' == 'true' and '%(EmbeddedResource.Type)' == 'Non-Resx' AND '$(UsingXBuild)' == 'false'">

      <Output TaskParameter="ResourceFilesWithManifestResourceNames" ItemName="_Temporary" />

    </CreateFSharpManifestResourceName>

  <!-- END MSBUILD -->


    <ItemGroup>
      <EmbeddedResource Remove="@(EmbeddedResource)" Condition="'%(EmbeddedResource.ManifestResourceName)' == ''"/>
      <EmbeddedResource Include="@(_Temporary)" />
      <_Temporary Remove="@(_Temporary)" />
    </ItemGroup>

  </Target>

  <ItemGroup>
    <DocFileItem Include="$(DocumentationFile)" Condition="'$(DocumentationFile)'!=''"/>
  </ItemGroup>

  <ItemGroup Condition="'$(_DebugSymbolsProduced)' == 'true' and '$(PdbFile)' != ''">
    <_DebugSymbolsIntermediatePathTemporary Include="$(PdbFile)"/>
    <!-- Add any missing .pdb extension, as the compiler does -->
    <_DebugSymbolsIntermediatePath Include="@(_DebugSymbolsIntermediatePathTemporary->'%(RootDir)%(Directory)%(Filename).pdb')"/>
  </ItemGroup>

  <PropertyGroup>
    <CoreCompileDependsOn></CoreCompileDependsOn>
  </PropertyGroup>

  <Target
      Name="CoreCompile"
      Inputs="$(MSBuildAllProjects);
                @(CompileBefore);
                @(Compile);                               
                @(CompileAfter);
                @(_CoreCompileResourceInputs);
                @(ManifestNonResxWithNoCultureOnDisk);
                $(ApplicationIcon);
                $(AssemblyOriginatorKeyFile);
                @(ReferencePath);
                @(CompiledLicenseFile);
                @(EmbeddedDocumentation); 
                $(Win32Resource);
                $(Win32Manifest);
                @(CustomAdditionalCompileInputs);
                $(VersionFile);
                $(KeyOriginatorFile)"
      Outputs="@(DocFileItem);
                 @(IntermediateAssembly);
                 @(_DebugSymbolsIntermediatePath);                 
                 $(NonExistentFile);
                 @(CustomAdditionalCompileOutputs)"
      DependsOnTargets="$(CoreCompileDependsOn)"
    >

    <!-- See bug 6053
        <Error  
            Condition="'$(SilverlightVersion)' != '' and !(Exists('$(ProgramFiles)\Microsoft F#\Silverlight\Libraries\Client\$(SilverlightVersion)\FSharp.Core.dll'))"
            Text="F# runtime for Silverlight version $(SilverlightVersion) is not installed. Please go to http://go.microsoft.com/fwlink/?LinkId=177463 to download and install matching F# runtime"
          />
          -->

    <Warning
        Condition="'$(Win32ResourceFile)' != '' "
        Text="The property &lt;Win32ResourceFile> has been renamed to &lt;Win32Resource>. Update your project file to ensure that the correct value is passed via the --win32res option to the F# compiler."
        />

    <!-- Condition is to filter out the _CoreCompileResourceInputs so that it doesn't pass in culture resources to the compiler -->
    <Fsc  Condition=" '%(_CoreCompileResourceInputs.WithCulture)' != 'true' "
          BaseAddress="$(BaseAddress)"
          CodePage="$(CodePage)"
          DebugSymbols="$(DebugSymbols)"
          DebugType="$(DebugType)"
          DefineConstants="$(DefineConstants)"
          DisabledWarnings="$(NoWarn)"
          DocumentationFile="$(DocumentationFile)"
          GenerateInterfaceFile="$(GenerateInterfaceFile)"
          KeyFile="$(KeyOriginatorFile)"
          LCID="$(LCID)"
          NoFramework="true"
          Optimize="$(Optimize)"
          OtherFlags="$(OtherFlags)"
          OutputAssembly="@(IntermediateAssembly)"
          PdbFile="$(PdbFile)"
          Platform="$(PlatformTarget)"
          References="@(ReferencePath)"
          ReferencePath="$(ReferencePath)"
          Resources="@(ManifestResourceWithNoCulture);@(ManifestNonResxWithNoCultureOnDisk);@(CompiledLicenseFile);@(AdditionalEmbeddedResource)"
          Sources="@(CompileBefore);@(Compile);@(CompileAfter)"
          Tailcalls="$(Tailcalls)"
          TargetType="$(OutputType)"
          ToolExe="$(FscToolExe)"
          ToolPath="$(FscToolPath)"
          TreatWarningsAsErrors="$(TreatWarningsAsErrors)"
          Utf8Output="$(Utf8Output)"
          ValidateTypeProviders="$(ValidateTypeProviders)"
          VersionFile="$(VersionFile)"
          VisualStudioStyleErrors="$(VisualStudioStyleErrors)"
          WarningLevel="$(WarningLevel)"
          WarningsAsErrors="$(WarningsAsErrors)"
          Win32ManifestFile="$(Win32Manifest)"
          Win32ResourceFile="$(Win32Resource)"
                />

     <!-- These parameters are supported by F# 3.0 but not yet supported by the F# open source edition:
              Prefer32Bit="$(Actual32Bit)" 
              SubsystemVersion="$(SubsystemVersion)"
              HighEntropyVA="$(HighEntropyVA)" -->

  <ItemGroup>
      <_CoreCompileResourceInputs Remove="@(_CoreCompileResourceInputs)" />
    </ItemGroup>

  </Target>

  <Import Project="$(MSBuildBinPath)\Microsoft.Common.targets"/>

  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\$(MSBuildThisFile)\ImportAfter\*" Condition="'$(ImportByWildcardAfterMicrosoftFSharpTargets)' == 'true' and exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\$(MSBuildThisFile)\ImportAfter')"/>

</Project>