//
// Helper methods
//
internal static CompilerType GetCompilerTypeFromBuildProvider(
BuildProvider buildProvider)
{
HttpContext context = null;
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure) && (context = HttpContext.Current) != null)
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_PARSE_ENTER, context.WorkerRequest);
}
try {
CompilerType compilerType = buildProvider.CodeCompilerType;
if (compilerType != null)
{
CompilationUtil.CheckCompilerOptionsAllowed(compilerType.CompilerParameters.CompilerOptions,
false /*config*/, null, 0);
}
return(compilerType);
}
finally {
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure) && context != null)
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_PARSE_LEAVE, context.WorkerRequest);
}
}
}
public void AddProvider(BuildProvider bp)
{
if (Count == 0)
{
// We need to set the name prefix
if (bp is ApplicationFileBuildProvider)
{
NamePrefix = "App_global.asax";
Application = true;
}
else if (bp is ThemeDirectoryBuildProvider)
{
NamePrefix = "App_Theme";
Master = true;
}
else
{
NamePrefix = "App_Web";
}
CompilerType ct = BuildManager.GetDefaultCompilerTypeForLanguage(bp.LanguageName, null);
if (ct != null)
{
CompilerType = ct;
}
}
Add(bp);
}
internal AssemblyBuilder(CompilationSection compConfig, ICollection referencedAssemblies, CompilerType compilerType, string outputAssemblyName)
{
this._compConfig = compConfig;
this._outputAssemblyName = outputAssemblyName;
this._initialReferencedAssemblies = AssemblySet.Create(referencedAssemblies);
this._compilerType = compilerType.Clone();
if (BuildManager.PrecompilingWithDebugInfo)
{
this._compilerType.CompilerParameters.IncludeDebugInformation = true;
}
else if (BuildManager.PrecompilingForDeployment)
{
this._compilerType.CompilerParameters.IncludeDebugInformation = false;
}
else if (DeploymentSection.RetailInternal)
{
this._compilerType.CompilerParameters.IncludeDebugInformation = false;
}
else if (this._compConfig.AssemblyPostProcessorTypeInternal != null)
{
this._compilerType.CompilerParameters.IncludeDebugInformation = true;
}
this._tempFiles.KeepFiles = this._compilerType.CompilerParameters.IncludeDebugInformation;
this._codeProvider = CompilationUtil.CreateCodeDomProviderNonPublic(this._compilerType.CodeDomProviderType);
this._maxBatchSize = this._compConfig.MaxBatchSize;
this._maxBatchGeneratedFileSize = this._compConfig.MaxBatchGeneratedFileSize * 0x400;
}
internal static CompilerType GetCompilerTypeFromBuildProvider(System.Web.Compilation.BuildProvider buildProvider)
{
HttpContext context = null;
CompilerType type2;
if (EtwTrace.IsTraceEnabled(5, 1) && ((context = HttpContext.Current) != null))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_PARSE_ENTER, context.WorkerRequest);
}
try
{
CompilerType codeCompilerType = buildProvider.CodeCompilerType;
if (codeCompilerType != null)
{
CompilationUtil.CheckCompilerOptionsAllowed(codeCompilerType.CompilerParameters.CompilerOptions, false, null, 0);
}
type2 = codeCompilerType;
}
finally
{
if (EtwTrace.IsTraceEnabled(5, 1) && (context != null))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_PARSE_LEAVE, context.WorkerRequest);
}
}
return(type2);
}
internal AssemblyBuilder(CompilationSection compConfig, ICollection referencedAssemblies, CompilerType compilerType, string outputAssemblyName)
{
this._compConfig = compConfig;
this._outputAssemblyName = outputAssemblyName;
this._initialReferencedAssemblies = AssemblySet.Create(referencedAssemblies);
this._compilerType = compilerType.Clone();
if (BuildManager.PrecompilingWithDebugInfo)
{
this._compilerType.CompilerParameters.IncludeDebugInformation = true;
}
else if (BuildManager.PrecompilingForDeployment)
{
this._compilerType.CompilerParameters.IncludeDebugInformation = false;
}
else if (DeploymentSection.RetailInternal)
{
this._compilerType.CompilerParameters.IncludeDebugInformation = false;
}
else if (this._compConfig.AssemblyPostProcessorTypeInternal != null)
{
this._compilerType.CompilerParameters.IncludeDebugInformation = true;
}
this._tempFiles.KeepFiles = this._compilerType.CompilerParameters.IncludeDebugInformation;
this._codeProvider = CompilationUtil.CreateCodeDomProviderNonPublic(this._compilerType.CodeDomProviderType);
this._maxBatchSize = this._compConfig.MaxBatchSize;
this._maxBatchGeneratedFileSize = this._compConfig.MaxBatchGeneratedFileSize * 0x400;
}
Type GetBuildProviderCodeDomType(BuildProvider bp)
{
CompilerType ct = bp.CodeCompilerType;
if (ct == null)
{
string language = bp.LanguageName;
if (String.IsNullOrEmpty(language))
{
language = CompilationSection.DefaultLanguage;
}
ct = BuildManager.GetDefaultCompilerTypeForLanguage(language, CompilationSection, false);
}
Type ret = ct != null ? ct.CodeDomProviderType : null;
if (ret == null)
{
throw new HttpException("Unable to determine code compilation language provider for virtual path '" + bp.VirtualPath + "'.");
}
return(ret);
}
public SimpleRazorBuildProvider()
{
this._codeLanguage = new CSharpRazorCodeLanguage();
this._compilerType = GetDefaultCompilerTypeForLanguage(this._codeLanguage.LanguageName);
this._host = new SimpleRazorEngineHost(this._codeLanguage);
this._virtualPathDependencies = null;
this._typeName = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", this._host.DefaultNamespace, "Foot");
}
public CSharpExtensionBuildProviderShim() {
OrchardHostContainerRegistry.RegisterShim(this);
_codeCompilerType = GetDefaultCompilerTypeForLanguage("C#");
// define a precompilation flag so that module can adapt for older version
var orchardVersion = typeof (IDependency).Assembly.GetName().Version;
_codeCompilerType.CompilerParameters.CompilerOptions += string.Format("/define:ORCHARD_{0}_{1}", orchardVersion.Major, orchardVersion.Minor) ;
}
internal static AssemblyBuilder GetDefaultAssemblyBuilder(CompilationSection compConfig,
ICollection referencedAssemblies, VirtualPath configPath,
string generatedFilesDir, string outputAssemblyName)
{
CompilerType ctwp = GetDefaultCompilerTypeWithParams(compConfig, configPath);
return(ctwp.CreateAssemblyBuilder(compConfig, referencedAssemblies,
generatedFilesDir, outputAssemblyName));
}
public override bool Equals(object o)
{
CompilerType type = o as CompilerType;
if (o == null)
{
return(false);
}
return((((this._codeDomProviderType == type._codeDomProviderType) && (this._compilParams.WarningLevel == type._compilParams.WarningLevel)) && (this._compilParams.IncludeDebugInformation == type._compilParams.IncludeDebugInformation)) && (this._compilParams.CompilerOptions == type._compilParams.CompilerOptions));
}
public CSharpExtensionBuildProviderShim() {
OrchardHostContainerRegistry.RegisterShim(this);
_codeCompilerType = GetDefaultCompilerTypeForLanguage("C#");
// NOTE: This code could be used to define a compilation flag with the current Orchar version
// but it's not compatible with Medium Trust
// var orchardVersion = new AssemblyName(typeof(IDependency).Assembly.FullName).Version;
// _codeCompilerType.CompilerParameters.CompilerOptions += string.Format("/define:ORCHARD_{0}_{1}", orchardVersion.Major, orchardVersion.Minor);
}
internal void GenerateSources(out Type codeDomProviderType, out CompilerParameters compilerParameters)
{
this.ProcessBuildProviders();
if (this._assemblyBuilder == null)
{
this._assemblyBuilder = CompilerType.GetDefaultAssemblyBuilder(this.CompConfig, this._referencedAssemblies, this._configPath, this._generatedFilesDir, null);
}
codeDomProviderType = this._assemblyBuilder.CodeDomProviderType;
compilerParameters = this._assemblyBuilder.GetCompilerParameters();
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpRazorBuildProvider"/> class.
/// </summary>
public CSharpRazorBuildProvider()
{
this.compilerType = this.GetDefaultCompilerTypeForLanguage("C#");
this.host = new RazorEngineHost(new CSharpRazorCodeLanguage()) {
DefaultBaseClass = typeof(ViewPageRef).FullName,
DefaultNamespace = "RazorOutput",
DefaultClassName = "ViewPage"
};
}
public override bool Equals(object o)
{
if (!(o is CompilerType))
{
return(false);
}
CompilerType other = (CompilerType)o;
//FIXME: parameters does NOT have an Equals override
return(other.type == type && other.parameters == parameters);
}
public override bool Equals(Object o)
{
CompilerType other = o as CompilerType;
if (o == null)
{
return(false);
}
return(_codeDomProviderType == other._codeDomProviderType &&
_compilParams.WarningLevel == other._compilParams.WarningLevel &&
_compilParams.IncludeDebugInformation == other._compilParams.IncludeDebugInformation &&
_compilParams.CompilerOptions == other._compilParams.CompilerOptions);
}
internal CbmCodeGeneratorBuildProviderHost(CompilationSection compConfig, ICollection referencedAssemblies, CompilerType compilerType, string generatedFilesDir, string outputAssemblyName) : base(compConfig, referencedAssemblies, compilerType, outputAssemblyName)
{
if (Directory.Exists(generatedFilesDir))
{
foreach (FileData data in (IEnumerable) FileEnumerator.Create(generatedFilesDir))
{
if (!data.IsDirectory)
{
File.Delete(data.FullName);
}
}
}
Directory.CreateDirectory(generatedFilesDir);
this._generatedFilesDir = generatedFilesDir;
}
internal void GenerateSources(out Type codeDomProviderType,
out CompilerParameters compilerParameters)
{
ProcessBuildProviders();
// If we didn't get an AssemblyBuilder (happens when there was nothing to build),
// get a default one.
if (_assemblyBuilder == null)
{
_assemblyBuilder = CompilerType.GetDefaultAssemblyBuilder(
CompConfig, _referencedAssemblies, _configPath,
_generatedFilesDir, null /*outputAssemblyName*/);
}
codeDomProviderType = _assemblyBuilder.CodeDomProviderType;
compilerParameters = _assemblyBuilder.GetCompilerParameters();
}
private System.Web.Compilation.BuildProvider GetCompilerParamsAndBuildProvider(VirtualPath virtualPath, out Type codeDomProviderType, out CompilerParameters compilerParameters)
{
virtualPath.CombineWithAppRoot();
CompilationSection compilationConfig = MTConfigUtil.GetCompilationConfig(virtualPath);
ICollection referencedAssemblies = BuildManager.GetReferencedAssemblies(compilationConfig);
System.Web.Compilation.BuildProvider provider = null;
if (StringUtil.EqualsIgnoreCase(virtualPath.VirtualPathString, BuildManager.GlobalAsaxVirtualPath.VirtualPathString))
{
ApplicationBuildProvider provider2 = new ApplicationBuildProvider();
provider2.SetVirtualPath(virtualPath);
provider2.SetReferencedAssemblies(referencedAssemblies);
provider = provider2;
}
else
{
provider = BuildManager.CreateBuildProvider(virtualPath, compilationConfig, referencedAssemblies, true);
}
provider.IgnoreParseErrors = true;
provider.IgnoreControlProperties = true;
provider.ThrowOnFirstParseError = false;
CompilerType codeCompilerType = provider.CodeCompilerType;
if (codeCompilerType == null)
{
codeDomProviderType = null;
compilerParameters = null;
return(null);
}
codeDomProviderType = codeCompilerType.CodeDomProviderType;
compilerParameters = codeCompilerType.CompilerParameters;
IAssemblyDependencyParser assemblyDependencyParser = provider.AssemblyDependencyParser;
if ((assemblyDependencyParser != null) && (assemblyDependencyParser.AssemblyDependencies != null))
{
Util.AddAssembliesToStringCollection(assemblyDependencyParser.AssemblyDependencies, compilerParameters.ReferencedAssemblies);
}
AssemblyBuilder.FixUpCompilerParameters(codeDomProviderType, compilerParameters);
return(provider);
}
/*
* Process a compileFile attribute (aka code besides)
*/
private void ProcessCodeFile(VirtualPath codeFileVirtualPath) {
Debug.Assert(_codeFileVirtualPath == null);
_codeFileVirtualPath = ResolveVirtualPath(codeFileVirtualPath);
// Get the language for the code beside page
CompilerType compilerType = CompilationUtil.GetCompilerInfoFromVirtualPath(
_codeFileVirtualPath);
// Make sure we don't get conflicting languages
if (_compilerType != null &&
_compilerType.CodeDomProviderType != compilerType.CodeDomProviderType) {
ProcessError(SR.GetString(SR.Inconsistent_CodeFile_Language));
return;
}
// Check if it's trying to go cross app, or points to a special directory.
// It's important to do this before checkin existence, to avoid revealing information
// about other apps (VSWhidbey 442957)
BuildManager.ValidateCodeFileVirtualPath(_codeFileVirtualPath);
// Make sure the file exists
Util.CheckVirtualFileExists(_codeFileVirtualPath);
_compilerType = compilerType;
// Add the code file to the list of files we depend on
AddSourceDependency(_codeFileVirtualPath);
}
private void ProcessBuildProviders()
{
CompilerType compilerType = null;
BuildProvider firstLanguageBuildProvider = null;
// First, delete all the existing satellite assemblies of the assembly
// we're about to build (VSWhidbey 87022) (only if it has a fixed name)
if (OutputAssemblyName != null)
{
Debug.Assert(!CbmGenerateOnlyMode);
StandardDiskBuildResultCache.RemoveSatelliteAssemblies(OutputAssemblyName);
}
// List of BuildProvider's that don't ask for a specific language
ArrayList languageFreeBuildProviders = null;
foreach (BuildProvider buildProvider in _buildProviders)
{
// If it's an InternalBuildProvider, give it the assembly references early on
buildProvider.SetReferencedAssemblies(_referencedAssemblies);
// Instruct the internal build providers to continue processing for more parse errors.
if (!BuildManager.ThrowOnFirstParseError)
{
InternalBuildProvider provider = buildProvider as InternalBuildProvider;
if (provider != null)
{
provider.ThrowOnFirstParseError = false;
}
}
// Get the language and culture
CompilerType ctwp = BuildProvider.GetCompilerTypeFromBuildProvider(buildProvider);
// Only look for a culture if we're supposed to (basically, in the resources directories)
string cultureName = null;
if (_supportLocalization)
{
cultureName = buildProvider.GetCultureName();
}
// Is it asking for a specific language?
if (ctwp != null)
{
// If it specifies a language, it can't also have a culture
if (cultureName != null)
{
throw new HttpException(SR.GetString(SR.Both_culture_and_language, BuildProvider.GetDisplayName(buildProvider)));
}
// Do we already know the language we'll be using
if (compilerType != null)
{
// If it's different from the current one, fail
if (!ctwp.Equals(compilerType))
{
throw new HttpException(SR.GetString(SR.Inconsistent_language,
BuildProvider.GetDisplayName(buildProvider),
BuildProvider.GetDisplayName(firstLanguageBuildProvider)));
}
}
else
{
// Keep track of the build provider of error handling purpose
firstLanguageBuildProvider = buildProvider;
// Keep track of the language
compilerType = ctwp;
_assemblyBuilder = compilerType.CreateAssemblyBuilder(
CompConfig, _referencedAssemblies, _generatedFilesDir, OutputAssemblyName);
}
}
else
{
if (cultureName != null)
{
// Ignore the culture files in generate-only mode
if (CbmGenerateOnlyMode)
{
continue;
}
if (_satelliteAssemblyBuilders == null)
{
_satelliteAssemblyBuilders = new Hashtable(
StringComparer.OrdinalIgnoreCase);
}
// Check if we already have an assembly builder for this culture
AssemblyBuilder satelliteAssemblyBuilder =
(AssemblyBuilder)_satelliteAssemblyBuilders[cultureName];
// If not, create one and store it in the hashtable
if (satelliteAssemblyBuilder == null)
{
satelliteAssemblyBuilder = CompilerType.GetDefaultAssemblyBuilder(
CompConfig, _referencedAssemblies, _configPath, OutputAssemblyName);
satelliteAssemblyBuilder.CultureName = cultureName;
_satelliteAssemblyBuilders[cultureName] = satelliteAssemblyBuilder;
}
satelliteAssemblyBuilder.AddBuildProvider(buildProvider);
continue;
}
if (_assemblyBuilder == null)
{
// If this provider doesn't need a specific language, and we don't know
// the language yet, just keep track of it
if (languageFreeBuildProviders == null)
{
languageFreeBuildProviders = new ArrayList();
}
languageFreeBuildProviders.Add(buildProvider);
continue;
}
}
_assemblyBuilder.AddBuildProvider(buildProvider);
}
// If we didn't get an AssemblyBuilder, use a default
if (_assemblyBuilder == null && languageFreeBuildProviders != null)
{
_assemblyBuilder = CompilerType.GetDefaultAssemblyBuilder(
CompConfig, _referencedAssemblies, _configPath,
_generatedFilesDir, OutputAssemblyName);
}
// Add all the language free providers (if any) to the AssemblyBuilder
if (_assemblyBuilder != null && languageFreeBuildProviders != null)
{
foreach (BuildProvider languageFreeBuildProvider in languageFreeBuildProviders)
{
_assemblyBuilder.AddBuildProvider(languageFreeBuildProvider);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NancyCSharpRazorBuildProvider"/> class.
/// </summary>
public NancyVisualBasicRazorBuildProvider()
{
this.compilerType = this.GetDefaultCompilerTypeForLanguage("VB");
this.host = new NancyRazorEngineHost(new VBRazorCodeLanguage());
}
private bool CompileNonDependentBuildProviders(ICollection buildProviders)
{
// Key: CompilerType, Value: AssemblyBuilder
IDictionary assemblyBuilders = new Hashtable();
// List of InternalBuildProvider's that don't ask for a specific language
ArrayList languageFreeBuildProviders = null;
// AssemblyBuilder used for providers that don't need a specific language
AssemblyBuilder defaultAssemblyBuilder = null;
bool hasParserErrors = false;
foreach (BuildProvider buildProvider in buildProviders)
{
if (IsBuildProviderSkipable(buildProvider))
{
continue;
}
// Instruct the internal build providers to continue processing for more parse errors.
if (!BuildManager.ThrowOnFirstParseError)
{
InternalBuildProvider provider = buildProvider as InternalBuildProvider;
if (provider != null)
{
provider.ThrowOnFirstParseError = false;
}
}
CompilerType compilerType = null;
// Get the language
try {
compilerType = BuildProvider.GetCompilerTypeFromBuildProvider(
buildProvider);
}
catch (HttpParseException ex) {
// Ignore the error if we are in that mode.
if (_ignoreProvidersWithErrors)
{
continue;
}
hasParserErrors = true;
// Remember the first parse exception
if (_firstException == null)
{
_firstException = ex;
}
if (_parserErrors == null)
{
_parserErrors = new ParserErrorCollection();
}
_parserErrors.AddRange(ex.ParserErrors);
continue;
}
catch {
// Ignore the error if we are in that mode.
if (_ignoreProvidersWithErrors)
{
continue;
}
throw;
}
AssemblyBuilder assemblyBuilder = defaultAssemblyBuilder;
ICollection typeNames = buildProvider.GetGeneratedTypeNames();
// Is it asking for a specific language?
if (compilerType == null)
{
// If this provider doesn't need a specific language, and we haven't yet created
// a default builder that is capable of building this, just keep track of it
if (defaultAssemblyBuilder == null || defaultAssemblyBuilder.IsBatchFull ||
defaultAssemblyBuilder.ContainsTypeNames(typeNames))
{
if (languageFreeBuildProviders == null)
{
languageFreeBuildProviders = new ArrayList();
}
languageFreeBuildProviders.Add(buildProvider);
continue;
}
}
else
{
// Check if we already have an assembly builder of the right type
assemblyBuilder = (AssemblyBuilder)assemblyBuilders[compilerType];
}
// Starts a new assemblyBuilder if the old one already contains another buildprovider
// that uses the same type name
if (assemblyBuilder == null || assemblyBuilder.IsBatchFull ||
assemblyBuilder.ContainsTypeNames(typeNames))
{
// If the assemblyBuilder is full, compile it.
if (assemblyBuilder != null)
{
CompileAssemblyBuilder(assemblyBuilder);
}
AssemblyBuilder newBuilder = compilerType.CreateAssemblyBuilder(
_compConfig, _referencedAssemblies);
assemblyBuilders[compilerType] = newBuilder;
// Remember it as the default if we don't already have one,
// or if the default is already full, switch the default to the new one.
if (defaultAssemblyBuilder == null ||
defaultAssemblyBuilder == assemblyBuilder)
{
defaultAssemblyBuilder = newBuilder;
}
assemblyBuilder = newBuilder;
}
assemblyBuilder.AddTypeNames(typeNames);
assemblyBuilder.AddBuildProvider(buildProvider);
}
// Don't try to compile providers, otherwise compile exceptions will be bubbled up,
// and we lose the parse errors.
if (hasParserErrors)
{
return(false);
}
// Handle all the left over language free providers
if (languageFreeBuildProviders != null)
{
// Indicates whether the default assembly builder is not a language specific builder.
bool newDefaultAssemblyBuilder = (defaultAssemblyBuilder == null);
// Add language independent providers to the default assembly builder.
foreach (BuildProvider languageFreeBuildProvider in languageFreeBuildProviders)
{
ICollection typeNames = languageFreeBuildProvider.GetGeneratedTypeNames();
// If we don't have a default language assembly builder, get one or
// starts a new assemblyBuilder if the old one already contains another buildprovider
// that uses the same type name
if (defaultAssemblyBuilder == null || defaultAssemblyBuilder.IsBatchFull ||
defaultAssemblyBuilder.ContainsTypeNames(typeNames))
{
// If the default assemblyBuilder is full, compile it.
if (defaultAssemblyBuilder != null)
{
CompileAssemblyBuilder(defaultAssemblyBuilder);
}
defaultAssemblyBuilder = CompilerType.GetDefaultAssemblyBuilder(
_compConfig, _referencedAssemblies, _vdir.VirtualPathObject /*configPath*/,
null /*outputAssemblyName*/);
// the default assembly builder needs to be compiled separately.
newDefaultAssemblyBuilder = true;
}
defaultAssemblyBuilder.AddTypeNames(typeNames);
defaultAssemblyBuilder.AddBuildProvider(languageFreeBuildProvider);
}
// Only compile the default assembly builder if it's not part of language specific
// assembly builder (which will be compiled separately)
if (newDefaultAssemblyBuilder)
{
// Compile the default assembly builder.
CompileAssemblyBuilder(defaultAssemblyBuilder);
}
}
CompileAssemblyBuilderParallel(assemblyBuilders.Values);
return(true);
}
private void ProcessBuildProviders()
{
CompilerType type = null;
System.Web.Compilation.BuildProvider buildProvider = null;
if (this.OutputAssemblyName != null)
{
StandardDiskBuildResultCache.RemoveSatelliteAssemblies(this.OutputAssemblyName);
}
ArrayList list = null;
foreach (System.Web.Compilation.BuildProvider provider2 in this._buildProviders)
{
provider2.SetReferencedAssemblies(this._referencedAssemblies);
if (!BuildManager.ThrowOnFirstParseError)
{
InternalBuildProvider provider3 = provider2 as InternalBuildProvider;
if (provider3 != null)
{
provider3.ThrowOnFirstParseError = false;
}
}
CompilerType compilerTypeFromBuildProvider = System.Web.Compilation.BuildProvider.GetCompilerTypeFromBuildProvider(provider2);
string cultureName = null;
if (this._supportLocalization)
{
cultureName = provider2.GetCultureName();
}
if (compilerTypeFromBuildProvider != null)
{
if (cultureName != null)
{
throw new HttpException(System.Web.SR.GetString("Both_culture_and_language", new object[] { System.Web.Compilation.BuildProvider.GetDisplayName(provider2) }));
}
if (type != null)
{
if (!compilerTypeFromBuildProvider.Equals(type))
{
throw new HttpException(System.Web.SR.GetString("Inconsistent_language", new object[] { System.Web.Compilation.BuildProvider.GetDisplayName(provider2), System.Web.Compilation.BuildProvider.GetDisplayName(buildProvider) }));
}
}
else
{
buildProvider = provider2;
this._assemblyBuilder = compilerTypeFromBuildProvider.CreateAssemblyBuilder(this.CompConfig, this._referencedAssemblies, this._generatedFilesDir, this.OutputAssemblyName);
}
}
else
{
if (cultureName != null)
{
if (!this.CbmGenerateOnlyMode)
{
if (this._satelliteAssemblyBuilders == null)
{
this._satelliteAssemblyBuilders = new Hashtable(StringComparer.OrdinalIgnoreCase);
}
AssemblyBuilder builder = (AssemblyBuilder)this._satelliteAssemblyBuilders[cultureName];
if (builder == null)
{
builder = CompilerType.GetDefaultAssemblyBuilder(this.CompConfig, this._referencedAssemblies, this._configPath, this.OutputAssemblyName);
builder.CultureName = cultureName;
this._satelliteAssemblyBuilders[cultureName] = builder;
}
builder.AddBuildProvider(provider2);
}
continue;
}
if (this._assemblyBuilder == null)
{
if (list == null)
{
list = new ArrayList();
}
list.Add(provider2);
continue;
}
}
this._assemblyBuilder.AddBuildProvider(provider2);
}
if ((this._assemblyBuilder == null) && (list != null))
{
this._assemblyBuilder = CompilerType.GetDefaultAssemblyBuilder(this.CompConfig, this._referencedAssemblies, this._configPath, this._generatedFilesDir, this.OutputAssemblyName);
}
if ((this._assemblyBuilder != null) && (list != null))
{
foreach (System.Web.Compilation.BuildProvider provider4 in list)
{
this._assemblyBuilder.AddBuildProvider(provider4);
}
}
}
private bool CompileNonDependentBuildProviders(ICollection buildProviders)
{
IDictionary dictionary = new Hashtable();
ArrayList list = null;
AssemblyBuilder builder = null;
bool flag = false;
foreach (System.Web.Compilation.BuildProvider provider in buildProviders)
{
ICollection is2;
if (this.IsBuildProviderSkipable(provider))
{
continue;
}
if (!BuildManager.ThrowOnFirstParseError)
{
InternalBuildProvider provider2 = provider as InternalBuildProvider;
if (provider2 != null)
{
provider2.ThrowOnFirstParseError = false;
}
}
CompilerType compilerTypeFromBuildProvider = null;
try
{
compilerTypeFromBuildProvider = System.Web.Compilation.BuildProvider.GetCompilerTypeFromBuildProvider(provider);
}
catch (HttpParseException exception)
{
if (!this._ignoreProvidersWithErrors)
{
flag = true;
if (this._firstException == null)
{
this._firstException = exception;
}
if (this._parserErrors == null)
{
this._parserErrors = new ParserErrorCollection();
}
this._parserErrors.AddRange(exception.ParserErrors);
}
continue;
}
catch
{
if (!this._ignoreProvidersWithErrors)
{
throw;
}
continue;
}
AssemblyBuilder builder2 = builder;
if (compilerTypeFromBuildProvider == null)
{
if (builder != null)
{
goto Label_00E6;
}
if (list == null)
{
list = new ArrayList();
}
list.Add(provider);
continue;
}
builder2 = (AssemblyBuilder)dictionary[compilerTypeFromBuildProvider];
Label_00E6:
is2 = provider.GetGeneratedTypeNames();
if (((builder2 == null) || builder2.IsBatchFull) || builder2.ContainsTypeNames(is2))
{
if (builder2 != null)
{
this.CompileAssemblyBuilder(builder2);
}
AssemblyBuilder builder3 = compilerTypeFromBuildProvider.CreateAssemblyBuilder(this._compConfig, this._referencedAssemblies);
dictionary[compilerTypeFromBuildProvider] = builder3;
if ((builder == null) || (builder == builder2))
{
builder = builder3;
}
builder2 = builder3;
}
builder2.AddTypeNames(is2);
builder2.AddBuildProvider(provider);
}
if (flag)
{
return(false);
}
if (list != null)
{
bool flag2 = builder == null;
foreach (System.Web.Compilation.BuildProvider provider3 in list)
{
ICollection generatedTypeNames = provider3.GetGeneratedTypeNames();
if (((builder == null) || builder.IsBatchFull) || builder.ContainsTypeNames(generatedTypeNames))
{
if (builder != null)
{
this.CompileAssemblyBuilder(builder);
}
builder = CompilerType.GetDefaultAssemblyBuilder(this._compConfig, this._referencedAssemblies, this._vdir.VirtualPathObject, null);
flag2 = true;
}
builder.AddTypeNames(generatedTypeNames);
builder.AddBuildProvider(provider3);
}
if (flag2)
{
this.CompileAssemblyBuilder(builder);
}
}
foreach (AssemblyBuilder builder4 in dictionary.Values)
{
this.CompileAssemblyBuilder(builder4);
}
return(true);
}
internal CbmCodeGeneratorBuildProviderHost(CompilationSection compConfig, ICollection referencedAssemblies, CompilerType compilerType, string generatedFilesDir, string outputAssemblyName) : base(compConfig, referencedAssemblies, compilerType, outputAssemblyName)
{
if (Directory.Exists(generatedFilesDir))
{
foreach (FileData data in (IEnumerable)FileEnumerator.Create(generatedFilesDir))
{
if (!data.IsDirectory)
{
File.Delete(data.FullName);
}
}
}
Directory.CreateDirectory(generatedFilesDir);
this._generatedFilesDir = generatedFilesDir;
}
internal virtual void ProcessDirective(string directiveName, IDictionary directive)
{
if (directiveName.Length == 0)
{
directiveName = this.DefaultDirectiveName;
}
if (this.IsMainDirective(directiveName))
{
if (this._fFoundMainDirective && !this.IgnoreParseErrors)
{
throw new HttpException(System.Web.SR.GetString("Only_one_directive_allowed", new object[] { this.DefaultDirectiveName }));
}
this._fFoundMainDirective = true;
directive.Remove("description");
directive.Remove("codebehind");
string andRemoveNonEmptyAttribute = Util.GetAndRemoveNonEmptyAttribute(directive, "language");
if (andRemoveNonEmptyAttribute != null)
{
this._compilerType = this._buildProvider.GetDefaultCompilerTypeForLanguageInternal(andRemoveNonEmptyAttribute);
}
else
{
this._compilerType = this._buildProvider.GetDefaultCompilerTypeInternal();
}
this._typeName = Util.GetAndRemoveRequiredAttribute(directive, "class");
if (this._compilerType.CompilerParameters != null)
{
ProcessCompilationParams(directive, this._compilerType.CompilerParameters);
}
}
else if (StringUtil.EqualsIgnoreCase(directiveName, "assembly"))
{
string assemblyName = Util.GetAndRemoveNonEmptyAttribute(directive, "name");
VirtualPath andRemoveVirtualPathAttribute = Util.GetAndRemoveVirtualPathAttribute(directive, "src");
if (((assemblyName != null) && (andRemoveVirtualPathAttribute != null)) && !this.IgnoreParseErrors)
{
throw new HttpException(System.Web.SR.GetString("Attributes_mutually_exclusive", new object[] { "Name", "Src" }));
}
if (assemblyName == null)
{
if (andRemoveVirtualPathAttribute == null)
{
if (!this.IgnoreParseErrors)
{
throw new HttpException(System.Web.SR.GetString("Missing_attr", new object[] { "name" }));
}
}
else
{
this.ImportSourceFile(andRemoveVirtualPathAttribute);
}
}
else
{
this.AddAssemblyDependency(assemblyName);
}
}
else if (!this.IgnoreParseErrors)
{
throw new HttpException(System.Web.SR.GetString("Unknown_directive", new object[] { directiveName }));
}
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
}
private BuildProvider GetCompilerParamsAndBuildProvider(VirtualPath virtualPath,
out Type codeDomProviderType, out CompilerParameters compilerParameters)
{
virtualPath.CombineWithAppRoot();
CompilationSection compConfig = MTConfigUtil.GetCompilationConfig(virtualPath);
ICollection referencedAssemblies = BuildManager.GetReferencedAssemblies(compConfig);
// Create the buildprovider for the passed in virtualPath
BuildProvider buildProvider = null;
// Special case global asax build provider here since we do not want to compile every files with ".asax" extension.
if (StringUtil.EqualsIgnoreCase(virtualPath.VirtualPathString, BuildManager.GlobalAsaxVirtualPath.VirtualPathString))
{
ApplicationBuildProvider provider = new ApplicationBuildProvider();
provider.SetVirtualPath(virtualPath);
provider.SetReferencedAssemblies(referencedAssemblies);
buildProvider = provider;
}
else
{
buildProvider = BuildManager.CreateBuildProvider(virtualPath, compConfig,
referencedAssemblies, true /*failIfUnknown*/);
}
// DevDiv 69017
// The methods restricted to internalBuildProvider have been moved up to BuildProvider
// to allow WCFBuildProvider to support .svc syntax highlighting.
// Ignore parse errors, since they should not break the designer
buildProvider.IgnoreParseErrors = true;
// Ignore all control properties, since we do not generate code for the properties
buildProvider.IgnoreControlProperties = true;
// Process as many errors as possible, do not rethrow on first error
buildProvider.ThrowOnFirstParseError = false;
// Get the language (causes the file to be parsed)
CompilerType compilerType = buildProvider.CodeCompilerType;
// compilerType could be null in the no-compile case (VSWhidbey 221749)
if (compilerType == null)
{
codeDomProviderType = null;
compilerParameters = null;
return(null);
}
// Return the provider type and compiler params
codeDomProviderType = compilerType.CodeDomProviderType;
compilerParameters = compilerType.CompilerParameters;
IAssemblyDependencyParser parser = buildProvider.AssemblyDependencyParser;
// Add all the assemblies that the page depends on (e.g. user controls)
if (parser != null && parser.AssemblyDependencies != null)
{
Util.AddAssembliesToStringCollection(parser.AssemblyDependencies,
compilerParameters.ReferencedAssemblies);
}
// Make any fix up adjustments to the CompilerParameters to work around some issues
AssemblyBuilder.FixUpCompilerParameters(compConfig, codeDomProviderType, compilerParameters);
return(buildProvider);
}
/*
* Do what needs to be done before returning after the parsing is complete
*/
internal virtual void HandlePostParse() {
// If there was no main directive in the page, process settings that may have come from config
if (!flags[mainDirectiveHandled]) {
ProcessMainDirective(_mainDirectiveConfigSettings);
flags[mainDirectiveHandled] = true;
}
// We need to check the PageParserFilter here to handle the case where the base was specified
// in web.config, and was *not* overridden with an 'inherits' attribute.
if (_pageParserFilter != null) {
if (!_pageParserFilter.AllowBaseType(BaseType)) {
throw new HttpException(
SR.GetString(SR.Base_type_not_allowed, BaseType.FullName));
}
}
// If there is more than one builder on the stack, some tag was
// not correctly closed, which is an error.
if (BuilderStack.Count > 1) {
BuilderStackEntry entry = (BuilderStackEntry) _builderStack.Peek();
string message = SR.GetString(SR.Unexpected_eof_looking_for_tag, entry._tagName);
ProcessException(new HttpParseException(message, null, entry.VirtualPath, entry._inputText, entry.Line));
return;
}
// If no language was specified in the page
if (_compilerType == null) {
if (!FInDesigner) {
// Get a default from config
_compilerType = CompilationUtil.GetDefaultLanguageCompilerInfo(
_compConfig, CurrentVirtualPath);
}
else {
// Get default from code
_compilerType = CompilationUtil.GetCodeDefaultLanguageCompilerInfo();
}
}
CompilerParameters compilParams = _compilerType.CompilerParameters;
// Override certain settings if they were specified on the page
if (flags[hasDebugAttribute])
compilParams.IncludeDebugInformation = flags[debug];
// Debugging requires medium trust level
if (compilParams.IncludeDebugInformation)
HttpRuntime.CheckAspNetHostingPermission(AspNetHostingPermissionLevel.Medium, SR.Debugging_not_supported_in_low_trust);
// If warningLevel was specified in the page, use it
if (_warningLevel >= 0) {
compilParams.WarningLevel = _warningLevel;
compilParams.TreatWarningsAsErrors = (_warningLevel>0);
}
if (_compilerOptions != null)
compilParams.CompilerOptions = _compilerOptions;
// Tell the filter (if any) that the parsing is complete
if (_pageParserFilter != null)
_pageParserFilter.ParseComplete(RootBuilder);
// Tell the ParseRecorders that parsing is complete
ParseRecorders.ParseComplete(RootBuilder);
}
private void ProcessDirective(string directiveName, IDictionary<string, string> attribs, int lineNumber)
{
this.lineNumber = lineNumber;
if (DefaultDirectiveName.Equals(directiveName, StringComparison.OrdinalIgnoreCase))
{
if (this.foundDirective)
{
throw new HttpParseException(String.Format(ErrorMultipleDirectives, DefaultDirectiveName), null, base.VirtualPath, this.sourceText, this.lineNumber);
}
this.foundDirective = true;
// determine source language
string language = attribs.ContainsKey("Language") ? attribs["Language"] : null;
if (String.IsNullOrEmpty(language))
{
// default to C# because it does not need additional assemblies
language = "C#";
}
this.compilerType = this.GetDefaultCompilerTypeForLanguage(language);
// determine backing class
this.serviceTypeName = attribs.ContainsKey("Class") ? attribs["Class"] : null;
}
else if ("Assembly".Equals(directiveName, StringComparison.OrdinalIgnoreCase))
{
string name = attribs.ContainsKey("Name") ? attribs["Name"] : null;
if (String.IsNullOrEmpty(name))
{
throw new HttpParseException(String.Format(ErrorMissingAttrib, "Name"), null, base.VirtualPath, this.sourceText, this.lineNumber);
}
this.AddAssemblyDependency(name);
}
else
{
throw new HttpParseException(String.Format(ErrorUnkownDirective, directiveName), null, base.VirtualPath, this.sourceText, this.lineNumber);
}
}
public CSharpExtensionBuildProviderShim() {
OrchardHostContainerRegistry.RegisterShim(this);
_codeCompilerType = GetDefaultCompilerTypeForLanguage("C#");
}
internal virtual void ProcessDirective(string directiveName, IDictionary directive)
{
if (directiveName.Length == 0)
{
directiveName = this.DefaultDirectiveName;
}
if (this.IsMainDirective(directiveName))
{
if (this._fFoundMainDirective && !this.IgnoreParseErrors)
{
throw new HttpException(System.Web.SR.GetString("Only_one_directive_allowed", new object[] { this.DefaultDirectiveName }));
}
this._fFoundMainDirective = true;
directive.Remove("description");
directive.Remove("codebehind");
string andRemoveNonEmptyAttribute = Util.GetAndRemoveNonEmptyAttribute(directive, "language");
if (andRemoveNonEmptyAttribute != null)
{
this._compilerType = this._buildProvider.GetDefaultCompilerTypeForLanguageInternal(andRemoveNonEmptyAttribute);
}
else
{
this._compilerType = this._buildProvider.GetDefaultCompilerTypeInternal();
}
this._typeName = Util.GetAndRemoveRequiredAttribute(directive, "class");
if (this._compilerType.CompilerParameters != null)
{
ProcessCompilationParams(directive, this._compilerType.CompilerParameters);
}
}
else if (StringUtil.EqualsIgnoreCase(directiveName, "assembly"))
{
string assemblyName = Util.GetAndRemoveNonEmptyAttribute(directive, "name");
VirtualPath andRemoveVirtualPathAttribute = Util.GetAndRemoveVirtualPathAttribute(directive, "src");
if (((assemblyName != null) && (andRemoveVirtualPathAttribute != null)) && !this.IgnoreParseErrors)
{
throw new HttpException(System.Web.SR.GetString("Attributes_mutually_exclusive", new object[] { "Name", "Src" }));
}
if (assemblyName == null)
{
if (andRemoveVirtualPathAttribute == null)
{
if (!this.IgnoreParseErrors)
{
throw new HttpException(System.Web.SR.GetString("Missing_attr", new object[] { "name" }));
}
}
else
{
this.ImportSourceFile(andRemoveVirtualPathAttribute);
}
}
else
{
this.AddAssemblyDependency(assemblyName);
}
}
else if (!this.IgnoreParseErrors)
{
throw new HttpException(System.Web.SR.GetString("Unknown_directive", new object[] { directiveName }));
}
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
}
private void ProcessDirective(string directiveName, IDictionary directive)
{
if (directiveName.Length == 0)
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderDirectiveNameMissing));
}
if (string.Compare(directiveName, "ServiceHost", StringComparison.OrdinalIgnoreCase) == 0)
{
if (this.foundMainDirective)
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderDuplicateDirective("ServiceHost")));
}
this.foundMainDirective = true;
directive.Remove("codebehind");
string andRemoveNonEmptyAttribute = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "language");
if (andRemoveNonEmptyAttribute != null)
{
this.compilerType = this.buildProvider.GetDefaultCompilerTypeForLanguageInternal(andRemoveNonEmptyAttribute);
}
else
{
this.compilerType = this.buildProvider.GetDefaultCompilerTypeInternal();
}
if (directive.Contains("Factory"))
{
this.factoryAttributeValue = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "Factory");
this.serviceAttributeValue = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "Service");
}
else
{
if (!directive.Contains("Service"))
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderMainAttributeMissing));
}
this.serviceAttributeValue = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "Service");
}
this.ProcessCompilationParams(directive, this.compilerType.CompilerParameters);
}
else
{
if (string.Compare(directiveName, "assembly", StringComparison.OrdinalIgnoreCase) != 0)
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderUnknownDirective(directiveName)));
}
if (directive.Contains("name") && directive.Contains("src"))
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderMutualExclusiveAttributes("src", "name")));
}
if (directive.Contains("name"))
{
string assemblyName = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "name");
if (assemblyName == null)
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderAttributeEmpty("name")));
}
this.AddAssemblyDependency(assemblyName);
}
else
{
if (!directive.Contains("src"))
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderRequiredAttributesMissing("src", "name")));
}
string path = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "src");
if (path == null)
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderAttributeEmpty("src")));
}
this.ImportSourceFile(path);
}
}
if (directive.Count > 0)
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderUnknownAttribute(ServiceParserUtilities.FirstDictionaryKey(directive))));
}
}
internal CompilerType GetCompilerInfoFromLanguage(string language)
{
CompilerType compilerTypeInternal;
this.EnsureCompilerCacheInit();
object obj2 = this._compilerLanguages[language];
Compiler compiler = obj2 as Compiler;
if (compiler != null)
{
compilerTypeInternal = compiler.CompilerTypeInternal;
this._compilerLanguages[language] = compilerTypeInternal;
}
else
{
compilerTypeInternal = obj2 as CompilerType;
}
if ((compilerTypeInternal == null) && CodeDomProvider.IsDefinedLanguage(language))
{
CompilerInfo compilerInfo = CodeDomProvider.GetCompilerInfo(language);
compilerTypeInternal = new CompilerType(compilerInfo.CodeDomProviderType, compilerInfo.CreateDefaultCompilerParameters());
this._compilerLanguages[language] = compilerTypeInternal;
}
if (compilerTypeInternal == null)
{
throw new HttpException(System.Web.SR.GetString("Invalid_lang", new object[] { language }));
}
CompilationUtil.CheckCompilerOptionsAllowed(compilerTypeInternal.CompilerParameters.CompilerOptions, true, null, 0);
compilerTypeInternal = compilerTypeInternal.Clone();
compilerTypeInternal.CompilerParameters.IncludeDebugInformation = this.Debug;
return compilerTypeInternal;
}
static CodeDomProvider CreateDomProvider (CompilerType ct)
{
if (codeDomProviders == null)
codeDomProviders = new Dictionary <Type, CodeDomProvider> ();
Type type = ct.CodeDomProviderType;
if (type == null) {
CompilationSection cs = CompilationConfig;
CompilerType tmp = GetDefaultCompilerTypeForLanguage (cs.DefaultLanguage, cs);
if (tmp != null)
type = tmp.CodeDomProviderType;
}
if (type == null)
return null;
CodeDomProvider ret;
if (codeDomProviders.TryGetValue (type, out ret))
return ret;
ret = Activator.CreateInstance (type) as CodeDomProvider;
if (ret == null)
return null;
codeDomProviders.Add (type, ret);
return ret;
}
internal CbmCodeGeneratorBuildProviderHost(CompilationSection compConfig,
ICollection referencedAssemblies, CompilerType compilerType,
string generatedFilesDir, string outputAssemblyName)
: base(compConfig, referencedAssemblies, compilerType, outputAssemblyName) {
// Wipe out any existing directory, and recreate it
// This is where we will put generated source files
if (Directory.Exists(generatedFilesDir)) {
// Delete all the files in the directory
foreach (FileData fileData in FileEnumerator.Create(generatedFilesDir)) {
// It should only contain files
Debug.Assert(!fileData.IsDirectory);
if (fileData.IsDirectory) continue;
Debug.Trace("CbmCodeGeneratorBuildProviderHost", "Deleting " + fileData.FullName);
File.Delete(fileData.FullName);
}
}
// Create it to make sure it exists
Directory.CreateDirectory(generatedFilesDir);
_generatedFilesDir = generatedFilesDir;
}
public void Compile()
{
string refsPath = Path.Combine(HttpRuntime.AppDomainAppPath, ResourcesDirName);
if (!Directory.Exists(refsPath))
{
return;
}
string[] files = Directory.GetFiles(refsPath, "*.wsdl", SearchOption.AllDirectories);
if (files == null || files.Length == 0)
{
return;
}
CompilationSection cs = WebConfigurationManager.GetWebApplicationSection("system.web/compilation") as CompilationSection;
if (cs == null)
{
throw new HttpException("Unable to determine default compilation language.");
}
CompilerType ct = BuildManager.GetDefaultCompilerTypeForLanguage(cs.DefaultLanguage, cs);
CodeDomProvider codeDomProvider = null;
Exception codeDomException = null;
try {
codeDomProvider = Activator.CreateInstance(ct.CodeDomProviderType) as CodeDomProvider;
} catch (Exception e) {
codeDomException = e;
}
if (codeDomProvider == null)
{
throw new HttpException("Unable to instantiate default compilation language provider.", codeDomException);
}
AssemblyBuilder ab = new AssemblyBuilder(codeDomProvider, "App_WebReferences_");
ab.CompilerOptions = ct.CompilerParameters;
VirtualPath vp;
WsdlBuildProvider wbp;
foreach (string file in files)
{
vp = VirtualPath.PhysicalToVirtual(file);
if (vp == null)
{
continue;
}
wbp = new WsdlBuildProvider();
wbp.SetVirtualPath(vp);
wbp.GenerateCode(ab);
}
CompilerResults results;
try {
results = ab.BuildAssembly();
} catch (CompilationException ex) {
throw new HttpException("Failed to compile web references.", ex);
}
if (results == null)
{
return;
}
Assembly asm = results.CompiledAssembly;
BuildManager.TopLevelAssemblies.Add(asm);
}
internal AssemblyBuilder(CompilationSection compConfig,
ICollection referencedAssemblies, CompilerType compilerType, string outputAssemblyName) {
_compConfig = compConfig;
_outputAssemblyName = outputAssemblyName;
// Clone the referenced assemblies
_initialReferencedAssemblies = AssemblySet.Create(referencedAssemblies);
// We need to clone it to avoid modifying the original (VSWhidbey 338935)
_compilerType = compilerType.Clone();
if (BuildManager.PrecompilingWithDebugInfo) {
// If the precompile flag indicates force debug, always compile as debug
_compilerType.CompilerParameters.IncludeDebugInformation = true;
}
else if (BuildManager.PrecompilingForDeployment) {
// If we're precompiling the app, never compile in debug mode (VSWhidbey 178377)
_compilerType.CompilerParameters.IncludeDebugInformation = false;
}
else if (DeploymentSection.RetailInternal) {
// If we're in retail deployment mode, always turn off debug (DevDiv 36396)
_compilerType.CompilerParameters.IncludeDebugInformation = false;
}
else if (_compConfig.AssemblyPostProcessorTypeInternal != null) {
// If an IAssemblyPostProcessor is registered always compile as debug
_compilerType.CompilerParameters.IncludeDebugInformation = true;
}
//
_tempFiles.KeepFiles = _compilerType.CompilerParameters.IncludeDebugInformation;
_codeProvider = CompilationUtil.CreateCodeDomProviderNonPublic(
_compilerType.CodeDomProviderType);
_maxBatchSize = _compConfig.MaxBatchSize;
_maxBatchGeneratedFileSize = _compConfig.MaxBatchGeneratedFileSize * 1024;
}
private static void SetIncludeDebugInfoFlag(CompilerType compilerType)
{
compilerType.CompilerParameters.IncludeDebugInformation = true;
}
/*
* Process a <%@ %> block
*/
internal virtual void ProcessDirective(string directiveName, IDictionary directive) {
// Empty means default
if (directiveName.Length == 0)
directiveName = DefaultDirectiveName;
// Check for the main directive
if (IsMainDirective(directiveName)) {
// Make sure the main directive was not already specified
if (_fFoundMainDirective && !IgnoreParseErrors) {
throw new HttpException(
SR.GetString(SR.Only_one_directive_allowed, DefaultDirectiveName));
}
_fFoundMainDirective = true;
// Since description is a no op, just remove it if it's there
directive.Remove("description");
// Similarily, ignore 'codebehind' attribute (ASURT 4591)
directive.Remove("codebehind");
string language = Util.GetAndRemoveNonEmptyAttribute(directive, "language");
// Get the compiler for the specified language (if any)
if (language != null) {
_compilerType = _buildProvider.GetDefaultCompilerTypeForLanguageInternal(language);
}
else {
// Get a default from config
_compilerType = _buildProvider.GetDefaultCompilerTypeInternal();
}
_typeName = Util.GetAndRemoveRequiredAttribute(directive, "class");
if (_compilerType.CompilerParameters != null)
ProcessCompilationParams(directive, _compilerType.CompilerParameters);
}
else if (StringUtil.EqualsIgnoreCase(directiveName, "assembly")) {
// Assembly directive
// Remove the attributes as we get them from the dictionary
string assemblyName = Util.GetAndRemoveNonEmptyAttribute(directive, "name");
VirtualPath src = Util.GetAndRemoveVirtualPathAttribute(directive, "src");
if (assemblyName != null && src != null && !IgnoreParseErrors) {
throw new HttpException(
SR.GetString(SR.Attributes_mutually_exclusive, "Name", "Src"));
}
if (assemblyName != null) {
AddAssemblyDependency(assemblyName);
}
// Is it a source file that needs to be compiled on the fly
else if (src != null) {
ImportSourceFile(src);
}
else if (!IgnoreParseErrors) {
throw new HttpException(SR.GetString(SR.Missing_attr, "name"));
}
}
else if (!IgnoreParseErrors) {
throw new HttpException(
SR.GetString(SR.Unknown_directive, directiveName));
}
// If there are some attributes left, fail
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
}
/// <summary>
/// Processes a directive block
/// </summary>
void ProcessDirective(string directiveName, IDictionary directive)
{
// Throw on empy, no directive specified
//
if (directiveName.Length == 0)
{
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderDirectiveNameMissing));
}
// Check for the main directive
//
if (string.Compare(directiveName, ServiceParser.DefaultDirectiveName, StringComparison.OrdinalIgnoreCase) == 0)
{
// Make sure the main directive was not already specified
//
if (foundMainDirective)
{
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderDuplicateDirective(ServiceParser.DefaultDirectiveName)));
}
foundMainDirective = true;
// Ignore 'codebehind' attribute (ASURT 4591)
//
directive.Remove("codebehind");
string language = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "language");
// Get the compiler for the specified language (if any)
// or get the one from config
//
if (language != null)
{
compilerType = buildProvider.GetDefaultCompilerTypeForLanguageInternal(language);
}
else
{
compilerType = buildProvider.GetDefaultCompilerTypeInternal();
}
if (directive.Contains(FactoryAttributeName))
{
factoryAttributeValue = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, FactoryAttributeName);
serviceAttributeValue = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, ServiceAttributeName);
}
else if (directive.Contains(ServiceAttributeName))
{
serviceAttributeValue = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, ServiceAttributeName);
}
else
{
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderMainAttributeMissing));
}
// parse the parameters that are related to the compiler
//
ProcessCompilationParams(directive, compilerType.CompilerParameters);
}
else if (string.Compare(directiveName, "assembly", StringComparison.OrdinalIgnoreCase) == 0)
{
if (directive.Contains("name") && directive.Contains("src"))
{
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderMutualExclusiveAttributes("src", "name")));
}
else if (directive.Contains("name"))
{
string assemblyName = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "name");
if (assemblyName != null)
{
AddAssemblyDependency(assemblyName);
}
else
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderAttributeEmpty("name")));
}
else if (directive.Contains("src"))
{
string srcPath = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "src");
if (srcPath != null)
{
ImportSourceFile(srcPath);
}
else
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderAttributeEmpty("src")));
}
else
{ // if (!directive.Contains("name") && !directive.Contains("src"))
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderRequiredAttributesMissing("src", "name")));
}
}
else
{
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderUnknownDirective(directiveName)));
}
// check if there are any directives that you did not process
//
if (directive.Count > 0)
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderUnknownAttribute(ServiceParserUtilities.FirstDictionaryKey(directive))));
}
private void ProcessDirective(string directiveName, IDictionary directive)
{
if (directiveName.Length == 0)
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderDirectiveNameMissing));
}
if (string.Compare(directiveName, "ServiceHost", StringComparison.OrdinalIgnoreCase) == 0)
{
if (this.foundMainDirective)
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderDuplicateDirective("ServiceHost")));
}
this.foundMainDirective = true;
directive.Remove("codebehind");
string andRemoveNonEmptyAttribute = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "language");
if (andRemoveNonEmptyAttribute != null)
{
this.compilerType = this.buildProvider.GetDefaultCompilerTypeForLanguageInternal(andRemoveNonEmptyAttribute);
}
else
{
this.compilerType = this.buildProvider.GetDefaultCompilerTypeInternal();
}
if (directive.Contains("Factory"))
{
this.factoryAttributeValue = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "Factory");
this.serviceAttributeValue = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "Service");
}
else
{
if (!directive.Contains("Service"))
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderMainAttributeMissing));
}
this.serviceAttributeValue = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "Service");
}
this.ProcessCompilationParams(directive, this.compilerType.CompilerParameters);
}
else
{
if (string.Compare(directiveName, "assembly", StringComparison.OrdinalIgnoreCase) != 0)
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderUnknownDirective(directiveName)));
}
if (directive.Contains("name") && directive.Contains("src"))
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderMutualExclusiveAttributes("src", "name")));
}
if (directive.Contains("name"))
{
string assemblyName = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "name");
if (assemblyName == null)
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderAttributeEmpty("name")));
}
this.AddAssemblyDependency(assemblyName);
}
else
{
if (!directive.Contains("src"))
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderRequiredAttributesMissing("src", "name")));
}
string path = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "src");
if (path == null)
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderAttributeEmpty("src")));
}
this.ImportSourceFile(path);
}
}
if (directive.Count > 0)
{
throw FxTrace.Exception.AsError(new HttpException(System.ServiceModel.Activation.SR.Hosting_BuildProviderUnknownAttribute(ServiceParserUtilities.FirstDictionaryKey(directive))));
}
}
/*
* Process a language attribute, as can appear in the Page directive and in
* <script runat=server> tags.
*/
private void ProcessLanguageAttribute(string language) {
if (language == null)
return;
// We don't have CompilationConfig at design-time and the language attribute isn't used either.
if (FInDesigner)
return;
CompilerType compilerType = CompilationUtil.GetCompilerInfoFromLanguage(
CurrentVirtualPath, language);
// Make sure we don't get conflicting languages
if (_compilerType != null &&
_compilerType.CodeDomProviderType != compilerType.CodeDomProviderType) {
ProcessError(SR.GetString(SR.Mixed_lang_not_supported, language));
return;
}
_compilerType = compilerType;
}
public FakeBuildProvider(Type type)
{
_type = type;
_compilerType = GetDefaultCompilerTypeForLanguage("C#");
}
/// <summary>
/// Initializes a new instance of the <see cref="NancyCSharpRazorBuildProvider"/> class.
/// </summary>
public NancyCSharpRazorBuildProvider()
{
this.compilerType = this.GetDefaultCompilerTypeForLanguage("C#");
this.host = new NancyRazorEngineHost(new CSharpRazorCodeLanguage());
}
internal CompilerType GetCompilerInfoFromExtension(string extension, bool throwOnFail)
{
CompilerType compilerTypeInternal;
this.EnsureCompilerCacheInit();
object obj2 = this._compilerExtensions[extension];
Compiler compiler = obj2 as Compiler;
if (compiler != null)
{
compilerTypeInternal = compiler.CompilerTypeInternal;
this._compilerExtensions[extension] = compilerTypeInternal;
}
else
{
compilerTypeInternal = obj2 as CompilerType;
}
if ((compilerTypeInternal == null) && CodeDomProvider.IsDefinedExtension(extension))
{
CompilerInfo compilerInfo = CodeDomProvider.GetCompilerInfo(CodeDomProvider.GetLanguageFromExtension(extension));
compilerTypeInternal = new CompilerType(compilerInfo.CodeDomProviderType, compilerInfo.CreateDefaultCompilerParameters());
this._compilerExtensions[extension] = compilerTypeInternal;
}
if (compilerTypeInternal == null)
{
if (throwOnFail)
{
throw new HttpException(System.Web.SR.GetString("Invalid_lang_extension", new object[] { extension }));
}
return null;
}
compilerTypeInternal = compilerTypeInternal.Clone();
compilerTypeInternal.CompilerParameters.IncludeDebugInformation = this.Debug;
return compilerTypeInternal;
}
