mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 03:51:19 -10:00
* XmlSchema.cs : Added internal XdtNamespace constant. don't fill schemaset compoenents here. * XmlSchemaAttribute.cs : Implemented AttributeSchemaType. * XmlSchemaElement.cs : Implemented ElementSchemaType. * XmlSchemaSimpleType.cs : Added predefined simple types * XmlSchemaType.cs : Implemented GetBuiltInSimpleType(). * XmlSchemaDatatype.cs : Allow Xdt namespaces too (not completed; quick fix for GetBuiltInSimpleType()). svn path=/trunk/mcs/; revision=31415
942 lines
44 KiB
C#
Executable File
942 lines
44 KiB
C#
Executable File
//
|
|
// System.Xml.Schema.XmlSchema.cs
|
|
//
|
|
// Author:
|
|
// Dwivedi, Ajay kumar [email protected]
|
|
// Atsushi Enomoto [email protected]
|
|
//
|
|
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
using System;
|
|
using System.Collections;
|
|
using System.Xml;
|
|
using System.IO;
|
|
using System.Xml.Serialization;
|
|
using System.ComponentModel;
|
|
|
|
namespace System.Xml.Schema
|
|
{
|
|
/// <summary>
|
|
/// Summary description for XmlSchema.
|
|
/// </summary>
|
|
[XmlRoot("schema",Namespace=XmlSchema.Namespace)]
|
|
public class XmlSchema : XmlSchemaObject
|
|
{
|
|
//public constants
|
|
public const string Namespace = "http://www.w3.org/2001/XMLSchema";
|
|
public const string InstanceNamespace = "http://www.w3.org/2001/XMLSchema-instance";
|
|
internal const string XdtNamespace = "http://www.w3.org/2003/11/xpath-datatypes";
|
|
|
|
//private fields
|
|
private XmlSchemaForm attributeFormDefault ;
|
|
private XmlSchemaObjectTable attributeGroups ;
|
|
private XmlSchemaObjectTable attributes ;
|
|
private XmlSchemaDerivationMethod blockDefault ;
|
|
private XmlSchemaForm elementFormDefault ;
|
|
private XmlSchemaObjectTable elements ;
|
|
private XmlSchemaDerivationMethod finalDefault ;
|
|
private XmlSchemaObjectTable groups ;
|
|
private string id ;
|
|
private XmlSchemaObjectCollection includes ;
|
|
private XmlSchemaObjectCollection items ;
|
|
private XmlSchemaObjectTable notations ;
|
|
private XmlSchemaObjectTable schemaTypes ;
|
|
private string targetNamespace ;
|
|
private XmlAttribute[] unhandledAttributes ;
|
|
private string version;
|
|
private string language;
|
|
|
|
// other post schema compilation infoset
|
|
private Hashtable idCollection;
|
|
private XmlSchemaObjectTable namedIdentities;
|
|
private XmlSchemaCollection schemas;
|
|
|
|
private XmlNameTable nameTable;
|
|
|
|
internal bool missedSubComponents;
|
|
|
|
// Only compilation-time use
|
|
private XmlSchemaObjectCollection compilationItems;
|
|
private Hashtable handledUris;
|
|
|
|
// Compiler specific things
|
|
const string xmlname = "schema";
|
|
|
|
public XmlSchema()
|
|
{
|
|
attributeFormDefault= XmlSchemaForm.None;
|
|
blockDefault = XmlSchemaDerivationMethod.None;
|
|
elementFormDefault = XmlSchemaForm.None;
|
|
finalDefault = XmlSchemaDerivationMethod.None;
|
|
includes = new XmlSchemaObjectCollection();
|
|
isCompiled = false;
|
|
items = new XmlSchemaObjectCollection();
|
|
attributeGroups = new XmlSchemaObjectTable();
|
|
attributes = new XmlSchemaObjectTable();
|
|
elements = new XmlSchemaObjectTable();
|
|
groups = new XmlSchemaObjectTable();
|
|
notations = new XmlSchemaObjectTable();
|
|
schemaTypes = new XmlSchemaObjectTable();
|
|
idCollection = new Hashtable ();
|
|
namedIdentities = new XmlSchemaObjectTable();
|
|
}
|
|
|
|
#region Properties
|
|
|
|
[DefaultValue(XmlSchemaForm.None)]
|
|
[System.Xml.Serialization.XmlAttribute("attributeFormDefault")]
|
|
public XmlSchemaForm AttributeFormDefault
|
|
{
|
|
get{ return attributeFormDefault; }
|
|
set{ this.attributeFormDefault = value;}
|
|
}
|
|
|
|
[DefaultValue(XmlSchemaDerivationMethod.None)]
|
|
[System.Xml.Serialization.XmlAttribute("blockDefault")]
|
|
public XmlSchemaDerivationMethod BlockDefault
|
|
{
|
|
get{ return blockDefault;}
|
|
set{ blockDefault = value;}
|
|
}
|
|
|
|
[DefaultValue(XmlSchemaDerivationMethod.None)]
|
|
[System.Xml.Serialization.XmlAttribute("finalDefault")]
|
|
public XmlSchemaDerivationMethod FinalDefault
|
|
{
|
|
get{ return finalDefault;}
|
|
set{ finalDefault = value;}
|
|
}
|
|
|
|
[DefaultValue(XmlSchemaForm.None)]
|
|
[System.Xml.Serialization.XmlAttribute("elementFormDefault")]
|
|
public XmlSchemaForm ElementFormDefault
|
|
{
|
|
get{ return elementFormDefault;}
|
|
set{ elementFormDefault = value;}
|
|
}
|
|
|
|
[System.Xml.Serialization.XmlAttribute("targetNamespace")]
|
|
public string TargetNamespace
|
|
{
|
|
get{ return targetNamespace;}
|
|
set{ targetNamespace = value;}
|
|
}
|
|
|
|
[System.Xml.Serialization.XmlAttribute("version")]
|
|
public string Version
|
|
{
|
|
get{ return version;}
|
|
set{ version = value;}
|
|
}
|
|
|
|
[XmlElement("include",typeof(XmlSchemaInclude),Namespace="http://www.w3.org/2001/XMLSchema")]
|
|
[XmlElement("import",typeof(XmlSchemaImport),Namespace="http://www.w3.org/2001/XMLSchema")]
|
|
[XmlElement("redefine",typeof(XmlSchemaRedefine),Namespace="http://www.w3.org/2001/XMLSchema")]
|
|
public XmlSchemaObjectCollection Includes
|
|
{
|
|
get{ return includes;}
|
|
}
|
|
|
|
[XmlElement("simpleType",typeof(XmlSchemaSimpleType),Namespace="http://www.w3.org/2001/XMLSchema")]
|
|
[XmlElement("complexType",typeof(XmlSchemaComplexType),Namespace="http://www.w3.org/2001/XMLSchema")]
|
|
[XmlElement("group",typeof(XmlSchemaGroup),Namespace="http://www.w3.org/2001/XMLSchema")]
|
|
//Only Schema's attributeGroup has type XmlSchemaAttributeGroup.
|
|
//Others (complextype, restrictions etc) must have XmlSchemaAttributeGroupRef
|
|
[XmlElement("attributeGroup",typeof(XmlSchemaAttributeGroup),Namespace="http://www.w3.org/2001/XMLSchema")]
|
|
[XmlElement("element",typeof(XmlSchemaElement),Namespace="http://www.w3.org/2001/XMLSchema")]
|
|
[XmlElement("attribute",typeof(XmlSchemaAttribute),Namespace="http://www.w3.org/2001/XMLSchema")]
|
|
[XmlElement("notation",typeof(XmlSchemaNotation),Namespace="http://www.w3.org/2001/XMLSchema")]
|
|
[XmlElement("annotation",typeof(XmlSchemaAnnotation),Namespace="http://www.w3.org/2001/XMLSchema")]
|
|
public XmlSchemaObjectCollection Items
|
|
{
|
|
get{ return items;}
|
|
}
|
|
|
|
[XmlIgnore]
|
|
public bool IsCompiled
|
|
{
|
|
get{ return this.CompilationId != Guid.Empty;}
|
|
}
|
|
|
|
[XmlIgnore]
|
|
public XmlSchemaObjectTable Attributes
|
|
{
|
|
get{ return attributes;}
|
|
}
|
|
|
|
[XmlIgnore]
|
|
public XmlSchemaObjectTable AttributeGroups
|
|
{
|
|
get{ return attributeGroups; }
|
|
}
|
|
|
|
[XmlIgnore]
|
|
public XmlSchemaObjectTable SchemaTypes
|
|
{
|
|
get{ return schemaTypes; }
|
|
}
|
|
|
|
[XmlIgnore]
|
|
public XmlSchemaObjectTable Elements
|
|
{
|
|
get{ return elements;}
|
|
}
|
|
|
|
[System.Xml.Serialization.XmlAttribute("id")]
|
|
public string Id
|
|
{
|
|
get{ return id;}
|
|
set{ id = value;}
|
|
}
|
|
|
|
[XmlAnyAttribute]
|
|
public XmlAttribute[] UnhandledAttributes
|
|
{
|
|
get
|
|
{
|
|
if(unhandledAttributeList != null)
|
|
{
|
|
unhandledAttributes = (XmlAttribute[]) unhandledAttributeList.ToArray(typeof(XmlAttribute));
|
|
unhandledAttributeList = null;
|
|
}
|
|
return unhandledAttributes;
|
|
}
|
|
set
|
|
{
|
|
unhandledAttributes = value;
|
|
unhandledAttributeList = null;
|
|
}
|
|
}
|
|
|
|
[XmlIgnore]
|
|
public XmlSchemaObjectTable Groups
|
|
{
|
|
get{ return groups;}
|
|
}
|
|
|
|
[XmlIgnore]
|
|
public XmlSchemaObjectTable Notations
|
|
{
|
|
get{ return notations;}
|
|
}
|
|
|
|
internal Hashtable IDCollection
|
|
{
|
|
get { return idCollection; }
|
|
}
|
|
|
|
internal XmlSchemaObjectTable NamedIdentities
|
|
{
|
|
get { return namedIdentities; }
|
|
}
|
|
|
|
internal XmlSchemaCollection Schemas
|
|
{
|
|
get { return schemas; }
|
|
}
|
|
#endregion
|
|
|
|
#region Compile
|
|
|
|
// Methods
|
|
/// <summary>
|
|
/// This compile method does two things:
|
|
/// 1. It compiles and fills the PSVI dataset
|
|
/// 2. Validates the schema by calling Validate method.
|
|
/// Every XmlSchemaObject has a Compile Method which gets called.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 1. blockDefault must be one of #all | List of (extension | restriction | substitution)
|
|
/// 2. finalDefault must be one of (#all | List of (extension | restriction| union| list))
|
|
/// 3. id must be of type ID
|
|
/// 4. targetNamespace should be any uri
|
|
/// 5. version should be a normalizedString
|
|
/// 6. xml:lang should be a language
|
|
/// </remarks>
|
|
public void Compile (ValidationEventHandler handler)
|
|
{
|
|
Compile (handler, new XmlUrlResolver ());
|
|
}
|
|
|
|
#if NET_1_0
|
|
internal void Compile (ValidationEventHandler handler, XmlResolver resolver)
|
|
#else
|
|
public void Compile (ValidationEventHandler handler, XmlResolver resolver)
|
|
#endif
|
|
{
|
|
Compile (handler, new Stack (), this, null, resolver);
|
|
isCompiled = true;
|
|
}
|
|
|
|
internal void Compile (ValidationEventHandler handler, XmlSchemaCollection col, XmlResolver resolver)
|
|
{
|
|
Compile (handler, new Stack (), this, col, resolver);
|
|
}
|
|
|
|
private void Compile (ValidationEventHandler handler, Stack schemaLocationStack, XmlSchema rootSchema, XmlSchemaCollection col, XmlResolver resolver)
|
|
{
|
|
if (rootSchema != this) {
|
|
CompilationId = rootSchema.CompilationId;
|
|
schemas = rootSchema.schemas;
|
|
}
|
|
else {
|
|
schemas = col;
|
|
if (schemas == null) {
|
|
schemas = new XmlSchemaCollection ();
|
|
schemas.SchemaSet.CompilationId = Guid.NewGuid ();
|
|
}
|
|
CompilationId = schemas.SchemaSet.CompilationId;
|
|
this.idCollection.Clear ();
|
|
}
|
|
schemas.Add (this);
|
|
|
|
attributeGroups.Clear ();
|
|
attributes.Clear ();
|
|
elements.Clear ();
|
|
groups.Clear ();
|
|
notations.Clear ();
|
|
schemaTypes.Clear ();
|
|
|
|
//1. Union and List are not allowed in block default
|
|
if(BlockDefault != XmlSchemaDerivationMethod.All)
|
|
{
|
|
if((BlockDefault & XmlSchemaDerivationMethod.List)!=0 )
|
|
error(handler, "list is not allowed in blockDefault attribute");
|
|
if((BlockDefault & XmlSchemaDerivationMethod.Union)!=0 )
|
|
error(handler, "union is not allowed in blockDefault attribute");
|
|
}
|
|
|
|
//2. Substitution is not allowed in finaldefault.
|
|
if(FinalDefault != XmlSchemaDerivationMethod.All)
|
|
{
|
|
if((FinalDefault & XmlSchemaDerivationMethod.Substitution)!=0 )
|
|
error(handler, "substitution is not allowed in finalDefault attribute");
|
|
}
|
|
|
|
//3. id must be of type ID
|
|
XmlSchemaUtil.CompileID(Id, this, this.IDCollection, handler);
|
|
|
|
//4. targetNamespace should be of type anyURI or absent
|
|
if(TargetNamespace != null)
|
|
{
|
|
if(!XmlSchemaUtil.CheckAnyUri(TargetNamespace))
|
|
error(handler, TargetNamespace+" is not a valid value for targetNamespace attribute of schema");
|
|
}
|
|
|
|
//5. version should be of type normalizedString
|
|
if(!XmlSchemaUtil.CheckNormalizedString(Version))
|
|
error(handler, Version + "is not a valid value for version attribute of schema");
|
|
|
|
//6. xml:lang must be a language
|
|
// if(!XmlSchemaUtil.CheckLanguage(Language))
|
|
// error(handler, Language + " is not a valid language");
|
|
|
|
// Compile the content of this schema
|
|
|
|
compilationItems = new XmlSchemaObjectCollection ();
|
|
for (int i = 0; i < Items.Count; i++)
|
|
compilationItems.Add (Items [i]);
|
|
if (this == rootSchema)
|
|
handledUris = new Hashtable ();
|
|
|
|
// First, we run into inclusion schemas to collect
|
|
// compilation target items into compiledItems.
|
|
for (int i = 0; i < Includes.Count; i++) {
|
|
XmlSchemaExternal ext = Includes [i] as XmlSchemaExternal;
|
|
if (ext != null) {
|
|
if (ext.SchemaLocation == null)
|
|
continue;
|
|
Stream stream = null;
|
|
string url = null;
|
|
if (resolver != null) {
|
|
url = GetResolvedUri (resolver, ext.SchemaLocation);
|
|
if (schemaLocationStack.Contains (url)) {
|
|
error(handler, "Nested inclusion was found: " + url);
|
|
// must skip this inclusion
|
|
continue;
|
|
}
|
|
if (rootSchema.handledUris.Contains (url))
|
|
// This schema is already handled, so simply skip (otherwise, duplicate definition errrors occur.
|
|
continue;
|
|
rootSchema.handledUris.Add (url, url);
|
|
try {
|
|
stream = resolver.GetEntity (new Uri (url), null, typeof (Stream)) as Stream;
|
|
} catch (Exception) {
|
|
// LAMESPEC: This is not good way to handle errors, but since we cannot know what kind of XmlResolver will come, so there are no mean to avoid this ugly catch.
|
|
warn (handler, "Could not resolve schema location URI: " + url);
|
|
stream = null;
|
|
}
|
|
}
|
|
|
|
// Process redefinition children in advance.
|
|
XmlSchemaRedefine redefine = Includes [i] as XmlSchemaRedefine;
|
|
if (redefine != null) {
|
|
for (int j = 0; j < redefine.Items.Count; j++) {
|
|
XmlSchemaObject redefinedObj = redefine.Items [j];
|
|
redefinedObj.isRedefinedComponent = true;
|
|
redefinedObj.isRedefineChild = true;
|
|
if (redefinedObj is XmlSchemaType ||
|
|
redefinedObj is XmlSchemaGroup ||
|
|
redefinedObj is XmlSchemaAttributeGroup)
|
|
compilationItems.Add (redefinedObj);
|
|
else
|
|
error (handler, "Redefinition is only allowed to simpleType, complexType, group and attributeGroup.");
|
|
}
|
|
}
|
|
|
|
XmlSchema includedSchema = null;
|
|
if (stream == null) {
|
|
// It is missing schema components.
|
|
missedSubComponents = true;
|
|
continue;
|
|
} else {
|
|
schemaLocationStack.Push (url);
|
|
XmlTextReader xtr = null;
|
|
try {
|
|
xtr = new XmlTextReader (url, stream, nameTable);
|
|
includedSchema = XmlSchema.Read (xtr, handler);
|
|
} finally {
|
|
if (xtr != null)
|
|
xtr.Close ();
|
|
}
|
|
includedSchema.schemas = schemas;
|
|
}
|
|
|
|
// Set - actual - target namespace for the included schema * before compilation*.
|
|
XmlSchemaImport import = ext as XmlSchemaImport;
|
|
if (import != null) {
|
|
if (TargetNamespace == includedSchema.TargetNamespace) {
|
|
error (handler, "Target namespace must be different from that of included schema.");
|
|
continue;
|
|
} else if (includedSchema.TargetNamespace != import.Namespace) {
|
|
error (handler, "Attribute namespace and its importing schema's target namespace must be the same.");
|
|
continue;
|
|
}
|
|
} else {
|
|
if (TargetNamespace == null &&
|
|
includedSchema.TargetNamespace != null) {
|
|
error (handler, "Target namespace is required to include a schema which has its own target namespace");
|
|
continue;
|
|
}
|
|
else if (TargetNamespace != null &&
|
|
includedSchema.TargetNamespace == null)
|
|
includedSchema.TargetNamespace = TargetNamespace;
|
|
}
|
|
|
|
// Compile included schema.
|
|
includedSchema.idCollection = this.IDCollection;
|
|
includedSchema.Compile (handler, schemaLocationStack, rootSchema, col, resolver);
|
|
schemaLocationStack.Pop ();
|
|
|
|
if (import != null)
|
|
rootSchema.schemas.Add (includedSchema);
|
|
|
|
// Note that we use compiled items. Items
|
|
// may not exist in Items, since included
|
|
// schema also includes another schemas.
|
|
foreach (DictionaryEntry entry in includedSchema.Attributes)
|
|
compilationItems.Add ((XmlSchemaObject) entry.Value);
|
|
foreach (DictionaryEntry entry in includedSchema.Elements)
|
|
compilationItems.Add ((XmlSchemaObject) entry.Value);
|
|
foreach (DictionaryEntry entry in includedSchema.SchemaTypes)
|
|
compilationItems.Add ((XmlSchemaObject) entry.Value);
|
|
foreach (DictionaryEntry entry in includedSchema.AttributeGroups)
|
|
compilationItems.Add ((XmlSchemaObject) entry.Value);
|
|
foreach (DictionaryEntry entry in includedSchema.Groups)
|
|
compilationItems.Add ((XmlSchemaObject) entry.Value);
|
|
foreach (DictionaryEntry entry in includedSchema.Notations)
|
|
compilationItems.Add ((XmlSchemaObject) entry.Value);
|
|
}
|
|
else
|
|
{
|
|
error(handler,"Object of Type "+Includes [i].GetType().Name+" is not valid in Includes Property of XmlSchema");
|
|
}
|
|
}
|
|
|
|
// Compilation phase.
|
|
// At least each Compile() must gives unique (qualified) name for each component.
|
|
// It also checks self-resolvable properties correct.
|
|
// Post compilation schema information contribution is not required here.
|
|
// It should be done by Validate().
|
|
for (int i = 0; i < compilationItems.Count; i++) {
|
|
XmlSchemaObject obj = compilationItems [i];
|
|
if(obj is XmlSchemaAnnotation)
|
|
{
|
|
int numerr = ((XmlSchemaAnnotation)obj).Compile(handler, this);
|
|
errorCount += numerr;
|
|
}
|
|
else if(obj is XmlSchemaAttribute)
|
|
{
|
|
XmlSchemaAttribute attr = (XmlSchemaAttribute) obj;
|
|
attr.ParentIsSchema = true;
|
|
int numerr = attr.Compile(handler, this);
|
|
errorCount += numerr;
|
|
if(numerr == 0)
|
|
{
|
|
// if (!attr.IsComplied (this.CompilationId))
|
|
// schemas.SchemaSet.GlobalAttributes.Add (attr.QualifiedName, attr);
|
|
XmlSchemaUtil.AddToTable (Attributes, attr, attr.QualifiedName, handler);
|
|
}
|
|
}
|
|
else if(obj is XmlSchemaAttributeGroup)
|
|
{
|
|
XmlSchemaAttributeGroup attrgrp = (XmlSchemaAttributeGroup) obj;
|
|
int numerr = attrgrp.Compile(handler, this);
|
|
errorCount += numerr;
|
|
if(numerr == 0)
|
|
{
|
|
XmlSchemaUtil.AddToTable (AttributeGroups, attrgrp, attrgrp.QualifiedName, handler);
|
|
}
|
|
}
|
|
else if(obj is XmlSchemaComplexType)
|
|
{
|
|
XmlSchemaComplexType ctype = (XmlSchemaComplexType) obj;
|
|
ctype.ParentIsSchema = true;
|
|
int numerr = ctype.Compile(handler, this);
|
|
errorCount += numerr;
|
|
if(numerr == 0)
|
|
{
|
|
// if (!ctype.IsComplied (this.CompilationId))
|
|
// schemas.SchemaSet.GlobalTypes.Add (ctype.QualifiedName, ctype);
|
|
XmlSchemaUtil.AddToTable (schemaTypes, ctype, ctype.QualifiedName, handler);
|
|
}
|
|
}
|
|
else if(obj is XmlSchemaSimpleType)
|
|
{
|
|
XmlSchemaSimpleType stype = (XmlSchemaSimpleType) obj;
|
|
stype.islocal = false; //This simple type is toplevel
|
|
int numerr = stype.Compile(handler, this);
|
|
errorCount += numerr;
|
|
if(numerr == 0)
|
|
{
|
|
// if (!stype.IsComplied (this.CompilationId))
|
|
// schemas.SchemaSet.GlobalTypes.Add (stype.QualifiedName, stype);
|
|
XmlSchemaUtil.AddToTable (SchemaTypes, stype, stype.QualifiedName, handler);
|
|
}
|
|
}
|
|
else if(obj is XmlSchemaElement)
|
|
{
|
|
XmlSchemaElement elem = (XmlSchemaElement) obj;
|
|
elem.parentIsSchema = true;
|
|
int numerr = elem.Compile(handler, this);
|
|
errorCount += numerr;
|
|
if(numerr == 0)
|
|
{
|
|
// if (!elem.IsComplied (this.CompilationId))
|
|
// schemas.SchemaSet.GlobalElements.Add (elem.QualifiedName, elem);
|
|
XmlSchemaUtil.AddToTable (Elements, elem, elem.QualifiedName, handler);
|
|
}
|
|
}
|
|
else if(obj is XmlSchemaGroup)
|
|
{
|
|
XmlSchemaGroup grp = (XmlSchemaGroup) obj;
|
|
int numerr = grp.Compile(handler, this);
|
|
errorCount += numerr;
|
|
if(numerr == 0)
|
|
{
|
|
XmlSchemaUtil.AddToTable (Groups, grp, grp.QualifiedName, handler);
|
|
}
|
|
}
|
|
else if(obj is XmlSchemaNotation)
|
|
{
|
|
XmlSchemaNotation ntn = (XmlSchemaNotation) obj;
|
|
int numerr = ntn.Compile(handler, this);
|
|
errorCount += numerr;
|
|
if(numerr == 0)
|
|
{
|
|
XmlSchemaUtil.AddToTable (Notations, ntn, ntn.QualifiedName, handler);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ValidationHandler.RaiseValidationEvent (
|
|
handler, null,
|
|
"Object of Type "+obj.GetType().Name+" is not valid in Item Property of Schema",
|
|
null, this, null, XmlSeverityType.Error);
|
|
}
|
|
}
|
|
|
|
if (rootSchema == this)
|
|
Validate(handler);
|
|
}
|
|
|
|
private string GetResolvedUri (XmlResolver resolver, string relativeUri)
|
|
{
|
|
Uri baseUri = null;
|
|
if (this.SourceUri != null && this.SourceUri != String.Empty)
|
|
baseUri = new Uri (this.SourceUri);
|
|
return resolver.ResolveUri (baseUri, relativeUri).ToString ();
|
|
}
|
|
|
|
internal bool IsNamespaceAbsent (string ns)
|
|
{
|
|
return this.schemas [ns] == null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
private void Validate(ValidationEventHandler handler)
|
|
{
|
|
ValidationId = CompilationId;
|
|
|
|
// Firstly Element needs to be filled their substitution group info
|
|
foreach(XmlSchemaElement elem in Elements.Values)
|
|
elem.FillSubstitutionElementInfo ();
|
|
|
|
// Validate
|
|
foreach(XmlSchemaAttribute attr in Attributes.Values)
|
|
{
|
|
errorCount += attr.Validate(handler, this);
|
|
}
|
|
foreach(XmlSchemaAttributeGroup attrgrp in AttributeGroups.Values)
|
|
{
|
|
errorCount += attrgrp.Validate(handler, this);
|
|
}
|
|
foreach(XmlSchemaType type in SchemaTypes.Values)
|
|
{
|
|
errorCount += type.Validate(handler, this);
|
|
}
|
|
foreach(XmlSchemaElement elem in Elements.Values)
|
|
{
|
|
errorCount += elem.Validate(handler, this);
|
|
}
|
|
foreach(XmlSchemaGroup grp in Groups.Values)
|
|
{
|
|
errorCount += grp.Validate(handler, this);
|
|
}
|
|
foreach(XmlSchemaNotation ntn in Notations.Values)
|
|
{
|
|
errorCount += ntn.Validate(handler, this);
|
|
}
|
|
}
|
|
|
|
#region Read
|
|
|
|
// We cannot use xml deserialization, since it does not provide line info, qname context, and so on.
|
|
public static XmlSchema Read (TextReader reader, ValidationEventHandler validationEventHandler)
|
|
{
|
|
return Read (new XmlTextReader (reader),validationEventHandler);
|
|
}
|
|
public static XmlSchema Read (Stream stream, ValidationEventHandler validationEventHandler)
|
|
{
|
|
return Read (new XmlTextReader (stream),validationEventHandler);
|
|
}
|
|
|
|
public static XmlSchema Read (XmlReader rdr, ValidationEventHandler validationEventHandler)
|
|
{
|
|
XmlSchemaReader reader = new XmlSchemaReader (rdr, validationEventHandler);
|
|
|
|
if (reader.ReadState == ReadState.Initial)
|
|
reader.ReadNextElement ();
|
|
|
|
int startDepth = reader.Depth;
|
|
|
|
do
|
|
{
|
|
switch(reader.NodeType)
|
|
{
|
|
case XmlNodeType.Element:
|
|
if(reader.LocalName == "schema")
|
|
{
|
|
XmlSchema schema = new XmlSchema ();
|
|
schema.nameTable = rdr.NameTable;
|
|
|
|
schema.LineNumber = reader.LineNumber;
|
|
schema.LinePosition = reader.LinePosition;
|
|
schema.SourceUri = reader.BaseURI;
|
|
|
|
ReadAttributes(schema, reader, validationEventHandler);
|
|
//IsEmptyElement does not behave properly if reader is
|
|
//positioned at an attribute.
|
|
reader.MoveToElement();
|
|
if(!reader.IsEmptyElement)
|
|
{
|
|
ReadContent(schema, reader, validationEventHandler);
|
|
}
|
|
else
|
|
rdr.Skip ();
|
|
|
|
if (rdr.NodeType == XmlNodeType.EndElement)
|
|
rdr.Read ();
|
|
return schema;
|
|
}
|
|
else
|
|
//Schema can't be generated. Throw an exception
|
|
error (validationEventHandler, "The root element must be schema", null);
|
|
break;
|
|
default:
|
|
error(validationEventHandler, "This should never happen. XmlSchema.Read 1 ",null);
|
|
break;
|
|
}
|
|
} while(reader.Depth > startDepth && reader.ReadNextElement());
|
|
|
|
// This is thrown regardless of ValidationEventHandler existence.
|
|
throw new XmlSchemaException ("The top level schema must have namespace " + XmlSchema.Namespace, null);
|
|
}
|
|
|
|
private static void ReadAttributes(XmlSchema schema, XmlSchemaReader reader, ValidationEventHandler h)
|
|
{
|
|
Exception ex;
|
|
|
|
reader.MoveToElement();
|
|
while(reader.MoveToNextAttribute())
|
|
{
|
|
switch(reader.Name)
|
|
{
|
|
case "attributeFormDefault" :
|
|
schema.attributeFormDefault = XmlSchemaUtil.ReadFormAttribute(reader,out ex);
|
|
if(ex != null)
|
|
error(h, reader.Value + " is not a valid value for attributeFormDefault.", ex);
|
|
break;
|
|
case "blockDefault" :
|
|
schema.blockDefault = XmlSchemaUtil.ReadDerivationAttribute(reader,out ex, "blockDefault",
|
|
XmlSchemaUtil.ElementBlockAllowed);
|
|
if(ex != null)
|
|
error (h, ex.Message, ex);
|
|
break;
|
|
case "elementFormDefault":
|
|
schema.elementFormDefault = XmlSchemaUtil.ReadFormAttribute(reader, out ex);
|
|
if(ex != null)
|
|
error(h, reader.Value + " is not a valid value for elementFormDefault.", ex);
|
|
break;
|
|
case "finalDefault":
|
|
schema.finalDefault = XmlSchemaUtil.ReadDerivationAttribute(reader, out ex, "finalDefault",
|
|
XmlSchemaUtil.FinalAllowed);
|
|
if(ex != null)
|
|
error (h, ex.Message , ex);
|
|
break;
|
|
case "id":
|
|
schema.id = reader.Value;
|
|
break;
|
|
case "targetNamespace":
|
|
schema.targetNamespace = reader.Value;
|
|
break;
|
|
case "version":
|
|
schema.version = reader.Value;
|
|
break;
|
|
case "xml:lang":
|
|
schema.language = reader.Value;
|
|
break;
|
|
default:
|
|
if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
|
|
error(h, reader.Name + " attribute is not allowed in schema element",null);
|
|
else
|
|
{
|
|
XmlSchemaUtil.ReadUnhandledAttribute(reader,schema);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void ReadContent(XmlSchema schema, XmlSchemaReader reader, ValidationEventHandler h)
|
|
{
|
|
reader.MoveToElement();
|
|
if(reader.LocalName != "schema" && reader.NamespaceURI != XmlSchema.Namespace && reader.NodeType != XmlNodeType.Element)
|
|
error(h, "UNREACHABLE CODE REACHED: Method: Schema.ReadContent, " + reader.LocalName + ", " + reader.NamespaceURI,null);
|
|
|
|
//(include | import | redefine | annotation)*,
|
|
//((simpleType | complexType | group | attributeGroup | element | attribute | notation | annotation)*
|
|
int level = 1;
|
|
while(reader.ReadNextElement())
|
|
{
|
|
if(reader.NodeType == XmlNodeType.EndElement)
|
|
{
|
|
if(reader.LocalName != xmlname)
|
|
error(h,"Should not happen :2: XmlSchema.Read, name="+reader.Name,null);
|
|
break;
|
|
}
|
|
if(level <= 1)
|
|
{
|
|
if(reader.LocalName == "include")
|
|
{
|
|
XmlSchemaInclude include = XmlSchemaInclude.Read(reader,h);
|
|
if(include != null)
|
|
schema.includes.Add(include);
|
|
continue;
|
|
}
|
|
if(reader.LocalName == "import")
|
|
{
|
|
XmlSchemaImport import = XmlSchemaImport.Read(reader,h);
|
|
if(import != null)
|
|
schema.includes.Add(import);
|
|
continue;
|
|
}
|
|
if(reader.LocalName == "redefine")
|
|
{
|
|
XmlSchemaRedefine redefine = XmlSchemaRedefine.Read(reader,h);
|
|
if(redefine != null)
|
|
schema.includes.Add(redefine);
|
|
continue;
|
|
}
|
|
if(reader.LocalName == "annotation")
|
|
{
|
|
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
|
|
if(annotation != null)
|
|
schema.items.Add(annotation);
|
|
continue;
|
|
}
|
|
}
|
|
if(level <=2)
|
|
{
|
|
level = 2;
|
|
if(reader.LocalName == "simpleType")
|
|
{
|
|
XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader,h);
|
|
if(stype != null)
|
|
schema.items.Add(stype);
|
|
continue;
|
|
}
|
|
if(reader.LocalName == "complexType")
|
|
{
|
|
XmlSchemaComplexType ctype = XmlSchemaComplexType.Read(reader,h);
|
|
if(ctype != null)
|
|
schema.items.Add(ctype);
|
|
continue;
|
|
}
|
|
if(reader.LocalName == "group")
|
|
{
|
|
XmlSchemaGroup group = XmlSchemaGroup.Read(reader,h);
|
|
if(group != null)
|
|
schema.items.Add(group);
|
|
continue;
|
|
}
|
|
if(reader.LocalName == "attributeGroup")
|
|
{
|
|
XmlSchemaAttributeGroup attributeGroup = XmlSchemaAttributeGroup.Read(reader,h);
|
|
if(attributeGroup != null)
|
|
schema.items.Add(attributeGroup);
|
|
continue;
|
|
}
|
|
if(reader.LocalName == "element")
|
|
{
|
|
XmlSchemaElement element = XmlSchemaElement.Read(reader,h);
|
|
if(element != null)
|
|
schema.items.Add(element);
|
|
continue;
|
|
}
|
|
if(reader.LocalName == "attribute")
|
|
{
|
|
XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader,h);
|
|
if(attr != null)
|
|
schema.items.Add(attr);
|
|
continue;
|
|
}
|
|
if(reader.LocalName == "notation")
|
|
{
|
|
XmlSchemaNotation notation = XmlSchemaNotation.Read(reader,h);
|
|
if(notation != null)
|
|
schema.items.Add(notation);
|
|
continue;
|
|
}
|
|
if(reader.LocalName == "annotation")
|
|
{
|
|
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
|
|
if(annotation != null)
|
|
schema.items.Add(annotation);
|
|
continue;
|
|
}
|
|
}
|
|
reader.RaiseInvalidElementError();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region write
|
|
|
|
public void Write(System.IO.Stream stream)
|
|
{
|
|
Write(stream,null);
|
|
}
|
|
public void Write(System.IO.TextWriter writer)
|
|
{
|
|
Write(writer,null);
|
|
}
|
|
public void Write(System.Xml.XmlWriter writer)
|
|
{
|
|
Write(writer,null);
|
|
}
|
|
public void Write(System.IO.Stream stream, System.Xml.XmlNamespaceManager namespaceManager)
|
|
{
|
|
Write(new XmlTextWriter(stream,null),namespaceManager);
|
|
}
|
|
public void Write(System.IO.TextWriter writer, System.Xml.XmlNamespaceManager namespaceManager)
|
|
{
|
|
XmlTextWriter xwriter = new XmlTextWriter(writer);
|
|
xwriter.Formatting = Formatting.Indented;
|
|
Write(xwriter,namespaceManager);
|
|
}
|
|
|
|
public void Write (System.Xml.XmlWriter writer, System.Xml.XmlNamespaceManager namespaceManager)
|
|
{
|
|
XmlSerializerNamespaces nss = new XmlSerializerNamespaces ();
|
|
|
|
if (namespaceManager != null) {
|
|
if (nss == null)
|
|
nss = new XmlSerializerNamespaces ();
|
|
foreach (string name in namespaceManager) {
|
|
//xml and xmlns namespaces are added by default in namespaceManager.
|
|
//So we should ignore them
|
|
if (name !="xml" && name != "xmlns")
|
|
nss.Add (name, namespaceManager.LookupNamespace (name));
|
|
}
|
|
}
|
|
|
|
if (Namespaces != null && Namespaces.Count > 0) {
|
|
nss.Add (String.Empty, XmlSchema.Namespace);
|
|
foreach (XmlQualifiedName qn in Namespaces.ToArray ()) {
|
|
nss.Add (qn.Name, qn.Namespace);
|
|
}
|
|
}
|
|
|
|
if (nss.Count == 0) {
|
|
// Add the xml schema namespace. (It is done
|
|
// only when no entry exists in Namespaces).
|
|
nss.Add ("xs", XmlSchema.Namespace);
|
|
if (TargetNamespace != null)
|
|
nss.Add ("tns", TargetNamespace);
|
|
}
|
|
|
|
// XmlSerializer xser = new XmlSerializer (typeof (XmlSchema));
|
|
// xser.Serialize (writer, this, nss);
|
|
XmlSchemaSerializer xser = new XmlSchemaSerializer ();
|
|
xser.Serialize (writer, this, nss);
|
|
writer.Flush();
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
class XmlSchemaSerializer : XmlSerializer
|
|
{
|
|
protected override void Serialize (object o, XmlSerializationWriter writer)
|
|
{
|
|
XmlSchemaSerializationWriter w = writer as XmlSchemaSerializationWriter;
|
|
w.WriteRoot_XmlSchema ((XmlSchema) o);
|
|
}
|
|
|
|
protected override XmlSerializationWriter CreateWriter ()
|
|
{
|
|
return new XmlSchemaSerializationWriter ();
|
|
}
|
|
}
|
|
}
|