UnityScript.Build.targets

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

	<UsingTask
		TaskName="UnityScript.Build.Tasks.CreateUnityScriptManifestResourceName"
		AssemblyFile="UnityScript.Build.Tasks.dll" />

	<UsingTask
		TaskName="UnityScript.Build.Tasks.US"
		AssemblyFile="UnityScript.Build.Tasks.dll"/>

	<PropertyGroup>
		<MSBuildAllProjects Condition="'$(UnityScriptBinPath)' != ''">
		$(MSBuildAllProjects);$(UnityScriptBinPath)\UnityScript.Build.targets
		</MSBuildAllProjects>
		<MSBuildAllProjects Condition="'$(UnityScriptBinPath)' == ''">
		$(MSBuildAllProjects);$(MSBuildBinPath)\UnityScript.Build.targets
		</MSBuildAllProjects>
		<DefaultLanguageSourceExtension>.us</DefaultLanguageSourceExtension>
		<Language>UnityScript</Language>
	</PropertyGroup>

	<!--
    The CreateManifestResourceNames target create the manifest resource names
	from the .RESX files.

        [IN]
        @(ResxWithNoCulture) - The names the non-culture .RESX files.
        @(ResxWithCulture) - The names the culture .RESX files.
        @(NonResxWithNoCulture) - The names of the non-culture non-RESX
		                          files (like bitmaps, etc).
								  
        @(NonResxWithCulture) - The names of the culture non-RESX
		                       files (like bitmaps, etc).

        [OUT]
        @(ManifestResourceWithNoCultureName) - The corresponding manifest
		                                       resource name (.RESOURCE)
											   
        @(ManifestResourceWithCultureName) - The corresponding manifest
		                                     resource name (.RESOURCE)
											 
        @(ManifestNonResxWithNoCulture) - The corresponding manifest
		                                  resource name.
										  
        @(ManifestNonResxWithCulture) - The corresponding manifest
		                               resource name.

    For Boo applications the transformation is like:

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

    For other project systems, this transformation may be different.
    -->
	
	<PropertyGroup>
		<CreateManifestResourceNamesDependsOn>
		</CreateManifestResourceNamesDependsOn>
	</PropertyGroup>
	
	<Target
		Name="CreateManifestResourceNames"
		DependsOnTargets="$(CreateManifestResourceNamesDependsOn)"
	>
		<CallTarget Targets="CreateManifestResourceNames_35" Condition="'$(MSBuildToolsVersion)' == '3.5'"/>
		<CallTarget Targets="CreateManifestResourceNames_20" Condition="'$(MSBuildToolsVersion)' != '3.5'"/>
	</Target>
	
	<Target
		Name="CreateManifestResourceNames_20"
		Condition="'
		@(ResxWithNoCulture)
		@(ResxWithCulture)
		@(NonResxWithNoCulture)
		@(NonResxWithCulture)'!=''"
	>
		<!-- Create the target resource names for non-culture resx files -->
		<CreateUnityScriptManifestResourceName
			Condition="'@(ResxWithNoCulture)'!=''"
			ResourceFiles="@(ResxWithNoCulture)"
			RootNamespace="$(RootNamespace)">
			
			<Output
				TaskParameter="ManifestResourceNames"
				ItemName="ManifestResourceWithNoCultureName"/>
		
		</CreateUnityScriptManifestResourceName>
		
		<!-- Create the target resource names for culture resx files. -->
		<CreateUnityScriptManifestResourceName
			Condition="'@(ResxWithCulture)'!=''"
			ResourceFiles="@(ResxWithCulture)"
			RootNamespace="$(RootNamespace)">
			
			<Output
				TaskParameter="ManifestResourceNames"
				ItemName="ManifestResourceWithCultureName"/>
		
		</CreateUnityScriptManifestResourceName>
		
		<!-- Create the target resource names for non-culture non-resx files. -->
		<CreateUnityScriptManifestResourceName
			Condition="'@(NonResxWithNoCulture)'!=''"
			ResourceFiles="@(NonResxWithNoCulture)"
			RootNamespace="$(RootNamespace)">
			
			<Output
				TaskParameter="ManifestResourceNames"
				ItemName="ManifestNonResxWithNoCulture"/>
		
		</CreateUnityScriptManifestResourceName>
		
		<!-- Create the target resource names for culture non-resx files. -->
		<CreateUnityScriptManifestResourceName
			Condition="'@(NonResxWithCulture)'!=''"
			ResourceFiles="@(NonResxWithCulture)"
			RootNamespace="$(RootNamespace)">
			
			<Output
				TaskParameter="ManifestResourceNames"
				ItemName="ManifestNonResxWithCulture"/>
		
		</CreateUnityScriptManifestResourceName>
	</Target>
	
	<Target
		Name="CreateManifestResourceNames_35"
		Condition="'@(EmbeddedResource)' != ''"
	>
		<ItemGroup>
			<_Temporary Remove="@(_Temporary)" />
		</ItemGroup>
		
		<CreateUnityScriptManifestResourceName
			ResourceFiles="@(EmbeddedResource)"
			RootNamespace="$(RootNamespace)"
			Condition="'%(EmbeddedResource.ManifestResourceName)' == ''">
			
			<Output TaskParameter="ResourceFilesWithManifestResourceNames" ItemName="_Temporary" />
		
		</CreateUnityScriptManifestResourceName>
		
		<ItemGroup>
			<EmbeddedResource Remove="@(EmbeddedResource)" Condition="'%(EmbeddedResource.ManifestResourceName)' == ''"/>
			<EmbeddedResource Include="@(_Temporary)" />
			<_Temporary Remove="@(_Temporary)" />
		</ItemGroup>
	</Target>
	
	<PropertyGroup>
		
		<!--
		"None" is not technically a valid DebugType, so we can't pass it
		in as such to the compiler.  So here, we modify the properties so
	    they make sense.
		-->
		<DebugSymbols Condition="'$(DebugType)' == 'none'">false</DebugSymbols>
		<DebugType    Condition="'$(DebugType)' == 'none'"></DebugType>
		
		<!-- Provide a facility to override UseHostCompilerIfAvailable-->
		<UseHostCompilerIfAvailable Condition="'$(UseHostCompilerIfAvailable)' == ''">true</UseHostCompilerIfAvailable>
	
	</PropertyGroup>
	
	<ItemGroup>
		<DocFileItem Include="$(DocumentationFile)" Condition="'$(DocumentationFile)'!=''">
			<InProject>false</InProject>
		</DocFileItem>
	</ItemGroup>
	
	<PropertyGroup>
		<CoreCompileDependsOn>_ComputeNonExistentFileProperty</CoreCompileDependsOn>
	</PropertyGroup>
	
	<PropertyGroup Condition=" '$(UnityScriptToolPath)' != '' ">
		<ReferencePath>$(ReferencePath);$(UnityScriptToolPath)</ReferencePath>
	</PropertyGroup>
	<PropertyGroup Condition=" '$(UnityScriptToolPath)' == '' ">
		<ReferencePath>$(ReferencePath);$(UnityScriptBinPath)</ReferencePath>
	</PropertyGroup>
	
	<Target
		Name="CoreCompile"
		Inputs="$(MSBuildAllProjects);
		        @(Compile);
		        @(ManifestResourceWithNoCulture);
		        $(ApplicationIcon);
		        $(AssemblyOriginatorKeyFile);
		        @(ManifestNonResxWithNoCultureOnDisk);
		        @(ReferencePath);
		        @(CompiledLicenseFile)"
		Outputs="@(IntermediateAssembly)"
		DependsOnTargets="$(CoreCompileDependsOn)">

		<US
			DefineSymbols="$(DefineConstants)"
			EmitDebugInformation="$(DebugSymbols)"
			GenerateFullPaths="$(GenerateFullPaths)"
			OutputAssembly="@(IntermediateAssembly)"
			References="@(ReferencePath)"
			Resources="@(ManifestResourceWithNoCulture);
			           @(ManifestNonResxWithNoCultureOnDisk);
			           @(CompiledLicenseFile)"
			ResponseFiles="$(CompilerResponseFile)"
			SourceDirectories="$(SourceDirectories)"
			Sources="@(Compile)"
			TargetType="$(OutputType)"
			ToolPath="$(UnityScriptToolPath)"
			Verbose="$(Verbose)"

			BaseClass="$(BaseClass)"
			Method="$(Method)"
			Expando="$(Expando)"
			Imports="$(Imports)"
			Pragmas="$(Pragmas)"
			TypeInferenceRuleAttribute="$(TypeInferenceRuleAttribute)"
			SuppressedWarnings="$(NoWarn)"
		/>
		
		<Copy
			Condition=" ('$(UnityScriptToolPath)' == '') and ('$(CopyUnityScriptLangToOutput)' != 'false') "
			SkipUnchangedFiles="true"
			SourceFiles="$(UnityScriptBinPath)\UnityScript.Lang.dll"
			DestinationFolder="$(OutputPath)"/>
		
		<Copy
			Condition=" ('$(UnityScriptToolPath)' != '') and ('$(CopyUnityScriptLangToOutput)' != 'false') "
			SkipUnchangedFiles="true"
			SourceFiles="$(UnityScriptToolPath)\UnityScript.Lang.dll"
			DestinationFolder="$(OutputPath)"/>
	</Target>
	
	<Import Project="$(MSBuildBinPath)\Microsoft.Common.targets" />
</Project>