Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

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

@@ -0,0 +1,355 @@
+//------------------------------------------------------------------------------
+// <copyright file="BaseTemplateParser.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.Hosting;
+    using System.Web.Compilation;
+    using HttpException = System.Web.HttpException;
+    using System.Text.RegularExpressions;
+    using System.Globalization;
+    using System.Security.Permissions;
+
+    /*
+     * Parser for Template Files (TemplateControls and PageTheme)
+     */
+
+    /// <internalonly/>
+    /// <devdoc>
+    ///    <para>[To be supplied.]</para>
+    /// </devdoc>
+    public abstract class BaseTemplateParser : TemplateParser {
+
+        private const string _sourceString = "src";
+        private const string _namespaceString = "namespace";
+        private const string _tagnameString = "tagname";
+
+        internal Type GetDesignTimeUserControlType(string tagPrefix, string tagName) {
+            Debug.Assert(FInDesigner);
+
+            Type type = typeof(UserControl);
+
+            IDesignerHost host = DesignerHost;
+            if (host != null) {
+                IUserControlTypeResolutionService ucTypeResService =
+                    (IUserControlTypeResolutionService)host.GetService(typeof(IUserControlTypeResolutionService));
+                if (ucTypeResService != null) {
+                    try {
+                        type = ucTypeResService.GetType(tagPrefix, tagName);
+                    }
+                    catch {
+                    }
+                }
+            }
+
+            return type;
+        }
+    
+        /*
+         * Compile a nested .ascx file (a User Control) and return its Type
+         */
+
+        protected internal Type GetUserControlType(string virtualPath) {
+            return GetUserControlType(VirtualPath.Create(virtualPath));
+        }
+
+        internal Type GetUserControlType(VirtualPath virtualPath) {
+            Type t = GetReferencedType(virtualPath, false /*allowNoCompile*/);
+
+            // Fail if it's a no compile uc, since it doesn't have a Type we can use
+            if (t == null) {
+                // First, check whether there is a PageParserFilter that can give us a type
+                if (_pageParserFilter != null)
+                    t = _pageParserFilter.GetNoCompileUserControlType();
+
+                if (t == null)
+                    ProcessError(SR.GetString(SR.Cant_use_nocompile_uc, virtualPath));
+            }
+            else {
+                // Make sure it has the correct base type
+                Util.CheckAssignableType(typeof(UserControl), t);
+            }
+
+            return t;
+        }
+
+        /*
+         * Compile a .aspx/.ascx file and return its Type
+         */
+
+        protected Type GetReferencedType(string virtualPath) {
+            return GetReferencedType(VirtualPath.Create(virtualPath));
+        }
+
+        internal Type GetReferencedType(VirtualPath virtualPath) {
+            return GetReferencedType(virtualPath, true /*allowNoCompile*/);
+        }
+
+        internal Type GetReferencedType(VirtualPath virtualPath, bool allowNoCompile) {
+
+            virtualPath = ResolveVirtualPath(virtualPath);
+
+            // If we have a page parser filter, make sure the reference is allowed
+            if (_pageParserFilter != null && !_pageParserFilter.AllowVirtualReference(CompConfig, virtualPath)) {
+                ProcessError(SR.GetString(SR.Reference_not_allowed, virtualPath));
+            }
+
+            BuildResult result = null;
+            Type t = null;
+
+            try {
+                result = BuildManager.GetVPathBuildResult(virtualPath);
+            }
+            catch (HttpCompileException e) {
+                // Add the path depdencies properly so we know when
+                // to invalidate the cached result.
+                if (e.VirtualPathDependencies != null) {
+                    foreach (string vPath in e.VirtualPathDependencies) {
+                        AddSourceDependency(VirtualPath.Create(vPath));
+                    }
+                }
+
+                throw;
+            }
+            catch {
+                // Add the virtualPath to the dependency so that
+                // we know when to check again. This could happen if the
+                // virtualPath points to a file not created yet.
+                // This only affects designtime code path since we do want to return
+                // partial result even if there is an error, and that result is
+                // cached. VSWhidbey 372585
+                if (IgnoreParseErrors) {
+                    AddSourceDependency(virtualPath);
+                }
+
+                throw;
+            }
+
+            // Is it a no-compile page/uc
+            BuildResultNoCompileTemplateControl noCompileResult = result as BuildResultNoCompileTemplateControl;
+            if (noCompileResult != null) {
+
+                // If no-compile is not acceptable, return null
+                if (!allowNoCompile)
+                    return null;
+
+                // In the no-compile case, use the base type, since we don't compile a type
+                t = noCompileResult.BaseType;
+            }
+            else if (result is BuildResultCompiledType) {
+                BuildResultCompiledType compiledResult = (BuildResultCompiledType) result;
+                Debug.Assert(compiledResult != null);
+
+                t = compiledResult.ResultType;
+            }
+            else {
+                throw new HttpException(SR.GetString(SR.Invalid_typeless_reference, _sourceString));
+            }
+
+            Debug.Assert(t != null);
+
+            // Add a dependency on the Type
+            AddTypeDependency(t);
+
+            // Add a dependency on the BuildResult
+            AddBuildResultDependency(result);
+
+            return t;
+        }
+
+        internal override void ProcessDirective(string directiveName, IDictionary directive) {
+            if (StringUtil.EqualsIgnoreCase(directiveName, "register")) {
+                // Register directive
+
+                // Get the tagprefix, which is required
+                string tagPrefix = Util.GetAndRemoveNonEmptyIdentifierAttribute(directive,
+                    "tagprefix", true /*required*/);
+
+                string tagName = Util.GetAndRemoveNonEmptyIdentifierAttribute(directive,
+                    _tagnameString, false /*required*/);
+
+                VirtualPath src = Util.GetAndRemoveVirtualPathAttribute(directive, 
+                    _sourceString, false /*required*/);
+
+                string ns = Util.GetAndRemoveNonEmptyNoSpaceAttribute(directive, 
+                    _namespaceString, false /*required*/);
+
+                // An Assembly can optionally be specified (ASURT 61326/VSWhidbey 87050)
+                string assemblyName = Util.GetAndRemoveNonEmptyAttribute(directive, "assembly",
+                    false /*required*/);
+
+                RegisterDirectiveEntry registerEntry;
+                if (tagName != null) {
+                    // It's a user control registration
+
+                    // 'src' is required
+                    if (src == null) {
+                        throw new HttpException(SR.GetString(SR.Missing_attr, _sourceString));
+                    }
+
+                    // 'namespace' is not allowed
+                    if (ns != null) {
+                        throw new HttpException(
+                            SR.GetString(SR.Invalid_attr, _namespaceString, "tagname"));
+                    }
+
+                    // 'assembly' is not allowed
+                    if (assemblyName != null) {
+                        throw new HttpException(
+                            SR.GetString(SR.Invalid_attr, "assembly", "tagname"));
+                    }
+
+                    UserControlRegisterEntry ucRegisterEntry = new UserControlRegisterEntry(tagPrefix, tagName);
+                    ucRegisterEntry.UserControlSource = src;
+                    registerEntry = ucRegisterEntry;
+
+                    TypeMapper.ProcessUserControlRegistration(ucRegisterEntry);
+                }
+                else if (src != null) {
+                    // It's missing the tagname attribute.
+                    throw new HttpException(SR.GetString(SR.Missing_attr, _tagnameString));
+                }
+                else {
+                    // It's a namespace prefix registration
+                    // 'namespace' is required
+                    if (ns == null) {
+                        throw new HttpException(SR.GetString(SR.Missing_attr, _namespaceString));
+                    }
+
+                    TagNamespaceRegisterEntry nsRegisterEntry = new TagNamespaceRegisterEntry(tagPrefix, ns, assemblyName);
+                    registerEntry = nsRegisterEntry;
+
+                    TypeMapper.ProcessTagNamespaceRegistration(nsRegisterEntry);
+                }
+
+                registerEntry.Line = _lineNumber;
+                registerEntry.VirtualPath = CurrentVirtualPathString;
+
+                // If there are some attributes left, fail
+                Util.CheckUnknownDirectiveAttributes(directiveName, directive);
+            }
+            else {
+                base.ProcessDirective(directiveName, directive);
+            }
+        }
+    }
+
+    /*
+     * Entry representing a register directive
+     * e.g. <%@ Register tagprefix="tagprefix" Namespace="namespace" Assembly="assembly" %> OR
+     * e.g. <%@ Register tagprefix="tagprefix" Tagname="tagname" Src="pathname" %>
+     */
+    internal abstract class RegisterDirectiveEntry: SourceLineInfo {
+
+        internal RegisterDirectiveEntry(string tagPrefix) {
+            _tagPrefix = tagPrefix;
+        }
+
+        private string _tagPrefix;
+        internal string TagPrefix {
+            get { return _tagPrefix;}
+        }
+    }
+
+    /*
+     * Entry representing the registration of a tag namespace
+     * e.g. <%@ Register tagprefix="tagprefix" Namespace="namespace" Assembly="assembly" %>
+     */
+    internal class TagNamespaceRegisterEntry: RegisterDirectiveEntry {
+
+        internal TagNamespaceRegisterEntry(string tagPrefix, string namespaceName, string assemblyName) : base(tagPrefix) {
+            _ns = namespaceName;
+            _assemblyName = assemblyName;
+        }
+
+        private string _ns;
+        internal string Namespace {
+            get { return _ns;}
+        }
+
+        private string _assemblyName;
+        internal string AssemblyName {
+            get { return _assemblyName;}
+        }
+
+#if DONT_COMPILE
+        internal string Key {
+            get {
+                return TagPrefix + ":" + _ns + ":" + (_assemblyName == null ? String.Empty : _assemblyName);
+            }
+        }
+#endif
+    }
+
+    /*
+     * Entry representing the registration of a user control
+     * e.g. <%@ Register tagprefix="tagprefix" Tagname="tagname" Src="pathname" %>
+     */
+    internal class UserControlRegisterEntry: RegisterDirectiveEntry {
+
+        internal UserControlRegisterEntry(string tagPrefix, string tagName) : base(tagPrefix) {
+            _tagName = tagName;
+        }
+
+        private string _tagName;
+        internal string TagName {
+            get { return _tagName;}
+        }
+
+        private VirtualPath _source;
+        internal VirtualPath UserControlSource {
+            get { return _source;}
+            set { _source = value;}
+        }
+
+        private bool _comesFromConfig;
+        internal bool ComesFromConfig {
+            get { return _comesFromConfig;}
+            set { _comesFromConfig = value;}
+        }
+
+        internal string Key {
+            get {
+                return TagPrefix + ":" + _tagName;
+            }
+        }
+    }
+
+    internal class TagNamespaceRegisterEntryTable : Hashtable {
+
+        public TagNamespaceRegisterEntryTable() : base(StringComparer.OrdinalIgnoreCase) {
+        }
+
+        public override object Clone() {
+            // We override clone to perform a deep copy of the hashtable contents but a shallow copy of
+            // the contained arraylist itself
+
+            TagNamespaceRegisterEntryTable newTable = new TagNamespaceRegisterEntryTable();
+            foreach (DictionaryEntry entry in this) {
+                newTable[entry.Key] = ((ArrayList)entry.Value).Clone();
+            }
+
+            return newTable;
+        }
+    }
+}