Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

396 lines
13 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="BatchParser.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.UI {
using System;
using System.IO;
using System.Web.Configuration;
using System.Collections;
using System.Collections.Specialized;
using System.Threading;
using System.Globalization;
using System.Web.Hosting;
using System.Web.Caching;
using System.Web.Util;
using System.Web.Compilation;
using HttpException = System.Web.HttpException;
using Debug=System.Web.Util.Debug;
using System.Text.RegularExpressions;
internal abstract class DependencyParser : BaseParser {
private VirtualPath _virtualPath;
private StringSet _virtualPathDependencies;
// Used to detect circular references
private StringSet _circularReferenceChecker = new CaseInsensitiveStringSet();
// The <pages> config section
private PagesSection _pagesConfig;
protected PagesSection PagesConfig {
get { return _pagesConfig; }
}
internal void Init(VirtualPath virtualPath) {
CurrentVirtualPath = virtualPath;
_virtualPath = virtualPath;
_pagesConfig = MTConfigUtil.GetPagesConfig(virtualPath);
}
internal ICollection GetVirtualPathDependencies() {
// Always set the culture to Invariant when parsing (ASURT 99071)
Thread currentThread = Thread.CurrentThread;
CultureInfo prevCulture = currentThread.CurrentCulture;
HttpRuntime.SetCurrentThreadCultureWithAssert(CultureInfo.InvariantCulture);
try {
try {
PrepareParse();
ParseFile();
}
finally {
// Restore the previous culture
HttpRuntime.SetCurrentThreadCultureWithAssert(prevCulture);
}
}
catch { throw; } // Prevent Exception Filter Security Issue (ASURT 122835)
return _virtualPathDependencies;
}
protected void AddDependency(VirtualPath virtualPath) {
virtualPath = ResolveVirtualPath(virtualPath);
Debug.Trace("Template", "Parsed dependency: " + _virtualPath + " depends on " + virtualPath);
if (_virtualPathDependencies == null)
_virtualPathDependencies = new CaseInsensitiveStringSet();
_virtualPathDependencies.Add(virtualPath.VirtualPathString);
}
internal abstract string DefaultDirectiveName { get; }
protected virtual void PrepareParse() {}
private void ParseFile() {
ParseFile(null /*physicalPath*/, _virtualPath);
}
private void ParseFile(string physicalPath, VirtualPath virtualPath) {
// Determine the file used for the circular references checker. Normally,
// we use the virtualPath, but we use the physical path if it specified,
// as is the case for <!-- #include file="foo.inc" -->
string fileToReferenceCheck = physicalPath != null ? physicalPath : virtualPath.VirtualPathString;
// Check for circular references of include files
if (_circularReferenceChecker.Contains(fileToReferenceCheck)) {
throw new HttpException(
SR.GetString(SR.Circular_include));
}
// Add the current file to the circular references checker.
_circularReferenceChecker.Add(fileToReferenceCheck);
try {
// Open a TextReader either from the physical or virtual path
TextReader reader;
if (physicalPath != null) {
using (reader = Util.ReaderFromFile(physicalPath, virtualPath)) {
ParseReader(reader);
}
}
else {
using (Stream stream = virtualPath.OpenFile()) {
reader = Util.ReaderFromStream(stream, virtualPath);
ParseReader(reader);
}
}
}
finally {
// Remove the current file from the circular references checker
_circularReferenceChecker.Remove(fileToReferenceCheck);
}
}
private void ParseReader(TextReader input) {
ParseString(input.ReadToEnd());
}
private void ParseString(string text) {
int textPos = 0;
for (;;) {
Match match;
// 1: scan for text up to the next tag.
if ((match = textRegex.Match(text, textPos)).Success) {
textPos = match.Index + match.Length;
}
// we might be done now
if (textPos == text.Length)
break;
// 2: handle constructs that start with <
// Check to see if it's a directive (i.e. <%@ %> block)
if ((match = directiveRegex.Match(text, textPos)).Success) {
IDictionary directive = CollectionsUtil.CreateCaseInsensitiveSortedList();
string directiveName = ProcessAttributes(match, directive);
ProcessDirective(directiveName, directive);
textPos = match.Index + match.Length;
}
else if ((match = includeRegex.Match(text, textPos)).Success) {
ProcessServerInclude(match);
textPos = match.Index + match.Length;
}
else if ((match = commentRegex.Match(text, textPos)).Success) {
// Just skip it
textPos = match.Index + match.Length;
}
else {
int newPos = text.IndexOf("<%@", textPos, StringComparison.Ordinal);
// 2nd condition is used to catch invalid directives, e.g. <%@ attr="value_without_end_quote >
if (newPos == -1 || newPos == textPos) {
return;
}
textPos = newPos;
}
// we might be done now
if (textPos == text.Length)
return;
}
}
/*
* Process a server side include. e.g. <!-- #include file="foo.inc" -->
*/
private void ProcessServerInclude(Match match) {
string pathType = match.Groups["pathtype"].Value;
string filename = match.Groups["filename"].Value;
if (filename.Length == 0) return;
VirtualPath newVirtualPath;
string newPhysicalPath = null;
if (StringUtil.EqualsIgnoreCase(pathType, "file")) {
if (UrlPath.IsAbsolutePhysicalPath(filename)) {
// If it's an absolute physical path, use it as is
newPhysicalPath = filename;
// Reuse the current virtual path
newVirtualPath = CurrentVirtualPath;
}
else {
// If it's relative, just treat it as virtual
newVirtualPath = ResolveVirtualPath(VirtualPath.Create(filename));
}
}
else if (StringUtil.EqualsIgnoreCase(pathType, "virtual")) {
newVirtualPath = ResolveVirtualPath(VirtualPath.Create(filename));
}
else {
// Unknown #include type: ignore it
return;
}
VirtualPath prevVirtualPath = _virtualPath;
try {
_virtualPath = newVirtualPath;
// Parse the included file recursively
ParseFile(newPhysicalPath, newVirtualPath);
}
finally {
// Restore the paths
_virtualPath = prevVirtualPath;
}
}
/*
* Process a <%@ %> block
*/
internal virtual void ProcessDirective(string directiveName, IDictionary directive) {
// Get all the directives into a bag
// Check for the main directive (e.g. "page" for an aspx)
if (directiveName == null ||
StringUtil.EqualsIgnoreCase(directiveName, DefaultDirectiveName) ) {
ProcessMainDirective(directive);
}
else if (StringUtil.EqualsIgnoreCase(directiveName, "register")) {
VirtualPath src = Util.GetAndRemoveVirtualPathAttribute(directive, "src");
if (src != null) {
AddDependency(src);
}
}
else if (StringUtil.EqualsIgnoreCase(directiveName, "reference")) {
VirtualPath virtualPath = Util.GetAndRemoveVirtualPathAttribute(directive, "virtualpath");
if (virtualPath != null)
AddDependency(virtualPath);
VirtualPath page = Util.GetAndRemoveVirtualPathAttribute(directive, "page");
if (page != null)
AddDependency(page);
VirtualPath control = Util.GetAndRemoveVirtualPathAttribute(directive, "control");
if (control != null)
AddDependency(control);
}
else if (StringUtil.EqualsIgnoreCase(directiveName, "assembly")) {
VirtualPath src = Util.GetAndRemoveVirtualPathAttribute(directive, "src");
if (src != null)
AddDependency(src);
}
}
private void ProcessMainDirective(IDictionary mainDirective) {
// Go through all the attributes on the directive
foreach (DictionaryEntry entry in mainDirective) {
string attribName = ((string)entry.Key).ToLower(CultureInfo.InvariantCulture);
// Parse out the device name, if any
string name;
string deviceName = Util.ParsePropertyDeviceFilter(attribName, out name);
// Process the attribute
ProcessMainDirectiveAttribute(deviceName, name, (string) entry.Value);
}
}
internal virtual void ProcessMainDirectiveAttribute(string deviceName, string name,
string value) {
// A "src" attribute is equivalent to an imported source file
if (name == "src") {
string src = Util.GetNonEmptyAttribute(name, value);
AddDependency(VirtualPath.Create(src));
}
}
/*
* Adds attributes and their values to the attribs
*/
private string ProcessAttributes(Match match, IDictionary attribs) {
string ret = null;
CaptureCollection attrnames = match.Groups["attrname"].Captures;
CaptureCollection attrvalues = match.Groups["attrval"].Captures;
CaptureCollection equalsign = match.Groups["equal"].Captures;
for (int i = 0; i < attrnames.Count; i++) {
string attribName = attrnames[i].ToString();
string attribValue = attrvalues[i].ToString();
bool fHasEqual = (equalsign[i].ToString().Length > 0);
if (attribName != null && !fHasEqual && ret == null) {
ret = attribName;
continue;
}
try {
if (attribs != null)
attribs.Add(attribName, attribValue);
}
catch (ArgumentException) {}
}
return ret;
}
}
internal abstract class TemplateControlDependencyParser : DependencyParser {
internal override void ProcessMainDirectiveAttribute(string deviceName, string name,
string value) {
switch (name) {
case "masterpagefile":
value = value.Trim();
if (value.Length > 0) {
// Add a dependency on the master, whether it has a device filter or not
AddDependency(VirtualPath.Create(value));
}
break;
default:
// We didn't handle the attribute. Try the base class
base.ProcessMainDirectiveAttribute(deviceName, name, value);
break;
}
}
}
internal class PageDependencyParser : TemplateControlDependencyParser {
internal override string DefaultDirectiveName {
get { return PageParser.defaultDirectiveName; }
}
protected override void PrepareParse() {
if (PagesConfig != null) {
if (PagesConfig.MasterPageFileInternal != null && PagesConfig.MasterPageFileInternal.Length != 0)
AddDependency(VirtualPath.Create(PagesConfig.MasterPageFileInternal));
}
}
internal override void ProcessDirective(string directiveName, IDictionary directive) {
base.ProcessDirective(directiveName, directive);
if (StringUtil.EqualsIgnoreCase(directiveName, "previousPageType") ||
StringUtil.EqualsIgnoreCase(directiveName, "masterType")) {
VirtualPath virtualPath = Util.GetAndRemoveVirtualPathAttribute(directive, "virtualPath");
if (virtualPath != null)
AddDependency(virtualPath);
}
}
}
internal class UserControlDependencyParser : TemplateControlDependencyParser {
internal override string DefaultDirectiveName {
get { return UserControlParser.defaultDirectiveName; }
}
}
internal class MasterPageDependencyParser : UserControlDependencyParser {
internal override string DefaultDirectiveName {
get { return MasterPageParser.defaultDirectiveName; }
}
internal override void ProcessDirective(string directiveName, IDictionary directive) {
base.ProcessDirective(directiveName, directive);
if (StringUtil.EqualsIgnoreCase(directiveName, "masterType")) {
VirtualPath virtualPath = Util.GetAndRemoveVirtualPathAttribute(directive, "virtualPath");
if (virtualPath != null)
AddDependency(virtualPath);
}
}
}
}