internal XNodeReader(XNode node, XmlNameTable nameTable, ReaderOptions options)
 {
     _source = node;
     _root = node;
     _nameTable = nameTable != null ? nameTable : CreateNameTable();
     _omitDuplicateNamespaces = (options & ReaderOptions.OmitDuplicateNamespaces) != 0 ? true : false;
 }

 public Preprocessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings)
     : base(nameTable, schemaNames, eventHandler, compilationSettings)
 {
     _referenceNamespaces = new Hashtable();
     _processedExternals = new Hashtable();
     _lockList = new SortedList();
 }

	// Constructor.
	public NameCache(XmlNameTable nt) : base(128)  // avoid expanding of hashtable
			{
				nameTable = nt;

				// only NameTable is guaranted to use String.Empty
				emptyString = nt.Add(String.Empty);
			}

        /// <summary>
        /// Create a new empty document.  All names should be atomized using "nameTable".
        /// </summary>
        internal XPathDocument(XmlNameTable nameTable)
        {
            if (nameTable == null)
                throw new ArgumentNullException(nameof(nameTable));

            _nameTable = nameTable;
        }

	public XmlParserInput
				(TextReader reader,
				 XmlNameTable nameTable,
				 ErrorHandler error)
			: this(reader, nameTable, null, error)
			{
			}

            : this(nameTable, schemaNames, eventHandler, new XmlSchemaCompilationSettings()) {} //Use the default for XmlSchemaCollection

        public BaseProcessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings) {
            Debug.Assert(nameTable != null);
            this.nameTable = nameTable;
            this.schemaNames = schemaNames;
            this.eventHandler = eventHandler;
            this.compilationSettings = compilationSettings;
            NsXml = nameTable.Add(XmlReservedNs.NsXml);
        }

 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 XmlSchemaSet (XmlNameTable nameTable)
		{
			if (nameTable == null)
				throw new ArgumentNullException ("nameTable");

			this.nameTable = nameTable;
			schemas = new ArrayList ();
			CompilationId = Guid.NewGuid ();
		}

 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();
 }

 /// <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("nametable");
     }
     nameTable = nametable;
     collection = Hashtable.Synchronized(new Hashtable());
     xmlResolver = System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver();
     isThreadSafe = true;
     if (isThreadSafe) {
         wLock = new ReaderWriterLock();
     }
 }

	// Constructor.
	protected XmlParserInputBase
				(XmlNameTable nameTable,
				 EOFHandler eof,
				 ErrorHandler error)
			: base(error)
			{
				this.nameTable = nameTable;
				this.eofHandler = eof;
				this.currChar = '\0';
				this.peekChar = '\0';
				this.logger = new LogManager();
			}

	public XmlParserInput
				(TextReader reader,
				 XmlNameTable nameTable,
				 EOFHandler eof,
				 ErrorHandler error)
			: base(nameTable, eof, error)
			{
				this.lineNumber = 1;
				this.linePosition = 1;
				this.bufferPos = 0;
				this.bufferLen = 0;
				this.buffer = new char[BUFSIZE];
				this.reader = reader;
				this.extraPeekChar = '\0';
			}

 /// <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();
     }
 }

 /// <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();
     }
 }

	// Constructor.
	public XmlDTDParserInput
				(XmlParserInput input,
				 XmlNameTable nameTable)
			: base(nameTable, null, input.ErrorHandler)
			{
				this.input = input;
				this.peValue = null;
				this.pePosition = -1;
				this.scanForPE = true;
				this.parameterEntities = new PEManager
					(nameTable, input.ErrorHandler);
			#if !ECMA_COMPAT
				this.valid = true;
				this.started = false;
			#endif
				base.logger = null;
			}

        internal Validator(XmlNameTable nameTable, SchemaNames schemaNames, XmlValidatingReader reader) {
            this.nameTable = nameTable;
            this.schemaNames = schemaNames;
            this.reader = reader;
            positionInfo = PositionInfo.GetPositionInfo(reader);
            nsManager = reader.NamespaceManager;
            if (nsManager == null) {
                nsManager = new XmlNamespaceManager(nameTable);
                isProcessContents = true;
            }
            SchemaInfo = new SchemaInfo(schemaNames);

            validationStack = new HWStack(STACK_INCREMENT);
            textValue = new StringBuilder();
            this.name = XmlQualifiedName.Empty;
            attPresence = new Hashtable();
            context = null;
            attnDef = null;
        }

        //Compile-time Facet Checking
        internal virtual RestrictionFacets ConstructRestriction(DatatypeImplementation datatype, XmlSchemaObjectCollection facets, XmlNameTable nameTable) {
            //Datatype is the type on which this method is called
            RestrictionFacets derivedRestriction = new RestrictionFacets();
            FacetsCompiler facetCompiler = new FacetsCompiler(datatype, derivedRestriction);

            for (int i = 0; i < facets.Count; ++i) {
                XmlSchemaFacet facet = (XmlSchemaFacet)facets[i];
                if (facet.Value == null) {
                    throw new XmlSchemaException(Res.Sch_InvalidFacet, facet);
                }
                IXmlNamespaceResolver nsmgr = new SchemaNamespaceManager(facet);
                switch(facet.FacetType) {
                    case FacetType.Length:
                        facetCompiler.CompileLengthFacet(facet);
                    break;

                    case FacetType.MinLength:
                        facetCompiler.CompileMinLengthFacet(facet);
                    break;

                    case FacetType.MaxLength:
                        facetCompiler.CompileMaxLengthFacet(facet);
                    break;
    
                    case FacetType.Pattern:
                        facetCompiler.CompilePatternFacet(facet as XmlSchemaPatternFacet);
                    break;

                    case FacetType.Enumeration:
                        facetCompiler.CompileEnumerationFacet(facet, nsmgr, nameTable);                        
                    break;

                    case FacetType.Whitespace:
                        facetCompiler.CompileWhitespaceFacet(facet);
                    break;

                    case FacetType.MinInclusive:
                        facetCompiler.CompileMinInclusiveFacet(facet);
                    break;

                    case FacetType.MinExclusive:
                        facetCompiler.CompileMinExclusiveFacet(facet);
                    break;

                    case FacetType.MaxInclusive:
                        facetCompiler.CompileMaxInclusiveFacet(facet);
                    break;

                    case FacetType.MaxExclusive:
                        facetCompiler.CompileMaxExclusiveFacet(facet);
                    break;

                    case FacetType.TotalDigits:
                        facetCompiler.CompileTotalDigitsFacet(facet);
                    break;

                    case FacetType.FractionDigits:
                        facetCompiler.CompileFractionDigitsFacet(facet);
                    break;

                    default:
                        throw new XmlSchemaException(Res.Sch_UnknownFacet, facet);
                }
            }
            facetCompiler.FinishFacetCompile();
            facetCompiler.CompileFacetCombinations();
            return derivedRestriction;
        }

 private object ParseFacetValue(XmlSchemaDatatype datatype, XmlSchemaFacet facet, string code, IXmlNamespaceResolver nsmgr, XmlNameTable nameTable) {
     object typedValue;
     Exception ex = datatype.TryParseValue(facet.Value, nameTable, nsmgr, out typedValue);
     if (ex == null) {
         return typedValue;
     }
     else {
         throw new XmlSchemaException(code, new string[] {ex.Message} , ex, facet.SourceUri, facet.LineNumber, facet.LinePosition, facet);
     }
 }