/* * Return a CompilerType that a extension maps to. */ private static CompilerType GetCompilerInfoFromExtension(VirtualPath configPath, string extension) { // Get the <compilation> config object CompilationSection config = MTConfigUtil.GetCompilationConfig(configPath); return(config.GetCompilerInfoFromExtension(extension, true /*throwOnFail*/)); }
internal string[] GetTopLevelAssemblyReferences(VirtualPath virtualPath) { this.AddPendingCall(); List <Assembly> fromList = new List <Assembly>(); try { virtualPath.CombineWithAppRoot(); foreach (AssemblyInfo info in MTConfigUtil.GetCompilationConfig(virtualPath).Assemblies) { Assembly[] assemblyInternal = info.AssemblyInternal; for (int i = 0; i < assemblyInternal.Length; i++) { if (assemblyInternal[i] != null) { fromList.Add(assemblyInternal[i]); } } } } finally { this.RemovePendingCall(); } StringCollection toList = new StringCollection(); Util.AddAssembliesToStringCollection(fromList, toList); string[] array = new string[toList.Count]; toList.CopyTo(array, 0); return(array); }
internal WebDirectoryBatchCompiler(VirtualDirectory vdir) { this._vdir = vdir; this._utcStart = DateTime.UtcNow; this._compConfig = MTConfigUtil.GetCompilationConfig(this._vdir.VirtualPath); this._referencedAssemblies = BuildManager.GetReferencedAssemblies(this._compConfig); }
/* * Return a CompilerType that a language maps to. */ internal static CompilerType GetCompilerInfoFromLanguage(VirtualPath configPath, string language) { // Get the <compilation> config object CompilationSection config = MTConfigUtil.GetCompilationConfig(configPath); return(config.GetCompilerInfoFromLanguage(language)); }
/* * Returns an array of the assemblies defined in the bin and assembly reference config section */ internal String[] GetTopLevelAssemblyReferences(VirtualPath virtualPath) { // Add a pending call to make sure our thread doesn't get killed AddPendingCall(); List <Assembly> assemblyList = new List <Assembly>(); try { // Treat it as relative to the app root virtualPath.CombineWithAppRoot(); CompilationSection compConfig = MTConfigUtil.GetCompilationConfig(virtualPath); // Add all the config assemblies to the list foreach (AssemblyInfo assemblyInfo in compConfig.Assemblies) { Assembly[] assemblies = assemblyInfo.AssemblyInternal; for (int i = 0; i < assemblies.Length; i++) { if (assemblies[i] != null) { assemblyList.Add(assemblies[i]); } } } } finally { RemovePendingCall(); } StringCollection paths = new StringCollection(); Util.AddAssembliesToStringCollection(assemblyList, paths); string[] references = new string[paths.Count]; paths.CopyTo(references, 0); return(references); }
// Add the referenced assemblies into the compileParameters. Notice that buildProviders do not have // the correct referenced assemblies and we don't cache them since the assemblies could change // between appdomains. (removing assemblies from bin, etc) private void FixupReferencedAssemblies(VirtualPath virtualPath, CompilerParameters compilerParameters) { CompilationSection compConfig = MTConfigUtil.GetCompilationConfig(virtualPath); ICollection referencedAssemblies = BuildManager.GetReferencedAssemblies(compConfig); Util.AddAssembliesToStringCollection(referencedAssemblies, compilerParameters.ReferencedAssemblies); }
protected override void ComputeHashCode(HashCodeCombiner hashCodeCombiner) { base.ComputeHashCode(hashCodeCombiner); CompilationSection compilationConfig = MTConfigUtil.GetCompilationConfig(base.VirtualPath); hashCodeCombiner.AddObject(compilationConfig.RecompilationHash); }
internal BuildProvidersCompiler(VirtualPath configPath, bool supportLocalization, string outputAssemblyName) { this._configPath = configPath; this._supportLocalization = supportLocalization; this._compConfig = MTConfigUtil.GetCompilationConfig(this._configPath); this._referencedAssemblies = BuildManager.GetReferencedAssemblies(this.CompConfig); this._outputAssemblyName = outputAssemblyName; }
/* * Return a file provider Type that an extension maps to. */ internal static Type GetBuildProviderTypeFromExtension(VirtualPath configPath, string extension, BuildProviderAppliesTo neededFor, bool failIfUnknown) { // Get the <compilation> config object CompilationSection config = MTConfigUtil.GetCompilationConfig(configPath); return(GetBuildProviderTypeFromExtension(config, extension, neededFor, failIfUnknown)); }
internal BuildProvidersCompiler(VirtualPath configPath, bool supportLocalization, string generatedFilesDir, int index) { this._configPath = configPath; this._supportLocalization = supportLocalization; this._compConfig = MTConfigUtil.GetCompilationConfig(this._configPath); this._referencedAssemblies = BuildManager.GetReferencedAssemblies(this.CompConfig, index); this._generatedFilesDir = generatedFilesDir; }
internal static CompilerType GetDefaultLanguageCompilerInfo(CompilationSection compConfig, VirtualPath configPath) { if (compConfig == null) { compConfig = MTConfigUtil.GetCompilationConfig(configPath); } if (compConfig.DefaultLanguage == null) { return(GetCodeDefaultLanguageCompilerInfo()); } return(compConfig.GetCompilerInfoFromLanguage(compConfig.DefaultLanguage)); }
internal static CompilerType GetCSharpCompilerInfo(CompilationSection compConfig, VirtualPath configPath) { if (compConfig == null) { compConfig = MTConfigUtil.GetCompilationConfig(configPath); } if (compConfig.DefaultLanguage == null) { return(new CompilerType(typeof(CSharpCodeProvider), null)); } return(compConfig.GetCompilerInfoFromLanguage("c#")); }
internal static System.Web.Compilation.ExpressionBuilder GetExpressionBuilder(string expressionPrefix, VirtualPath virtualPath, IDesignerHost host) { if (expressionPrefix.Length == 0) { if (dataBindingExpressionBuilder == null) { dataBindingExpressionBuilder = new DataBindingExpressionBuilder(); } return(dataBindingExpressionBuilder); } CompilationSection compilationConfig = null; if (host != null) { IWebApplication application = (IWebApplication)host.GetService(typeof(IWebApplication)); if (application != null) { compilationConfig = application.OpenWebConfiguration(true).GetSection("system.web/compilation") as CompilationSection; } } if (compilationConfig == null) { compilationConfig = MTConfigUtil.GetCompilationConfig(virtualPath); } System.Web.Configuration.ExpressionBuilder builder = compilationConfig.ExpressionBuilders[expressionPrefix]; if (builder == null) { throw new HttpParseException(System.Web.SR.GetString("InvalidExpressionPrefix", new object[] { expressionPrefix })); } Type c = null; if (host != null) { ITypeResolutionService service = (ITypeResolutionService)host.GetService(typeof(ITypeResolutionService)); if (service != null) { c = service.GetType(builder.Type); } } if (c == null) { c = builder.TypeInternal; } if (!typeof(System.Web.Compilation.ExpressionBuilder).IsAssignableFrom(c)) { throw new HttpParseException(System.Web.SR.GetString("ExpressionBuilder_InvalidType", new object[] { c.FullName })); } return((System.Web.Compilation.ExpressionBuilder)HttpRuntime.FastCreatePublicInstance(c)); }
internal static CompilerType GetDefaultLanguageCompilerInfo(CompilationSection compConfig, VirtualPath configPath) { if (compConfig == null) { // Get the <compilation> config object compConfig = MTConfigUtil.GetCompilationConfig(configPath); } // If no default language was specified in config, use VB if (compConfig.DefaultLanguage == null) { return(GetCodeDefaultLanguageCompilerInfo()); } else { return(compConfig.GetCompilerInfoFromLanguage(compConfig.DefaultLanguage)); } }
internal static bool NeedToCopyFile(VirtualPath virtualPath, bool updatable, out bool createStub) { createStub = false; CompilationSection compilationConfig = MTConfigUtil.GetCompilationConfig(virtualPath); string extension = virtualPath.Extension; BuildProviderInfo buildProviderInfo = System.Web.Compilation.BuildProvider.GetBuildProviderInfo(compilationConfig, extension); if (buildProviderInfo != null) { if ((BuildProviderAppliesTo.Web & buildProviderInfo.AppliesTo) == 0) { return(true); } if (buildProviderInfo.Type == typeof(ForceCopyBuildProvider)) { return(true); } if ((buildProviderInfo.Type != typeof(IgnoreFileBuildProvider)) && BuildManager.PrecompilingForUpdatableDeployment) { return(true); } createStub = true; if (((buildProviderInfo.Type == typeof(UserControlBuildProvider)) || (buildProviderInfo.Type == typeof(MasterPageBuildProvider))) || (buildProviderInfo.Type == typeof(IgnoreFileBuildProvider))) { createStub = false; } return(false); } if (compilationConfig.GetCompilerInfoFromExtension(extension, false) != null) { return(false); } if (System.Web.Util.StringUtil.EqualsIgnoreCase(extension, ".asax")) { return(false); } if (!updatable && System.Web.Util.StringUtil.EqualsIgnoreCase(extension, ".skin")) { return(false); } return(true); }
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); }
internal static ExpressionBuilder GetExpressionBuilder(string expressionPrefix, VirtualPath virtualPath, IDesignerHost host) { // If there is no expressionPrefix, it's a v1 style databinding expression if (expressionPrefix.Length == 0) { if (dataBindingExpressionBuilder == null) { dataBindingExpressionBuilder = new DataBindingExpressionBuilder(); } return(dataBindingExpressionBuilder); } CompilationSection config = null; // If we are in the designer, we need to access IWebApplication config instead #if !FEATURE_PAL // FEATURE_PAL does not support designer-based features if (host != null) { IWebApplication webapp = (IWebApplication)host.GetService(typeof(IWebApplication)); if (webapp != null) { config = webapp.OpenWebConfiguration(true).GetSection("system.web/compilation") as CompilationSection; } } #endif // !FEATURE_PAL // If we failed to get config from the designer, fall back on runtime config always if (config == null) { config = MTConfigUtil.GetCompilationConfig(virtualPath); } System.Web.Configuration.ExpressionBuilder builder = config.ExpressionBuilders[expressionPrefix]; if (builder == null) { throw new HttpParseException(SR.GetString(SR.InvalidExpressionPrefix, expressionPrefix)); } Type expressionBuilderType = null; if (host != null) { // If we are in the designer, we have to use the type resolution service ITypeResolutionService ts = (ITypeResolutionService)host.GetService(typeof(ITypeResolutionService)); if (ts != null) { expressionBuilderType = ts.GetType(builder.Type); } } if (expressionBuilderType == null) { expressionBuilderType = builder.TypeInternal; } Debug.Assert(expressionBuilderType != null, "expressionBuilderType should not be null"); if (!typeof(ExpressionBuilder).IsAssignableFrom(expressionBuilderType)) { throw new HttpParseException(SR.GetString(SR.ExpressionBuilder_InvalidType, expressionBuilderType.FullName)); } ExpressionBuilder expressionBuilder = (ExpressionBuilder)HttpRuntime.FastCreatePublicInstance(expressionBuilderType); return(expressionBuilder); }
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); }
internal NonBatchDirectoryCompiler(VirtualDirectory vdir) { _vdir = vdir; _compConfig = MTConfigUtil.GetCompilationConfig(_vdir.VirtualPath); }
internal static bool IsBatchingEnabled(string configPath) { return(MTConfigUtil.GetCompilationConfig(configPath).Batch); }
private void FixupReferencedAssemblies(VirtualPath virtualPath, CompilerParameters compilerParameters) { Util.AddAssembliesToStringCollection(BuildManager.GetReferencedAssemblies(MTConfigUtil.GetCompilationConfig(virtualPath)), compilerParameters.ReferencedAssemblies); }
internal static bool IsBatchingEnabled(string configPath) { CompilationSection config = MTConfigUtil.GetCompilationConfig(configPath); return(config.Batch); }
// This is used to determine what files need to be copied, and what stub files // need to be created during deployment precompilation. // Note: createStub only applies if the method returns false. internal static bool NeedToCopyFile(VirtualPath virtualPath, bool updatable, out bool createStub) { createStub = false; // Get the <compilation> config object CompilationSection config = MTConfigUtil.GetCompilationConfig(virtualPath); string extension = virtualPath.Extension; BuildProviderInfo providerInfo = BuildProvider.GetBuildProviderInfo(config, extension); if (providerInfo != null) { // We only care about 'web' providers. Everything else we treat as static if ((BuildProviderAppliesTo.Web & providerInfo.AppliesTo) == 0) { return(true); } // If the provider is a ForceCopyBuildProvider, treat as static if (providerInfo.Type == typeof(ForceCopyBuildProvider)) { return(true); } // During updatable precomp, everything needs to be copied over. However, // aspx files that use code beside will later be overwritten by modified // versions (see TemplateParser.CreateModifiedMainDirectiveFileIfNeeded) if (providerInfo.Type != typeof(IgnoreFileBuildProvider) && BuildManager.PrecompilingForUpdatableDeployment) { return(true); } // There is a real provider, so don't copy the file. We also need to determine whether // a stub file needs to be created. createStub = true; // Skip the stub file for some non-requestable types if (providerInfo.Type == typeof(UserControlBuildProvider) || providerInfo.Type == typeof(MasterPageBuildProvider) || providerInfo.Type == typeof(IgnoreFileBuildProvider)) { createStub = false; } return(false); } // If the extension is registered as a compiler extension, don't copy if (config.GetCompilerInfoFromExtension(extension, false /*throwOnFail*/) != null) { return(false); } // Skip the copying for asax and skin files, which are not static even though they // don't have a registered BuildProvider (but don't skip .skin files during // updatable precomp). // if (StringUtil.EqualsIgnoreCase(extension, ".asax")) { return(false); } if (!updatable && StringUtil.EqualsIgnoreCase(extension, ThemeDirectoryCompiler.skinExtension)) { return(false); } // // If there is no BuildProvider registered, it's a static file, and should be copied // return(true); }
internal static bool IsDebuggingEnabled(HttpContext context) { CompilationSection compConfig = MTConfigUtil.GetCompilationConfig(context); return(compConfig.Debug); }
internal static bool IsDebuggingEnabled(HttpContext context) { return(MTConfigUtil.GetCompilationConfig(context).Debug); }
internal static CompilerType GetCompilerInfoFromLanguage(VirtualPath configPath, string language) { return(MTConfigUtil.GetCompilationConfig(configPath).GetCompilerInfoFromLanguage(language)); }
internal static Type GetBuildProviderTypeFromExtension(VirtualPath configPath, string extension, BuildProviderAppliesTo neededFor, bool failIfUnknown) { return(GetBuildProviderTypeFromExtension(MTConfigUtil.GetCompilationConfig(configPath), extension, neededFor, failIfUnknown)); }
private static CompilerType GetCompilerInfoFromExtension(VirtualPath configPath, string extension) { return(MTConfigUtil.GetCompilationConfig(configPath).GetCompilerInfoFromExtension(extension, true)); }