internal static string XdrCanonizeUri(string uri, XmlNameTable nameTable, SchemaNames schemaNames) { string nsXdr; int length = 5; bool flag = false; if ((uri.Length > 5) && uri.StartsWith("uuid:", StringComparison.Ordinal)) { flag = true; } else if ((uri.Length > 9) && uri.StartsWith("urn:uuid:", StringComparison.Ordinal)) { flag = true; length = 9; } if (flag) { nsXdr = nameTable.Add(uri.Substring(0, length) + uri.Substring(length, uri.Length - length).ToUpper(CultureInfo.InvariantCulture)); } else { nsXdr = uri; } if (Ref.Equal(schemaNames.NsDataTypeAlias, nsXdr) || Ref.Equal(schemaNames.NsDataTypeOld, nsXdr)) { return(schemaNames.NsDataType); } if (Ref.Equal(schemaNames.NsXdrAlias, nsXdr)) { nsXdr = schemaNames.NsXdr; } return(nsXdr); }
public Preprocessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings) : base(nameTable, schemaNames, eventHandler, compilationSettings) { _referenceNamespaces = new Hashtable(); _processedExternals = new Hashtable(); _lockList = new SortedList(); }
/// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Read2"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public static XmlSchema Read(XmlReader reader, ValidationEventHandler validationEventHandler) { XmlNameTable nameTable = reader.NameTable; SchemaNames schemaNames = new SchemaNames(nameTable); return(new Parser(null, nameTable, schemaNames, validationEventHandler).Parse(reader, null, new SchemaInfo(schemaNames))); }
internal Parser(XmlSchemaCollection schemaCollection, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventhandler) { this.SchemaCollection = schemaCollection; this.nameTable = nameTable; this.schemaNames = schemaNames; this.validationEventHandler += eventhandler; }
: 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); }
} //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 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 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(); this.processMarkup = true; this.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; eventHandling = other.eventHandling; 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.Add1"]/*' /> /// <devdoc> /// <para>Add the given schema into the schema collection. /// If the given schema references other namespaces, the schemas for those /// other namespaces are NOT automatically loaded.</para> /// </devdoc> public XmlSchema Add(String ns, XmlReader reader) { if (reader == null) { throw new ArgumentNullException("reader"); } XmlNameTable tmpNameTable = reader.NameTable; SchemaNames tmpSchemaNames = nameTable == tmpNameTable ? schemaNames : new SchemaNames(tmpNameTable); SchemaInfo schemaInfo = new SchemaInfo(tmpSchemaNames); return(Add(ns, schemaInfo, new Parser(this, reader.NameTable, tmpSchemaNames, validationEventHandler).Parse(reader, ns, schemaInfo), true)); }
public BaseValidator(BaseValidator other) { reader = other.reader; _schemaCollection = other._schemaCollection; _eventHandling = other._eventHandling; _nameTable = other._nameTable; _schemaNames = other._schemaNames; _positionInfo = other._positionInfo; _xmlResolver = other._xmlResolver; _baseUri = other._baseUri; elementName = other.elementName; }
internal SchemaNames GetSchemaNames(XmlNameTable nt) { if (this.nameTable != nt) { return(new SchemaNames(nt)); } if (this.schemaNames == null) { this.schemaNames = new SchemaNames(this.nameTable); } return(this.schemaNames); }
/// <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()); schemaNames = new SchemaNames(nametable); isThreadSafe = true; if (isThreadSafe) { wLock = new ReaderWriterLock(); } }
private void ValidateElement() { elementName.Init(reader.LocalName, XmlSchemaDatatype.XdrCanonizeUri(reader.NamespaceURI, NameTable, SchemaNames)); ValidateChildElement(); if (SchemaNames.IsXDRRoot(elementName.Name, elementName.Namespace) && reader.Depth > 0) { _inlineSchemaParser = new Parser(SchemaType.XDR, NameTable, SchemaNames, EventHandler); _inlineSchemaParser.StartParsing(reader, null); _inlineSchemaParser.ParseReaderNode(); } else { ProcessElement(); } }
internal SchemaNames GetSchemaNames(XmlNameTable nt) { if (_nameTable != nt) { return(new SchemaNames(nt)); } else { if (_schemaNames == null) { _schemaNames = new SchemaNames(_nameTable); } return(_schemaNames); } }
internal XdrBuilder(XmlReader reader, XmlNamespaceManager curmgr, SchemaInfo sinfo, string targetNamspace, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventhandler) { this._SchemaInfo = sinfo; this._TargetNamespace = targetNamspace; this._reader = reader; this._CurNsMgr = curmgr; this.validationEventHandler = eventhandler; this._StateHistory = new HWStack(10); this._ElementDef = new ElementContent(); this._AttributeDef = new AttributeContent(); this._GroupStack = new HWStack(10); this._GroupDef = new GroupContent(); this._NameTable = nameTable; this._SchemaNames = schemaNames; this._CurState = S_SchemaEntries[0]; this.positionInfo = PositionInfo.GetPositionInfo(this._reader); this.xmlResolver = new XmlUrlResolver(); }
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; }
internal XmlSchema ParseSchema(string targetNamespace, XmlReader reader) { XmlNameTable nameTable = reader.NameTable; SchemaNames schemaNames = this.GetSchemaNames(nameTable); System.Xml.Schema.Parser parser = new System.Xml.Schema.Parser(SchemaType.XSD, nameTable, schemaNames, this.eventHandler) { XmlResolver = this.readerSettings.GetXmlResolver() }; try { parser.Parse(reader, targetNamespace); } catch (XmlSchemaException exception) { this.SendValidationEvent(exception, XmlSeverityType.Error); return(null); } return(parser.XmlSchema); }
internal void Preprocess(ValidationEventHandler eventhandler) { errorCount = 0; Compiler.Cleanup(this); isPreprocessed = false; SchemaNames sn = new SchemaNames(NameTable); new Compiler(NameTable, sn, eventhandler, true).Preprocess(this, null); if (errorCount == 0) { isPreprocessed = true; foreach (XmlSchemaExternal include in Includes) { if (include.Schema != null) { include.Schema.isPreprocessed = true; } } } }
internal static string XdrCanonizeUri(string uri, XmlNameTable nameTable, SchemaNames schemaNames) { string canonicalUri; int offset = 5; bool convert = false; if (uri.Length > 5 && uri.StartsWith("uuid:", StringComparison.Ordinal)) { convert = true; } else if (uri.Length > 9 && uri.StartsWith("urn:uuid:", StringComparison.Ordinal)) { convert = true; offset = 9; } if (convert) { canonicalUri = nameTable.Add(string.Concat(uri.AsSpan(0, offset), CultureInfo.InvariantCulture.TextInfo.ToUpper(uri.Substring(offset, uri.Length - offset)))); } else { canonicalUri = uri; } if ( Ref.Equal(schemaNames.NsDataTypeAlias, canonicalUri) || Ref.Equal(schemaNames.NsDataTypeOld, canonicalUri) ) { canonicalUri = schemaNames.NsDataType; } else if (Ref.Equal(schemaNames.NsXdrAlias, canonicalUri)) { canonicalUri = schemaNames.NsXdr; } return(canonicalUri); }
internal XdrAttributeEntry(SchemaNames.Token a, XmlTokenizedType ttype, int schemaFlags, XdrBuildFunction build) { _Attribute = a; _Datatype = XmlSchemaDatatype.FromXmlTokenizedType(ttype); _SchemaFlags = schemaFlags; _BuildFunc = build; }
internal SchemaElementDecl(XmlSchemaDatatype dtype, SchemaNames names) { Datatype = dtype; Content = new CompiledContentModel(names); Content.ContentType = CompiledContentModel.Type.Text; }
public SchemaElementDecl(XmlQualifiedName name, String prefix, SchemaType schemaType, SchemaNames names) : base(name, prefix) { content = new CompiledContentModel(names); }
public bool ParseContent; // whether text content is allowed public XsdEntry(SchemaNames.Token n, State state, State[] nextStates, XsdAttributeEntry[] attributes, XsdInitFunction init, XsdEndChildFunction end, bool parseContent) { Name = n; CurrentState = state; NextStates = nextStates; Attributes = attributes; InitFunc = init; EndChildFunc = end; ParseContent = parseContent; }
internal XsdBuilder( XmlReader reader, XmlNamespaceManager curmgr, XmlSchema schema, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventhandler ) { this.reader = reader; this.xso = this.schema = schema; this.namespaceManager = new BuilderNamespaceManager(curmgr, reader); this.validationEventHandler = eventhandler; this.nameTable = nameTable; this.schemaNames = schemaNames; this.stateHistory = new HWStack(STACK_INCREMENT); this.currentEntry = SchemaEntries[0]; positionInfo = PositionInfo.GetPositionInfo(reader); }
internal static string XdrCanonizeUri(string uri, XmlNameTable nameTable, SchemaNames schemaNames) { string nsXdr; int length = 5; bool flag = false; if ((uri.Length > 5) && uri.StartsWith("uuid:", StringComparison.Ordinal)) { flag = true; } else if ((uri.Length > 9) && uri.StartsWith("urn:uuid:", StringComparison.Ordinal)) { flag = true; length = 9; } if (flag) { nsXdr = nameTable.Add(uri.Substring(0, length) + uri.Substring(length, uri.Length - length).ToUpper(CultureInfo.InvariantCulture)); } else { nsXdr = uri; } if (Ref.Equal(schemaNames.NsDataTypeAlias, nsXdr) || Ref.Equal(schemaNames.NsDataTypeOld, nsXdr)) { return schemaNames.NsDataType; } if (Ref.Equal(schemaNames.NsXdrAlias, nsXdr)) { nsXdr = schemaNames.NsXdr; } return nsXdr; }
public BaseProcessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) : this(nameTable, schemaNames, eventHandler, new XmlSchemaCompilationSettings()) { } //Use the default for XmlSchemaCollection
internal SchemaInfo(SchemaNames names) { schemaType = SchemaType.None; schemaNames = names; }
internal CompiledContentModel(SchemaNames names) { schemaNames = names; endNode = null; }
internal CompiledContentModel( SchemaNames names ) { schemaNames = names; endNode = null; }
internal XdrAttributeEntry(SchemaNames.Token a, XmlTokenizedType ttype, XdrBuilder.XdrBuildFunction build) { this._Attribute = a; this._Datatype = XmlSchemaDatatype.FromXmlTokenizedType(ttype); this._SchemaFlags = 0; this._BuildFunc = build; }
/// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Compile1"]/*' /> public void Compile(ValidationEventHandler validationEventHandler, XmlResolver resolver) { SchemaNames sn = new SchemaNames(NameTable); Compile(null, NameTable, sn, validationEventHandler, null, new SchemaInfo(sn), false, resolver); }
private void LoadExternals(XmlSchemaCollection schemaCollection, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler validationEventHandler, XmlSchema schema) { foreach (XmlSchemaExternal include in schema.Includes) { string fullPath = null; if (include.Schema != null) { // already loaded fullPath = include.FullPath; if (fullPath != null) { this.schemaLocations.Add(fullPath, fullPath); } LoadExternals(schemaCollection, nameTable, schemaNames, validationEventHandler, include.Schema); continue; } string schemaLocation = include.SchemaLocation; if (schemaCollection != null && include is XmlSchemaImport) { include.Schema = schemaCollection[((XmlSchemaImport)include).Namespace]; if (include.Schema != null) { include.Schema = include.Schema.Clone(); continue; } } if (include is XmlSchemaImport && ((XmlSchemaImport)include).Namespace == XmlReservedNs.NsXml) { if (!buildinIncluded) { buildinIncluded = true; include.Schema = GetBuildInSchema(nameTable); } continue; } if (schemaLocation == null) { continue; } Stream stream = ResolveSchemaLocation(schema, schemaLocation, out fullPath); if (stream != null) { include.FullPath = fullPath; if (this.schemaLocations[fullPath] == null) { this.schemaLocations.Add(fullPath, fullPath); XmlTextReader reader = new XmlTextReader(fullPath, stream, nameTable); try { reader.XmlResolver = xmlResolver; include.Schema = new Parser(schemaCollection, nameTable, schemaNames, validationEventHandler).Parse(reader, null, null); while (reader.Read()) { ; // wellformness check } this.errorCount += include.Schema.ErrorCount; LoadExternals(schemaCollection, nameTable, schemaNames, validationEventHandler, include.Schema); } catch (XmlSchemaException e) { if (validationEventHandler != null) { validationEventHandler(null, new ValidationEventArgs( new XmlSchemaException(Res.Sch_CannotLoadSchema, new string[] { schemaLocation, e.Message }), XmlSeverityType.Error )); } } catch (Exception) { if (validationEventHandler != null) { validationEventHandler(null, new ValidationEventArgs( new XmlSchemaException(Res.Sch_InvalidIncludeLocation, include), XmlSeverityType.Warning )); } } finally { reader.Close(); } } else { stream.Close(); } } else { if (validationEventHandler != null) { validationEventHandler(null, new ValidationEventArgs( new XmlSchemaException(Res.Sch_InvalidIncludeLocation, include), XmlSeverityType.Warning )); } } } }
internal SchemaNames GetSchemaNames(XmlNameTable nt) { if (nameTable != nt) { return new SchemaNames(nt); } else { if (schemaNames == null) { schemaNames = new SchemaNames( nameTable ); } return schemaNames; } }
public SchemaCollectionPreprocessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) : base(nameTable, schemaNames, eventHandler) { }
private ValidationType DetectValidationType() { //Type not yet detected : Check in Schema Collection if (reader.Schemas != null && reader.Schemas.Count > 0) { XmlSchemaCollectionEnumerator enumerator = reader.Schemas.GetEnumerator(); while (enumerator.MoveNext()) { XmlSchemaCollectionNode node = enumerator.CurrentNode !; SchemaInfo schemaInfo = node.SchemaInfo !; if (schemaInfo.SchemaType == SchemaType.XSD) { return(ValidationType.Schema); } else if (schemaInfo.SchemaType == SchemaType.XDR) { return(ValidationType.XDR); } } } if (reader.NodeType == XmlNodeType.Element) { SchemaType schemaType = SchemaNames.SchemaTypeFromRoot(reader.LocalName, reader.NamespaceURI); if (schemaType == SchemaType.XSD) { return(ValidationType.Schema); } else if (schemaType == SchemaType.XDR) { return(ValidationType.XDR); } else { int count = reader.AttributeCount; for (int i = 0; i < count; i++) { reader.MoveToAttribute(i); string objectNs = reader.NamespaceURI; string objectName = reader.LocalName; if (Ref.Equal(objectNs, SchemaNames.NsXmlNs)) { if (XdrBuilder.IsXdrSchema(reader.Value)) { reader.MoveToElement(); return(ValidationType.XDR); } } else if (Ref.Equal(objectNs, SchemaNames.NsXsi)) { reader.MoveToElement(); return(ValidationType.Schema); } else if (Ref.Equal(objectNs, SchemaNames.QnDtDt.Namespace) && Ref.Equal(objectName, SchemaNames.QnDtDt.Name)) { reader.SchemaTypeObject = XmlSchemaDatatype.FromXdrName(reader.Value); reader.MoveToElement(); return(ValidationType.XDR); } } //end of for if (count > 0) { reader.MoveToElement(); } } } return(ValidationType.Auto); }
internal static string XdrCanonizeUri(string uri, XmlNameTable nameTable, SchemaNames schemaNames) { string canonicalUri; int offset = 5; bool convert = false; if (uri.Length > 5 && uri.StartsWith("uuid:", StringComparison.Ordinal)) { convert = true; } else if (uri.Length > 9 && uri.StartsWith("urn:uuid:", StringComparison.Ordinal)) { convert = true; offset = 9; } if (convert) { canonicalUri = nameTable.Add(uri.Substring(0, offset) + CultureInfo.InvariantCulture.TextInfo.ToUpper(uri.Substring(offset, uri.Length - offset))); } else { canonicalUri = uri; } if ( Ref.Equal(schemaNames.NsDataTypeAlias, canonicalUri) || Ref.Equal(schemaNames.NsDataTypeOld, canonicalUri) ) { canonicalUri = schemaNames.NsDataType; } else if (Ref.Equal(schemaNames.NsXdrAlias, canonicalUri)) { canonicalUri = schemaNames.NsXdr; } return canonicalUri; }
public XsdBuildFunction BuildFunc; // Corresponding build functions for attribute value public XsdAttributeEntry(SchemaNames.Token a, XsdBuildFunction build) { Attribute = a; BuildFunc = build; }
internal bool _AllowText; // whether text content is allowed internal XdrEntry(SchemaNames.Token n, int[] states, XdrAttributeEntry[] attributes, XdrInitFunction init, XdrBeginChildFunction begin, XdrEndChildFunction end, bool fText) { _Name = n; _NextStates = states; _Attributes = attributes; _InitFunc = init; _BeginChildFunc = begin; _EndChildFunc = end; _AllowText = fText; }
public Preprocessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) : this(nameTable, schemaNames, eventHandler, new XmlSchemaCompilationSettings()) { }
internal void Compile(XmlSchemaCollection collection, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler validationEventHandler, string targetNamespace, SchemaInfo schemaInfo, bool compileContentModel, XmlResolver resolver) { errorCount = 0; xmlResolver = resolver; if (needCleanup) { schemaLocations.Clear(); Compiler.Cleanup(this); } needCleanup = true; isPreprocessed = false; isCompiled = false; if (baseUri != null) { schemaLocations.Add(baseUri, baseUri); } if (xmlResolver != null) { LoadExternals(collection, nameTable, schemaNames, validationEventHandler, this); } if (errorCount == 0) { new Compiler(nameTable, schemaNames, validationEventHandler, compileContentModel).Compile(this, targetNamespace, schemaInfo); if (errorCount == 0) { isPreprocessed = true; isCompiled = true; foreach (XmlSchemaExternal include in Includes) { if (include.Schema != null) { include.Schema.isPreprocessed = true; include.Schema.isCompiled = true; include.Schema.LineNumber = include.LineNumber; include.Schema.LinePosition = include.LinePosition; include.Schema.SourceUri = include.SchemaLocation; } } } } }
public BaseProcessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) : this(nameTable, schemaNames, eventHandler, new XmlSchemaCompilationSettings()) {} //Use the default for XmlSchemaCollection
internal XsdBuilder( XmlReader reader, XmlNamespaceManager curmgr, XmlSchema schema, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventhandler ) { _reader = reader; _xso = _schema = schema; _namespaceManager = new BuilderNamespaceManager(curmgr, reader); _validationEventHandler = eventhandler; _nameTable = nameTable; _schemaNames = schemaNames; _stateHistory = new HWStack(STACK_INCREMENT); _currentEntry = s_schemaEntries[0]; _positionInfo = PositionInfo.GetPositionInfo(reader); }
internal Compiler(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventhandler, bool compileContentModel) { this.nameTable = nameTable; this.schemaNames = schemaNames; this.validationEventHandler += eventhandler; this.compileContentModel = compileContentModel; }
public XmlQualifiedName GetName(SchemaNames.Token token) { return TokenToQName[(int)token]; }
internal XdrBuilder( XmlReader reader, XmlNamespaceManager curmgr, SchemaInfo sinfo, string targetNamspace, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventhandler ) { _SchemaInfo = sinfo; _TargetNamespace = targetNamspace; _reader = reader; _CurNsMgr = curmgr; _validationEventHandler = eventhandler; _StateHistory = new HWStack(StackIncrement); _ElementDef = new ElementContent(); _AttributeDef = new AttributeContent(); _GroupStack = new HWStack(StackIncrement); _GroupDef = new GroupContent(); _NameTable = nameTable; _SchemaNames = schemaNames; _CurState = s_schemaEntries[0]; _positionInfo = PositionInfo.GetPositionInfo(_reader); _xmlResolver = null; }