public void AddParam(String name, String namespaceUri, Object parameter)
		{
			XmlQualifiedName qName;

			if(namespaceUri == null)
			{
				throw new ArgumentException("namespaceUri");
			}
			if(namespaceUri == "http://www.w3.org/1999/XSL/Transform")
			{
				throw new ArgumentException("namespaceUri");
			}
			if(name == null)
			{
				throw new ArgumentException("name");
			}

			qName = new XmlQualifiedName(name, namespaceUri);
			if(parameters.Contains(qName))
			{
				throw new ArgumentException("namespaceUri");
			}
			parameter = ValidateParam(parameter);
			parameters[qName] = parameter;
		}

        internal void StartParsing(XmlReader reader, string targetNamespace, SchemaInfo schemaInfo) {
            this.reader = reader;
            positionInfo = PositionInfo.GetPositionInfo(reader);
            this.namespaceManager = reader.NamespaceManager;
            if (this.namespaceManager == null) {
                this.namespaceManager = new XmlNamespaceManager(this.nameTable);
                this.isProcessNamespaces = true;
            } 
            else {
                this.isProcessNamespaces = false;
            }
            while (this.reader.NodeType != XmlNodeType.Element && this.reader.Read()) {}

            this.markupDepth = int.MaxValue;
			this.schemaXmlDepth = reader.Depth;
            XmlQualifiedName qname = new XmlQualifiedName(this.reader.LocalName, XmlSchemaDatatype.XdrCanonizeUri(this.reader.NamespaceURI, this.nameTable, this.schemaNames));
            if (this.schemaNames.IsXDRRoot(qname)) {
                Debug.Assert(schemaInfo != null);
                schemaInfo.SchemaType = SchemaType.XDR;
                this.schema = null;
                this.builder = new XdrBuilder(reader, this.namespaceManager, schemaInfo, targetNamespace, this.nameTable, this.schemaNames, this.validationEventHandler);
            }
            else if (this.schemaNames.IsXSDRoot(qname)) {
                if (schemaInfo != null) {
                    schemaInfo.SchemaType = SchemaType.XSD;
                }
                this.schema = new XmlSchema();
                this.schema.BaseUri = reader.BaseURI;
                this.builder = new XsdBuilder(reader, this.namespaceManager, this.schema, this.nameTable, this.schemaNames, this.validationEventHandler);
            }
            else { 
                throw new XmlSchemaException(Res.Sch_SchemaRootExpected, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition);
            }
                
        }

     	/// <include file='doc\XsltArgumentList.uex' path='docs/doc[@for="XsltArgumentList.AddParam"]/*' />
     	/// <devdoc>
     	///    <para>[To be supplied.]</para>
     	/// </devdoc>
        public void AddParam(string name, string namespaceUri, object parameter) {
            CheckArgumentNull(name        , "name"        );
            CheckArgumentNull(namespaceUri, "namespaceUri");
            CheckArgumentNull(parameter   , "parameter"   );
            ValidateParamNamespace(namespaceUri);

            if (
                parameter is XPathNodeIterator ||
                parameter is XPathNavigator    ||
                parameter is Boolean           ||
                parameter is Double            ||
                parameter is String
            ) {
                // doing nothing
            }
            else if (
                parameter is Int16  || parameter is UInt16 ||
                parameter is Int32  || parameter is UInt32 ||
                parameter is Int64  || parameter is UInt64 ||
                parameter is Single || parameter is Decimal
            ) {
                parameter = XmlConvert.ToXPathDouble(parameter);
            }
            else {
                parameter = parameter.ToString();
            }
            XmlQualifiedName qname = new XmlQualifiedName(name, namespaceUri);
            qname.Verify();
            this.parameters.Add(qname, parameter);
        }

 public object RemoveParam(string name, string namespaceUri)
 {
     XmlQualifiedName qname = new XmlQualifiedName(name, namespaceUri);
     object parameter = _parameters[qname];
     _parameters.Remove(qname);
     return parameter;
 }

 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public static XmlSchemaSimpleType GetBuiltInSimpleType(XmlQualifiedName qualifiedName)
 {
     if (qualifiedName == null)
     {
         throw new ArgumentNullException(nameof(qualifiedName));
     }
     return DatatypeImplementation.GetSimpleTypeFromXsdType(qualifiedName);
 }

 IDtdAttributeInfo IDtdAttributeListInfo.LookupAttribute(string prefix, string localName) {
     XmlQualifiedName qname = new XmlQualifiedName(localName, prefix);
     SchemaAttDef attDef;
     if (attdefs.TryGetValue(qname, out attDef)) {
         return attDef;
     }
     return null;
 }

 internal object this[XmlQualifiedName qname] {
     get {
         return table[new NameKey(qname.Name, qname.Namespace)];
     }
     set {
         table[new NameKey(qname.Name, qname.Namespace)] = value;
     }
 }

        protected List<string> values;    // array of values for enumerated and notation types
