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
385 lines
14 KiB
C#
385 lines
14 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="TemplateControlParser.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
/*
|
|
* Implements the ASP.NET template parser
|
|
*
|
|
* Copyright (c) 1998 Microsoft Corporation
|
|
*/
|
|
|
|
namespace System.Web.UI {
|
|
|
|
using System.Text;
|
|
using System;
|
|
using System.IO;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Design;
|
|
using System.Reflection;
|
|
using System.Configuration;
|
|
using System.Web.Caching;
|
|
using System.Web.Util;
|
|
using System.Web.Compilation;
|
|
using HttpException = System.Web.HttpException;
|
|
using System.Text.RegularExpressions;
|
|
using System.Globalization;
|
|
using System.Security.Permissions;
|
|
|
|
|
|
/*
|
|
* Parser for TemplateControl's (UserControls and Pages)
|
|
*/
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public abstract class TemplateControlParser : BaseTemplateParser {
|
|
|
|
// Attributes in <%@ outputcache ... %> directive
|
|
private IDictionary _outputCacheDirective;
|
|
|
|
private OutputCacheParameters _outputCacheSettings;
|
|
internal OutputCacheParameters OutputCacheParameters { get { return _outputCacheSettings; } }
|
|
|
|
internal bool FAutoEventWireup { get { return !flags[noAutoEventWireup]; } }
|
|
|
|
internal override bool RequiresCompilation {
|
|
get { return flags[requiresCompilation] || CompilationMode == CompilationMode.Always; }
|
|
}
|
|
|
|
// Get default settings from config
|
|
internal override void ProcessConfigSettings() {
|
|
base.ProcessConfigSettings();
|
|
|
|
if (PagesConfig != null) {
|
|
flags[noAutoEventWireup] = !PagesConfig.AutoEventWireup;
|
|
|
|
// If config has a non-default EnableViewState value, set it in the main directive
|
|
if (PagesConfig.EnableViewState != Control.EnableViewStateDefault)
|
|
_mainDirectiveConfigSettings["enableviewstate"] = Util.GetStringFromBool(PagesConfig.EnableViewState);
|
|
|
|
CompilationMode = PagesConfig.CompilationMode;
|
|
}
|
|
|
|
// if there is a filter, ask it if it wants to use a different mode
|
|
if (_pageParserFilter != null)
|
|
CompilationMode = _pageParserFilter.GetCompilationMode(CompilationMode);
|
|
}
|
|
|
|
internal override void ProcessDirective(string directiveName, IDictionary directive) {
|
|
|
|
if (StringUtil.EqualsIgnoreCase(directiveName, "outputcache")) {
|
|
|
|
// Ignore the OutputCache directive in design mode (VSWhidbey 470314)
|
|
if (FInDesigner)
|
|
return;
|
|
|
|
if (_outputCacheSettings == null) {
|
|
_outputCacheSettings = new OutputCacheParameters();
|
|
}
|
|
|
|
// Make sure the outputcache directive was not already specified
|
|
if (_outputCacheDirective != null) {
|
|
throw new HttpException(
|
|
SR.GetString(SR.Only_one_directive_allowed, directiveName));
|
|
}
|
|
|
|
ProcessOutputCacheDirective(directiveName, directive);
|
|
|
|
_outputCacheDirective = directive;
|
|
}
|
|
else if (StringUtil.EqualsIgnoreCase(directiveName, "reference")) {
|
|
|
|
// Ignore the OutputCache directive in design mode (VSWhidbey 517783)
|
|
if (FInDesigner) {
|
|
return;
|
|
}
|
|
|
|
// Even though this only makes sense for compiled pages, Sharepoint needs us to
|
|
// ignore instead of throw when the page in non-compiled.
|
|
|
|
|
|
// For historical reasons, the virtual path can be specified by 3 different attributes:
|
|
// virtualpath, page and control. They all do the same, and virtualpath is the recommended
|
|
// one (the other two are deprecated).
|
|
|
|
// Make sure that no more than one is specified.
|
|
|
|
VirtualPath virtualPath = Util.GetAndRemoveVirtualPathAttribute(directive, "virtualpath");
|
|
|
|
bool enforcePage = false;
|
|
bool enforceControl = false;
|
|
|
|
VirtualPath tmp = Util.GetAndRemoveVirtualPathAttribute(directive, "page");
|
|
if (tmp != null) {
|
|
if (virtualPath != null) {
|
|
ProcessError(SR.GetString(SR.Invalid_reference_directive));
|
|
return;
|
|
}
|
|
virtualPath = tmp;
|
|
enforcePage = true;
|
|
}
|
|
|
|
tmp = Util.GetAndRemoveVirtualPathAttribute(directive, "control");
|
|
if (tmp != null) {
|
|
if (virtualPath != null) {
|
|
ProcessError(SR.GetString(SR.Invalid_reference_directive));
|
|
return;
|
|
}
|
|
virtualPath = tmp;
|
|
enforceControl = true;
|
|
}
|
|
|
|
// If we didn't get a virtual path, fail
|
|
if (virtualPath == null) {
|
|
ProcessError(SR.GetString(SR.Invalid_reference_directive));
|
|
return;
|
|
}
|
|
|
|
Type t = GetReferencedType(virtualPath);
|
|
|
|
if (t == null) {
|
|
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
|
|
}
|
|
|
|
// If the 'page' attribute was used, make sure it's indeed a Page
|
|
if (enforcePage && !typeof(Page).IsAssignableFrom(t)) {
|
|
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
|
|
}
|
|
|
|
// If the 'control' attribute was used, make sure it's indeed a UserControl
|
|
if (enforceControl && !typeof(UserControl).IsAssignableFrom(t)) {
|
|
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
|
|
}
|
|
|
|
// If there are some attributes left, fail
|
|
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
|
|
}
|
|
else {
|
|
base.ProcessDirective(directiveName, directive);
|
|
}
|
|
}
|
|
|
|
internal override void ProcessMainDirective(IDictionary mainDirective) {
|
|
|
|
// We want to make sure that we process the compilationmode attribute before any
|
|
// of the other main directive attributes, since its presence can cause other
|
|
// attributes to be illegal. So we handle it instead of in ProcessMainDirectiveAttribute.
|
|
object tmpObj = null;
|
|
|
|
try {
|
|
tmpObj = Util.GetAndRemoveEnumAttribute(mainDirective,
|
|
typeof(CompilationMode), "compilationmode");
|
|
}
|
|
// catch the exception here so we can continue to process the rest of the main directive
|
|
// when called from CBM
|
|
catch (Exception ex) {
|
|
ProcessError(ex.Message);
|
|
}
|
|
|
|
if (tmpObj != null) {
|
|
CompilationMode = (CompilationMode) tmpObj;
|
|
|
|
// if there is a filter, ask it if it wants to use a different mode
|
|
if (_pageParserFilter != null)
|
|
CompilationMode = _pageParserFilter.GetCompilationMode(CompilationMode);
|
|
}
|
|
|
|
base.ProcessMainDirective(mainDirective);
|
|
}
|
|
|
|
internal override bool ProcessMainDirectiveAttribute(string deviceName, string name,
|
|
string value, IDictionary parseData) {
|
|
|
|
switch (name) {
|
|
|
|
// Ignore 'targetschema' attribute (ASURT 85670)
|
|
case "targetschema":
|
|
break;
|
|
|
|
case "autoeventwireup":
|
|
// This only makes sense for compiled pages
|
|
OnFoundAttributeRequiringCompilation(name);
|
|
|
|
flags[noAutoEventWireup] = !Util.GetBooleanAttribute(name, value);
|
|
break;
|
|
|
|
case "enabletheming":
|
|
// Return false to let the generic attribute processing continue
|
|
// which will cause the EnableTheming property to be set on the
|
|
// TemplateControl instance.
|
|
return false;
|
|
|
|
case CodeFileBaseClassAttributeName:
|
|
// Remember the base class for post processing
|
|
parseData[name] = Util.GetNonEmptyAttribute(name, value);
|
|
break;
|
|
|
|
default:
|
|
// We didn't handle the attribute. Try the base class
|
|
return base.ProcessMainDirectiveAttribute(deviceName, name, value, parseData);
|
|
}
|
|
|
|
// The attribute was handled
|
|
|
|
// Make sure no device filter or resource expression was specified
|
|
ValidateBuiltInAttribute(deviceName, name, value);
|
|
|
|
return true;
|
|
}
|
|
|
|
internal override void ProcessUnknownMainDirectiveAttribute(string filter, string attribName, string value) {
|
|
|
|
// Don't allow the id to be specified on the directive, even though it is
|
|
// a public member of the control class (VSWhidbey 85384)
|
|
if (attribName == "id") {
|
|
base.ProcessUnknownMainDirectiveAttribute(filter, attribName, value);
|
|
return;
|
|
}
|
|
|
|
// Process unknown attributes as regular control attribute, hence allowing
|
|
// arbitrary properties of the base class to be set.
|
|
// But turn off IAttributeAccessor support, otherwise any bad string on a
|
|
// user control's directive won't be caught.
|
|
|
|
try {
|
|
RootBuilder.PreprocessAttribute(filter, attribName, value, true /*mainDirectiveMode*/);
|
|
}
|
|
catch (Exception e) {
|
|
ProcessError(SR.GetString(SR.Attrib_parse_error, attribName, e.Message));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Add assembly dependencies for a collection of static objects
|
|
*/
|
|
private void AddStaticObjectAssemblyDependencies(HttpStaticObjectsCollection staticObjects) {
|
|
if (staticObjects == null || staticObjects.Objects == null) return;
|
|
|
|
IDictionaryEnumerator en = staticObjects.Objects.GetEnumerator();
|
|
while (en.MoveNext()) {
|
|
HttpStaticObjectsEntry entry = (HttpStaticObjectsEntry)en.Value;
|
|
|
|
AddTypeDependency(entry.ObjectType);
|
|
}
|
|
}
|
|
|
|
internal Type GetDirectiveType(IDictionary directive, string directiveName) {
|
|
string typeName = Util.GetAndRemoveNonEmptyNoSpaceAttribute(directive, "typeName");
|
|
VirtualPath virtualPath = Util.GetAndRemoveVirtualPathAttribute(directive, "virtualPath");
|
|
|
|
Type resultType = null;
|
|
|
|
// If neither or both are specified, fail
|
|
if ((typeName == null) == (virtualPath == null)) {
|
|
throw new HttpException(SR.GetString(SR.Invalid_typeNameOrVirtualPath_directive, directiveName));
|
|
}
|
|
|
|
if (typeName != null) {
|
|
resultType = GetType(typeName);
|
|
AddTypeDependency(resultType);
|
|
}
|
|
else {
|
|
resultType = GetReferencedType(virtualPath);
|
|
}
|
|
|
|
// If there are some attributes left, fail
|
|
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
|
|
|
|
return resultType;
|
|
}
|
|
|
|
internal override void HandlePostParse() {
|
|
base.HandlePostParse();
|
|
|
|
if (!FInDesigner) {
|
|
// Omit AutoEventWireup if there can't possibly be any events defined (ASURT 97772)
|
|
if (ScriptList.Count == 0 && BaseType == DefaultBaseType && CodeFileVirtualPath == null)
|
|
flags[noAutoEventWireup] = true;
|
|
|
|
_applicationObjects = HttpApplicationFactory.ApplicationState.StaticObjects;
|
|
AddStaticObjectAssemblyDependencies(_applicationObjects);
|
|
|
|
_sessionObjects = HttpApplicationFactory.ApplicationState.SessionStaticObjects;
|
|
AddStaticObjectAssemblyDependencies(_sessionObjects);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Process the contents of the <%@ OutputCache ... %> directive
|
|
*/
|
|
internal virtual void ProcessOutputCacheDirective(string directiveName, IDictionary directive) {
|
|
int duration = 0; // Unit is second
|
|
string varyByParams;
|
|
string varyByCustom;
|
|
string outputCacheProfile = null;
|
|
string varyByControls;
|
|
|
|
bool fHasDuration = Util.GetAndRemovePositiveIntegerAttribute(directive, "duration", ref duration);
|
|
if (fHasDuration) {
|
|
OutputCacheParameters.Duration = duration;
|
|
}
|
|
|
|
//
|
|
if (this is PageParser) {
|
|
outputCacheProfile = Util.GetAndRemoveNonEmptyAttribute(directive, "cacheProfile");
|
|
if (outputCacheProfile != null) {
|
|
OutputCacheParameters.CacheProfile = outputCacheProfile;
|
|
}
|
|
}
|
|
|
|
if (!fHasDuration && (outputCacheProfile == null || outputCacheProfile.Length == 0) && FDurationRequiredOnOutputCache)
|
|
throw new HttpException(SR.GetString(SR.Missing_attr, "duration"));
|
|
|
|
varyByCustom = Util.GetAndRemoveNonEmptyAttribute(directive, "varybycustom");
|
|
if (varyByCustom != null) {
|
|
OutputCacheParameters.VaryByCustom = varyByCustom;
|
|
}
|
|
|
|
varyByControls = Util.GetAndRemoveNonEmptyAttribute(directive, "varybycontrol");
|
|
if (varyByControls != null) {
|
|
OutputCacheParameters.VaryByControl = varyByControls;
|
|
}
|
|
|
|
varyByParams = Util.GetAndRemoveNonEmptyAttribute(directive, "varybyparam");
|
|
if (varyByParams != null) {
|
|
OutputCacheParameters.VaryByParam = varyByParams;
|
|
}
|
|
|
|
// VaryByParams is required (ASURT 76763)
|
|
if (varyByParams == null &&
|
|
varyByControls == null &&
|
|
(outputCacheProfile == null || outputCacheProfile.Length == 0) &&
|
|
FVaryByParamsRequiredOnOutputCache)
|
|
throw new HttpException(SR.GetString(SR.Missing_varybyparam_attr));
|
|
|
|
// If it's "none", set it to null
|
|
if (StringUtil.EqualsIgnoreCase(varyByParams, "none"))
|
|
OutputCacheParameters.VaryByParam = null;
|
|
|
|
if (StringUtil.EqualsIgnoreCase(varyByControls, "none"))
|
|
OutputCacheParameters.VaryByControl = null;
|
|
|
|
// If there are some attributes left, fail
|
|
Util.CheckUnknownDirectiveAttributes(directiveName, directive, UnknownOutputCacheAttributeError);
|
|
}
|
|
|
|
internal virtual bool FDurationRequiredOnOutputCache {
|
|
get { return true; }
|
|
}
|
|
|
|
internal virtual bool FVaryByParamsRequiredOnOutputCache {
|
|
get { return true; }
|
|
}
|
|
|
|
internal abstract string UnknownOutputCacheAttributeError {
|
|
get;
|
|
}
|
|
}
|
|
}
|