context: //	
  // System.Web.UI.PageParser
  //
  // Authors:
  //	Gonzalo Paniagua Javier (gonzalo@ximian.com)
  //
  // (C) 2002,2003 Ximian, Inc (http://www.ximian.com)
  // Copyright (C) 2005-2010 Novell, Inc (http://www.novell.com)
  //
  // Permission is hereby granted, free of charge, to any person obtaining
  // a copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to
  // permit persons to whom the Software is furnished to do so, subject to
  // the following conditions:
  // 
  // The above copyright notice and this permission notice shall be
  // included in all copies or substantial portions of the Software.
  // 
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  //
  
  using System.Collections;
  using System.Collections.Specialized;
  using System.Globalization;
  using System.Security.Permissions;
  using System.Text;
  using System.Web.Compilation;
  using System.Web.Configuration;
  using System.Web.Hosting;
  using System.Web.Util;
  using System.IO;
  
  namespace System.Web.UI
  {
  	// CAS - no InheritanceDemand here as the class is sealed
  	[AspNetHostingPermission (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  	public sealed class PageParser : TemplateControlParser
  	{
  #if NET_4_0
  		static Type defaultPageBaseType;
  		static Type defaultApplicationBaseType;
  		static Type defaultPageParserFilterType;
  		static Type defaultUserControlBaseType;
  		static bool enableLongStringsAsResources = true;
  #endif
  		PagesEnableSessionState enableSessionState = PagesEnableSessionState.True;
  		bool enableViewStateMac;
  		bool enableViewStateMacSet;
  		bool smartNavigation;
  		bool haveTrace;
  		bool trace;
  		bool notBuffer;
  		TraceMode tracemode = TraceMode.Default;
  		string contentType;
  		MainDirectiveAttribute <int> codepage;
  		MainDirectiveAttribute <string> responseEncoding;
  		MainDirectiveAttribute <int> lcid;
  		MainDirectiveAttribute <string> clientTarget;
  		MainDirectiveAttribute <string> masterPage;
  		MainDirectiveAttribute <string> title;
  		MainDirectiveAttribute <string> theme;
  #if NET_4_0
  		MainDirectiveAttribute <string> metaDescription;
  		MainDirectiveAttribute <string> metaKeywords;
  #endif
  		string culture;
  		string uiculture;
  		string errorPage;
  		bool validateRequest;
  		bool async;
  		int asyncTimeout = -1;
  		Type masterType;
  		string masterVirtualPath;
  		string styleSheetTheme;
  		bool enable_event_validation;
  		bool maintainScrollPositionOnPostBack;
  		int maxPageStateFieldLength = -1;
  		Type previousPageType;
  		string previousPageVirtualPath;
  #if NET_4_0
  		public static bool EnableLongStringsAsResources {
  			get { return enableLongStringsAsResources; }
  			set {
  				BuildManager.AssertPreStartMethodsRunning ();
  				enableLongStringsAsResources = value;
  			}
  		}
  		
  		public static Type DefaultPageBaseType {
  			get { return defaultPageBaseType; }
  			set {
  				BuildManager.AssertPreStartMethodsRunning ();
  				if (value != null && !typeof (Page).IsAssignableFrom (value))
  					throw new ArgumentException (String.Format ("The value assigned to property '{0}' is invalid.", "DefaultPageBaseType"));
  				
  				defaultPageBaseType = value;
  			}
  		}
  
  		public static Type DefaultApplicationBaseType {
  			get { return defaultApplicationBaseType; }
  			set {
  				BuildManager.AssertPreStartMethodsRunning ();
  				if (value != null && !typeof (HttpApplication).IsAssignableFrom (value))
  					throw new ArgumentException (String.Format ("The value assigned to property '{0}' is invalid.", "DefaultApplicationBaseType"));
  				defaultApplicationBaseType = value;
  			}
  		}
  
  		public static Type DefaultPageParserFilterType {
  			get { return defaultPageParserFilterType; }
  			set {
  				BuildManager.AssertPreStartMethodsRunning ();
  				if (value != null && !typeof (PageParserFilter).IsAssignableFrom (value))
  					throw new ArgumentException (String.Format ("The value assigned to property '{0}' is invalid.", "DefaultPageParserFilterType"));
  				defaultPageParserFilterType = value;
  			}
  		}
  
  		public static Type DefaultUserControlBaseType {
  			get { return defaultUserControlBaseType; }
  			set {
  				if (value != null && !typeof (UserControl).IsAssignableFrom (value))
  					throw new ArgumentException (String.Format ("The value assigned to property '{0}' is invalid.", "DefaultUserControlBaseType"));
  				BuildManager.AssertPreStartMethodsRunning ();
  				defaultUserControlBaseType = value;
  			}
  		}
  #endif
  		public PageParser ()
  		{
  			LoadConfigDefaults ();
  		}
  		
  		internal PageParser (string virtualPath, string inputFile, HttpContext context)
  		{
  			this.VirtualPath = new VirtualPath (virtualPath);
  			Context = context;
  			BaseVirtualDir = VirtualPathUtility.GetDirectory (virtualPath, false);
  			InputFile = inputFile;
  			SetBaseType (null);
  			AddApplicationAssembly ();
  			LoadConfigDefaults ();
  		}
  
  		internal PageParser (VirtualPath virtualPath, TextReader reader, HttpContext context)
  			: this (virtualPath, null, reader, context)
  		{
  		}
  		
  		internal PageParser (VirtualPath virtualPath, string inputFile, TextReader reader, HttpContext context)
  		{
  			this.VirtualPath = virtualPath;
  			Context = context;
  			BaseVirtualDir = virtualPath.DirectoryNoNormalize;
  			Reader = reader;
  			if (String.IsNullOrEmpty (inputFile))
  				InputFile = virtualPath.PhysicalPath;
  			else
  				InputFile = inputFile;
  			SetBaseType (null);
  			AddApplicationAssembly ();
  			LoadConfigDefaults ();
  		}
  
  		internal override void LoadConfigDefaults ()
  		{
  			base.LoadConfigDefaults ();
  			PagesSection ps = PagesConfig;
  
  			notBuffer = !ps.Buffer;
  			enableSessionState = ps.EnableSessionState;
  			enableViewStateMac = ps.EnableViewStateMac;
  			smartNavigation = ps.SmartNavigation;
  			validateRequest = ps.ValidateRequest;
  
  			string value = ps.MasterPageFile;
  			if (value.Length > 0)
  				masterPage = new MainDirectiveAttribute <string> (value, true);
  			
  			enable_event_validation = ps.EnableEventValidation;
  			maxPageStateFieldLength = ps.MaxPageStateFieldLength;
  			value = ps.Theme;
  			if (value.Length > 0)
  				theme = new MainDirectiveAttribute <string> (value, true);
  			
  			styleSheetTheme = ps.StyleSheetTheme;
  			if (styleSheetTheme.Length == 0)
  				styleSheetTheme = null;
  			maintainScrollPositionOnPostBack = ps.MaintainScrollPositionOnPostBack;
  		}
  		
  		public static IHttpHandler GetCompiledPageInstance (string virtualPath, string inputFile, HttpContext context)
  		{
  			bool isFake = false;
  
  			if (!String.IsNullOrEmpty (inputFile))
  				isFake = !inputFile.StartsWith (HttpRuntime.AppDomainAppPath);
  			
  			return BuildManager.CreateInstanceFromVirtualPath (new VirtualPath (virtualPath, inputFile, isFake), typeof (IHttpHandler)) as IHttpHandler;
  		}
  
  		internal override void ProcessMainAttributes (IDictionary atts)
  		{
  			// note: the 'enableSessionState' configuration property is
  			// processed in a case-sensitive manner while the page-level
  			// attribute is processed case-insensitive
  			string enabless = GetString (atts, "EnableSessionState", null);
  			if (enabless != null) {
  				if (String.Compare (enabless, "readonly", true, Helpers.InvariantCulture) == 0)
  					enableSessionState = PagesEnableSessionState.ReadOnly;
  				else if (String.Compare (enabless, "true", true, Helpers.InvariantCulture) == 0)
  					enableSessionState = PagesEnableSessionState.True;
  				else if (String.Compare (enabless, "false", true, Helpers.InvariantCulture) == 0)
  					enableSessionState = PagesEnableSessionState.False;
  				else
  					ThrowParseException ("Invalid value for enableSessionState: " + enabless);
  			}
  
  			string value = GetString (atts, "CodePage", null);
  			if (value != null) {
  				if (responseEncoding != null)
  					ThrowParseException ("CodePage and ResponseEncoding are mutually exclusive.");
  				
  				if (!BaseParser.IsExpression (value)) {
  					int cpval = -1;
  
  					try {
  						cpval = (int) UInt32.Parse (value);
  					} catch {
  
gt: 						ThrowParseException ("Invalid value for CodePage: " + value);