TemplateParser.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / UI / TemplateParser.cs / 1471291 / TemplateParser.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

/* 
 * Implements the ASP.NET template parser 
 *
 * Copyright (c) 1998 Microsoft Corporation 
 */

// Turn this on to do regex profiling
//#define PROFILE_REGEX 

namespace System.Web.UI { 
using System.Runtime.Serialization.Formatters; 
using System.Text;
using System.Runtime.InteropServices; 
using System.Runtime.Serialization;
using System;
using System.IO;
using System.Collections; 
using System.Collections.Generic;
using System.Collections.Specialized; 
using System.Threading; 
using System.Reflection;
using System.Globalization; 
using System.CodeDom.Compiler;
using System.ComponentModel;
using System.ComponentModel.Design;
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.Security.Permissions;
using System.Web.Configuration;

 
/// 
///  
///    [To be supplied.] 
/// 
public abstract class TemplateParser : BaseParser, IAssemblyDependencyParser { 

    internal const string CodeFileBaseClassAttributeName = "codefilebaseclass";

    // The  config section 
    private CompilationSection _compConfig;
    internal CompilationSection CompConfig { 
        get { return _compConfig; } 
    }
 
    // The  config section
    private PagesSection _pagesConfig;
    internal PagesSection PagesConfig {
        get { return _pagesConfig; } 
    }
 
    // const masks into the BitVector32 
    private const int isServerTag                   = 0x00000001;
    private const int inScriptTag                   = 0x00000002; 
    private const int ignoreScriptTag               = 0x00000004;
    private const int ignoreNextSpaceString         = 0x00000008;
    internal const int requiresCompilation          = 0x00000010;   // Has constructs that require compilation
    private const int ignoreControlProperties       = 0x00000020; 
    internal const int aspCompatMode                = 0x00000040;
    private const int hasCodeBehind                 = 0x00000080; 
    private const int inDesigner                    = 0x00000100; 
    private const int ignoreParseErrors             = 0x00000200;
    private const int mainDirectiveSpecified        = 0x00000400; 
    private const int mainDirectiveHandled          = 0x00000800;
    private const int useExplicit                   = 0x00001000;
    private const int hasDebugAttribute             = 0x00002000;
    private const int debug                         = 0x00004000; 
    private const int noLinePragmas                 = 0x00008000;
    private const int strict                        = 0x00010000; 
    internal const int noAutoEventWireup            = 0x00020000; 
    private const int attemptedImplicitResources    = 0x00040000;
    internal const int buffer                       = 0x00080000; 
    internal const int requiresSessionState         = 0x00100000;
    internal const int readOnlySessionState         = 0x00200000;
    internal const int validateRequest              = 0x00400000;
    internal const int asyncMode                    = 0x00800000; 
    private const int throwOnFirstParseError        = 0x01000000;
    private const int ignoreParserFilter            = 0x02000000; 
    internal const int calledFromParseControlFlag   = 0x04000000; 
    #pragma warning disable 0649
    internal SimpleBitVector32 flags; 
    #pragma warning restore 0649

    private MainTagNameToTypeMapper _typeMapper;
    internal MainTagNameToTypeMapper TypeMapper { get { return _typeMapper; } } 

    internal ICollection UserControlRegisterEntries { get { return TypeMapper.UserControlRegisterEntries; } } 
    internal List TagRegisterEntries { get { return TypeMapper.TagRegisterEntries; } } 

    private Stack _builderStack; // Stack of BuilderStackEntry's 
    internal Stack BuilderStack {
        get {
            EnsureRootBuilderCreated();
            return _builderStack; 
        }
    } 
 
    private string _id;
    private StringSet _idList; 
    private Stack _idListStack;
    private ScriptBlockData _currentScript;
    private StringBuilder _literalBuilder;
 
    // The line number in file currently being parsed
    internal int _lineNumber; 
 
    // The line number at which the current script block started
    private int _scriptStartLineNumber; 

    // String that contains the data to be parsed
    private string _text;
    internal string Text { 
        get { return _text; }
        set { _text = value; } 
    } 

    // The class from which to inherit if we are compiling a class 
    private Type _baseType;
    internal Type BaseType {
        get { return _baseType; }
        set { _baseType = value; } 
    }
 
