Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / wpf / src / BuildTasks / Microsoft / Build / Tasks / Windows / MarkupCompilePass1.cs / 1 / MarkupCompilePass1.cs
//----------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
// Description: An MSBuild Task that can generate .xaml markup file to specific
// Mangaged language code such as .cs, .js, .vb,etc, and /or binary
// token file .baml
//
// Spec: http://avalon/app/Compilation/Avalon-MSBUILD%20Targets.doc
//
// History:
// 06/20/03: weibz rewrite and moved over to WCP tree
//
//---------------------------------------------------------------------------
using System;
using System.IO;
using System.Collections;
using System.Security;
using System.Security.Permissions;
using System.Globalization;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.InteropServices;
using System.CodeDom;
using System.CodeDom.Compiler;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
using MS.Utility;
using MS.Internal;
using MS.Internal.Tasks;
using MS.Internal.Markup;
// Since we disable PreSharp warnings in this file, PreSharp warning is unknown to C# compiler.
// We first need to disable warnings about unknown message numbers and unknown pragmas.
#pragma warning disable 1634, 1691
namespace Microsoft.Build.Tasks.Windows
{
#region MarkupCompilePass1 Task class
///
/// Class of MarkupCompilePass1 Task
///
public sealed class MarkupCompilePass1 : Task
{
// Security Concerns: hamidm 04/13/05
//
// 1) OutputPath property exposes the current dir and is publicly available.
// 2) This class generates code files and copies them on the disk.
//
// The above two are already mitigated by the following facts:
//
// 1) PresentationBuildTasks is not APTCA and thus partial trust assemblies
// cannot call into it.
// 2) There is a possibility that some APTCA assembly (eg. PF.dll) can create
// this object and pass it on to partial trust code. This is mitigated by
// FxCop rule against it.
//
//-----------------------------------------------------
//
// Constructors
//
//-----------------------------------------------------
#region Constructors
///
/// Constructor
///
public MarkupCompilePass1( ) : base(SR.ResourceManager)
{
// set the source directory
_sourceDir = Directory.GetCurrentDirectory() + "\\";
_outputType = SharedStrings.WinExe;
// By default, no localization information is stripped out.
_localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.None;
_nErrors = 0;
}
#endregion Constructors
//------------------------------------------------------
//
// Public Methods
//
//-----------------------------------------------------
#region Public Methods
///
/// Execute method in Task
///
///
/// The Language the managed compiler supports.
/// the valid languages are C#, VB, Jscript, J#, C++
///
[Required]
public string Language
{
get { return _language; }
set { _language = value;}
}
///
/// The valid source file extension for the passed language.
/// Normally a language supports more valid source file extensions.
/// User could choose one of them in project file.
/// If this property is not set, we will take use of the default one for the language.
///
public string LanguageSourceExtension
{
get { return _languageSourceExtension; }
set { _languageSourceExtension = value; }
}
///
/// OutputPath : Generated code files, Baml fles will be put in this directory.
///
[Required]
public string OutputPath
{
get { return _outputDir; }
set
{
string filePath = value;
// Get the relative path based on sourceDir
_outputDir= TaskHelper.CreateFullFilePath(filePath, SourceDir);
// Make sure OutputDir always ends with '\\'.
if (!_outputDir.EndsWith("\\", StringComparison.Ordinal))
{
_outputDir += "\\";
}
}
}
///
/// OutputType
/// Valid types: winexe, exe, library, netmodule.
///
[Required]
public string OutputType
{
get { return _outputType; }
set { _outputType = TaskHelper.GetLowerString(value); }
}
///
/// AssemblyName
/// The short name of assembly which will be generated for this project.
///
[Required]
public string AssemblyName
{
get { return _assemblyName; }
set { _assemblyName = value; }
}
///
/// The version of the assembly
///
public string AssemblyVersion
{
get { return _assemblyVersion; }
set { _assemblyVersion = value; }
}
///
/// The public key token of the assembly
///
public string AssemblyPublicKeyToken
{
get { return _assemblyPublicKeyToken; }
set { _assemblyPublicKeyToken = value; }
}
///
/// Root namespace for the classes inside the project.
/// It is also used as default CLR namespace of a generated code file
/// when the corresponding markup page is not set x:Class attribute.
///
public string RootNamespace
{
get { return _rootNamespace; }
set { _rootNamespace = value; }
}
///
/// The UI Culture controls which culture satellite assembly will hold
/// the generated baml files.
/// If UICulture is not set, the generated baml files will be embedded
/// into main assembly.
///
public string UICulture
{
get { return _uiCulture; }
set { _uiCulture = value; }
}
///
/// Source code file list for the current project.
/// It doesnt include any generated code files.
///
public ITaskItem[] SourceCodeFiles
{
get { return _sourceCodeFiles; }
set { _sourceCodeFiles = value; }
}
///
/// DefineConstants
///
/// Keep the current value of DefineConstants.
///
/// DefineConstants can affect the final assembly generation, if DefineConstants
/// value is changed, the public API might be changed in the target assembly, which
/// then has potential impacts on compilation for xaml files which contains local types.
///
///
public string DefineConstants
{
get { return _defineConstants; }
set { _defineConstants = value; }
}
///
/// ApplicationMarkup
///
public ITaskItem [] ApplicationMarkup
{
get { return _applicationMarkup; }
set { _applicationMarkup = value;}
}
///
/// Description
///
public ITaskItem [] PageMarkup
{
get { return _pagemarkupFiles; }
set { _pagemarkupFiles = value; }
}
///
/// Splash screen image to be displayed before application init
///
public ITaskItem[] SplashScreen
{
get { return _splashScreen; }
set { _splashScreen = value; }
}
internal string SplashImageName
{
get
{
if (SplashScreen != null && SplashScreen.Length > 0)
{
return SplashScreen[0].ItemSpec.ToLowerInvariant();
}
return null;
}
}
///
/// Loose file content list
///
public ITaskItem[] ContentFiles
{
get { return _contentFiles; }
set { _contentFiles = value; }
}
///
/// Assembly References.
///
///
///
public bool XamlDebuggingInformation
{
get { return _xamlDebuggingInformation; }
set { _xamlDebuggingInformation = value; }
}
///
/// Keep a list of Build control files.
/// If one of them is changed since last build, it would trigger recompilation of all the xaml files.
/// Such as WinFX target file change could require a rebuild etc.
///
public ITaskItem [] ExtraBuildControlFiles
{
get { return _extraBuildControlFiles; }
set { _extraBuildControlFiles = value; }
}
///
///If true code for supporting hosting in Browser is generated
///
public string HostInBrowser
{
get { return _hostInBrowser; }
set { _hostInBrowser = TaskHelper.GetLowerString(value); }
}
///
/// Controls how to generate localization information for each xaml file.
/// Valid values: None, CommentsOnly, All.
///
public string LocalizationDirectivesToLocFile
{
get
{
string localizationDirectives = SharedStrings.Loc_None;
switch (_localizationDirectives)
{
case MS.Internal.LocalizationDirectivesToLocFile.None :
localizationDirectives = SharedStrings.Loc_None;
break;
case MS.Internal.LocalizationDirectivesToLocFile.CommentsOnly:
localizationDirectives = SharedStrings.Loc_CommentsOnly;
break;
case MS.Internal.LocalizationDirectivesToLocFile.All:
localizationDirectives = SharedStrings.Loc_All;
break;
}
return localizationDirectives;
}
set
{
string localizationDirectives = value;
if (localizationDirectives != null)
{
localizationDirectives = localizationDirectives.ToLower(CultureInfo.InvariantCulture);
}
switch (localizationDirectives)
{
case SharedStrings.Loc_None :
_localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.None;
break;
case SharedStrings.Loc_CommentsOnly :
_localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.CommentsOnly;
break;
case SharedStrings.Loc_All :
_localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.All;
break;
default:
_localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.Unknown;
break;
}
}
}
///
/// Known reference paths hold referenced assemblies which are never changed during the build procedure.
/// such as references in GAC, in framework directory or framework SDK directory etc.
/// Users could add their own known reference paths in project files.
///
public string[] KnownReferencePaths
{
get
{
return _knownReferencePaths;
}
set
{
_knownReferencePaths = value;
}
}
///
/// A list of reference assemblies that are to change for sure during the build cycle.
///
/// Such as in VS.NET, if one project wants to reference another project's output, the
/// second project's output could be put in AssembliesGeneratedDuringBuild list.
/// Note: Once this property is set, it must contain the complete list of generated
/// assemblies in this build solution.
///
public string[] AssembliesGeneratedDuringBuild
{
get
{
return _assembliesGeneratedDuringBuild;
}
set
{
_assembliesGeneratedDuringBuild = value;
}
}
///
/// Control whether to run the compilation in second appdomain.
/// By default, it is set to true, but project can set this property
/// to false to make markup file compilation faster.
///
public bool AlwaysCompileMarkupFilesInSeparateDomain
{
get { return _alwaysCompileMarkupFilesInSeparateDomain; }
set { _alwaysCompileMarkupFilesInSeparateDomain = value; }
}
///
/// Generated source code files for the given programing language.
///
[Output]
public ITaskItem [] GeneratedCodeFiles
{
get
{
if (_generatedCodeFiles == null)
_generatedCodeFiles = new TaskItem[0];
return _generatedCodeFiles;
}
set
{
_generatedCodeFiles = value;
}
}
///
/// Generated Baml files for the passed Markup files.
///
[Output]
public ITaskItem [] GeneratedBamlFiles
{
get
{
if (_generatedBamlFiles == null)
_generatedBamlFiles = new TaskItem[0];
return _generatedBamlFiles;
}
set
{
_generatedBamlFiles = value;
}
}
///
/// The generated localization file for each localizable xaml file.
///
[Output]
public ITaskItem[] GeneratedLocalizationFiles
{
get
{
if (_generatedLocalizationFiles == null)
_generatedLocalizationFiles = new TaskItem[0];
return _generatedLocalizationFiles;
}
set
{
_generatedLocalizationFiles = value;
}
}
#region Local Reference Xaml markup files
///
/// Indicate whether the project contains xaml files which reference local types and
/// the corresponding baml file will be embedded into main assembly.
///
[Output]
public bool RequirePass2ForMainAssembly
{
get { return _requirePass2ForMainAssembly; }
set { _requirePass2ForMainAssembly = value; }
}
///
/// Indicate whether the project contains xaml files which reference local types and
/// the corresponding baml file will be embedded into satellite assembly for current UICulture.
///
[Output]
public bool RequirePass2ForSatelliteAssembly
{
get { return _requirePass2ForSatelliteAssembly; }
set { _requirePass2ForSatelliteAssembly = value; }
}
#endregion Local Reference Xaml markup files
///
/// A complete list of files which are generated by MarkupCompiler.
///
[Output]
public ITaskItem[] AllGeneratedFiles
{
get { return _allGeneratedFiles; }
set { _allGeneratedFiles = value; }
}
#endregion Public Properties
#region internal methods
//
// Get the generated code file and baml file for a given xaml file
// If the generated file doesn't exist, the output paramter is set to empty string.
//
internal void GetGeneratedFiles(string xamlFile, out string codeFile, out string bamlFile)
{
string newSourceDir = SourceDir;
codeFile = String.Empty;
bamlFile = String.Empty;
if (String.IsNullOrEmpty(xamlFile))
{
// if xaml file is empty, return it now.
return;
}
string relativeFilePath = GetResolvedFilePath(xamlFile, ref newSourceDir);
string langExt =
(TaskFileService.IsRealBuild? SharedStrings.GeneratedExtension : SharedStrings.IntellisenseGeneratedExtension)
+ LanguageSourceExtension;
// Replace the .xaml with corresponding generated file extensions.
codeFile = OutputPath + Path.ChangeExtension(relativeFilePath, langExt);
bamlFile = OutputPath + Path.ChangeExtension(relativeFilePath, SharedStrings.BamlExtension);
// If the file doesn't exist, return empty string for the corresponding output parameter.
if (!TaskFileService.Exists(codeFile))
{
codeFile = String.Empty;
}
//
// Baml file is not generated for intellisense build.
//
if ((TaskFileService.IsRealBuild == false) || (!TaskFileService.Exists(bamlFile)))
{
bamlFile = String.Empty;
}
}
#endregion internal methods
#region internal Properties
internal bool IsApplicationTarget
{
get { return _isApplicationTarget; }
}
//
// ApplicationFile
//
internal string ApplicationFile
{
get { return _applicationFile; }
}
//
// PageMarkupCache
// It is caculated from current PageMarkup list, will be saved in the
// cache file to support incremental compilation.
//
internal string PageMarkupCache
{
get { return _pageMarkupCache; }
}
//
// ContentFilesCache
// It is caculated from current ContentFiles list, will be saved in the
// cache file to support incremental compilation.
//
internal string ContentFilesCache
{
get { return _contentFilesCache; }
}
//
// SourceCodeFilesCache
// It is caculated from current SourceCodeFiles list, will be saved in the
// cache file to support incremental compilation.
//
internal string SourceCodeFilesCache
{
get { return _sourceCodeFilesCache; }
}
//
// ReferencesCache
// It is caculated from current ReferencesCache list, will be saved in the
// cache file to support incremental compilation.
//
internal string ReferencesCache
{
get { return _referencesCache; }
}
//
// Application File with Local Type
//
internal LocalReferenceFile LocalApplicationFile
{
get { return _localApplicationFile; }
}
//
// Markup Page files with local types
//
internal LocalReferenceFile[] LocalMarkupPages
{
get { return _localMarkupPages; }
}
//
// TaskFileService
//
internal ITaskFileService TaskFileService
{
get { return _taskFileService; }
}
//
// CompilerState
//
internal CompilerState CompilerState
{
get { return _compilerState; }
}
//
// CompilerLocalReference
//
internal CompilerLocalReference CompilerLocalReference
{
get { return _compilerLocalRefCache; }
}
//
// Tell MarkupCompilePass2 whether it further handles InternalTypeHelper class.
//
internal bool FurtherCheckInternalTypeHelper
{
get { return _furtherCheckInternalTypeHelper; }
set { _furtherCheckInternalTypeHelper = value; }
}
//
// Get the file path for the generated InternalTypeHelper class.
//
internal string InternalTypeHelperFile
{
get
{
string fileName = SharedStrings.GeneratedInternalTypeHelperFileName
+ (TaskFileService.IsRealBuild? SharedStrings.GeneratedExtension : SharedStrings.IntellisenseGeneratedExtension)
+ LanguageSourceExtension;
return Path.Combine(OutputPath, fileName);
}
}
#endregion internal Properties
//-----------------------------------------------------
//
// Private Methods
//
//------------------------------------------------------
#region Private Methods
//
// Check if all the input properties are set valid values
// If any property contains an invalid value, Error counter _nErrors will
// be changed.
//
private void VerifyInputs()
{
// Check if the OutputType is valid type.
IsSupportedOutputType(OutputType);
// Check if the Localization property is set correctly.
IsValidLocalizationDirectives();
VerifyApplicationFile();
if (PageMarkup != null && PageMarkup.Length > 0)
{
VerifyInputTaskItems(PageMarkup);
}
if (SplashScreen != null && SplashScreen.Length > 1)
{
Log.LogErrorWithCodeFromResources(SRID.MultipleSplashScreenImages);
_nErrors++;
}
}
//
// Verify if the Application file is set correctly
// in project file.
//
private void VerifyApplicationFile()
{
if (!IsApplicationTarget)
{
//
// For non Application target type.
//
if (ApplicationMarkup != null && ApplicationMarkup.Length > 0)
{
//
// For non-Application target type, Application definition should not be set.
//
Log.LogErrorWithCodeFromResources(SRID.AppDefIsNotRequired);
_nErrors++;
}
}
else
{
//
// For Application Target type.
//
if (ApplicationMarkup != null && ApplicationMarkup.Length > 0)
{
if (ApplicationMarkup.Length > 1)
{
Log.LogErrorWithCodeFromResources(SRID.MutlipleApplicationFiles);
_nErrors++;
}
_applicationFile = TaskHelper.CreateFullFilePath(ApplicationMarkup[0].ItemSpec, SourceDir);
Log.LogMessageFromResources(MessageImportance.Low, SRID.ApplicationDefinitionFile, ApplicationFile);
if (!TaskFileService.Exists(ApplicationFile))
{
Log.LogErrorWithCodeFromResources(SRID.FileNotFound, ApplicationFile);
_nErrors++;
}
}
}
}
//
// Don't support local reference xaml compilation for Container and netmodule type.
//
private bool IsSupportedOutputType(string outputType)
{
bool isSupported = false;
switch (outputType)
{
case SharedStrings.Exe:
case SharedStrings.WinExe:
isSupported = true;
_isApplicationTarget = true;
break;
case SharedStrings.Library:
case SharedStrings.Module:
isSupported = true;
break;
default:
isSupported = false;
break;
}
if (isSupported == false)
{
Log.LogErrorWithCodeFromResources(SRID.TargetIsNotSupported, outputType);
// Keep the error numbers so that the task can stop immediatelly
// later when Execute( ) is called.
_nErrors++;
}
return isSupported;
}
private bool IsValidLocalizationDirectives()
{
bool bValid = true;
if (_localizationDirectives == MS.Internal.LocalizationDirectivesToLocFile.Unknown)
{
bValid = false;
Log.LogErrorWithCodeFromResources(SRID.WrongLocalizationPropertySetting_Pass1);
// Keep the error numbers so that the task can stop immediatelly
// later when Execute( ) is called.
_nErrors++;
}
return bValid;
}
//
// Check if the passed TaskItems have valid ItemSpec
//
//
//
// Generate the required Output Items.
//
private void GenerateOutputItems( )
{
// For the rest target types,
// Create the output lists for CS and Baml files.
ArrayList bamlFileList = new ArrayList();
ArrayList csFileList = new ArrayList();
ArrayList localRefPageList = new ArrayList();
ArrayList localRefAppdefList = new ArrayList();
// Generate Output Items for PageMarkup
if (PageMarkup != null && PageMarkup.Length > 0)
{
GenerateOutputItemsForCompiledXamlFiles(PageMarkup,
_localXamlPages,
ref bamlFileList,
ref csFileList,
ref localRefPageList);
}
//
// Generate output items for ApplicationDefinition if it is set in the project file.
//
if (ApplicationFile != null && ApplicationFile.Length > 0)
{
string[] appdefLocalList = null;
if (!String.IsNullOrEmpty(_localXamlApplication))
{
appdefLocalList = new string[1] { _localXamlApplication };
}
GenerateOutputItemsForCompiledXamlFiles(ApplicationMarkup,
appdefLocalList,
ref bamlFileList,
ref csFileList,
ref localRefAppdefList);
}
if (TaskFileService.Exists(ContentCodeFile))
{
csFileList.Add(new TaskItem(ContentCodeFile));
}
// Generate the Baml, code and /or locally-defined type related output items.
GeneratedBamlFiles = (ITaskItem[])bamlFileList.ToArray(typeof(ITaskItem));
if (!SkipMarkupCompilation)
{
if (localRefAppdefList.Count > 0)
{
_localApplicationFile = (LocalReferenceFile)localRefAppdefList[0];
}
if (localRefPageList.Count > 0)
{
_localMarkupPages = (LocalReferenceFile[])localRefPageList.ToArray(typeof(LocalReferenceFile));
}
//
// If MarkupCompilePass2 is required for Main assembly, there is no need to invoke MarkupCompilePass2
// for satellite assembly again.
//
if (_requirePass2ForMainAssembly)
{
_requirePass2ForSatelliteAssembly = false;
}
}
//
// Detect whether or not to ask Pass2 to do further handding for the InternalTypeHelper class.
//
// Only when all of below conditions are true, it requires Pass2 to further handling this wrapper class:
//
// 1. InternalTypeHelper file exists.
// 2. It is a CleanBuild.
// 3. No any xaml files which don't contain local types contains internal types from friend assembly.
// 4. _requirePass2ForMainAssembly is true.
//
// If InternalTypeHelper File exists, Pass1 would always add it to the code file list, so that consequent task
// can take it. If Pass2 determines that this wrapper class is not required, it can simply make an empty file.
// But we still keep the list of generated code files.
bool existsInternalTypeHelper = TaskFileService.Exists(InternalTypeHelperFile);
if (IsCleanBuild && existsInternalTypeHelper && _requirePass2ForMainAssembly && !_hasInternals)
{
FurtherCheckInternalTypeHelper = true;
}
else
{
FurtherCheckInternalTypeHelper = false;
}
if (existsInternalTypeHelper)
{
csFileList.Add(new TaskItem(InternalTypeHelperFile));
}
GeneratedCodeFiles = (ITaskItem[])csFileList.ToArray(typeof(ITaskItem));
// Generate the Localization Output files
if (_localizationDirectives != MS.Internal.LocalizationDirectivesToLocFile.None)
{
GenerateOutputItemsForLocFiles();
}
HandleCacheFiles();
//
// Put all the generated files into one output Item so that it can be set to
// FileWrites item in target file, this list of files will be cleaned up for
// next clean build by msbuild.
// The generated files should include Baml files, code files, localization files
// and the cache files.
//
ArrayList allGeneratedFiles = new ArrayList( );
for (int i = 0; i < GeneratedBamlFiles.Length; i++)
{
allGeneratedFiles.Add(GeneratedBamlFiles[i]);
}
for (int i = 0; i < GeneratedCodeFiles.Length; i++)
{
allGeneratedFiles.Add(GeneratedCodeFiles[i]);
}
for (int i = 0; i < GeneratedLocalizationFiles.Length; i++)
{
allGeneratedFiles.Add(GeneratedLocalizationFiles[i]);
}
// Add the CompilerState cache file into the list
allGeneratedFiles.Add(new TaskItem(CompilerState.CacheFilePath));
if (CompilerLocalReference.CacheFileExists())
{
allGeneratedFiles.Add(new TaskItem(CompilerLocalReference.CacheFilePath));
}
AllGeneratedFiles = (ITaskItem[])allGeneratedFiles.ToArray(typeof(ITaskItem));
}
//
// Both MarkupPage and MarkupResource have the similar code to generate
// output baml, code file and /or locallyDefined xaml files.
// so put all the common code in this private method.
//
// Inputs :
// Xaml file items: PageMarkup or MarkupResource
// LocallyDefined Xaml List (Generated by MarkupCompiler)
//
// Outputs: BamlFile List,
// CodeFile List,
// LocallyDefined Xaml List
//
private void GenerateOutputItemsForCompiledXamlFiles(ITaskItem[] inputXamlItemList,
string[] inputLocalRefXamlFileList,
ref ArrayList outputBamlFileList,
ref ArrayList outputCodeFileList,
ref ArrayList outputLocalRefXamlList)
{
//
// For each input xaml file, check if the code and baml file are generated or not.
// If baml or code files are generated, put them into the appropriate output file item list.
//
for (int i = 0; i < inputXamlItemList.Length; i++)
{
string genLangFilePath, bamlFile;
GetGeneratedFiles(inputXamlItemList[i].ItemSpec, out genLangFilePath, out bamlFile);
if (!String.IsNullOrEmpty(genLangFilePath) && outputCodeFileList != null)
{
TaskItem codeItem;
codeItem = new TaskItem();
codeItem.ItemSpec = genLangFilePath;
outputCodeFileList.Add(codeItem);
Log.LogMessageFromResources(MessageImportance.Low, SRID.GeneratedCodeFile, codeItem.ItemSpec);
}
if (!String.IsNullOrEmpty(bamlFile))
{
TaskItem bamlItem = GenerateBamlItem(bamlFile, inputXamlItemList[i]);
// Add bamlItem to the output Baml List
outputBamlFileList.Add(bamlItem);
Log.LogMessageFromResources(MessageImportance.Low, SRID.GeneratedBamlFile, bamlItem.ItemSpec);
}
} // End of for { } loop.
//
// If the project contains local-type xaml files, put them into the right output item list here.
//
//
// If MarkupCompilation is skipped, there is no need to check local-type xaml files.
//
if (!SkipMarkupCompilation && inputLocalRefXamlFileList != null && inputLocalRefXamlFileList.Length > 0)
{
for (int i = 0; i < inputLocalRefXamlFileList.Length; i++)
{
string fullLocalXamlFile = TaskHelper.CreateFullFilePath(inputLocalRefXamlFileList[i], SourceDir);
LocalReferenceFile localFile = GenerateLocalTypeItem(fullLocalXamlFile, inputXamlItemList);
if (localFile != null && outputLocalRefXamlList != null)
{
outputLocalRefXamlList.Add(localFile);
}
}
}
}
//
// Generate appropriate output file list for local-type xaml file. This information will be saved
// into the .lref cache file so that the MarkupCompilePass2 can take it.
//
private LocalReferenceFile GenerateLocalTypeItem(string localTypeXamlFile, ITaskItem[] inputXamlItemList)
{
LocalReferenceFile localFile = null;
bool isLocalizable = false;
//
// Check if the local-type xaml file is localizable or not.
//
for (int i = 0; i < inputXamlItemList.Length; i++)
{
ITaskItem inputXamlItem = inputXamlItemList[i];
string xamlInputFullPath = TaskHelper.CreateFullFilePath(inputXamlItem.ItemSpec, SourceDir);
if (String.Compare(localTypeXamlFile, xamlInputFullPath, StringComparison.OrdinalIgnoreCase) == 0)
{
//
// Got this file from the original XamlFile TaskItem list.
// Check if this item is localizable or not and stop the search here.
//
isLocalizable = IsItemLocalizable(inputXamlItem);
break;
}
}
//
// Generate the instance of LocalReferenceFile for this local-type xaml file.
//
localFile = new LocalReferenceFile(localTypeXamlFile, isLocalizable);
if (isLocalizable)
{
_requirePass2ForSatelliteAssembly = true;
}
else
{
_requirePass2ForMainAssembly = true;
}
return localFile;
}
//
// Generate a baml TaskItem for the given xmal file, and transfer the appropriate
// source task item's custom attributes to the generated baml item if necessary.
// The xaml file could be an application definition file, a Markup Page.
// The bamlFile must exist before this method is called.
private TaskItem GenerateBamlItem(string bamlFile, ITaskItem SourceItem)
{
TaskItem bamlItem;
bamlItem = new TaskItem();
bamlItem.ItemSpec = bamlFile;
//
// Transfer some special custom attributes from source task item
// to output item.
// Such as transfer the Localizable attribute from a given .xaml file item
// to the generated .baml file item.
//
// Normally MarkupPage and MarkupResource need to transfer their attributes.
// But Application definition doesn't require this.
if (SourceItem != null)
{
string[] listCarryOverAttribute = new string[] {
"Localizable"
};
for (int j = 0; j < listCarryOverAttribute.Length; j++)
{
string attributeValue;
attributeValue = SourceItem.GetMetadata(listCarryOverAttribute[j]);
if (attributeValue != null)
{
bamlItem.SetMetadata(listCarryOverAttribute[j], attributeValue);
}
}
}
return bamlItem;
}
//
// Generate output item list for localization files.
//
private void GenerateOutputItemsForLocFiles()
{
ArrayList locFileItemList = new ArrayList();
TaskItem tiLoc;
ITaskItem xamlItem;
if (ApplicationMarkup != null && ApplicationMarkup.Length > 0 && ApplicationMarkup[0] != null)
{
tiLoc = ProcessLocFileForXamlItem(ApplicationMarkup[0]);
if (tiLoc != null)
{
// Add this LocItem to the locFileItemList
locFileItemList.Add(tiLoc);
}
}
if (PageMarkup != null)
{
for (int i = 0; i < PageMarkup.Length; i++)
{
xamlItem = PageMarkup[i];
tiLoc = ProcessLocFileForXamlItem(xamlItem);
if (tiLoc != null)
{
// Add this LocItem to the locFileItemList
locFileItemList.Add(tiLoc);
}
}
}
// Generate the Output TaskItem List
GeneratedLocalizationFiles = (ITaskItem[])locFileItemList.ToArray(typeof(ITaskItem));
}
//
// General method to handle an input xaml file item for Localization.
//
// If the XamlFile is localizable, generate a TaskItem for LocFile.
// If the XamlFile is not localizable, and if the .loc file is generated, delelet it
// so that it won't affec the incremental build next time.
//
private TaskItem ProcessLocFileForXamlItem(ITaskItem xamlItem)
{
TaskItem tiLoc = null;
string tempDir = SourceDir; // Just for calling GetResolvedFilePath, the value is not used here.
// Get a relative file path for the passed .xaml file
string xamlRelativeFilePath = GetResolvedFilePath(xamlItem.ItemSpec, ref tempDir);
string locFile;
// Change the extension from .xaml to .loc
locFile = Path.ChangeExtension(xamlRelativeFilePath, SharedStrings.LocExtension);
// the .loc file is at OutputPath + relative Path.
locFile = OutputPath + locFile;
if (TaskFileService.Exists(locFile))
{
//
// Per discussion with Globalization team:
//
// Globalization requests to collect .loc file for a baml file
// no matter the baml is in main assembly or satelliate assembly.
//
// The localization tool can localize the baml from the main assembly as well.
//
// Generate a TaskItem to include .loc file
// The item is going to add to the output LocFile list
tiLoc = new TaskItem(locFile);
}
return tiLoc;
}
//
// Check if the given TaskItem localizable.
//
private bool IsItemLocalizable(ITaskItem ti)
{
bool bIsLocalizable;
if (String.IsNullOrEmpty(UICulture))
{
// if UICulture is not set, all baml files are not localizable.
// The Localizable metadate value is ignored for this case.
bIsLocalizable = false;
}
else
{
string strLocalizable;
// if UICulture is set, by default all the baml files are localizable unless
// an explicit value "false" is set to Localizable metadata.
bIsLocalizable = true;
strLocalizable = ti.GetMetadata(SharedStrings.Localizable);
if (strLocalizable != null && String.Compare(strLocalizable, "false", StringComparison.OrdinalIgnoreCase) == 0)
{
bIsLocalizable = false;
}
}
return bIsLocalizable;
}
//
// Cleanup the cache files.
// It could happen if build error occurs.
//
private void CleanupCacheFiles()
{
CompilerState.CleanupCache();
CompilerLocalReference.CleanupCache();
}
//
// A central place to update cache files based on current build status MarkupCompiler result.
//
// This method should be called after the markupcompiler is done or skipped.
//
private void HandleCacheFiles()
{
// Update the CompilerState file based on new project setting, no matter MarkupCompiler is skipped or not.
CompilerState.SaveStateInformation(this);
if ( (CompilerAnalyzer.AnalyzeResult & ( RecompileCategory.PagesWithLocalType | RecompileCategory.ModifiedPages )) != RecompileCategory.NoRecompile)
{
// The modified xaml files and all the local-type xaml files should be recompiled, depends on the
// MarkupCompiler return, it will keep or delete the cache file for local type xaml files.
if (_requirePass2ForMainAssembly || _requirePass2ForSatelliteAssembly)
{
CompilerLocalReference.SaveCacheInformation(this);
}
else
{
CompilerLocalReference.CleanupCache();
}
}
// if build doesn't handle the local-ref xaml files, (it implies not handling the modified xaml files either),
// such as the build handles only for Application (HIB change) and Content files changes, or the markup compilation
// is skipped, ( NoRecompile).
//
// For this scenario, if .lref file exists, it should still be kept.
//
}
#endregion Private Methods
//-----------------------------------------------------
//
// Private Properties
//
//-----------------------------------------------------
#region Private Properties
//
// The root directory for the applicaiton project.
//
private string SourceDir
{
get { return _sourceDir; }
}
private IncrementalCompileAnalyzer CompilerAnalyzer
{
get { return _compilerAnalyzer; }
}
//
// If no input file is modified, Markup compilation will be skipped.
// But the code still generates the correct output item lists.
//
private bool SkipMarkupCompilation
{
get { return CompilerAnalyzer.AnalyzeResult == RecompileCategory.NoRecompile; }
}
private string ContentCodeFile
{
get
{
return OutputPath + AssemblyName + SharedStrings.ContentFile
+ (TaskFileService.IsRealBuild? SharedStrings.GeneratedExtension : SharedStrings.IntellisenseGeneratedExtension)
+ LanguageSourceExtension;
}
}
//
// Whether this is a clean build or not
//
private bool IsCleanBuild
{
get { return _isCleanBuild; }
}
#endregion Private Properties
//-----------------------------------------------------
//
// Private Fields
//
//------------------------------------------------------
#region Private Fields
private string _language;
private string _languageSourceExtension = string.Empty;
private ITaskItem [] _pagemarkupFiles;
private ITaskItem [] _contentFiles;
private ITaskItem [] _references;
private bool _xamlDebuggingInformation = false;
private string _outputType;
private string _assemblyName;
private string _assemblyVersion;
private string _assemblyPublicKeyToken;
private string _rootNamespace = String.Empty;
private ITaskItem [] _applicationMarkup;
private ITaskItem[] _splashScreen;
private bool _alwaysCompileMarkupFilesInSeparateDomain = true;
private string[] _assembliesGeneratedDuringBuild;
private string[] _knownReferencePaths;
private string _sourceDir;
private string _outputDir;
private ITaskItem[] _extraBuildControlFiles;
private string _uiCulture = String.Empty;
private string _applicationFile = String.Empty;
private bool _isApplicationTarget = false;
private string _hostInBrowser = String.Empty;
private LocalizationDirectivesToLocFile _localizationDirectives;
private ITaskItem [] _generatedCodeFiles;
private ITaskItem [] _generatedBamlFiles;
private ITaskItem [] _generatedLocalizationFiles;
private ITaskItem [] _allGeneratedFiles = null;
private string _localXamlApplication;
private string[] _localXamlPages;
private bool _hasInternals = false;
private int _nErrors;
private string _defineConstants = String.Empty;
private ITaskItem[] _sourceCodeFiles;
private string _pageMarkupCache = String.Empty;
private string _contentFilesCache = String.Empty;
private string _sourceCodeFilesCache = String.Empty;
private string _referencesCache = String.Empty;
private LocalReferenceFile _localApplicationFile = null;
private LocalReferenceFile[] _localMarkupPages = null;
private bool _requirePass2ForMainAssembly = false;
private bool _requirePass2ForSatelliteAssembly = false;
private bool _furtherCheckInternalTypeHelper = false;
private CompilerState _compilerState;
private CompilerLocalReference _compilerLocalRefCache;
private IncrementalCompileAnalyzer _compilerAnalyzer;
private ITaskFileService _taskFileService;
private bool _isCleanBuild = true; // Indicates whether this is a cleanbuild or incremental build.
#region const string
private const string UnknownErrorID = "MC1000";
#endregion const string
#endregion Private Fields
}
#endregion MarkupCompilePass1 Task class
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
// Description: An MSBuild Task that can generate .xaml markup file to specific
// Mangaged language code such as .cs, .js, .vb,etc, and /or binary
// token file .baml
//
// Spec: http://avalon/app/Compilation/Avalon-MSBUILD%20Targets.doc
//
// History:
// 06/20/03: weibz rewrite and moved over to WCP tree
//
//---------------------------------------------------------------------------
using System;
using System.IO;
using System.Collections;
using System.Security;
using System.Security.Permissions;
using System.Globalization;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.InteropServices;
using System.CodeDom;
using System.CodeDom.Compiler;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
using MS.Utility;
using MS.Internal;
using MS.Internal.Tasks;
using MS.Internal.Markup;
// Since we disable PreSharp warnings in this file, PreSharp warning is unknown to C# compiler.
// We first need to disable warnings about unknown message numbers and unknown pragmas.
#pragma warning disable 1634, 1691
namespace Microsoft.Build.Tasks.Windows
{
#region MarkupCompilePass1 Task class
///
/// Class of MarkupCompilePass1 Task
///
public sealed class MarkupCompilePass1 : Task
{
// Security Concerns: hamidm 04/13/05
//
// 1) OutputPath property exposes the current dir and is publicly available.
// 2) This class generates code files and copies them on the disk.
//
// The above two are already mitigated by the following facts:
//
// 1) PresentationBuildTasks is not APTCA and thus partial trust assemblies
// cannot call into it.
// 2) There is a possibility that some APTCA assembly (eg. PF.dll) can create
// this object and pass it on to partial trust code. This is mitigated by
// FxCop rule against it.
//
//-----------------------------------------------------
//
// Constructors
//
//-----------------------------------------------------
#region Constructors
///
/// Constructor
///
public MarkupCompilePass1( ) : base(SR.ResourceManager)
{
// set the source directory
_sourceDir = Directory.GetCurrentDirectory() + "\\";
_outputType = SharedStrings.WinExe;
// By default, no localization information is stripped out.
_localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.None;
_nErrors = 0;
}
#endregion Constructors
//------------------------------------------------------
//
// Public Methods
//
//-----------------------------------------------------
#region Public Methods
///
/// Execute method in Task
///
///
/// The Language the managed compiler supports.
/// the valid languages are C#, VB, Jscript, J#, C++
///
[Required]
public string Language
{
get { return _language; }
set { _language = value;}
}
///
/// The valid source file extension for the passed language.
/// Normally a language supports more valid source file extensions.
/// User could choose one of them in project file.
/// If this property is not set, we will take use of the default one for the language.
///
public string LanguageSourceExtension
{
get { return _languageSourceExtension; }
set { _languageSourceExtension = value; }
}
///
/// OutputPath : Generated code files, Baml fles will be put in this directory.
///
[Required]
public string OutputPath
{
get { return _outputDir; }
set
{
string filePath = value;
// Get the relative path based on sourceDir
_outputDir= TaskHelper.CreateFullFilePath(filePath, SourceDir);
// Make sure OutputDir always ends with '\\'.
if (!_outputDir.EndsWith("\\", StringComparison.Ordinal))
{
_outputDir += "\\";
}
}
}
///
/// OutputType
/// Valid types: winexe, exe, library, netmodule.
///
[Required]
public string OutputType
{
get { return _outputType; }
set { _outputType = TaskHelper.GetLowerString(value); }
}
///
/// AssemblyName
/// The short name of assembly which will be generated for this project.
///
[Required]
public string AssemblyName
{
get { return _assemblyName; }
set { _assemblyName = value; }
}
///
/// The version of the assembly
///
public string AssemblyVersion
{
get { return _assemblyVersion; }
set { _assemblyVersion = value; }
}
///
/// The public key token of the assembly
///
public string AssemblyPublicKeyToken
{
get { return _assemblyPublicKeyToken; }
set { _assemblyPublicKeyToken = value; }
}
///
/// Root namespace for the classes inside the project.
/// It is also used as default CLR namespace of a generated code file
/// when the corresponding markup page is not set x:Class attribute.
///
public string RootNamespace
{
get { return _rootNamespace; }
set { _rootNamespace = value; }
}
///
/// The UI Culture controls which culture satellite assembly will hold
/// the generated baml files.
/// If UICulture is not set, the generated baml files will be embedded
/// into main assembly.
///
public string UICulture
{
get { return _uiCulture; }
set { _uiCulture = value; }
}
///
/// Source code file list for the current project.
/// It doesnt include any generated code files.
///
public ITaskItem[] SourceCodeFiles
{
get { return _sourceCodeFiles; }
set { _sourceCodeFiles = value; }
}
///
/// DefineConstants
///
/// Keep the current value of DefineConstants.
///
/// DefineConstants can affect the final assembly generation, if DefineConstants
/// value is changed, the public API might be changed in the target assembly, which
/// then has potential impacts on compilation for xaml files which contains local types.
///
///
public string DefineConstants
{
get { return _defineConstants; }
set { _defineConstants = value; }
}
///
/// ApplicationMarkup
///
public ITaskItem [] ApplicationMarkup
{
get { return _applicationMarkup; }
set { _applicationMarkup = value;}
}
///
/// Description
///
public ITaskItem [] PageMarkup
{
get { return _pagemarkupFiles; }
set { _pagemarkupFiles = value; }
}
///
/// Splash screen image to be displayed before application init
///
public ITaskItem[] SplashScreen
{
get { return _splashScreen; }
set { _splashScreen = value; }
}
internal string SplashImageName
{
get
{
if (SplashScreen != null && SplashScreen.Length > 0)
{
return SplashScreen[0].ItemSpec.ToLowerInvariant();
}
return null;
}
}
///
/// Loose file content list
///
public ITaskItem[] ContentFiles
{
get { return _contentFiles; }
set { _contentFiles = value; }
}
///
/// Assembly References.
///
///
///
public bool XamlDebuggingInformation
{
get { return _xamlDebuggingInformation; }
set { _xamlDebuggingInformation = value; }
}
///
/// Keep a list of Build control files.
/// If one of them is changed since last build, it would trigger recompilation of all the xaml files.
/// Such as WinFX target file change could require a rebuild etc.
///
public ITaskItem [] ExtraBuildControlFiles
{
get { return _extraBuildControlFiles; }
set { _extraBuildControlFiles = value; }
}
///
///If true code for supporting hosting in Browser is generated
///
public string HostInBrowser
{
get { return _hostInBrowser; }
set { _hostInBrowser = TaskHelper.GetLowerString(value); }
}
///
/// Controls how to generate localization information for each xaml file.
/// Valid values: None, CommentsOnly, All.
///
public string LocalizationDirectivesToLocFile
{
get
{
string localizationDirectives = SharedStrings.Loc_None;
switch (_localizationDirectives)
{
case MS.Internal.LocalizationDirectivesToLocFile.None :
localizationDirectives = SharedStrings.Loc_None;
break;
case MS.Internal.LocalizationDirectivesToLocFile.CommentsOnly:
localizationDirectives = SharedStrings.Loc_CommentsOnly;
break;
case MS.Internal.LocalizationDirectivesToLocFile.All:
localizationDirectives = SharedStrings.Loc_All;
break;
}
return localizationDirectives;
}
set
{
string localizationDirectives = value;
if (localizationDirectives != null)
{
localizationDirectives = localizationDirectives.ToLower(CultureInfo.InvariantCulture);
}
switch (localizationDirectives)
{
case SharedStrings.Loc_None :
_localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.None;
break;
case SharedStrings.Loc_CommentsOnly :
_localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.CommentsOnly;
break;
case SharedStrings.Loc_All :
_localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.All;
break;
default:
_localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.Unknown;
break;
}
}
}
///
/// Known reference paths hold referenced assemblies which are never changed during the build procedure.
/// such as references in GAC, in framework directory or framework SDK directory etc.
/// Users could add their own known reference paths in project files.
///
public string[] KnownReferencePaths
{
get
{
return _knownReferencePaths;
}
set
{
_knownReferencePaths = value;
}
}
///
/// A list of reference assemblies that are to change for sure during the build cycle.
///
/// Such as in VS.NET, if one project wants to reference another project's output, the
/// second project's output could be put in AssembliesGeneratedDuringBuild list.
/// Note: Once this property is set, it must contain the complete list of generated
/// assemblies in this build solution.
///
public string[] AssembliesGeneratedDuringBuild
{
get
{
return _assembliesGeneratedDuringBuild;
}
set
{
_assembliesGeneratedDuringBuild = value;
}
}
///
/// Control whether to run the compilation in second appdomain.
/// By default, it is set to true, but project can set this property
/// to false to make markup file compilation faster.
///
public bool AlwaysCompileMarkupFilesInSeparateDomain
{
get { return _alwaysCompileMarkupFilesInSeparateDomain; }
set { _alwaysCompileMarkupFilesInSeparateDomain = value; }
}
///
/// Generated source code files for the given programing language.
///
[Output]
public ITaskItem [] GeneratedCodeFiles
{
get
{
if (_generatedCodeFiles == null)
_generatedCodeFiles = new TaskItem[0];
return _generatedCodeFiles;
}
set
{
_generatedCodeFiles = value;
}
}
///
/// Generated Baml files for the passed Markup files.
///
[Output]
public ITaskItem [] GeneratedBamlFiles
{
get
{
if (_generatedBamlFiles == null)
_generatedBamlFiles = new TaskItem[0];
return _generatedBamlFiles;
}
set
{
_generatedBamlFiles = value;
}
}
///
/// The generated localization file for each localizable xaml file.
///
[Output]
public ITaskItem[] GeneratedLocalizationFiles
{
get
{
if (_generatedLocalizationFiles == null)
_generatedLocalizationFiles = new TaskItem[0];
return _generatedLocalizationFiles;
}
set
{
_generatedLocalizationFiles = value;
}
}
#region Local Reference Xaml markup files
///
/// Indicate whether the project contains xaml files which reference local types and
/// the corresponding baml file will be embedded into main assembly.
///
[Output]
public bool RequirePass2ForMainAssembly
{
get { return _requirePass2ForMainAssembly; }
set { _requirePass2ForMainAssembly = value; }
}
///
/// Indicate whether the project contains xaml files which reference local types and
/// the corresponding baml file will be embedded into satellite assembly for current UICulture.
///
[Output]
public bool RequirePass2ForSatelliteAssembly
{
get { return _requirePass2ForSatelliteAssembly; }
set { _requirePass2ForSatelliteAssembly = value; }
}
#endregion Local Reference Xaml markup files
///
/// A complete list of files which are generated by MarkupCompiler.
///
[Output]
public ITaskItem[] AllGeneratedFiles
{
get { return _allGeneratedFiles; }
set { _allGeneratedFiles = value; }
}
#endregion Public Properties
#region internal methods
//
// Get the generated code file and baml file for a given xaml file
// If the generated file doesn't exist, the output paramter is set to empty string.
//
internal void GetGeneratedFiles(string xamlFile, out string codeFile, out string bamlFile)
{
string newSourceDir = SourceDir;
codeFile = String.Empty;
bamlFile = String.Empty;
if (String.IsNullOrEmpty(xamlFile))
{
// if xaml file is empty, return it now.
return;
}
string relativeFilePath = GetResolvedFilePath(xamlFile, ref newSourceDir);
string langExt =
(TaskFileService.IsRealBuild? SharedStrings.GeneratedExtension : SharedStrings.IntellisenseGeneratedExtension)
+ LanguageSourceExtension;
// Replace the .xaml with corresponding generated file extensions.
codeFile = OutputPath + Path.ChangeExtension(relativeFilePath, langExt);
bamlFile = OutputPath + Path.ChangeExtension(relativeFilePath, SharedStrings.BamlExtension);
// If the file doesn't exist, return empty string for the corresponding output parameter.
if (!TaskFileService.Exists(codeFile))
{
codeFile = String.Empty;
}
//
// Baml file is not generated for intellisense build.
//
if ((TaskFileService.IsRealBuild == false) || (!TaskFileService.Exists(bamlFile)))
{
bamlFile = String.Empty;
}
}
#endregion internal methods
#region internal Properties
internal bool IsApplicationTarget
{
get { return _isApplicationTarget; }
}
//
// ApplicationFile
//
internal string ApplicationFile
{
get { return _applicationFile; }
}
//
// PageMarkupCache
// It is caculated from current PageMarkup list, will be saved in the
// cache file to support incremental compilation.
//
internal string PageMarkupCache
{
get { return _pageMarkupCache; }
}
//
// ContentFilesCache
// It is caculated from current ContentFiles list, will be saved in the
// cache file to support incremental compilation.
//
internal string ContentFilesCache
{
get { return _contentFilesCache; }
}
//
// SourceCodeFilesCache
// It is caculated from current SourceCodeFiles list, will be saved in the
// cache file to support incremental compilation.
//
internal string SourceCodeFilesCache
{
get { return _sourceCodeFilesCache; }
}
//
// ReferencesCache
// It is caculated from current ReferencesCache list, will be saved in the
// cache file to support incremental compilation.
//
internal string ReferencesCache
{
get { return _referencesCache; }
}
//
// Application File with Local Type
//
internal LocalReferenceFile LocalApplicationFile
{
get { return _localApplicationFile; }
}
//
// Markup Page files with local types
//
internal LocalReferenceFile[] LocalMarkupPages
{
get { return _localMarkupPages; }
}
//
// TaskFileService
//
internal ITaskFileService TaskFileService
{
get { return _taskFileService; }
}
//
// CompilerState
//
internal CompilerState CompilerState
{
get { return _compilerState; }
}
//
// CompilerLocalReference
//
internal CompilerLocalReference CompilerLocalReference
{
get { return _compilerLocalRefCache; }
}
//
// Tell MarkupCompilePass2 whether it further handles InternalTypeHelper class.
//
internal bool FurtherCheckInternalTypeHelper
{
get { return _furtherCheckInternalTypeHelper; }
set { _furtherCheckInternalTypeHelper = value; }
}
//
// Get the file path for the generated InternalTypeHelper class.
//
internal string InternalTypeHelperFile
{
get
{
string fileName = SharedStrings.GeneratedInternalTypeHelperFileName
+ (TaskFileService.IsRealBuild? SharedStrings.GeneratedExtension : SharedStrings.IntellisenseGeneratedExtension)
+ LanguageSourceExtension;
return Path.Combine(OutputPath, fileName);
}
}
#endregion internal Properties
//-----------------------------------------------------
//
// Private Methods
//
//------------------------------------------------------
#region Private Methods
//
// Check if all the input properties are set valid values
// If any property contains an invalid value, Error counter _nErrors will
// be changed.
//
private void VerifyInputs()
{
// Check if the OutputType is valid type.
IsSupportedOutputType(OutputType);
// Check if the Localization property is set correctly.
IsValidLocalizationDirectives();
VerifyApplicationFile();
if (PageMarkup != null && PageMarkup.Length > 0)
{
VerifyInputTaskItems(PageMarkup);
}
if (SplashScreen != null && SplashScreen.Length > 1)
{
Log.LogErrorWithCodeFromResources(SRID.MultipleSplashScreenImages);
_nErrors++;
}
}
//
// Verify if the Application file is set correctly
// in project file.
//
private void VerifyApplicationFile()
{
if (!IsApplicationTarget)
{
//
// For non Application target type.
//
if (ApplicationMarkup != null && ApplicationMarkup.Length > 0)
{
//
// For non-Application target type, Application definition should not be set.
//
Log.LogErrorWithCodeFromResources(SRID.AppDefIsNotRequired);
_nErrors++;
}
}
else
{
//
// For Application Target type.
//
if (ApplicationMarkup != null && ApplicationMarkup.Length > 0)
{
if (ApplicationMarkup.Length > 1)
{
Log.LogErrorWithCodeFromResources(SRID.MutlipleApplicationFiles);
_nErrors++;
}
_applicationFile = TaskHelper.CreateFullFilePath(ApplicationMarkup[0].ItemSpec, SourceDir);
Log.LogMessageFromResources(MessageImportance.Low, SRID.ApplicationDefinitionFile, ApplicationFile);
if (!TaskFileService.Exists(ApplicationFile))
{
Log.LogErrorWithCodeFromResources(SRID.FileNotFound, ApplicationFile);
_nErrors++;
}
}
}
}
//
// Don't support local reference xaml compilation for Container and netmodule type.
//
private bool IsSupportedOutputType(string outputType)
{
bool isSupported = false;
switch (outputType)
{
case SharedStrings.Exe:
case SharedStrings.WinExe:
isSupported = true;
_isApplicationTarget = true;
break;
case SharedStrings.Library:
case SharedStrings.Module:
isSupported = true;
break;
default:
isSupported = false;
break;
}
if (isSupported == false)
{
Log.LogErrorWithCodeFromResources(SRID.TargetIsNotSupported, outputType);
// Keep the error numbers so that the task can stop immediatelly
// later when Execute( ) is called.
_nErrors++;
}
return isSupported;
}
private bool IsValidLocalizationDirectives()
{
bool bValid = true;
if (_localizationDirectives == MS.Internal.LocalizationDirectivesToLocFile.Unknown)
{
bValid = false;
Log.LogErrorWithCodeFromResources(SRID.WrongLocalizationPropertySetting_Pass1);
// Keep the error numbers so that the task can stop immediatelly
// later when Execute( ) is called.
_nErrors++;
}
return bValid;
}
//
// Check if the passed TaskItems have valid ItemSpec
//
//
//
// Generate the required Output Items.
//
private void GenerateOutputItems( )
{
// For the rest target types,
// Create the output lists for CS and Baml files.
ArrayList bamlFileList = new ArrayList();
ArrayList csFileList = new ArrayList();
ArrayList localRefPageList = new ArrayList();
ArrayList localRefAppdefList = new ArrayList();
// Generate Output Items for PageMarkup
if (PageMarkup != null && PageMarkup.Length > 0)
{
GenerateOutputItemsForCompiledXamlFiles(PageMarkup,
_localXamlPages,
ref bamlFileList,
ref csFileList,
ref localRefPageList);
}
//
// Generate output items for ApplicationDefinition if it is set in the project file.
//
if (ApplicationFile != null && ApplicationFile.Length > 0)
{
string[] appdefLocalList = null;
if (!String.IsNullOrEmpty(_localXamlApplication))
{
appdefLocalList = new string[1] { _localXamlApplication };
}
GenerateOutputItemsForCompiledXamlFiles(ApplicationMarkup,
appdefLocalList,
ref bamlFileList,
ref csFileList,
ref localRefAppdefList);
}
if (TaskFileService.Exists(ContentCodeFile))
{
csFileList.Add(new TaskItem(ContentCodeFile));
}
// Generate the Baml, code and /or locally-defined type related output items.
GeneratedBamlFiles = (ITaskItem[])bamlFileList.ToArray(typeof(ITaskItem));
if (!SkipMarkupCompilation)
{
if (localRefAppdefList.Count > 0)
{
_localApplicationFile = (LocalReferenceFile)localRefAppdefList[0];
}
if (localRefPageList.Count > 0)
{
_localMarkupPages = (LocalReferenceFile[])localRefPageList.ToArray(typeof(LocalReferenceFile));
}
//
// If MarkupCompilePass2 is required for Main assembly, there is no need to invoke MarkupCompilePass2
// for satellite assembly again.
//
if (_requirePass2ForMainAssembly)
{
_requirePass2ForSatelliteAssembly = false;
}
}
//
// Detect whether or not to ask Pass2 to do further handding for the InternalTypeHelper class.
//
// Only when all of below conditions are true, it requires Pass2 to further handling this wrapper class:
//
// 1. InternalTypeHelper file exists.
// 2. It is a CleanBuild.
// 3. No any xaml files which don't contain local types contains internal types from friend assembly.
// 4. _requirePass2ForMainAssembly is true.
//
// If InternalTypeHelper File exists, Pass1 would always add it to the code file list, so that consequent task
// can take it. If Pass2 determines that this wrapper class is not required, it can simply make an empty file.
// But we still keep the list of generated code files.
bool existsInternalTypeHelper = TaskFileService.Exists(InternalTypeHelperFile);
if (IsCleanBuild && existsInternalTypeHelper && _requirePass2ForMainAssembly && !_hasInternals)
{
FurtherCheckInternalTypeHelper = true;
}
else
{
FurtherCheckInternalTypeHelper = false;
}
if (existsInternalTypeHelper)
{
csFileList.Add(new TaskItem(InternalTypeHelperFile));
}
GeneratedCodeFiles = (ITaskItem[])csFileList.ToArray(typeof(ITaskItem));
// Generate the Localization Output files
if (_localizationDirectives != MS.Internal.LocalizationDirectivesToLocFile.None)
{
GenerateOutputItemsForLocFiles();
}
HandleCacheFiles();
//
// Put all the generated files into one output Item so that it can be set to
// FileWrites item in target file, this list of files will be cleaned up for
// next clean build by msbuild.
// The generated files should include Baml files, code files, localization files
// and the cache files.
//
ArrayList allGeneratedFiles = new ArrayList( );
for (int i = 0; i < GeneratedBamlFiles.Length; i++)
{
allGeneratedFiles.Add(GeneratedBamlFiles[i]);
}
for (int i = 0; i < GeneratedCodeFiles.Length; i++)
{
allGeneratedFiles.Add(GeneratedCodeFiles[i]);
}
for (int i = 0; i < GeneratedLocalizationFiles.Length; i++)
{
allGeneratedFiles.Add(GeneratedLocalizationFiles[i]);
}
// Add the CompilerState cache file into the list
allGeneratedFiles.Add(new TaskItem(CompilerState.CacheFilePath));
if (CompilerLocalReference.CacheFileExists())
{
allGeneratedFiles.Add(new TaskItem(CompilerLocalReference.CacheFilePath));
}
AllGeneratedFiles = (ITaskItem[])allGeneratedFiles.ToArray(typeof(ITaskItem));
}
//
// Both MarkupPage and MarkupResource have the similar code to generate
// output baml, code file and /or locallyDefined xaml files.
// so put all the common code in this private method.
//
// Inputs :
// Xaml file items: PageMarkup or MarkupResource
// LocallyDefined Xaml List (Generated by MarkupCompiler)
//
// Outputs: BamlFile List,
// CodeFile List,
// LocallyDefined Xaml List
//
private void GenerateOutputItemsForCompiledXamlFiles(ITaskItem[] inputXamlItemList,
string[] inputLocalRefXamlFileList,
ref ArrayList outputBamlFileList,
ref ArrayList outputCodeFileList,
ref ArrayList outputLocalRefXamlList)
{
//
// For each input xaml file, check if the code and baml file are generated or not.
// If baml or code files are generated, put them into the appropriate output file item list.
//
for (int i = 0; i < inputXamlItemList.Length; i++)
{
string genLangFilePath, bamlFile;
GetGeneratedFiles(inputXamlItemList[i].ItemSpec, out genLangFilePath, out bamlFile);
if (!String.IsNullOrEmpty(genLangFilePath) && outputCodeFileList != null)
{
TaskItem codeItem;
codeItem = new TaskItem();
codeItem.ItemSpec = genLangFilePath;
outputCodeFileList.Add(codeItem);
Log.LogMessageFromResources(MessageImportance.Low, SRID.GeneratedCodeFile, codeItem.ItemSpec);
}
if (!String.IsNullOrEmpty(bamlFile))
{
TaskItem bamlItem = GenerateBamlItem(bamlFile, inputXamlItemList[i]);
// Add bamlItem to the output Baml List
outputBamlFileList.Add(bamlItem);
Log.LogMessageFromResources(MessageImportance.Low, SRID.GeneratedBamlFile, bamlItem.ItemSpec);
}
} // End of for { } loop.
//
// If the project contains local-type xaml files, put them into the right output item list here.
//
//
// If MarkupCompilation is skipped, there is no need to check local-type xaml files.
//
if (!SkipMarkupCompilation && inputLocalRefXamlFileList != null && inputLocalRefXamlFileList.Length > 0)
{
for (int i = 0; i < inputLocalRefXamlFileList.Length; i++)
{
string fullLocalXamlFile = TaskHelper.CreateFullFilePath(inputLocalRefXamlFileList[i], SourceDir);
LocalReferenceFile localFile = GenerateLocalTypeItem(fullLocalXamlFile, inputXamlItemList);
if (localFile != null && outputLocalRefXamlList != null)
{
outputLocalRefXamlList.Add(localFile);
}
}
}
}
//
// Generate appropriate output file list for local-type xaml file. This information will be saved
// into the .lref cache file so that the MarkupCompilePass2 can take it.
//
private LocalReferenceFile GenerateLocalTypeItem(string localTypeXamlFile, ITaskItem[] inputXamlItemList)
{
LocalReferenceFile localFile = null;
bool isLocalizable = false;
//
// Check if the local-type xaml file is localizable or not.
//
for (int i = 0; i < inputXamlItemList.Length; i++)
{
ITaskItem inputXamlItem = inputXamlItemList[i];
string xamlInputFullPath = TaskHelper.CreateFullFilePath(inputXamlItem.ItemSpec, SourceDir);
if (String.Compare(localTypeXamlFile, xamlInputFullPath, StringComparison.OrdinalIgnoreCase) == 0)
{
//
// Got this file from the original XamlFile TaskItem list.
// Check if this item is localizable or not and stop the search here.
//
isLocalizable = IsItemLocalizable(inputXamlItem);
break;
}
}
//
// Generate the instance of LocalReferenceFile for this local-type xaml file.
//
localFile = new LocalReferenceFile(localTypeXamlFile, isLocalizable);
if (isLocalizable)
{
_requirePass2ForSatelliteAssembly = true;
}
else
{
_requirePass2ForMainAssembly = true;
}
return localFile;
}
//
// Generate a baml TaskItem for the given xmal file, and transfer the appropriate
// source task item's custom attributes to the generated baml item if necessary.
// The xaml file could be an application definition file, a Markup Page.
// The bamlFile must exist before this method is called.
private TaskItem GenerateBamlItem(string bamlFile, ITaskItem SourceItem)
{
TaskItem bamlItem;
bamlItem = new TaskItem();
bamlItem.ItemSpec = bamlFile;
//
// Transfer some special custom attributes from source task item
// to output item.
// Such as transfer the Localizable attribute from a given .xaml file item
// to the generated .baml file item.
//
// Normally MarkupPage and MarkupResource need to transfer their attributes.
// But Application definition doesn't require this.
if (SourceItem != null)
{
string[] listCarryOverAttribute = new string[] {
"Localizable"
};
for (int j = 0; j < listCarryOverAttribute.Length; j++)
{
string attributeValue;
attributeValue = SourceItem.GetMetadata(listCarryOverAttribute[j]);
if (attributeValue != null)
{
bamlItem.SetMetadata(listCarryOverAttribute[j], attributeValue);
}
}
}
return bamlItem;
}
//
// Generate output item list for localization files.
//
private void GenerateOutputItemsForLocFiles()
{
ArrayList locFileItemList = new ArrayList();
TaskItem tiLoc;
ITaskItem xamlItem;
if (ApplicationMarkup != null && ApplicationMarkup.Length > 0 && ApplicationMarkup[0] != null)
{
tiLoc = ProcessLocFileForXamlItem(ApplicationMarkup[0]);
if (tiLoc != null)
{
// Add this LocItem to the locFileItemList
locFileItemList.Add(tiLoc);
}
}
if (PageMarkup != null)
{
for (int i = 0; i < PageMarkup.Length; i++)
{
xamlItem = PageMarkup[i];
tiLoc = ProcessLocFileForXamlItem(xamlItem);
if (tiLoc != null)
{
// Add this LocItem to the locFileItemList
locFileItemList.Add(tiLoc);
}
}
}
// Generate the Output TaskItem List
GeneratedLocalizationFiles = (ITaskItem[])locFileItemList.ToArray(typeof(ITaskItem));
}
//
// General method to handle an input xaml file item for Localization.
//
// If the XamlFile is localizable, generate a TaskItem for LocFile.
// If the XamlFile is not localizable, and if the .loc file is generated, delelet it
// so that it won't affec the incremental build next time.
//
private TaskItem ProcessLocFileForXamlItem(ITaskItem xamlItem)
{
TaskItem tiLoc = null;
string tempDir = SourceDir; // Just for calling GetResolvedFilePath, the value is not used here.
// Get a relative file path for the passed .xaml file
string xamlRelativeFilePath = GetResolvedFilePath(xamlItem.ItemSpec, ref tempDir);
string locFile;
// Change the extension from .xaml to .loc
locFile = Path.ChangeExtension(xamlRelativeFilePath, SharedStrings.LocExtension);
// the .loc file is at OutputPath + relative Path.
locFile = OutputPath + locFile;
if (TaskFileService.Exists(locFile))
{
//
// Per discussion with Globalization team:
//
// Globalization requests to collect .loc file for a baml file
// no matter the baml is in main assembly or satelliate assembly.
//
// The localization tool can localize the baml from the main assembly as well.
//
// Generate a TaskItem to include .loc file
// The item is going to add to the output LocFile list
tiLoc = new TaskItem(locFile);
}
return tiLoc;
}
//
// Check if the given TaskItem localizable.
//
private bool IsItemLocalizable(ITaskItem ti)
{
bool bIsLocalizable;
if (String.IsNullOrEmpty(UICulture))
{
// if UICulture is not set, all baml files are not localizable.
// The Localizable metadate value is ignored for this case.
bIsLocalizable = false;
}
else
{
string strLocalizable;
// if UICulture is set, by default all the baml files are localizable unless
// an explicit value "false" is set to Localizable metadata.
bIsLocalizable = true;
strLocalizable = ti.GetMetadata(SharedStrings.Localizable);
if (strLocalizable != null && String.Compare(strLocalizable, "false", StringComparison.OrdinalIgnoreCase) == 0)
{
bIsLocalizable = false;
}
}
return bIsLocalizable;
}
//
// Cleanup the cache files.
// It could happen if build error occurs.
//
private void CleanupCacheFiles()
{
CompilerState.CleanupCache();
CompilerLocalReference.CleanupCache();
}
//
// A central place to update cache files based on current build status MarkupCompiler result.
//
// This method should be called after the markupcompiler is done or skipped.
//
private void HandleCacheFiles()
{
// Update the CompilerState file based on new project setting, no matter MarkupCompiler is skipped or not.
CompilerState.SaveStateInformation(this);
if ( (CompilerAnalyzer.AnalyzeResult & ( RecompileCategory.PagesWithLocalType | RecompileCategory.ModifiedPages )) != RecompileCategory.NoRecompile)
{
// The modified xaml files and all the local-type xaml files should be recompiled, depends on the
// MarkupCompiler return, it will keep or delete the cache file for local type xaml files.
if (_requirePass2ForMainAssembly || _requirePass2ForSatelliteAssembly)
{
CompilerLocalReference.SaveCacheInformation(this);
}
else
{
CompilerLocalReference.CleanupCache();
}
}
// if build doesn't handle the local-ref xaml files, (it implies not handling the modified xaml files either),
// such as the build handles only for Application (HIB change) and Content files changes, or the markup compilation
// is skipped, ( NoRecompile).
//
// For this scenario, if .lref file exists, it should still be kept.
//
}
#endregion Private Methods
//-----------------------------------------------------
//
// Private Properties
//
//-----------------------------------------------------
#region Private Properties
//
// The root directory for the applicaiton project.
//
private string SourceDir
{
get { return _sourceDir; }
}
private IncrementalCompileAnalyzer CompilerAnalyzer
{
get { return _compilerAnalyzer; }
}
//
// If no input file is modified, Markup compilation will be skipped.
// But the code still generates the correct output item lists.
//
private bool SkipMarkupCompilation
{
get { return CompilerAnalyzer.AnalyzeResult == RecompileCategory.NoRecompile; }
}
private string ContentCodeFile
{
get
{
return OutputPath + AssemblyName + SharedStrings.ContentFile
+ (TaskFileService.IsRealBuild? SharedStrings.GeneratedExtension : SharedStrings.IntellisenseGeneratedExtension)
+ LanguageSourceExtension;
}
}
//
// Whether this is a clean build or not
//
private bool IsCleanBuild
{
get { return _isCleanBuild; }
}
#endregion Private Properties
//-----------------------------------------------------
//
// Private Fields
//
//------------------------------------------------------
#region Private Fields
private string _language;
private string _languageSourceExtension = string.Empty;
private ITaskItem [] _pagemarkupFiles;
private ITaskItem [] _contentFiles;
private ITaskItem [] _references;
private bool _xamlDebuggingInformation = false;
private string _outputType;
private string _assemblyName;
private string _assemblyVersion;
private string _assemblyPublicKeyToken;
private string _rootNamespace = String.Empty;
private ITaskItem [] _applicationMarkup;
private ITaskItem[] _splashScreen;
private bool _alwaysCompileMarkupFilesInSeparateDomain = true;
private string[] _assembliesGeneratedDuringBuild;
private string[] _knownReferencePaths;
private string _sourceDir;
private string _outputDir;
private ITaskItem[] _extraBuildControlFiles;
private string _uiCulture = String.Empty;
private string _applicationFile = String.Empty;
private bool _isApplicationTarget = false;
private string _hostInBrowser = String.Empty;
private LocalizationDirectivesToLocFile _localizationDirectives;
private ITaskItem [] _generatedCodeFiles;
private ITaskItem [] _generatedBamlFiles;
private ITaskItem [] _generatedLocalizationFiles;
private ITaskItem [] _allGeneratedFiles = null;
private string _localXamlApplication;
private string[] _localXamlPages;
private bool _hasInternals = false;
private int _nErrors;
private string _defineConstants = String.Empty;
private ITaskItem[] _sourceCodeFiles;
private string _pageMarkupCache = String.Empty;
private string _contentFilesCache = String.Empty;
private string _sourceCodeFilesCache = String.Empty;
private string _referencesCache = String.Empty;
private LocalReferenceFile _localApplicationFile = null;
private LocalReferenceFile[] _localMarkupPages = null;
private bool _requirePass2ForMainAssembly = false;
private bool _requirePass2ForSatelliteAssembly = false;
private bool _furtherCheckInternalTypeHelper = false;
private CompilerState _compilerState;
private CompilerLocalReference _compilerLocalRefCache;
private IncrementalCompileAnalyzer _compilerAnalyzer;
private ITaskFileService _taskFileService;
private bool _isCleanBuild = true; // Indicates whether this is a cleanbuild or incremental build.
#region const string
private const string UnknownErrorID = "MC1000";
#endregion const string
#endregion Private Fields
}
#endregion MarkupCompilePass1 Task class
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- Classification.cs
- RadialGradientBrush.cs
- Type.cs
- Evaluator.cs
- COM2ICategorizePropertiesHandler.cs
- TemplateParser.cs
- ToolStripDropDownItem.cs
- QilStrConcat.cs
- DataBoundLiteralControl.cs
- LinearQuaternionKeyFrame.cs
- PhysicalFontFamily.cs
- GPRECT.cs
- GenerateScriptTypeAttribute.cs
- ListViewSortEventArgs.cs
- SafeMemoryMappedViewHandle.cs
- Parameter.cs
- SoapDocumentMethodAttribute.cs
- KnownBoxes.cs
- TreeView.cs
- ValidatorCompatibilityHelper.cs
- FrameworkReadOnlyPropertyMetadata.cs
- ChildrenQuery.cs
- SectionXmlInfo.cs
- Timer.cs
- DisplayNameAttribute.cs
- DataControlButton.cs
- TypeBrowser.xaml.cs
- SettingsPropertyWrongTypeException.cs
- ByteStack.cs
- GeneralTransform.cs
- EventMetadata.cs
- Configuration.cs
- InvalidEnumArgumentException.cs
- cookiecollection.cs
- OrderedDictionary.cs
- StoreItemCollection.cs
- ZoneMembershipCondition.cs
- CompModSwitches.cs
- ApplicationId.cs
- ButtonBaseDesigner.cs
- RuntimeResourceSet.cs
- GeneralEndpointIdentity.cs
- Stack.cs
- RTLAwareMessageBox.cs
- CompilationLock.cs
- processwaithandle.cs
- ValidationHelper.cs
- TextContainerHelper.cs
- MessagingActivityHelper.cs
- IUnknownConstantAttribute.cs
- CodeExporter.cs
- ToolTipService.cs
- SimpleType.cs
- PropertyConverter.cs
- SmiRequestExecutor.cs
- MulticastNotSupportedException.cs
- OdbcConnectionFactory.cs
- RoleGroup.cs
- MSG.cs
- Decoder.cs
- SortKey.cs
- XmlIlVisitor.cs
- IndexObject.cs
- TdsValueSetter.cs
- WebPartEditVerb.cs
- HandledMouseEvent.cs
- BinaryFormatterWriter.cs
- unsafenativemethodstextservices.cs
- HttpServerVarsCollection.cs
- PrintDialog.cs
- TypeForwardedFromAttribute.cs
- ValidationHelpers.cs
- CheckedListBox.cs
- ItemCollection.cs
- CqlIdentifiers.cs
- FontWeights.cs
- OracleFactory.cs
- XmlSerializationGeneratedCode.cs
- TypeElement.cs
- WebEventTraceProvider.cs
- SoapMessage.cs
- PageContentCollection.cs
- BitmapMetadataBlob.cs
- Paragraph.cs
- Geometry.cs
- WebPartDeleteVerb.cs
- Configuration.cs
- CodeDOMProvider.cs
- IisTraceWebEventProvider.cs
- ChannelManagerBase.cs
- x509utils.cs
- HostExecutionContextManager.cs
- FixedSOMContainer.cs
- DoubleAnimationClockResource.cs
- EncodingInfo.cs
- JoinTreeNode.cs
- NamedServiceModelExtensionCollectionElement.cs
- CredentialCache.cs
- HttpRawResponse.cs
- RNGCryptoServiceProvider.cs