#endif

        protected SchemaDeclBase(XmlQualifiedName name, string prefix) {
            this.name = name;
            this.prefix = prefix;
#if !SILVERLIGHT
            maxLength = -1;
            minLength = -1;
#endif
        }

 /// <include file='doc\XmlSerializerNamespaces.uex' path='docs/doc[@for="XmlSerializerNamespaces.XmlSerializerNamespaces2"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public XmlSerializerNamespaces(XmlQualifiedName[] namespaces)
 {
     for (int i = 0; i < namespaces.Length; i++)
     {
         XmlQualifiedName qname = namespaces[i];
         Add(qname.Name, qname.Namespace);
     }
 }

		public XmlSerializerNamespaces(XmlQualifiedName[] namespaces)
			: this()
		{
			foreach(XmlQualifiedName qname in namespaces) 
			{
				this.namespaces.Add (qname.Name, qname);
			}
		}

 public BaseValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, ValidationEventHandler eventHandler) {
     Debug.Assert(schemaCollection == null || schemaCollection.NameTable == reader.NameTable);
     this.reader = reader;
     this.schemaCollection = schemaCollection;
     this.eventHandler = eventHandler;
     nameTable = reader.NameTable;
     positionInfo = PositionInfo.GetPositionInfo(reader);
     elementName = new XmlQualifiedName();
 }

        public void AddParam(string name, string namespaceUri, object parameter) {
            CheckArgumentNull(name        , "name"        );
            CheckArgumentNull(namespaceUri, "namespaceUri");
            CheckArgumentNull(parameter   , "parameter"   );

            XmlQualifiedName qname = new XmlQualifiedName(name, namespaceUri);
            qname.Verify();
            this.parameters.Add(qname, parameter);
        }

        // --------------------------- XsltContext -------------------
        //                Resolving variables and functions

        public override IXsltContextVariable ResolveVariable(string prefix, string name) {
            string namespaceURI = this.LookupNamespace(prefix);
            XmlQualifiedName qname = new XmlQualifiedName(name, namespaceURI);
            IXsltContextVariable variable = this.manager.VariableScope.ResolveVariable(qname);
            if (variable == null) {
                throw XsltException.Create(Res.Xslt_InvalidVariable, qname.ToString());
            }
            return variable;
        }

 internal void Replace(XmlQualifiedName name,  XmlSchemaObject value) {
     XmlSchemaObject oldValue;
     if (table.TryGetValue(name, out oldValue)) {
         table[name] = value; //set new value
         Debug.Assert(oldValue != null);
         int matchedIndex = FindIndexByValue(oldValue);
         Debug.Assert(entries[matchedIndex].qname == name);
         entries[matchedIndex] = new XmlSchemaObjectEntry(name, value);
     }
 }

 private void Init() {
     Debug.Assert(reader != null);
     validationStack = new HWStack(STACK_INCREMENT);
     textValue = new StringBuilder();
     name = XmlQualifiedName.Empty;
     attPresence = new Hashtable();
     schemaInfo = new SchemaInfo();
     checkDatatype = false;
     Push(name);
 }

        public void AddParam(string name, string namespaceUri, object parameter)
        {
            CheckArgumentNull(name, nameof(name));
            CheckArgumentNull(namespaceUri, nameof(namespaceUri));
            CheckArgumentNull(parameter, nameof(parameter));

            XmlQualifiedName qname = new XmlQualifiedName(name, namespaceUri);
            qname.Verify();
            _parameters.Add(qname, parameter);
        }

 internal void Remove(XmlQualifiedName name) {
     XmlSchemaObject value;
     if (table.TryGetValue(name, out value)) {
         table.Remove(name);
         int matchedIndex = FindIndexByValue(value);
         Debug.Assert(matchedIndex >= 0);
         Debug.Assert(entries[matchedIndex].qname == name);
         entries.RemoveAt(matchedIndex);                    
     }
 }

        /// <include file='doc\XmlSchemaImporter.uex' path='docs/doc[@for="XmlSchemaImporter.ImportDerivedTypeMapping1"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public XmlTypeMapping ImportDerivedTypeMapping(XmlQualifiedName name, Type baseType, bool baseTypeCanBeIndirect) {
            ElementAccessor element = ImportElement(EncodeQName(name), typeof(TypeMapping), baseType);

            if (element.Mapping is StructMapping) {
                MakeDerived((StructMapping)element.Mapping, baseType, baseTypeCanBeIndirect);
            }
            else if (baseType != null) {
                // Element '{0}' from namespace '{1}' is not a complex type and cannot be used as a {2}.
                throw new InvalidOperationException(Res.GetString(Res.XmlBadBaseType, name.Name, name.Namespace, baseType.FullName));
            }
            return new XmlTypeMapping(scope, element);
        }

 /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.GetXsdComplexType"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public static XmlSchemaComplexType GetBuiltInComplexType(XmlQualifiedName qualifiedName) {
     if (qualifiedName == null) {
         throw new ArgumentNullException("qualifiedName");
     }
     if (qualifiedName.Equals(XmlSchemaComplexType.AnyType.QualifiedName)) {
         return XmlSchemaComplexType.AnyType;
     }
     if (qualifiedName.Equals(XmlSchemaComplexType.UntypedAnyType.QualifiedName)) {
         return XmlSchemaComplexType.UntypedAnyType;
     }
     return null;
 }

 internal object this[XmlQualifiedName qname]
 {
     get
     {
         object obj;
         return _table.TryGetValue(new NameKey(qname.Name, qname.Namespace), out obj) ? obj : null;
     }
     set
     {
         _table[new NameKey(qname.Name, qname.Namespace)] = value;
     }
 }