Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/UI/TemplateControlParser.cs

@@ -0,0 +1,384 @@
+//------------------------------------------------------------------------------
+// <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;
+    }
+}
+}