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); } }
public async Task StartParsingAsync(XmlReader reader, string targetNamespace) { this.reader = reader; positionInfo = PositionInfo.GetPositionInfo(reader); namespaceManager = reader.NamespaceManager; if (namespaceManager == null) { namespaceManager = new XmlNamespaceManager(nameTable); isProcessNamespaces = true; } else { isProcessNamespaces = false; } while (reader.NodeType != XmlNodeType.Element && await reader.ReadAsync().ConfigureAwait(false)) {} markupDepth = int.MaxValue; schemaXmlDepth = reader.Depth; SchemaType rootType = schemaNames.SchemaTypeFromRoot(reader.LocalName, reader.NamespaceURI); string code; if (!CheckSchemaRoot(rootType, out code)) { throw new XmlSchemaException(code, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition); } if (schemaType == SchemaType.XSD) { schema = new XmlSchema(); schema.BaseUri = new Uri(reader.BaseURI, UriKind.RelativeOrAbsolute); builder = new XsdBuilder(reader, namespaceManager, schema, nameTable, schemaNames, eventHandler); } else { Debug.Assert(schemaType == SchemaType.XDR); xdrSchema = new SchemaInfo(); xdrSchema.SchemaType = SchemaType.XDR; builder = new XdrBuilder(reader, namespaceManager, xdrSchema, targetNamespace, nameTable, schemaNames, eventHandler); ((XdrBuilder)builder).XmlResolver = xmlResolver; } }
private void Init() { _nsManager = reader.NamespaceManager; if (_nsManager == null) { _nsManager = new XmlNamespaceManager(NameTable); _bManageNamespaces = true; } _validationStack = new HWStack(STACK_INCREMENT); textValue = new StringBuilder(); _attPresence = new Hashtable(); schemaInfo = new SchemaInfo(); checkDatatype = false; _processContents = XmlSchemaContentProcessing.Strict; Push(XmlQualifiedName.Empty); //Add common strings to be compared to NameTable _nsXmlNs = NameTable.Add(XmlReservedNs.NsXmlNs); _nsXs = NameTable.Add(XmlReservedNs.NsXs); _nsXsi = NameTable.Add(XmlReservedNs.NsXsi); _xsiType = NameTable.Add("type"); _xsiNil = NameTable.Add("nil"); _xsiSchemaLocation = NameTable.Add("schemaLocation"); _xsiNoNamespaceSchemaLocation = NameTable.Add("noNamespaceSchemaLocation"); _xsdSchema = NameTable.Add("schema"); }
internal void Compile(XmlSchema schema, string targetNamespace, SchemaInfo schemaInfo) { //CompModSwitches.XmlSchema.Level = TraceLevel.Error; schema.ErrorCount = 0; Preprocess(schema, targetNamespace); if (schema.ErrorCount == 0) { CompileTo(schemaInfo); } }
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 bool Execute(XmlSchema schema, SchemaInfo schemaInfo, bool compileContentModel) { this.compileContentModel = compileContentModel; this.schema = schema; Prepare(); Cleanup(); Compile(); if (!HasErrors) { Output(schemaInfo); } return !HasErrors; }
public bool Execute(XmlSchemaSet schemaSet, SchemaInfo schemaCompiledInfo) { Compile(); if (!HasErrors) { Output(schemaCompiledInfo); schemaSet.elements = elements; schemaSet.attributes = attributes; schemaSet.schemaTypes = schemaTypes; schemaSet.substitutionGroups = examplars; } return !HasErrors; }
public static void CheckDefaultValue(string value, SchemaAttDef attdef, SchemaInfo sinfo, XmlNamespaceManager nsManager, XmlNameTable NameTable, object sender, ValidationEventHandler eventhandler, string baseUri, int lineNo, int linePos) { try { XmlSchemaDatatype datatype = attdef.Datatype; if (datatype != null) { if (datatype.TokenizedType != XmlTokenizedType.CDATA) { value = value.Trim(); } if (value.Length != 0) { object pVal = datatype.ParseValue(value, NameTable, nsManager); XmlTokenizedType tokenizedType = datatype.TokenizedType; if (tokenizedType == XmlTokenizedType.ENTITY) { if (datatype.Variety == XmlSchemaDatatypeVariety.List) { string[] strArray = (string[]) pVal; for (int i = 0; i < strArray.Length; i++) { BaseValidator.ProcessEntity(sinfo, strArray[i], sender, eventhandler, baseUri, lineNo, linePos); } } else { BaseValidator.ProcessEntity(sinfo, (string) pVal, sender, eventhandler, baseUri, lineNo, linePos); } } else if ((tokenizedType == XmlTokenizedType.ENUMERATION) && !attdef.CheckEnumeration(pVal)) { XmlSchemaException ex = new XmlSchemaException("Sch_EnumerationValue", pVal.ToString(), baseUri, lineNo, linePos); if (eventhandler == null) { throw ex; } eventhandler(sender, new ValidationEventArgs(ex)); } attdef.DefaultValueTyped = pVal; } } } catch { XmlSchemaException exception2 = new XmlSchemaException("Sch_AttributeDefaultDataType", attdef.Name.ToString(), baseUri, lineNo, linePos); if (eventhandler == null) { throw exception2; } eventhandler(sender, new ValidationEventArgs(exception2)); } }
internal void Add(SchemaInfo sinfo, ValidationEventHandler eventhandler) { if (this.schemaType == System.Xml.Schema.SchemaType.None) { this.schemaType = sinfo.SchemaType; } else if (this.schemaType != sinfo.SchemaType) { if (eventhandler != null) { eventhandler(this, new ValidationEventArgs(new XmlSchemaException("Sch_MixSchemaTypes", string.Empty))); } return; } foreach (string str in sinfo.TargetNamespaces.Keys) { if (!this.targetNamespaces.ContainsKey(str)) { this.targetNamespaces.Add(str, true); } } foreach (KeyValuePair<XmlQualifiedName, SchemaElementDecl> pair in sinfo.elementDecls) { if (!this.elementDecls.ContainsKey(pair.Key)) { this.elementDecls.Add(pair.Key, pair.Value); } } foreach (KeyValuePair<XmlQualifiedName, SchemaElementDecl> pair2 in sinfo.elementDeclsByType) { if (!this.elementDeclsByType.ContainsKey(pair2.Key)) { this.elementDeclsByType.Add(pair2.Key, pair2.Value); } } foreach (SchemaAttDef def in sinfo.AttributeDecls.Values) { if (!this.attributeDecls.ContainsKey(def.Name)) { this.attributeDecls.Add(def.Name, def); } } foreach (SchemaNotation notation in sinfo.Notations.Values) { if (!this.Notations.ContainsKey(notation.Name.Name)) { this.Notations.Add(notation.Name.Name, notation); } } }
private void Init() { nsManager = reader.NamespaceManager; if (nsManager == null) { nsManager = new XmlNamespaceManager(NameTable); isProcessContents = true; } validationStack = new HWStack(STACK_INCREMENT); textValue = new StringBuilder(); name = XmlQualifiedName.Empty; attPresence = new Hashtable(); Push(XmlQualifiedName.Empty); schemaInfo = new SchemaInfo(); checkDatatype = false; }
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 void AddCompiledInfo(SchemaInfo schemaInfo) { XmlQualifiedName qualifiedName; foreach (XmlSchemaElement element in this.elements.Values) { qualifiedName = element.QualifiedName; schemaInfo.TargetNamespaces[qualifiedName.Namespace] = true; if (schemaInfo.ElementDecls[qualifiedName] == null) { schemaInfo.ElementDecls.Add(qualifiedName, element.ElementDecl); } } foreach (XmlSchemaAttribute attribute in this.attributes.Values) { qualifiedName = attribute.QualifiedName; schemaInfo.TargetNamespaces[qualifiedName.Namespace] = true; if (schemaInfo.ElementDecls[qualifiedName] == null) { schemaInfo.AttributeDecls.Add(qualifiedName, attribute.AttDef); } } foreach (XmlSchemaType type in this.types.Values) { qualifiedName = type.QualifiedName; schemaInfo.TargetNamespaces[qualifiedName.Namespace] = true; if ((!(type is XmlSchemaComplexType) || (type != XmlSchemaComplexType.AnyType)) && (schemaInfo.ElementDeclsByType[qualifiedName] == null)) { schemaInfo.ElementDeclsByType.Add(qualifiedName, type.ElementDecl); } } foreach (XmlSchemaNotation notation in this.notations.Values) { qualifiedName = notation.QualifiedName; schemaInfo.TargetNamespaces[qualifiedName.Namespace] = true; SchemaNotation notation2 = new SchemaNotation(qualifiedName) { SystemLiteral = notation.System, Pubid = notation.Public }; if (schemaInfo.Notations[qualifiedName.Name] == null) { schemaInfo.Notations.Add(qualifiedName.Name, notation2); } } }
public static void CheckDefaultValue(SchemaAttDef attdef, SchemaInfo sinfo, IValidationEventHandling eventHandling, string baseUriStr) { try { if (baseUriStr == null) { baseUriStr = string.Empty; } XmlSchemaDatatype datatype = attdef.Datatype; if (datatype != null) { object defaultValueTyped = attdef.DefaultValueTyped; XmlTokenizedType tokenizedType = datatype.TokenizedType; if (tokenizedType == XmlTokenizedType.ENTITY) { if (datatype.Variety == XmlSchemaDatatypeVariety.List) { string[] strArray = (string[]) defaultValueTyped; for (int i = 0; i < strArray.Length; i++) { BaseValidator.ProcessEntity(sinfo, strArray[i], eventHandling, baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition); } } else { BaseValidator.ProcessEntity(sinfo, (string) defaultValueTyped, eventHandling, baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition); } } else if (((tokenizedType == XmlTokenizedType.ENUMERATION) && !attdef.CheckEnumeration(defaultValueTyped)) && (eventHandling != null)) { XmlSchemaException exception = new XmlSchemaException("Sch_EnumerationValue", defaultValueTyped.ToString(), baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition); eventHandling.SendEvent(exception, XmlSeverityType.Error); } } } catch (Exception) { if (eventHandling != null) { XmlSchemaException exception2 = new XmlSchemaException("Sch_AttributeDefaultDataType", attdef.Name.ToString()); eventHandling.SendEvent(exception2, XmlSeverityType.Error); } } }
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; }
public XmlSchemaSet(XmlNameTable nameTable) { if (nameTable == null) { throw new ArgumentNullException("nameTable"); } this.nameTable = nameTable; this.schemas = new SortedList(); this.schemaLocations = new Hashtable(); this.chameleonSchemas = new Hashtable(); this.targetNamespaces = new Hashtable(); this.internalEventHandler = new System.Xml.Schema.ValidationEventHandler(this.InternalValidationCallback); this.eventHandler = this.internalEventHandler; this.readerSettings = new XmlReaderSettings(); this.readerSettings.NameTable = nameTable; this.readerSettings.DtdProcessing = DtdProcessing.Prohibit; this.compilationSettings = new XmlSchemaCompilationSettings(); this.cachedCompiledInfo = new SchemaInfo(); this.compileAll = true; }
internal void Check(SchemaInfo sinfo, Validator validator, ValidationEventHandler eventhandler) { Object o = null; string code = null; switch (RefType) { case ForwardRef.Type.ID: o = validator.FindID(ID); code = Res.Sch_UndeclaredId; break; case ForwardRef.Type.NOTATION: o = sinfo.Notations[ID]; code = Res.Sch_UndeclaredNotation; break; } if (o == null) { string baseuri = (null != validator && null != validator.BaseUri ? validator.BaseUri.AbsolutePath : string.Empty); eventhandler(this, new ValidationEventArgs(new XmlSchemaException(code, ID, baseuri, Line, Col))); } }
protected static void ProcessEntity(SchemaInfo sinfo, string name, IValidationEventHandling eventHandling, string baseUriStr, int lineNumber, int linePosition) { SchemaEntity en; string errorResId = null; if (!sinfo.GeneralEntities.TryGetValue(new XmlQualifiedName(name), out en)) { // validation error, see xml spec [68] errorResId = Res.Sch_UndeclaredEntity; } else if (en.NData.IsEmpty) { errorResId = Res.Sch_UnparsedEntityRef; } if (errorResId != null) { XmlSchemaException e = new XmlSchemaException(errorResId, name, baseUriStr, lineNumber, linePosition); if (eventHandling != null) { eventHandling.SendEvent(e, XmlSeverityType.Error); } else { throw e; } } }
protected static void ProcessEntity(SchemaInfo sinfo, string name, object sender, ValidationEventHandler eventhandler, string baseUri, int lineNumber, int linePosition) { SchemaEntity en; XmlSchemaException e = null; if (!sinfo.GeneralEntities.TryGetValue(new XmlQualifiedName(name), out en)) { // validation error, see xml spec [68] e = new XmlSchemaException(Res.Sch_UndeclaredEntity, name, baseUri, lineNumber, linePosition); } else if (en.NData.IsEmpty) { e = new XmlSchemaException(Res.Sch_UnparsedEntityRef, name, baseUri, lineNumber, linePosition); } if (e != null) { if (eventhandler != null) { eventhandler(sender, new ValidationEventArgs(e)); } else { throw e; } } }
internal void CopyFromCompiledSet(XmlSchemaSet otherSet) { SortedList sortedSchemas = otherSet.SortedSchemas; bool flag = this.schemas.Count == 0; ArrayList list2 = new ArrayList(); SchemaInfo info = new SchemaInfo(); for (int i = 0; i < sortedSchemas.Count; i++) { XmlSchema byIndex = (XmlSchema)sortedSchemas.GetByIndex(i); Uri baseUri = byIndex.BaseUri; if (this.schemas.ContainsKey(byIndex.SchemaId) || (((baseUri != null) && (baseUri.OriginalString.Length != 0)) && (this.schemaLocations[baseUri] != null))) { list2.Add(byIndex); } else { this.schemas.Add(byIndex.SchemaId, byIndex); if ((baseUri != null) && (baseUri.OriginalString.Length != 0)) { this.schemaLocations.Add(baseUri, byIndex); } string targetNamespace = this.GetTargetNamespace(byIndex); if (this.targetNamespaces[targetNamespace] == null) { this.targetNamespaces.Add(targetNamespace, targetNamespace); } } } this.VerifyTables(); foreach (XmlSchemaElement element in otherSet.GlobalElements.Values) { if (!this.AddToTable(this.elements, element.QualifiedName, element)) { goto Label_026E; } } foreach (XmlSchemaAttribute attribute in otherSet.GlobalAttributes.Values) { if (!this.AddToTable(this.attributes, attribute.QualifiedName, attribute)) { goto Label_026E; } } foreach (XmlSchemaType type in otherSet.GlobalTypes.Values) { if (!this.AddToTable(this.schemaTypes, type.QualifiedName, type)) { goto Label_026E; } } this.ProcessNewSubstitutionGroups(otherSet.SubstitutionGroups, false); info.Add(this.cachedCompiledInfo, this.eventHandler); info.Add(otherSet.CompiledInfo, this.eventHandler); this.cachedCompiledInfo = info; if (flag) { this.isCompiled = true; this.compileAll = false; } return; Label_026E: foreach (XmlSchema schema2 in sortedSchemas.Values) { if (!list2.Contains(schema2)) { this.Remove(schema2, false); } } foreach (XmlSchemaElement element2 in otherSet.GlobalElements.Values) { if (!list2.Contains((XmlSchema)element2.Parent)) { this.elements.Remove(element2.QualifiedName); } } foreach (XmlSchemaAttribute attribute2 in otherSet.GlobalAttributes.Values) { if (!list2.Contains((XmlSchema)attribute2.Parent)) { this.attributes.Remove(attribute2.QualifiedName); } } foreach (XmlSchemaType type2 in otherSet.GlobalTypes.Values) { if (!list2.Contains((XmlSchema)type2.Parent)) { this.schemaTypes.Remove(type2.QualifiedName); } } }
private void Output(SchemaInfo schemaInfo) { string tns; foreach(XmlSchema schema in schemasToCompile.Values) { tns = schema.TargetNamespace; if (tns == null) { tns = string.Empty; } schemaInfo.TargetNamespaces[tns] = true; } foreach (XmlSchemaElement element in elements.Values) { schemaInfo.ElementDecls.Add(element.QualifiedName, element.ElementDecl); } foreach (XmlSchemaAttribute attribute in attributes.Values) { schemaInfo.AttributeDecls.Add(attribute.QualifiedName, attribute.AttDef); } foreach (XmlSchemaType type in schemaTypes.Values) { schemaInfo.ElementDeclsByType.Add(type.QualifiedName, type.ElementDecl); } foreach (XmlSchemaNotation notation in notations.Values) { SchemaNotation no = new SchemaNotation(notation.QualifiedName); no.SystemLiteral = notation.System; no.Pubid = notation.Public; if (!schemaInfo.Notations.ContainsKey(no.Name.Name)) { schemaInfo.Notations.Add(no.Name.Name, no); } } }
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; }
private bool LoadSchema(string uri) { if (_xmlResolver == null) { return false; } uri = _NameTable.Add(uri); if (_SchemaInfo.TargetNamespaces.ContainsKey(uri)) { return false; } SchemaInfo schemaInfo = null; Uri _baseUri = _xmlResolver.ResolveUri(null, _reader.BaseURI); XmlReader reader = null; try { Uri ruri = _xmlResolver.ResolveUri(_baseUri, uri.Substring(x_schema.Length)); Stream stm = (Stream)_xmlResolver.GetEntity(ruri, null, null); reader = new XmlTextReader(ruri.ToString(), stm, _NameTable); schemaInfo = new SchemaInfo(); Parser parser = new Parser(SchemaType.XDR, _NameTable, _SchemaNames, _validationEventHandler); parser.XmlResolver = _xmlResolver; parser.Parse(reader, uri); schemaInfo = parser.XdrSchema; } catch (XmlException e) { SendValidationEvent(SR.Sch_CannotLoadSchema, new string[] { uri, e.Message }, XmlSeverityType.Warning); schemaInfo = null; } finally { if (reader != null) { reader.Close(); } } if (schemaInfo != null && schemaInfo.ErrorCount == 0) { _SchemaInfo.Add(schemaInfo, _validationEventHandler); return true; } return false; }
internal XmlSchema?Add(string?ns, SchemaInfo schemaInfo, XmlSchema?schema, bool compile) { return(Add(ns, schemaInfo, schema, compile, _xmlResolver)); }
public void Compile() { if (!this.isCompiled) { if (this.schemas.Count == 0) { this.ClearTables(); this.cachedCompiledInfo = new SchemaInfo(); this.isCompiled = true; this.compileAll = false; } else { lock (this.InternalSyncObject) { if (!this.isCompiled) { Compiler compiler = new Compiler(this.nameTable, this.eventHandler, this.schemaForSchema, this.compilationSettings); SchemaInfo schemaCompiledInfo = new SchemaInfo(); int index = 0; if (!this.compileAll) { compiler.ImportAllCompiledSchemas(this); } try { XmlSchema buildInSchema = Preprocessor.GetBuildInSchema(); index = 0; while (index < this.schemas.Count) { XmlSchema byIndex = (XmlSchema)this.schemas.GetByIndex(index); Monitor.Enter(byIndex); if (!byIndex.IsPreprocessed) { this.SendValidationEvent(new XmlSchemaException("Sch_SchemaNotPreprocessed", string.Empty), XmlSeverityType.Error); this.isCompiled = false; goto Label_01BA; } if (byIndex.IsCompiledBySet) { if (!this.compileAll) { goto Label_00FD; } if (byIndex == buildInSchema) { compiler.Prepare(byIndex, false); goto Label_00FD; } } compiler.Prepare(byIndex, true); Label_00FD: index++; } this.isCompiled = compiler.Execute(this, schemaCompiledInfo); if (this.isCompiled) { if (!this.compileAll) { schemaCompiledInfo.Add(this.cachedCompiledInfo, this.eventHandler); } this.compileAll = false; this.cachedCompiledInfo = schemaCompiledInfo; } } finally { if (index == this.schemas.Count) { index--; } for (int i = index; i >= 0; i--) { XmlSchema schema3 = (XmlSchema)this.schemas.GetByIndex(i); if (schema3 == Preprocessor.GetBuildInSchema()) { Monitor.Exit(schema3); } else { schema3.IsCompiledBySet = this.isCompiled; Monitor.Exit(schema3); } } } } Label_01BA :; } } } }
public static void CheckDefaultValue( SchemaAttDef attdef, SchemaInfo sinfo, IValidationEventHandling eventHandling, string baseUriStr ) { try { if (baseUriStr == null) { baseUriStr = string.Empty; } XmlSchemaDatatype dtype = attdef.Datatype; if (dtype == null) { return; // no reason to check } object typedValue = attdef.DefaultValueTyped; // Check special types XmlTokenizedType ttype = dtype.TokenizedType; if (ttype == XmlTokenizedType.ENTITY) { if (dtype.Variety == XmlSchemaDatatypeVariety.List) { string[] ss = (string[])typedValue; for (int i = 0; i < ss.Length; ++i) { ProcessEntity(sinfo, ss[i], eventHandling, baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition); } } else { ProcessEntity(sinfo, (string)typedValue, eventHandling, baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition); } } else if (ttype == XmlTokenizedType.ENUMERATION) { if (!attdef.CheckEnumeration(typedValue)) { if (eventHandling != null) { XmlSchemaException e = new XmlSchemaException(Res.Sch_EnumerationValue, typedValue.ToString(), baseUriStr, attdef.ValueLineNumber, attdef.ValueLinePosition); eventHandling.SendEvent(e, XmlSeverityType.Error); } } } } #if DEBUG catch (XmlSchemaException ex) { Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, ex.Message); #else catch (Exception) { #endif if (eventHandling != null) { XmlSchemaException e = new XmlSchemaException(Res.Sch_AttributeDefaultDataType, attdef.Name.ToString()); eventHandling.SendEvent(e, XmlSeverityType.Error); } } }
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); }
private void Output(SchemaInfo schemaInfo) { foreach (XmlSchemaElement element in this.schema.Elements.Values) { schemaInfo.TargetNamespaces[element.QualifiedName.Namespace] = true; schemaInfo.ElementDecls.Add(element.QualifiedName, element.ElementDecl); } foreach (XmlSchemaAttribute attribute in this.schema.Attributes.Values) { schemaInfo.TargetNamespaces[attribute.QualifiedName.Namespace] = true; schemaInfo.AttributeDecls.Add(attribute.QualifiedName, attribute.AttDef); } foreach (XmlSchemaType type in this.schema.SchemaTypes.Values) { schemaInfo.TargetNamespaces[type.QualifiedName.Namespace] = true; XmlSchemaComplexType type2 = type as XmlSchemaComplexType; if ((type2 == null) || (!type2.IsAbstract && (type != XmlSchemaComplexType.AnyType))) { schemaInfo.ElementDeclsByType.Add(type.QualifiedName, type.ElementDecl); } } foreach (XmlSchemaNotation notation in this.schema.Notations.Values) { schemaInfo.TargetNamespaces[notation.QualifiedName.Namespace] = true; SchemaNotation notation2 = new SchemaNotation(notation.QualifiedName) { SystemLiteral = notation.System, Pubid = notation.Public }; if (!schemaInfo.Notations.ContainsKey(notation2.Name.Name)) { schemaInfo.Notations.Add(notation2.Name.Name, notation2); } } }
public AutoValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, ValidationEventHandler eventHandler) : base(reader, schemaCollection, eventHandler) { schemaInfo = new SchemaInfo(); }
internal void RecompileSchemaSet() { if (!this.schemaSet.IsCompiled) { try { this.schemaSet.Compile(); } catch (XmlSchemaException exception) { this.SendValidationEvent(exception); } } this.compiledSchemaInfo = this.schemaSet.CompiledInfo; }
internal XmlSchema Add(string ns, SchemaInfo schemaInfo, XmlSchema schema, bool compile) { return(this.Add(ns, schemaInfo, schema, compile, this.xmlResolver)); }
private ValidationType DetectValidationType() { if ((base.reader.Schemas != null) && (base.reader.Schemas.Count > 0)) { XmlSchemaCollectionEnumerator enumerator = base.reader.Schemas.GetEnumerator(); while (enumerator.MoveNext()) { SchemaInfo schemaInfo = enumerator.CurrentNode.SchemaInfo; if (schemaInfo.SchemaType == SchemaType.XSD) { return(ValidationType.Schema); } if (schemaInfo.SchemaType == SchemaType.XDR) { return(ValidationType.XDR); } } } if (base.reader.NodeType == XmlNodeType.Element) { switch (base.SchemaNames.SchemaTypeFromRoot(base.reader.LocalName, base.reader.NamespaceURI)) { case SchemaType.XSD: return(ValidationType.Schema); case SchemaType.XDR: return(ValidationType.XDR); } int attributeCount = base.reader.AttributeCount; for (int i = 0; i < attributeCount; i++) { base.reader.MoveToAttribute(i); string namespaceURI = base.reader.NamespaceURI; string localName = base.reader.LocalName; if (Ref.Equal(namespaceURI, base.SchemaNames.NsXmlNs)) { if (XdrBuilder.IsXdrSchema(base.reader.Value)) { base.reader.MoveToElement(); return(ValidationType.XDR); } } else { if (Ref.Equal(namespaceURI, base.SchemaNames.NsXsi)) { base.reader.MoveToElement(); return(ValidationType.Schema); } if (Ref.Equal(namespaceURI, base.SchemaNames.QnDtDt.Namespace) && Ref.Equal(localName, base.SchemaNames.QnDtDt.Name)) { base.reader.SchemaTypeObject = XmlSchemaDatatype.FromXdrName(base.reader.Value); base.reader.MoveToElement(); return(ValidationType.XDR); } } } if (attributeCount > 0) { base.reader.MoveToElement(); } } return(ValidationType.Auto); }
public void StartParsing(XmlReader reader, string targetNamespace) { _reader = reader; _positionInfo = PositionInfo.GetPositionInfo(reader); _namespaceManager = reader.NamespaceManager; if (_namespaceManager == null) { _namespaceManager = new XmlNamespaceManager(_nameTable); _isProcessNamespaces = true; } else { _isProcessNamespaces = false; } while (reader.NodeType != XmlNodeType.Element && reader.Read()) { } _markupDepth = int.MaxValue; _schemaXmlDepth = reader.Depth; SchemaType rootType = _schemaNames.SchemaTypeFromRoot(reader.LocalName, reader.NamespaceURI); string code; if (!CheckSchemaRoot(rootType, out code)) { throw new XmlSchemaException(code, reader.BaseURI, _positionInfo.LineNumber, _positionInfo.LinePosition); } if (_schemaType == SchemaType.XSD) { _schema = new XmlSchema(); _schema.BaseUri = new Uri(reader.BaseURI, UriKind.RelativeOrAbsolute); _builder = new XsdBuilder(reader, _namespaceManager, _schema, _nameTable, _schemaNames, _eventHandler); } else { Debug.Assert(_schemaType == SchemaType.XDR); _xdrSchema = new SchemaInfo(); _xdrSchema.SchemaType = SchemaType.XDR; _builder = new XdrBuilder(reader, _namespaceManager, _xdrSchema, targetNamespace, _nameTable, _schemaNames, _eventHandler); ((XdrBuilder)_builder).XmlResolver = _xmlResolver; } }
public AutoValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling) : base(reader, schemaCollection, eventHandling) { schemaInfo = new SchemaInfo(); }
// // Initialization methods // private void Initialize(IDtdParserAdapter readerAdapter) { Debug.Assert(readerAdapter != null); _readerAdapter = readerAdapter; #if !SILVERLIGHT _readerAdapterWithValidation = readerAdapter as IDtdParserAdapterWithValidation; #endif _nameTable = readerAdapter.NameTable; #if !SILVERLIGHT IDtdParserAdapterWithValidation raWithValidation = readerAdapter as IDtdParserAdapterWithValidation; if (raWithValidation != null) { _validate = raWithValidation.DtdValidation; } IDtdParserAdapterV1 raV1 = readerAdapter as IDtdParserAdapterV1; if (raV1 != null) { _v1Compat = raV1.V1CompatibilityMode; _normalize = raV1.Normalization; _supportNamespaces = raV1.Namespaces; } #endif _schemaInfo = new SchemaInfo(); #if !SILVERLIGHT _schemaInfo.SchemaType = SchemaType.DTD; #endif _stringBuilder = new StringBuilder(); Uri baseUri = readerAdapter.BaseUri; if (baseUri != null) { _documentBaseUri = baseUri.ToString(); } _freeFloatingDtd = false; }
public static void CheckDefaultValue( string value, SchemaAttDef attdef, SchemaInfo sinfo, XmlNamespaceManager nsManager, XmlNameTable NameTable, object sender, ValidationEventHandler eventhandler, string baseUri, int lineNo, int linePos ) { try { XmlSchemaDatatype dtype = attdef.Datatype; if (dtype == null) { return; // no reason to check } if (dtype.TokenizedType != XmlTokenizedType.CDATA) { value = value.Trim(); } if (value.Length == 0) { return; // don't need to check } object typedValue = dtype.ParseValue(value, NameTable, nsManager); // Check special types XmlTokenizedType ttype = dtype.TokenizedType; if (ttype == XmlTokenizedType.ENTITY) { if (dtype.Variety == XmlSchemaDatatypeVariety.List) { string[] ss = (string[])typedValue; for (int i = 0; i < ss.Length; ++i) { ProcessEntity(sinfo, ss[i], sender, eventhandler, baseUri, lineNo, linePos); } } else { ProcessEntity(sinfo, (string)typedValue, sender, eventhandler, baseUri, lineNo, linePos); } } else if (ttype == XmlTokenizedType.ENUMERATION) { if (!attdef.CheckEnumeration(typedValue)) { XmlSchemaException e = new XmlSchemaException(SR.Sch_EnumerationValue, typedValue.ToString(), baseUri, lineNo, linePos); if (eventhandler != null) { eventhandler(sender, new ValidationEventArgs(e)); } else { throw e; } } } attdef.DefaultValueTyped = typedValue; } #if DEBUG catch (XmlSchemaException ex) { Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, ex.Message); #else catch { #endif XmlSchemaException e = new XmlSchemaException(SR.Sch_AttributeDefaultDataType, attdef.Name.ToString(), baseUri, lineNo, linePos); if (eventhandler != null) { eventhandler(sender, new ValidationEventArgs(e)); } else { throw e; } } }
/// <summary> /// Gets the list schema. /// </summary> /// <param name="t">The t.</param> /// <returns>schema info</returns> public static SchemaInfo GetListSchema(this Type t) { var schemaInfo = new SchemaInfo(); var classType = new XmlSchemaComplexType { Name = "ArrayOf" + t.Name }; var sequence = new XmlSchemaSequence(); schemaInfo.Schema.Items.Add(classType); classType.Particle = sequence; sequence.Items.Add(new XmlSchemaElement { Name = t.Name, MinOccurs = 0, MaxOccursString = "unbounded", SchemaTypeName = new XmlQualifiedName(t.Name) }); return schemaInfo; }
internal void Compile(XmlSchemaCollection collection, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler validationEventHandler, string targetNamespace, SchemaInfo schemaInfo, bool compileContentModel) { errorCount = 0; if (needCleanup) { schemaLocations.Clear(); Compiler.Cleanup(this); } needCleanup = true; isPreprocessed = false; isCompiled = false; if (baseUri != null) { schemaLocations.Add(baseUri, baseUri); } 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; } } } } }
/// <summary> /// Gets the enum schema. /// </summary> /// <param name="t">The t.</param> /// <returns>schema info</returns> public static SchemaInfo GetEnumSchema(this Type t) { if (!t.IsEnum) { return null; } var schemaInfo = new SchemaInfo(); var classType = new XmlSchemaSimpleType { Name = t.Name }; var attribData = t.GetCustomAttributeDataOfType(typeof(DataContractAttribute)); if (attribData.NamedArguments != null && attribData.NamedArguments.Count > 0) { foreach (var p1 in attribData.NamedArguments) { switch (p1.MemberInfo.Name) { case "Namespace": schemaInfo.Schema.TargetNamespace = p1.TypedValue.Value as string; break; } } } var content = new XmlSchemaSimpleTypeRestriction(); classType.Content = content; content.BaseTypeName = typeof(string).XmlName(); foreach (var e in t.GetEnumNames()) { content.Facets.Add(new XmlSchemaEnumerationFacet { Value = e }); } schemaInfo.Schema.Items.Add(classType); return schemaInfo; }
/// <summary> /// Gets the class schema. /// </summary> /// <param name="t">The t.</param> /// <returns>schema info</returns> public static SchemaInfo GetClassSchema(this Type t) { var schemaInfo = new SchemaInfo(); var classType = new XmlSchemaComplexType { Name = t.Name }; var attribData = t.GetCustomAttributeDataOfType(typeof(DataContractAttribute)); if (attribData.NamedArguments != null && attribData.NamedArguments.Count > 0) { foreach (var p1 in attribData.NamedArguments) { switch (p1.MemberInfo.Name) { case "Namespace": schemaInfo.Schema.TargetNamespace = p1.TypedValue.Value as string; break; } } } var sequence = new XmlSchemaSequence(); classType.Particle = sequence; var propList = t.GetProperties(); foreach (var p1 in propList) { var el = new XmlSchemaElement { Name = p1.Name, MinOccurs = 0 }; var xmlName = p1.PropertyType.XmlName(); if (xmlName != null) { el.SchemaTypeName = xmlName; } else { if (p1.PropertyType.IsListType()) { // what is this a list of? if (p1.PropertyType.FullName != null) { var pr = Primitive2Xml.XmlName(InternalType(p1.PropertyType.FullName, false)); if (pr != null) { el.SchemaTypeName = new XmlQualifiedName("ArrayOf" + pr.Name); schemaInfo.CustomTypes.Add(el.SchemaTypeName); } else { var schName = InternalType(p1.PropertyType.FullName, true); el.SchemaTypeName = new XmlQualifiedName("ArrayOf" + schName); schemaInfo.CustomTypes.Add(new XmlQualifiedName(schName)); schemaInfo.CustomTypes.Add(el.SchemaTypeName); } } } else if (p1.PropertyType.Name.Contains("Nullable")) { // what is this a nullable of? if (p1.PropertyType.FullName != null) { var pr = Primitive2Xml.XmlName(InternalType(p1.PropertyType.FullName, false)); if (pr != null) { el.SchemaTypeName = pr; } else { var schName = InternalType(p1.PropertyType.FullName, true); el.SchemaTypeName = new XmlQualifiedName(schName); schemaInfo.CustomTypes.Add(el.SchemaTypeName); } el.IsNillable = true; } } else { el.SchemaTypeName = new XmlQualifiedName(p1.PropertyType.Name); schemaInfo.CustomTypes.Add(el.SchemaTypeName); } } // get data member var attrData = p1.GetCustomAttributeDataOfType(typeof(DataMemberAttribute)); if (attrData != null && attrData.NamedArguments != null && attrData.NamedArguments.Count > 0) { foreach (var pp in attrData.NamedArguments) { switch (pp.MemberInfo.Name) { case "IsRequired": { var v = (bool)pp.TypedValue.Value; el.MinOccurs = v ? 1 : 0; } break; } } } sequence.Items.Add(el); } schemaInfo.Schema.Items.Add(classType); return schemaInfo; }
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; }