mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
950 lines
37 KiB
C#
950 lines
37 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Activation
|
|
{
|
|
using System.CodeDom;
|
|
using System.CodeDom.Compiler;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Text.RegularExpressions;
|
|
using System.Web;
|
|
using System.Web.Hosting;
|
|
using System.Web.Compilation;
|
|
using System.Web.RegularExpressions;
|
|
using System.ServiceModel.Activation.Diagnostics;
|
|
using System.Security;
|
|
using System.Runtime.Diagnostics;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Runtime;
|
|
|
|
/// <summary>
|
|
/// This class will parse the .svc file and maintains a list of useful information that the build
|
|
/// provider needs in order to compile the file. The parser creates a list of dependent assemblies,
|
|
/// understands the compiler that we need to use, fully parses all the supported directives etc.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The class is not thread-safe.
|
|
/// </remarks>
|
|
#pragma warning disable 618 // have not moved to the v4 security model yet
|
|
[SecurityCritical(SecurityCriticalScope.Everything)]
|
|
#pragma warning restore 618
|
|
class ServiceParser
|
|
{
|
|
// the delimiter for the compiled custom string
|
|
const string Delimiter = ServiceHostingEnvironment.ServiceParserDelimiter;
|
|
|
|
// attribute names
|
|
const string DefaultDirectiveName = "ServiceHost";
|
|
const string FactoryAttributeName = "Factory";
|
|
const string ServiceAttributeName = "Service";
|
|
|
|
// regular exression for the directive
|
|
readonly static SimpleDirectiveRegex directiveRegex;
|
|
|
|
// the build provider we will work with
|
|
ServiceBuildProvider buildProvider;
|
|
|
|
// text for the file
|
|
string serviceText;
|
|
|
|
// the class attribute value
|
|
string factoryAttributeValue = string.Empty;
|
|
|
|
// the constructorstring
|
|
string serviceAttributeValue = string.Empty;
|
|
|
|
// the line number in file currently being parsed
|
|
int lineNumber;
|
|
|
|
// the column number in file currently being parsed
|
|
int startColumn;
|
|
|
|
// the main directive was found or not
|
|
bool foundMainDirective;
|
|
|
|
// the type of the compiler (i.e C#)
|
|
CompilerType compilerType;
|
|
|
|
// the string containing the code to be compiled,
|
|
// it will be null when all the code is "behind"
|
|
string sourceString;
|
|
|
|
// assemblies to be linked with, we need a unique list
|
|
// of them and we maintain a Dictionary for it.
|
|
HybridDictionary linkedAssemblies;
|
|
|
|
// the set of assemblies that the build system is
|
|
// telling us we will be linked with. There is no unique
|
|
// requirement for them.
|
|
ICollection referencedAssemblies;
|
|
|
|
// used to figure out where the new lines start
|
|
static char[] newlineChars = new char[] { '\r', '\n' };
|
|
|
|
// source file dependencies
|
|
HybridDictionary sourceDependencies;
|
|
|
|
// virtual path for the file that we are parsing
|
|
string virtualPath;
|
|
|
|
[SuppressMessage(FxCop.Category.Security, FxCop.Rule.AptcaMethodsShouldOnlyCallAptcaMethods, Justification = "Users cannot pass arbitrary data to this code.")]
|
|
static ServiceParser()
|
|
{
|
|
directiveRegex = new SimpleDirectiveRegex();
|
|
}
|
|
|
|
/// <summary>
|
|
/// The Contructor needs the path to the file that it will parse and a reference to
|
|
/// the build provider that we are using. This is necessary because there are things that
|
|
/// need to be set on the build provider directly as we are parsing...
|
|
/// </summary>
|
|
internal ServiceParser(string virtualPath, ServiceBuildProvider buildProvider)
|
|
{
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.WebHostCompilation, SR.TraceCodeWebHostCompilation,
|
|
new StringTraceRecord("VirtualPath", virtualPath), this, (Exception)null);
|
|
}
|
|
|
|
this.virtualPath = virtualPath;
|
|
this.buildProvider = buildProvider;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructor that is used when the whole svc file content is provided. This is the case
|
|
/// when the COM+ Admin tool calls into it.
|
|
/// </summary>
|
|
ServiceParser(string serviceText)
|
|
{
|
|
this.serviceText = serviceText;
|
|
this.buildProvider = new ServiceBuildProvider();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parsing the content of the service file and retrieve the serviceAttributeValue attribute for ComPlus.
|
|
/// </summary>
|
|
/// <param name="serviceText">The content of the service file.</param>
|
|
/// <returns>The "serviceAttributeValue" attribute of the Service directive. </returns>
|
|
/// <exception cref="System.Web.HttpParseException"/>
|
|
internal static IDictionary<string, string> ParseServiceDirective(string serviceText)
|
|
{
|
|
ServiceParser parser = new ServiceParser(serviceText);
|
|
parser.ParseString();
|
|
|
|
// the list of valid attributes for ComPlus for Service Directive
|
|
IDictionary<string, string> attributeTable = new Dictionary<string, string>(
|
|
StringComparer.OrdinalIgnoreCase);
|
|
|
|
if (!string.IsNullOrEmpty(parser.factoryAttributeValue))
|
|
attributeTable.Add(FactoryAttributeName, parser.factoryAttributeValue);
|
|
|
|
if (!string.IsNullOrEmpty(parser.serviceAttributeValue))
|
|
attributeTable.Add(ServiceAttributeName, parser.serviceAttributeValue);
|
|
|
|
return attributeTable;
|
|
}
|
|
|
|
/// <summary>
|
|
/// </summary>
|
|
|
|
// various getters for private objects that the build
|
|
// provider will need
|
|
//
|
|
internal CompilerType CompilerType
|
|
{
|
|
get
|
|
{
|
|
return compilerType;
|
|
}
|
|
}
|
|
|
|
internal ICollection AssemblyDependencies
|
|
{
|
|
get
|
|
{
|
|
if (linkedAssemblies == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return linkedAssemblies.Keys;
|
|
}
|
|
}
|
|
|
|
internal ICollection SourceDependencies
|
|
{
|
|
get
|
|
{
|
|
if (sourceDependencies == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return sourceDependencies.Keys;
|
|
}
|
|
}
|
|
|
|
internal bool HasInlineCode
|
|
{
|
|
get
|
|
{
|
|
return (sourceString != null);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses the code file appropriately. This method is used by the
|
|
/// build provider.
|
|
/// </summary>
|
|
internal void Parse(ICollection referencedAssemblies)
|
|
{
|
|
if (referencedAssemblies == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("referencedAssemblies");
|
|
}
|
|
|
|
this.referencedAssemblies = referencedAssemblies;
|
|
AddSourceDependency(virtualPath);
|
|
|
|
using (TextReader reader = buildProvider.OpenReaderInternal())
|
|
{
|
|
this.serviceText = reader.ReadToEnd();
|
|
ParseString();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method returns a code compile unit that will be added
|
|
/// to the other depdnecies in order to compile
|
|
/// </summary>
|
|
internal CodeCompileUnit GetCodeModel()
|
|
{
|
|
// Do we have something to compile?
|
|
//
|
|
if (sourceString == null || sourceString.Length == 0)
|
|
return null;
|
|
|
|
CodeSnippetCompileUnit snippetCompileUnit = new CodeSnippetCompileUnit(sourceString);
|
|
|
|
// Put in some context so that the file can be debugged.
|
|
//
|
|
string pragmaFile = HostingEnvironmentWrapper.MapPath(virtualPath);
|
|
snippetCompileUnit.LinePragma = new CodeLinePragma(pragmaFile, lineNumber);
|
|
|
|
return snippetCompileUnit;
|
|
}
|
|
|
|
Exception CreateParseException(string message, string sourceCode)
|
|
{
|
|
return CreateParseException(message, null, sourceCode);
|
|
}
|
|
|
|
Exception CreateParseException(Exception innerException, string sourceCode)
|
|
{
|
|
return CreateParseException(innerException.Message, innerException, sourceCode);
|
|
}
|
|
|
|
Exception CreateParseException(string message, Exception innerException, string sourceCode)
|
|
{
|
|
return new HttpParseException(message, innerException, this.virtualPath, sourceCode, this.lineNumber);
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method returns the custom string that is to be passed to ServiceHostingEnvironment from BuildManager.
|
|
/// </summary>
|
|
/// <param name="compiledAssembly">The full name of the built assembly for inline code.</param>
|
|
internal string CreateParseString(Assembly compiledAssembly)
|
|
{
|
|
Type typeToPreserve = this.GetCompiledType(compiledAssembly);
|
|
string typeToPreserveName = string.Empty;
|
|
if (typeToPreserve != null)
|
|
typeToPreserveName = typeToPreserve.AssemblyQualifiedName;
|
|
|
|
System.Text.StringBuilder builder = new System.Text.StringBuilder();
|
|
if (compiledAssembly != null)
|
|
{
|
|
builder.Append(Delimiter);
|
|
builder.Append(compiledAssembly.FullName);
|
|
}
|
|
|
|
if (this.referencedAssemblies != null)
|
|
{
|
|
// CSDMain #192135
|
|
// Minimize code change by doing 2 passes to have assembly containing type at the top of the list.
|
|
// As a result, this assembly will get loaded first in ServiceHostFactory.CreateServiceHost.
|
|
// In the multi-targetting scenario this prevents the runtime from trying to load a newer CLR assembly
|
|
// and failing. In the happy case, duplicate assembly references may occur (no effect on runtime).
|
|
// Note that if the service type is contained in a framework assembly, this does not fix the problem.
|
|
// Future improvement is to write fully qualified type name and let CLR handle load/search.
|
|
if (!string.IsNullOrEmpty(serviceAttributeValue))
|
|
{
|
|
foreach (Assembly assembly in this.referencedAssemblies)
|
|
{
|
|
Type serviceType;
|
|
try
|
|
{
|
|
serviceType = assembly.GetType(serviceAttributeValue, false);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (System.Runtime.Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
// log exception, but do not rethrow
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
|
|
|
|
break;
|
|
}
|
|
|
|
if (serviceType != null)
|
|
{
|
|
builder.Append(Delimiter);
|
|
builder.Append(assembly.FullName);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (Assembly assembly in this.referencedAssemblies)
|
|
{
|
|
builder.Append(Delimiter);
|
|
builder.Append(assembly.FullName);
|
|
}
|
|
}
|
|
|
|
if (this.AssemblyDependencies != null)
|
|
{
|
|
foreach (Assembly assembly in this.AssemblyDependencies)
|
|
{
|
|
builder.Append(Delimiter);
|
|
builder.Append(assembly.FullName);
|
|
}
|
|
}
|
|
// use application relative virtualpath instead of the absolute path
|
|
// so that the compliedcustomstring is applicationame independent
|
|
return string.Concat(VirtualPathUtility.ToAppRelative(virtualPath), Delimiter,
|
|
typeToPreserveName, Delimiter,
|
|
serviceAttributeValue, builder.ToString());
|
|
}
|
|
|
|
void AddSourceDependency(string fileName)
|
|
{
|
|
if (sourceDependencies == null)
|
|
sourceDependencies = new HybridDictionary(true);
|
|
|
|
sourceDependencies.Add(fileName, fileName);
|
|
}
|
|
|
|
Type GetCompiledType(Assembly compiledAssembly)
|
|
{
|
|
if (string.IsNullOrEmpty(factoryAttributeValue))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
Type type = null;
|
|
|
|
// First, try to get the type from the assembly that has been built (if any)
|
|
if (this.HasInlineCode && (compiledAssembly != null))
|
|
{
|
|
type = compiledAssembly.GetType(factoryAttributeValue);
|
|
}
|
|
|
|
// If not, try to get it from other assemblies
|
|
if (type == null)
|
|
{
|
|
type = GetType(factoryAttributeValue);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
internal IDictionary GetLinePragmasTable()
|
|
{
|
|
LinePragmaCodeInfo info = new LinePragmaCodeInfo(this.lineNumber, this.startColumn, 1, -1, false);
|
|
IDictionary dictionary = new Hashtable();
|
|
dictionary[this.lineNumber] = info;
|
|
return dictionary;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses the content of the svc file for each directive line
|
|
/// </summary>
|
|
void ParseString()
|
|
{
|
|
try
|
|
{
|
|
int textPos = 0;
|
|
Match match;
|
|
lineNumber = 1;
|
|
|
|
// Check for ending bracket first, MB 45013.
|
|
if (this.serviceText.IndexOf('>') == -1)
|
|
{
|
|
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderDirectiveEndBracketMissing(ServiceParser.DefaultDirectiveName)));
|
|
}
|
|
|
|
// First, parse all the <%@ ... %> directives
|
|
//
|
|
for (;;)
|
|
{
|
|
match = directiveRegex.Match(this.serviceText, textPos);
|
|
|
|
// Done with the directives?
|
|
//
|
|
if (!match.Success)
|
|
break;
|
|
|
|
lineNumber += ServiceParserUtilities.LineCount(this.serviceText, textPos, match.Index);
|
|
textPos = match.Index;
|
|
|
|
// Get all the directives into a bag
|
|
//
|
|
IDictionary directive = CollectionsUtil.CreateCaseInsensitiveSortedList();
|
|
string directiveName = ProcessAttributes(match, directive);
|
|
|
|
// Understand the directive
|
|
//
|
|
ProcessDirective(directiveName, directive);
|
|
lineNumber += ServiceParserUtilities.LineCount(this.serviceText, textPos, match.Index + match.Length);
|
|
textPos = match.Index + match.Length;
|
|
|
|
// Fixup line and column numbers to have meaninglful errors
|
|
//
|
|
int newlineIndex = this.serviceText.LastIndexOfAny(newlineChars, textPos - 1);
|
|
startColumn = textPos - newlineIndex;
|
|
}
|
|
|
|
if (!foundMainDirective)
|
|
{
|
|
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderDirectiveMissing(ServiceParser.DefaultDirectiveName)));
|
|
}
|
|
|
|
// skip the directives chunk
|
|
//
|
|
string remainingText = this.serviceText.Substring(textPos);
|
|
|
|
// If there is something else in the file, it needs to be compiled
|
|
//
|
|
if (!ServiceParserUtilities.IsWhiteSpaceString(remainingText))
|
|
{
|
|
sourceString = remainingText;
|
|
}
|
|
}
|
|
catch (HttpException e)
|
|
{
|
|
// the string is set in the internal exception, no need to set it again.
|
|
//
|
|
Exception parseException = CreateParseException(e, this.serviceText);
|
|
throw FxTrace.Exception.AsError(
|
|
new HttpCompileException(parseException.Message, parseException));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the directive if it exists or an empty string
|
|
/// </summary>
|
|
string ProcessAttributes(Match match, IDictionary attribs)
|
|
{
|
|
// creates 3 parallel capture collections
|
|
// for the attribute names, the attribute values and the
|
|
// equal signs
|
|
//
|
|
string ret = String.Empty;
|
|
|
|
CaptureCollection attrnames = match.Groups["attrname"].Captures;
|
|
CaptureCollection attrvalues = match.Groups["attrval"].Captures;
|
|
CaptureCollection equalsign = match.Groups["equal"].Captures;
|
|
|
|
// Iterate through all of them and add then to
|
|
// the dictionary of attributes
|
|
//
|
|
for (int i = 0; i < attrnames.Count; i++)
|
|
{
|
|
string attribName = attrnames[i].ToString();
|
|
string attribValue = attrvalues[i].ToString();
|
|
|
|
// Check if there is an equal sign.
|
|
//
|
|
bool fHasEqual = (equalsign[i].ToString().Length > 0);
|
|
|
|
if (attribName != null)
|
|
{
|
|
// A <%@ %> block can have two formats:
|
|
// <%@ directive foo=1 bar=hello %>
|
|
// <%@ foo=1 bar=hello %>
|
|
// Check if we have the first format
|
|
//
|
|
if (!fHasEqual && i == 0)
|
|
{
|
|
// return the main directive
|
|
//
|
|
ret = attribName;
|
|
continue;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (attribs != null)
|
|
attribs.Add(attribName, attribValue);
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderDuplicateAttribute(attribName)));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method understands the compilation parameters if any ...
|
|
/// </summary>
|
|
[SuppressMessage(FxCop.Category.Security, FxCop.Rule.DoNotIndirectlyExposeMethodsWithLinkDemands, Justification = "This method doesn't allow callers to access sensitive information, operations, or resources that can be used in a destructive manner.")]
|
|
void ProcessCompilationParams(IDictionary directive, CompilerParameters compilParams)
|
|
{
|
|
bool debug = false;
|
|
if (ServiceParserUtilities.GetAndRemoveBooleanAttribute(directive, "debug", ref debug))
|
|
{
|
|
compilParams.IncludeDebugInformation = debug;
|
|
}
|
|
|
|
int warningLevel = 0;
|
|
if (ServiceParserUtilities.GetAndRemoveNonNegativeIntegerAttribute(directive, "warninglevel", ref warningLevel))
|
|
{
|
|
compilParams.WarningLevel = warningLevel;
|
|
if (warningLevel > 0)
|
|
compilParams.TreatWarningsAsErrors = true;
|
|
}
|
|
|
|
string compilerOptions = ServiceParserUtilities.GetAndRemoveNonEmptyAttribute(directive, "compileroptions");
|
|
if (compilerOptions != null)
|
|
{
|
|
compilParams.CompilerOptions = compilerOptions;
|
|
}
|
|
}
|
|
|
|
|
|
/// <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))));
|
|
}
|
|
|
|
void ImportSourceFile(string path)
|
|
{
|
|
// Get a full path to the source file, compile it to an assembly
|
|
// add the depedency to the assembly
|
|
//
|
|
string baseVirtualDir = VirtualPathUtility.GetDirectory(virtualPath);
|
|
string fullVirtualPath = VirtualPathUtility.Combine(baseVirtualDir, path);
|
|
|
|
AddSourceDependency(fullVirtualPath);
|
|
Assembly a = BuildManager.GetCompiledAssembly(fullVirtualPath);
|
|
AddAssemblyDependency(a);
|
|
}
|
|
|
|
void AddAssemblyDependency(string assemblyName)
|
|
{
|
|
// Load and keep track of the assembly
|
|
//
|
|
Assembly a = Assembly.Load(assemblyName);
|
|
AddAssemblyDependency(a);
|
|
}
|
|
|
|
void AddAssemblyDependency(Assembly assembly)
|
|
{
|
|
if (linkedAssemblies == null)
|
|
linkedAssemblies = new HybridDictionary(false);
|
|
|
|
linkedAssemblies.Add(assembly, null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Look for a type by name in the assemblies available to this page
|
|
/// </summary>
|
|
Type GetType(string typeName)
|
|
{
|
|
Type type;
|
|
|
|
// If it contains an assembly name, just call Type.GetType (ASURT 53589)
|
|
//
|
|
if (ServiceParserUtilities.TypeNameIncludesAssembly(typeName))
|
|
{
|
|
try
|
|
{
|
|
type = Type.GetType(typeName, true);
|
|
}
|
|
catch (ArgumentException e)
|
|
{
|
|
Exception parseException = CreateParseException(e, this.sourceString);
|
|
throw FxTrace.Exception.AsError(
|
|
new HttpCompileException(parseException.Message, parseException));
|
|
}
|
|
catch (TargetInvocationException e)
|
|
{
|
|
Exception parseException = CreateParseException(e, this.sourceString);
|
|
throw FxTrace.Exception.AsError(
|
|
new HttpCompileException(parseException.Message, parseException));
|
|
}
|
|
catch (TypeLoadException e)
|
|
{
|
|
Exception parseException = CreateParseException(SR.Hosting_BuildProviderCouldNotCreateType(typeName), e, this.sourceString);
|
|
throw FxTrace.Exception.AsError(
|
|
new HttpCompileException(parseException.Message, parseException));
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
try
|
|
{
|
|
type = ServiceParserUtilities.GetTypeFromAssemblies(referencedAssemblies, typeName, false /*ignoreCase*/);
|
|
if (type != null)
|
|
return type;
|
|
|
|
type = ServiceParserUtilities.GetTypeFromAssemblies(AssemblyDependencies, typeName, false /*ignoreCase*/);
|
|
if (type != null)
|
|
return type;
|
|
}
|
|
catch (HttpException e)
|
|
{
|
|
Exception parseException = CreateParseException(SR.Hosting_BuildProviderCouldNotCreateType(typeName), e, this.sourceString);
|
|
throw FxTrace.Exception.AsError(
|
|
new HttpCompileException(parseException.Message, parseException));
|
|
}
|
|
|
|
Exception exception = CreateParseException(SR.Hosting_BuildProviderCouldNotCreateType(typeName), this.sourceString);
|
|
throw FxTrace.Exception.AsError(
|
|
new HttpCompileException(exception.Message, exception));
|
|
}
|
|
|
|
/// <summary>
|
|
/// This class contains static methods that are necessary to manipulate the
|
|
/// structures that contain the directives. The logic assumes that the parser will
|
|
/// create a dictionary that contains all the directives and we can pull certain directives as
|
|
/// necessary while processing/compiling the page. The directives are strings.
|
|
///
|
|
/// </summary>
|
|
static class ServiceParserUtilities
|
|
{
|
|
/// <summary>
|
|
/// Return the first key of the dictionary as a string. Throws if it's
|
|
/// empty or if the key is not a string.
|
|
/// </summary>
|
|
internal static string FirstDictionaryKey(IDictionary dictionary)
|
|
{
|
|
// assume that the caller has checked the dictionary before calling
|
|
//
|
|
IDictionaryEnumerator e = dictionary.GetEnumerator();
|
|
e.MoveNext();
|
|
return (string)e.Key;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a string value from a dictionary, and remove
|
|
/// it from the dictionary of attributes if it exists.
|
|
/// </summary>
|
|
/// <remarks>Returns null if the value was not there ...</remarks>
|
|
static string GetAndRemove(IDictionary dictionary, string key)
|
|
{
|
|
string val = (string)dictionary[key];
|
|
|
|
if (val != null)
|
|
{
|
|
dictionary.Remove(key);
|
|
val = val.Trim();
|
|
}
|
|
else
|
|
return string.Empty;
|
|
|
|
return val;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a value from a dictionary, and remove it from the dictionary if
|
|
/// it exists. Throw an exception if the value is a whitespace string.
|
|
/// However, don't complain about null, which simply means the value is not
|
|
/// in the dictionary.
|
|
/// </summary>
|
|
internal static string GetAndRemoveNonEmptyAttribute(IDictionary directives, string key, bool required)
|
|
{
|
|
string val = ServiceParserUtilities.GetAndRemove(directives, key);
|
|
|
|
if (val.Length == 0)
|
|
{
|
|
if (required)
|
|
{
|
|
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderAttributeMissing(key)));
|
|
}
|
|
return null;
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
|
|
internal static string GetAndRemoveNonEmptyAttribute(IDictionary directives, string key)
|
|
{
|
|
return GetAndRemoveNonEmptyAttribute(directives, key, false /*required*/);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a string value from a dictionary, and convert it to bool. Throw an
|
|
/// exception if it's not a valid bool string.
|
|
/// However, don't complain about null, which simply means the value is not
|
|
/// in the dictionary.
|
|
/// The value is returned through a REF param (unchanged if null)
|
|
/// </summary>
|
|
/// <returns>True if attrib exists, false otherwise</returns>
|
|
internal static bool GetAndRemoveBooleanAttribute(IDictionary directives, string key, ref bool val)
|
|
{
|
|
string s = ServiceParserUtilities.GetAndRemove(directives, key);
|
|
|
|
if (s.Length == 0)
|
|
return false;
|
|
|
|
try
|
|
{
|
|
val = bool.Parse(s);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderInvalidValueForBooleanAttribute(s, key)));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a string value from a dictionary, and convert it to integer. Throw an
|
|
/// exception if it's not a valid positive integer string.
|
|
/// However, don't complain about null, which simply means the value is not
|
|
/// in the dictionary.
|
|
/// The value is returned through a REF param (unchanged if null)
|
|
/// </summary>
|
|
/// <returns>True if attrib exists, false otherwise</returns>
|
|
internal static bool GetAndRemoveNonNegativeIntegerAttribute(IDictionary directives, string key, ref int val)
|
|
{
|
|
string s = ServiceParserUtilities.GetAndRemove(directives, key);
|
|
|
|
if (s.Length == 0)
|
|
return false;
|
|
|
|
val = GetNonNegativeIntegerAttribute(key, s);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parse a string attribute into a non-negative integer
|
|
/// </summary>
|
|
/// <param name="name">Name of the attribute, used only for the error messages</param>
|
|
/// <param name="value">Value to convert to int</param>
|
|
static int GetNonNegativeIntegerAttribute(string name, string value)
|
|
{
|
|
int ret;
|
|
|
|
try
|
|
{
|
|
ret = int.Parse(value, CultureInfo.InvariantCulture);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderInvalidValueForNonNegativeIntegerAttribute(value, name)));
|
|
}
|
|
|
|
// Make sure it's not negative
|
|
//
|
|
if (ret < 0)
|
|
{
|
|
throw FxTrace.Exception.AsError(new HttpException(SR.Hosting_BuildProviderInvalidValueForNonNegativeIntegerAttribute(value, name)));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
internal static bool IsWhiteSpaceString(string s)
|
|
{
|
|
return (s.Trim().Length == 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method takes the code that will be compiled as a string and it
|
|
/// will count how many lines exist between the given offset and the final
|
|
/// offset.
|
|
/// </summary>
|
|
/// <param name="text">The text that contains the source code</param>
|
|
/// <param name="offset">Starting offset for lookup</param>
|
|
/// <param name="newoffset">Ending offset</param>
|
|
/// <returns>The number of lines</returns>
|
|
internal static int LineCount(string text, int offset, int newoffset)
|
|
{
|
|
int linecount = 0;
|
|
|
|
while (offset < newoffset)
|
|
{
|
|
if (text[offset] == '\r' || (text[offset] == '\n' && (offset == 0 || text[offset - 1] != '\r')))
|
|
linecount++;
|
|
|
|
offset++;
|
|
}
|
|
|
|
return linecount;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses a string that contains a type trying to figure out if the assembly info is there.
|
|
/// </summary>
|
|
/// <param name="typeName">The string to search</param>
|
|
internal static bool TypeNameIncludesAssembly(string typeName)
|
|
{
|
|
return (typeName.IndexOf(",", StringComparison.Ordinal) >= 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Loops through a list of assemblies that are already collected by the parser/provider and
|
|
/// looks for the specified type.
|
|
/// </summary>
|
|
/// <param name="assemblies">The collection of assemblies</param>
|
|
/// <param name="typeName">The type name</param>
|
|
/// <param name="ignoreCase">Case sensitivity knob</param>
|
|
/// <returns></returns>
|
|
internal static Type GetTypeFromAssemblies(ICollection assemblies, string typeName, bool ignoreCase)
|
|
{
|
|
if (assemblies == null)
|
|
return null;
|
|
|
|
Type type = null;
|
|
|
|
foreach (Assembly assembly in assemblies)
|
|
{
|
|
Type t = assembly.GetType(typeName, false /*throwOnError*/, ignoreCase);
|
|
|
|
if (t == null)
|
|
continue;
|
|
|
|
// If we had already found a different one, it's an ambiguous type reference
|
|
//
|
|
if (type != null && t != type)
|
|
{
|
|
throw FxTrace.Exception.AsError(new HttpException(
|
|
SR.Hosting_BuildProviderAmbiguousType(typeName, type.Assembly.FullName, t.Assembly.FullName)));
|
|
}
|
|
|
|
// Keep track of it
|
|
//
|
|
type = t;
|
|
}
|
|
|
|
return type;
|
|
}
|
|
}
|
|
}
|
|
}
|