public void Load(IXPathNavigable stylesheet, XmlResolver resolver)
 {
     if (stylesheet == null)
     {
         throw new ArgumentNullException(nameof(stylesheet));
     }
     Load(stylesheet.CreateNavigator(), resolver);
 }

	// Initialize this dtd reader.
	public void Init
				(XmlParserInput input,
				 XmlResolver resolver)
			{
				base.ErrorHandler = input.ErrorHandler;
				this.input = new XmlDTDParserInput(input, context.NameTable);
				this.resolver = resolver;
			}

        public void Load(Compiler compiler, object stylesheet, XmlResolver xmlResolver)
        {
            Debug.Assert(compiler != null);
            _compiler = compiler;
            _xmlResolver = xmlResolver ?? XmlNullResolver.Singleton;

            XmlReader reader = stylesheet as XmlReader;
            if (reader != null)
            {
                _readerSettings = new QueryReaderSettings(reader);
                Load(reader);
            }
            else
            {
                // We should take DefaultReaderSettings from Compiler.Settings.DefaultReaderSettings.

                string uri = stylesheet as string;
                if (uri != null)
                {
                    // If xmlResolver == null, then the original uri will be resolved using XmlUrlResolver
                    XmlResolver origResolver = xmlResolver;
                    if (xmlResolver == null || xmlResolver == XmlNullResolver.Singleton)
                        origResolver = new XmlUrlResolver();
                    Uri resolvedUri = origResolver.ResolveUri(null, uri);
                    if (resolvedUri == null)
                    {
                        throw new XslLoadException(SR.Xslt_CantResolve, uri);
                    }

                    _readerSettings = new QueryReaderSettings(new NameTable());
                    using (reader = CreateReader(resolvedUri, origResolver))
                    {
                        Load(reader);
                    }
                }
                else
                {
                    IXPathNavigable navigable = stylesheet as IXPathNavigable;
                    if (navigable != null)
                    {
                        reader = XPathNavigatorReader.Create(navigable.CreateNavigator());
                        _readerSettings = new QueryReaderSettings(reader.NameTable);
                        Load(reader);
                    }
                    else
                    {
                        Debug.Fail("Should never get here");
                    }
                }
            }
            Debug.Assert(compiler.Root != null);
            compiler.StartApplyTemplates = f.ApplyTemplates(nullMode);
            ProcessOutputSettings();
            foreach (AttributeSet attSet in compiler.AttributeSets.Values)
            {
                CheckAttributeSetsDfs(attSet); // Check attribute sets for circular references using dfs marking method
            }
        }

        /// <summary>
        /// Default document as XPathNavigator.
        /// </summary>
        public override void Execute(IXPathNavigable contextDocument, XmlResolver dataSources, XsltArgumentList argumentList, XmlWriter results) {
            if (results == null)
                throw new ArgumentNullException(nameof(results));

            if (contextDocument != null)
                Execute(contextDocument.CreateNavigator(), dataSources, argumentList, results, false);
            else
                Execute(null, dataSources, argumentList, results, false);
        }

 public void Load(XPathNavigator stylesheet, XmlResolver resolver) {
     if (stylesheet == null) {
         throw new ArgumentNullException("stylesheet");
     }
     if (resolver == null) {
         resolver = new XmlNullResolver();
     }
     Compile(stylesheet, resolver, /*evidence:*/null);
 }

        public void Load(Compiler compiler, object stylesheet, XmlResolver xmlResolver) {
            Debug.Assert(compiler != null);
            this.compiler = compiler;
            this.xmlResolver = xmlResolver ?? XmlNullResolver.Singleton;

            XmlReader reader = stylesheet as XmlReader;
            if (reader != null) {
                readerSettings = new QueryReaderSettings(reader);
                LoadStylesheet(reader, /*include:*/false);
            } else {
                // We should take DefaultReaderSettings from Compiler.Settings.DefaultReaderSettings.

                string uri = stylesheet as string;
                if (uri != null) {
                    // If xmlResolver == null, then the original uri will be resolved using XmlUrlResolver
                    XmlResolver origResolver = xmlResolver ?? new XmlUrlResolver();
                    Uri resolvedUri = origResolver.ResolveUri(null, uri);
                    if (resolvedUri == null) {
                        throw new XslLoadException(Res.Xslt_CantResolve, uri);
                    }

                    readerSettings = new QueryReaderSettings(new NameTable());
                    using (reader = CreateReader(resolvedUri, origResolver)) {
                        LoadStylesheet(reader, /*include:*/false);
                    }
                } else {
                    IXPathNavigable navigable = stylesheet as IXPathNavigable;
                    if (navigable != null) {
                        reader = XPathNavigatorReader.Create(navigable.CreateNavigator());
                        readerSettings = new QueryReaderSettings(reader.NameTable);
                        LoadStylesheet(reader, /*include:*/false);
                    } else {
                        Debug.Fail("Should never get here");
                    }
                }
            }
            Process();
        }

 internal XmlReader Validate(XmlReader reader, XmlResolver resolver, XmlSchemaSet schemaSet, ValidationEventHandler valEventHandler) {
     if (schemaSet != null) {
         XmlReaderSettings readerSettings = new XmlReaderSettings();
         readerSettings.ValidationType = ValidationType.Schema;
         readerSettings.Schemas = schemaSet;
         readerSettings.ValidationEventHandler += valEventHandler;                
         return new XsdValidatingReader(reader, resolver, readerSettings, this);
     }
     return null;
 }

 /// <devdoc>
 ///     <para>
 ///         Executes the query by accessing datasources via the XmlResolver and using
 ///         run-time parameters as provided by the XsltArgumentList. The default document
 ///         is mapped into the XmlResolver with the provided name. The results are returned
 ///         as an IList.
 ///     </para>
 /// </devdoc>
 public abstract IList Evaluate(XmlReader contextDocument, XmlResolver dataSources, XsltArgumentList argumentList);

 /// <devdoc>
 ///     <para>
 ///         Executes the query over the provided XPathNavigator with the given XsltArgumentList
 ///         as run-time parameters. The results are output to the provided Stream.
 ///     </para>
 /// </devdoc>
 public abstract void Execute(IXPathNavigable contextDocument, XmlResolver dataSources, XsltArgumentList argumentList, Stream results);

 /// <summary>
 /// Executes the query by accessing datasources via the XmlResolver and using
 /// run-time parameters as provided by the XsltArgumentList. The default document
 /// is mapped into the XmlResolver with the provided name. The results are returned
 /// as an IList.
 /// </summary>
 public override IList Evaluate(XmlReader contextDocument, XmlResolver dataSources, XsltArgumentList argumentList) {
     XmlCachedSequenceWriter seqwrt = new XmlCachedSequenceWriter();
     Execute(contextDocument, dataSources, argumentList, seqwrt);
     return seqwrt.ResultSequence;
 }

        private XmlSchema Add(string ns, SchemaInfo schemaInfo, XmlSchema schema, bool compile, XmlResolver resolver) {
            int errorCount = 0;
            if (schema != null) {
                if (schema.ErrorCount == 0 && compile) {
					if (!schema.CompileSchema(this, resolver, schemaInfo, ns, validationEventHandler, nameTable, true)) {
						errorCount = 1;
					}
					ns = schema.TargetNamespace == null ? string.Empty : schema.TargetNamespace;
                }
				errorCount += schema.ErrorCount;
            } 
            else {
                errorCount += schemaInfo.ErrorCount;
                //ns = ns == null? string.Empty : NameTable.Add(ns);
                ns = NameTable.Add(ns); //Added without checking for ns == null, since XDR cannot have null namespace
            }
            if (errorCount == 0) {
                XmlSchemaCollectionNode node = new XmlSchemaCollectionNode();
                node.NamespaceURI = ns;
                node.SchemaInfo = schemaInfo; 
				node.Schema = schema; 
                Add(ns, node);
                return schema;
            }
            return null;
        }

	// Constructor.
	public XmlDTDReader(XmlParserContext context)
			: base(null)
			{
				this.context = context;
				this.input = null;
				this.resolver = null;
			}

 public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) {
     this.schemaType = schemaType;
     this.nameTable = nameTable;
     this.schemaNames = schemaNames;
     this.eventHandler = eventHandler;
     this.xmlResolver = System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver();
     processMarkup = true;
     dummyDocument = new XmlDocument();
 }

 public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) {
     this.schemaType = schemaType;
     this.nameTable = nameTable;
     this.schemaNames = schemaNames;
     this.eventHandler = eventHandler;
     this.xmlResolver = new XmlUrlResolver();
     processMarkup = true;
     dummyDocument = new XmlDocument();
 }

 public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler)
 {
     _schemaType = schemaType;
     _nameTable = nameTable;
     _schemaNames = schemaNames;
     _eventHandler = eventHandler;
     _xmlResolver = null;
     _processMarkup = true;
     _dummyDocument = new XmlDocument();
 }

 public BaseValidator(BaseValidator other) {
     reader = other.reader;
     schemaCollection = other.schemaCollection;
     eventHandler = other.eventHandler;
     nameTable = other.nameTable;
     schemaNames = other.schemaNames;
     positionInfo = other.positionInfo;
     xmlResolver = other.xmlResolver;
     baseUri = other.baseUri;
     elementName = other.elementName;
 }

 /// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.XmlSchemaCollection1"]/*' />
 /// <devdoc>
 ///    <para>Construct a new empty schema collection with associated XmlNameTable.
 ///       The XmlNameTable is used when loading schemas</para>
 /// </devdoc>
 public XmlSchemaCollection(XmlNameTable nametable) {
     if (nametable == null) {
         throw new ArgumentNullException("nametable");
     }
     nameTable = nametable;
     collection = Hashtable.Synchronized(new Hashtable());
     xmlResolver = System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver();
     isThreadSafe = true;
     if (isThreadSafe) {
         wLock = new ReaderWriterLock();
     }
 }

 /// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.XmlSchemaCollection1"]/*' />
 /// <devdoc>
 ///    <para>Construct a new empty schema collection with associated XmlNameTable.
 ///       The XmlNameTable is used when loading schemas</para>
 /// </devdoc>
 public XmlSchemaCollection(XmlNameTable nametable) {
     if (nametable == null) {
         throw new ArgumentNullException("nametable");
     }
     nameTable = nametable;
     collection = Hashtable.Synchronized(new Hashtable());
     xmlResolver = new XmlUrlResolver();
     isThreadSafe = true;
     if (isThreadSafe) {
         wLock = new ReaderWriterLock();
     }
 }

 /// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.XmlSchemaCollection1"]/*' />
 /// <devdoc>
 ///    <para>Construct a new empty schema collection with associated XmlNameTable.
 ///       The XmlNameTable is used when loading schemas</para>
 /// </devdoc>
 public XmlSchemaCollection(XmlNameTable nametable)
 {
     if (nametable == null)
     {
         throw new ArgumentNullException(nameof(nametable));
     }
     _nameTable = nametable;
     _collection = Hashtable.Synchronized(new Hashtable());
     _xmlResolver = null;
     _isThreadSafe = true;
     if (_isThreadSafe)
     {
         _wLock = new object();
     }
 }

 /// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.XmlSchemaCollection1"]/*' />
 /// <devdoc>
 ///    <para>Construct a new empty schema collection with associated XmlNameTable.
 ///       The XmlNameTable is used when loading schemas</para>
 /// </devdoc>
 public XmlSchemaCollection(XmlNameTable nametable)
 {
     if (nametable == null)
     {
         throw new ArgumentNullException(nameof(nametable));
     }
     _nameTable = nametable;
     _collection = Hashtable.Synchronized(new Hashtable());
     _xmlResolver = System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver();
     _isThreadSafe = true;
     if (_isThreadSafe)
     {
         _wLock = new object();
     }
 }