File: UI\TemplateControlParser.cs
Project: ndp\fx\src\xsp\system\Web\System.Web.csproj (System.Web)
//------------------------------------------------------------------------------
// <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;
    }
}
}