private VirtualDirectoryMapping(VirtualPath virtualDirectory, string physicalDirectory, bool isAppRoot, string configFileBaseName)
 {
     this._virtualDirectory = virtualDirectory;
     this._isAppRoot = isAppRoot;
     this.PhysicalDirectory = physicalDirectory;
     this.ConfigFileBaseName = configFileBaseName;
 }

 private void ParseFile(string physicalPath, VirtualPath virtualPath)
 {
     string o = (physicalPath != null) ? physicalPath : virtualPath.VirtualPathString;
     if (this._circularReferenceChecker.Contains(o))
     {
         throw new HttpException(System.Web.SR.GetString("Circular_include"));
     }
     this._circularReferenceChecker.Add(o);
     try
     {
         TextReader reader;
         if (physicalPath != null)
         {
             using (reader = Util.ReaderFromFile(physicalPath, virtualPath))
             {
                 this.ParseReader(reader);
                 return;
             }
         }
         using (Stream stream = virtualPath.OpenFile())
         {
             reader = Util.ReaderFromStream(stream, virtualPath);
             this.ParseReader(reader);
         }
     }
     finally
     {
         this._circularReferenceChecker.Remove(o);
     }
 }

 bool IServerConfig.GetUncUser(IApplicationHost appHost, VirtualPath path, out string username, out string password)
 {
     bool flag = false;
     username = null;
     password = null;
     IntPtr zero = IntPtr.Zero;
     int cchUserName = 0;
     IntPtr bstrPassword = IntPtr.Zero;
     int cchPassword = 0;
     try
     {
         if (UnsafeIISMethods.MgdGetVrPathCreds(IntPtr.Zero, appHost.GetSiteName(), path.VirtualPathString, out zero, out cchUserName, out bstrPassword, out cchPassword) == 0)
         {
             username = (cchUserName > 0) ? StringUtil.StringFromWCharPtr(zero, cchUserName) : null;
             password = (cchPassword > 0) ? StringUtil.StringFromWCharPtr(bstrPassword, cchPassword) : null;
             flag = !string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(password);
         }
     }
     finally
     {
         if (zero != IntPtr.Zero)
         {
             Marshal.FreeBSTR(zero);
         }
         if (bstrPassword != IntPtr.Zero)
         {
             Marshal.FreeBSTR(bstrPassword);
         }
     }
     return flag;
 }

 private VirtualPath GetAppPathForPathWorker(string siteID, VirtualPath path)
 {
     string str;
     uint result = 0;
     if (!uint.TryParse(siteID, out result))
     {
         return VirtualPath.RootVirtualPath;
     }
     IntPtr zero = IntPtr.Zero;
     int cchPath = 0;
     try
     {
         str = ((UnsafeIISMethods.MgdGetAppPathForPath(IntPtr.Zero, result, path.VirtualPathString, out zero, out cchPath) == 0) && (cchPath > 0)) ? StringUtil.StringFromWCharPtr(zero, cchPath) : null;
     }
     finally
     {
         if (zero != IntPtr.Zero)
         {
             Marshal.FreeBSTR(zero);
         }
     }
     if (str == null)
     {
         return VirtualPath.RootVirtualPath;
     }
     return VirtualPath.Create(str);
 }

		public ApplicationFileParser (string fname, HttpContext context)
		{
			InputFile = fname;
			Context = context;
			VirtualPath = new VirtualPath ("/" + Path.GetFileName (fname));
			LoadConfigDefaults ();
		}

        //
        // GetConfig(context, path) - returns the config at 'path'.
        //
        // This method is more efficient than not using context, as
        // the config cached in the context is used if it matches the
        // context path.
        //
        // For config derived from ConfigurationSection, this will either
        // return a non-null object or throw an exception.
        //
        // For config implemented with IConfigurationSectionHandler, this 
        // may return null, non-null, or throw an exception.
        //
        static internal RuntimeConfig GetConfig(HttpContext context, VirtualPath path) {
            if (!HttpConfigurationSystem.UseHttpConfigurationSystem)  {
                return GetClientRuntimeConfig();
            }

            return context.GetRuntimeConfig(path);
        }

 internal CachedPathData(string configPath, VirtualPath virtualPath, string physicalPath, bool exists)
 {
     this._configPath = configPath;
     this._virtualPath = virtualPath;
     this._physicalPath = physicalPath;
     this._flags[4] = exists;
     string schemeDelimiter = Uri.SchemeDelimiter;
 }

 internal CodeBlockBuilder(CodeBlockType blockType, string content, int lineNumber, int column, VirtualPath virtualPath)
 {
     this._content = content;
     this._blockType = blockType;
     this._column = column;
     base.Line = lineNumber;
     base.VirtualPath = virtualPath;
 }

 internal void AddSourceDependency(VirtualPath fileName)
 {
     if (this._sourceDependencies == null)
     {
         this._sourceDependencies = new CaseInsensitiveStringSet();
     }
     this._sourceDependencies.Add(fileName.VirtualPathString);
 }

		internal MasterPageParser (VirtualPath virtualPath, string inputFile, TextReader reader, HttpContext context)
			: base (virtualPath, inputFile, reader, context)
		{
			this.cacheEntryName = String.Concat ("@@MasterPagePHIDS:", virtualPath, ":", InputFile);
			
			contentPlaceHolderIds = HttpRuntime.InternalCache.Get (this.cacheEntryName) as List <string>;
			LoadConfigDefaults ();
		}

 protected void AddDependency(VirtualPath virtualPath)
 {
     virtualPath = base.ResolveVirtualPath(virtualPath);
     if (this._virtualPathDependencies == null)
     {
         this._virtualPathDependencies = new CaseInsensitiveStringSet();
     }
     this._virtualPathDependencies.Add(virtualPath.VirtualPathString);
 }

 internal static VirtualPath CombineVirtualPathsInternal(VirtualPath basePath, VirtualPath relativePath)
 {
     VirtualPathProvider virtualPathProvider = HostingEnvironment.VirtualPathProvider;
     if (virtualPathProvider != null)
     {
         return virtualPathProvider.CombineVirtualPaths(basePath, relativePath);
     }
     return basePath.Parent.Combine(relativePath);
 }

 internal static bool IsUserAllowedToPath(HttpContext context, VirtualPath virtualPath)
 {
     AuthorizationSection authorization = RuntimeConfig.GetConfig(context, virtualPath).Authorization;
     if (!authorization.EveryoneAllowed)
     {
         return authorization.IsUserAllowed(context.User, context.Request.RequestType);
     }
     return true;
 }

		public BuildManagerDirectoryBuilder (VirtualPath virtualPath)
		{
			if (virtualPath == null)
				throw new ArgumentNullException ("virtualPath");

			this.vpp = HostingEnvironment.VirtualPathProvider;
			this.virtualPath = virtualPath;
			this.virtualPathDirectory = VirtualPathUtility.GetDirectory (virtualPath.Absolute);
		}

 internal static object AddVirtualPathToFileMapping(VirtualPath virtualPath, string physicalPath)
 {
     CallContext.SetData(GetFixedMappingSlotName(virtualPath), physicalPath);
     VirtualPathToFileMappingState state = new VirtualPathToFileMappingState {
         VirtualPath = virtualPath,
         VirtualPathProvider = _theHostingEnvironment._virtualPathProvider
     };
     _theHostingEnvironment._virtualPathProvider = _theHostingEnvironment._mapPathBasedVirtualPathProvider;
     return state;
 }

 internal override string ComputeSourceDependenciesHashCode(VirtualPath virtualPath)
 {
     if (virtualPath == null)
     {
         virtualPath = base.VirtualPath;
     }
     HashCodeCombiner combiner = new HashCodeCombiner();
     combiner.AddResourcesDirectory(virtualPath.MapPathInternal());
     return combiner.CombinedHashString;
 }

		internal UserControlParser (VirtualPath virtualPath, string inputFile, HttpContext context, string type)
		{
			VirtualPath = virtualPath;
			Context = context;
			BaseVirtualDir = virtualPath.DirectoryNoNormalize;
			InputFile = inputFile;
			SetBaseType (type);
			AddApplicationAssembly ();
			LoadConfigDefaults ();
		}

 internal Type GetReferencedType(VirtualPath virtualPath, bool allowNoCompile)
 {
     virtualPath = base.ResolveVirtualPath(virtualPath);
     if ((base._pageParserFilter != null) && !base._pageParserFilter.AllowVirtualReference(base.CompConfig, virtualPath))
     {
         base.ProcessError(System.Web.SR.GetString("Reference_not_allowed", new object[] { virtualPath }));
     }
     BuildResult vPathBuildResult = null;
     Type baseType = null;
     try
     {
         vPathBuildResult = BuildManager.GetVPathBuildResult(virtualPath);
     }
     catch (HttpCompileException exception)
     {
         if (exception.VirtualPathDependencies != null)
         {
             foreach (string str in exception.VirtualPathDependencies)
             {
                 base.AddSourceDependency(VirtualPath.Create(str));
             }
         }
         throw;
     }
     catch
     {
         if (this.IgnoreParseErrors)
         {
             base.AddSourceDependency(virtualPath);
         }
         throw;
     }
     BuildResultNoCompileTemplateControl control = vPathBuildResult as BuildResultNoCompileTemplateControl;
     if (control != null)
     {
         if (!allowNoCompile)
         {
             return null;
         }
         baseType = control.BaseType;
     }
     else
     {
         if (!(vPathBuildResult is BuildResultCompiledType))
         {
             throw new HttpException(System.Web.SR.GetString("Invalid_typeless_reference", new object[] { "src" }));
         }
         BuildResultCompiledType type2 = (BuildResultCompiledType) vPathBuildResult;
         baseType = type2.ResultType;
     }
     base.AddTypeDependency(baseType);
     base.AddBuildResultDependency(vPathBuildResult);
     return baseType;
 }

 private void GetPathConfigFilenameWorker(string siteID, VirtualPath path, out string directory, out string baseName)
 {
     directory = this.MapPathCaching(siteID, path);
     if (directory != null)
     {
         baseName = "web.config";
     }
     else
     {
         baseName = null;
     }
 }

 internal HttpHandlerAction FindMapping(string verb, VirtualPath path)
 {
     this.ValidateHandlers();
     for (int i = 0; i < this.Handlers.Count; i++)
     {
         HttpHandlerAction action = this.Handlers[i];
         if (action.IsMatch(verb, path))
         {
             return action;
         }
     }
     return null;
 }