    // The namespace and name of the class from which to inherit.  Only used with code separation, 
    // since we don't have the live Type in that case (not yet compiled)
    private string _baseTypeNamespace; 
    internal string BaseTypeNamespace { get { return _baseTypeNamespace; } }
    private string _baseTypeName;
    internal string BaseTypeName { get { return _baseTypeName; } }
 
    internal bool IgnoreControlProperties {
        get { return flags[ignoreControlProperties]; } 
        set { flags[ignoreControlProperties] = value; } 
    }
 
    // Indicates whether the parser should throw on the first error.
    internal bool ThrowOnFirstParseError {
        get { return flags[throwOnFirstParseError]; }
        set { flags[throwOnFirstParseError] = value; } 
    }
 
    // The interfaces that we implement (ArrayList of Type objects) 
    private ArrayList _implementedInterfaces;
    internal ArrayList ImplementedInterfaces { get { return _implementedInterfaces; } } 

    internal bool HasCodeBehind { get { return flags[hasCodeBehind]; } }

    internal abstract Type DefaultBaseType { get; } 

    internal PageParserFilter _pageParserFilter; 
 
    private IImplicitResourceProvider _implicitResourceProvider;
 
    // The FInDesigner property gets used by control builders so that
    // they can behave differently if needed.
    internal virtual bool FInDesigner {
        get { return flags[inDesigner]; } 
        set { flags[inDesigner] = value; }
    } 
 
    // When this is set, we ignore parse errors and keep on processing the page as
    // well as possible.  This is used for the Venus CBM scenario 
    internal virtual bool IgnoreParseErrors {
        get { return flags[ignoreParseErrors]; }
        set { flags[ignoreParseErrors] = value; }
    } 

    // When true, it is not legal to have any constructs that require compilation 
    private CompilationMode _compilationMode; 
    internal CompilationMode CompilationMode {
        get { 
            // When precompiling for deployment, always compile everything (VSWhidbey 266509)
            if (BuildManager.PrecompilingForDeployment)
                return CompilationMode.Always;
 
            return _compilationMode;
        } 
        set { 
            if (value == CompilationMode.Never && flags[requiresCompilation]) {
                ProcessError(SR.GetString(SR.Compilmode_not_allowed)); 
            }

            _compilationMode = value;
        } 
    }
 
    private ParserErrorCollection _parserErrors; 
    private ParserErrorCollection ParserErrors {
        get { 
            if (_parserErrors == null) {
                _parserErrors = new ParserErrorCollection();
            }
 
            return _parserErrors;
        } 
    } 

    private bool HasParserErrors { 
        get { return _parserErrors != null && _parserErrors.Count > 0; }
    }

    // Method to report parser errors. 
    protected void ProcessError(string message) {
        // Ignore the errors if in that mode. 
        if (IgnoreParseErrors) { 
            return;
        } 

        // Rethrow as innerexception if in that mode.
        if (ThrowOnFirstParseError) {
            throw new HttpException(message); 
        }
 
        // otherwise add to the error collection with proper info. 
        ParserError parseError = new ParserError(message, CurrentVirtualPath, _lineNumber);
        ParserErrors.Add(parseError); 

        // If there is a CBM callback, inform it of the error
        BuildManager.ReportParseError(parseError);
    } 

    // Method to report exception, this is called when external exceptions are caught in the parser. 
    protected void ProcessException(Exception ex) { 
        // Ignore the errors if in that mode.
        if (IgnoreParseErrors) { 
            return;
        }

        // Rethrow as innerexception if in that mode or it is a compile exception. 
        if (ThrowOnFirstParseError || ex is HttpCompileException) {
            if (ex is HttpParseException) 
                throw ex; 
            throw new HttpParseException(ex.Message, ex);
        } 

        // If it is already a parser exception remember the location corresponding to
        // the original error.
        ParserError parseError; 

        HttpParseException hpe = ex as HttpParseException; 
        if (hpe != null) { 
            parseError = new ParserError(hpe.Message, hpe.VirtualPath, hpe.Line);
        } 
        else {
            parseError = new ParserError(ex.Message, CurrentVirtualPath, _lineNumber);
        }
 
        // Remember the original exception.
        parseError.Exception = ex; 
 
        ParserErrors.Add(parseError);
 
        // If there is a CBM callback, inform it of the error only if the HttpParseException comes
        // from the current virtualpath. Since if the exception is thrown from parsing another file,
        // it would have been reported already.
        if (hpe == null || CurrentVirtualPath.Equals(hpe.VirtualPathObject)) { 
            BuildManager.ReportParseError(parseError);
        } 
    } 

    // When true, there are construct that require compilation 
    internal virtual bool RequiresCompilation {
        get {
            // By default, require compilation.  The Page parser overrides this
            // and can allow no-compile pages depending on the page contents 
            return true;
        } 
    } 

    internal virtual bool IsCodeAllowed { 
        get {
            // If it's a no-compile page, code is not allowed
            if (CompilationMode == CompilationMode.Never)
                return false; 

            // Likewise, check if the PageParserFilter allows code 
            if (_pageParserFilter != null && !_pageParserFilter.AllowCode) 
                return false;
 
            return true;
        }
    }
 
    internal void EnsureCodeAllowed() {
 
        // If it's a no-compile page, fail since there is code on it. 
        // Likewise if the PageParserFilter returns IsCodeAllowed == false
        if (!IsCodeAllowed) { 
            ProcessError(SR.GetString(SR.Code_not_allowed));
        }

        // Remember the fact that this page MUST be compiled 
        flags[requiresCompilation] = true;
    } 
 
    // This is called whenever we parse an attribute that requires compilation
    internal void OnFoundAttributeRequiringCompilation(string attribName) { 

        // If compilation is not alowed, fail
        if (!IsCodeAllowed) {
            ProcessError(SR.GetString(SR.Attrib_not_allowed, attribName)); 
        }
 
        // Remember the fact that this page MUST be compiled 
        flags[requiresCompilation] = true;
    } 

    // This is called whenever we parse a directive that requires compilation
    internal void OnFoundDirectiveRequiringCompilation(string directiveName) {
 
        // If compilation is not alowed, fail
        if (!IsCodeAllowed) { 
            ProcessError(SR.GetString(SR.Directive_not_allowed, directiveName)); 
        }
 
        // Remember the fact that this page MUST be compiled
        flags[requiresCompilation] = true;
    }
 
    // This is called whenever we parse an event attribute on a tag
    internal void OnFoundEventHandler(string directiveName) { 
 
        // If compilation is not alowed, fail
        if (!IsCodeAllowed) { 
            ProcessError(SR.GetString(SR.Event_not_allowed, directiveName));
        }

        // Remember the fact that this page MUST be compiled 
        flags[requiresCompilation] = true;
    } 
 
    private IDesignerHost _designerHost;
    private ITypeResolutionService _typeResolutionService; 
    internal IDesignerHost DesignerHost {
        get {
            Debug.Assert(FInDesigner, "DesignerHost should be accessed only when FInDesigner == true");
            return _designerHost; 
        }
        set { 
            Debug.Assert(FInDesigner, "DesignerHost should be accessed only when FInDesigner == true"); 
            _designerHost = value;
 
            _typeResolutionService = null;
            if (_designerHost != null) {
                _typeResolutionService = (ITypeResolutionService)_designerHost.GetService(typeof(ITypeResolutionService));
                if (_typeResolutionService == null) { 
                    throw new ArgumentException(SR.GetString(SR.TypeResService_Needed));
                } 
            } 
        }
    } 

    // true if we're parsing global.asax
    internal virtual bool FApplicationFile { get { return false; } }
 
    // The global delegate to use for the DataBind event on controls when
    // the parser is run in design-mode. 
    private EventHandler _designTimeDataBindHandler; 
    internal EventHandler DesignTimeDataBindHandler {
        get { return _designTimeDataBindHandler; } 
        set { _designTimeDataBindHandler = value; }
    }

    // Used to detect circular references 
    private StringSet _circularReferenceChecker;
 
    // The set of assemblies that the build system is telling us we will be linked with 
    private ICollection _referencedAssemblies;
 
    // The set of assemblies that this file is explicitly asking for
    private AssemblySet _assemblyDependencies;
    internal AssemblySet AssemblyDependencies {
        get { return _assemblyDependencies; } 
    }
 
    // The list of virtual paths to source files we are dependent on 
    private StringSet _sourceDependencies;
    internal StringSet SourceDependencies { 
        get { return _sourceDependencies; }
    }

    // The collection of