//<documentation
// source = anyURI
// xml:lang = language>
// Content: ({any})*
//</documentation>
internal static XmlSchemaDocumentation Read(XmlSchemaReader reader, ValidationEventHandler h, out bool skip)
{
skip = false;
XmlSchemaDocumentation doc = new XmlSchemaDocumentation();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != "documentation")
{
error(h,"Should not happen :1: XmlSchemaDocumentation.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
doc.LineNumber = reader.LineNumber;
doc.LinePosition = reader.LinePosition;
doc.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "source")
{
doc.source = reader.Value;
}
else if(reader.Name == "xml:lang")
{
doc.language = reader.Value;
}
else
{
error(h,reader.Name + " is not a valid attribute for documentation",null);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement) {
doc.Markup = new XmlNode[0];
return doc;
}
//Content {any}*
XmlDocument xmldoc = new XmlDocument();
xmldoc.AppendChild(xmldoc.ReadNode(reader));
XmlNode root = xmldoc.FirstChild;
if(root != null && root.ChildNodes != null)
{
doc.Markup = new XmlNode[root.ChildNodes.Count];
for(int i=0;i<root.ChildNodes.Count;i++)
{
doc.Markup[i] = root.ChildNodes[i];
}
}
if(reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.EndElement)
skip = true;
return doc;
}
//<appinfo
// source = anyURI>
// Content: ({any})*
//</appinfo>
internal static XmlSchemaAppInfo Read(XmlSchemaReader reader, ValidationEventHandler h, out bool skip)
{
skip = false;
XmlSchemaAppInfo appinfo = new XmlSchemaAppInfo();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != "appinfo")
{
error(h,"Should not happen :1: XmlSchemaAppInfo.Read, name="+reader.Name,null);
reader.SkipToEnd();
return null;
}
appinfo.LineNumber = reader.LineNumber;
appinfo.LinePosition = reader.LinePosition;
appinfo.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "source")
{
appinfo.source = reader.Value;
}
else
{
error(h,reader.Name + " is not a valid attribute for appinfo",null);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement) {
appinfo.Markup = new XmlNode [0];
return appinfo;
}
//Content {any}*
//FIXME: This is a pure Quick Hack; There must be a another method;
XmlDocument xmldoc = new XmlDocument();
xmldoc.AppendChild(xmldoc.ReadNode(reader));
XmlNode root = xmldoc.FirstChild;
if(root != null && root.ChildNodes != null)
{
appinfo.Markup = new XmlNode[root.ChildNodes.Count];
for(int i=0;i<root.ChildNodes.Count;i++)
{
appinfo.Markup[i] = root.ChildNodes[i];
}
}
if(reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.EndElement)
skip = true;
return appinfo;
}
//<anyAttribute
// id = ID
// namespace = ((##any | ##other) | List of (anyURI | (##targetNamespace | ##local)) ) : ##any
// processContents = (lax | skip | strict) : strict
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</anyAttribute>
internal static XmlSchemaAnyAttribute Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAnyAttribute any = new XmlSchemaAnyAttribute();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaAnyAttribute.Read, name="+reader.Name,null);
reader.SkipToEnd();
return null;
}
any.LineNumber = reader.LineNumber;
any.LinePosition = reader.LinePosition;
any.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
any.Id = reader.Value;
}
else if(reader.Name == "namespace")
{
any.nameSpace = reader.Value;
}
else if(reader.Name == "processContents")
{
Exception innerex;
any.processing = XmlSchemaUtil.ReadProcessingAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for processContents",innerex);
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for anyAttribute",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,any);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return any;
// Content: (annotation?)
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaAnyAttribute.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
any.Annotation = annotation;
continue;
}
reader.RaiseInvalidElementError();
}
return any;
}
//<redefine
// id = ID
// schemaLocation = anyURI
// {any attributes with non-schema namespace . . .}>
// Content: (annotation | (simpleType | complexType | group | attributeGroup))*
//</redefine>
internal static XmlSchemaRedefine Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaRedefine redefine = new XmlSchemaRedefine();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaRedefine.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
redefine.LineNumber = reader.LineNumber;
redefine.LinePosition = reader.LinePosition;
redefine.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
redefine.Id = reader.Value;
}
else if(reader.Name == "schemaLocation")
{
redefine.SchemaLocation = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for redefine",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,redefine);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return redefine;
//(annotation | (simpleType | complexType | group | attributeGroup))*
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaRedefine.Read, name="+reader.Name,null);
break;
}
if(reader.LocalName == "annotation")
{
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
redefine.items.Add(annotation);
continue;
}
if(reader.LocalName == "simpleType")
{
XmlSchemaSimpleType simpleType = XmlSchemaSimpleType.Read(reader,h);
if(simpleType != null)
redefine.items.Add(simpleType);
continue;
}
if(reader.LocalName == "complexType")
{
XmlSchemaComplexType complexType = XmlSchemaComplexType.Read(reader,h);
if(complexType != null)
redefine.items.Add(complexType);
continue;
}
if(reader.LocalName == "group")
{
XmlSchemaGroup group = XmlSchemaGroup.Read(reader,h);
if(group != null)
redefine.items.Add(group);
continue;
}
if(reader.LocalName == "attributeGroup")
{
XmlSchemaAttributeGroup attributeGroup = XmlSchemaAttributeGroup.Read(reader,h);
if(attributeGroup != null)
redefine.items.Add(attributeGroup);
continue;
}
reader.RaiseInvalidElementError();
}
return redefine;
}
// <group
// id = ID
// ref = QName
// minOccurs = ? : 1
// maxOccurs = ? : 1>
// Content: (annotation?)
// </group>
internal static XmlSchemaGroupRef Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaGroupRef groupref = new XmlSchemaGroupRef();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaGroup.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
groupref.LineNumber = reader.LineNumber;
groupref.LinePosition = reader.LinePosition;
groupref.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
groupref.Id = reader.Value;
}
else if(reader.Name == "ref")
{
Exception innerex;
groupref.refName = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for ref attribute",innerex);
}
else if(reader.Name == "maxOccurs")
{
try
{
groupref.MaxOccursString = reader.Value;
}
catch(Exception e)
{
error(h,reader.Value + " is an invalid value for maxOccurs",e);
}
}
else if(reader.Name == "minOccurs")
{
try
{
groupref.MinOccursString = reader.Value;
}
catch(Exception e)
{
error(h,reader.Value + " is an invalid value for minOccurs", e);
}
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for group",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,groupref);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return groupref;
// Content: (annotation?)
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaGroupRef.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
groupref.Annotation = annotation;
continue;
}
reader.RaiseInvalidElementError();
}
return groupref;
}
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 ();
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);
}
//<attributeGroup
// id = ID
// ref = QName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</attributeGroup>
internal static XmlSchemaAttributeGroupRef Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAttributeGroupRef attrgrp = new XmlSchemaAttributeGroupRef();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaAttributeGroupRef.Read, name="+reader.Name,null);
reader.SkipToEnd();
return null;
}
attrgrp.LineNumber = reader.LineNumber;
attrgrp.LinePosition = reader.LinePosition;
attrgrp.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
attrgrp.Id = reader.Value;
}
else if(reader.Name == "ref")
{
Exception innerex;
attrgrp.refName = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for ref attribute",innerex);
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for attributeGroup in this context",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,attrgrp);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return attrgrp;
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaAttributeGroupRef.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
attrgrp.Annotation = annotation;
continue;
}
reader.RaiseInvalidElementError();
}
return attrgrp;
}
//<attributeGroup
// id = ID
// name = NCName
// ref = QName // Not present in this class.
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, ((attribute | attributeGroup)*, anyAttribute?))
//</attributeGroup>
internal static XmlSchemaAttributeGroup Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAttributeGroup attrgrp = new XmlSchemaAttributeGroup();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaAttributeGroup.Read, name="+reader.Name,null);
reader.SkipToEnd();
return null;
}
attrgrp.LineNumber = reader.LineNumber;
attrgrp.LinePosition = reader.LinePosition;
attrgrp.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
attrgrp.Id = reader.Value;
}
else if(reader.Name == "name")
{
attrgrp.name = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for attributeGroup in this context",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,attrgrp);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return attrgrp;
//Content: 1.annotation?, 2.(attribute | attributeGroup)*, 3.anyAttribute?
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaAttributeGroup.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
attrgrp.Annotation = annotation;
continue;
}
if(level <= 2)
{
if(reader.LocalName == "attribute")
{
level = 2;
XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader,h);
if(attr != null)
attrgrp.Attributes.Add(attr);
continue;
}
if(reader.LocalName == "attributeGroup")
{
level = 2;
XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader,h);
if(attr != null)
attrgrp.attributes.Add(attr);
continue;
}
}
if(level <= 3 && reader.LocalName == "anyAttribute")
{
level = 4;
XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader,h);
if(anyattr != null)
attrgrp.AnyAttribute = anyattr;
continue;
}
reader.RaiseInvalidElementError();
}
return attrgrp;
}
//<element
// abstract = boolean : false
// block = (#all | List of (extension | restriction | substitution))
// default = string
// final = (#all | List of (extension | restriction))
// fixed = string
// form = (qualified | unqualified)
// id = ID
// maxOccurs = (nonNegativeInteger | unbounded) : 1
// minOccurs = nonNegativeInteger : 1
// name = NCName
// nillable = boolean : false
// ref = QName
// substitutionGroup = QName
// type = QName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, ((simpleType | complexType)?, (unique | key | keyref)*))
//</element>
internal static XmlSchemaElement Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaElement element = new XmlSchemaElement();
Exception innerex;
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaElement.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
element.LineNumber = reader.LineNumber;
element.LinePosition = reader.LinePosition;
element.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "abstract")
{
element.IsAbstract = XmlSchemaUtil.ReadBoolAttribute(reader,out innerex);
if(innerex != null)
error(h,reader.Value + " is invalid value for abstract",innerex);
}
else if(reader.Name == "block")
{
element.block = XmlSchemaUtil.ReadDerivationAttribute(reader,out innerex, "block",
XmlSchemaUtil.ElementBlockAllowed);
if(innerex != null)
error (h,"some invalid values for block attribute were found",innerex);
}
else if(reader.Name == "default")
{
element.defaultValue = reader.Value;
}
else if(reader.Name == "final")
{
element.Final = XmlSchemaUtil.ReadDerivationAttribute(reader,out innerex, "final",
XmlSchemaUtil.FinalAllowed);
if(innerex != null)
error (h,"some invalid values for final attribute were found",innerex);
}
else if(reader.Name == "fixed")
{
element.fixedValue = reader.Value;
}
else if(reader.Name == "form")
{
element.form = XmlSchemaUtil.ReadFormAttribute(reader,out innerex);
if(innerex != null)
error(h,reader.Value + " is an invalid value for form attribute",innerex);
}
else if(reader.Name == "id")
{
element.Id = reader.Value;
}
else if(reader.Name == "maxOccurs")
{
try
{
element.MaxOccursString = reader.Value;
}
catch(Exception e)
{
error(h,reader.Value + " is an invalid value for maxOccurs",e);
}
}
else if(reader.Name == "minOccurs")
{
try
{
element.MinOccursString = reader.Value;
}
catch(Exception e)
{
error(h,reader.Value + " is an invalid value for minOccurs",e);
}
}
else if(reader.Name == "name")
{
element.Name = reader.Value;
}
else if(reader.Name == "nillable")
{
element.IsNillable = XmlSchemaUtil.ReadBoolAttribute(reader,out innerex);
if(innerex != null)
error(h,reader.Value + "is not a valid value for nillable",innerex);
}
else if(reader.Name == "ref")
{
element.refName = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for ref attribute",innerex);
}
else if(reader.Name == "substitutionGroup")
{
element.substitutionGroup = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for substitutionGroup attribute",innerex);
}
else if(reader.Name == "type")
{
element.SchemaTypeName = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for type attribute",innerex);
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for element",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,element);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return element;
// Content: annotation?,
// (simpleType | complexType)?,
// (unique | key | keyref)*
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaElement.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
element.Annotation = annotation;
continue;
}
if(level <= 2)
{
if(reader.LocalName == "simpleType")
{
level = 3;
XmlSchemaSimpleType simple = XmlSchemaSimpleType.Read(reader,h);
if(simple != null)
element.SchemaType = simple;
continue;
}
if(reader.LocalName == "complexType")
{
level = 3;
XmlSchemaComplexType complex = XmlSchemaComplexType.Read(reader,h);
if(complex != null)
{
element.SchemaType = complex;
}
continue;
}
}
if(level <= 3)
{
if(reader.LocalName == "unique")
{
level = 3;
XmlSchemaUnique unique = XmlSchemaUnique.Read(reader,h);
if(unique != null)
element.constraints.Add(unique);
continue;
}
else if(reader.LocalName == "key")
{
level = 3;
XmlSchemaKey key = XmlSchemaKey.Read(reader,h);
if(key != null)
element.constraints.Add(key);
continue;
}
else if(reader.LocalName == "keyref")
{
level = 3;
XmlSchemaKeyref keyref = XmlSchemaKeyref.Read(reader,h);
if(keyref != null)
element.constraints.Add(keyref);
continue;
}
}
reader.RaiseInvalidElementError();
}
return element;
}
internal static XmlSchemaNotation Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaNotation xmlSchemaNotation = new XmlSchemaNotation();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "notation")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaInclude.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
xmlSchemaNotation.LineNumber = reader.LineNumber;
xmlSchemaNotation.LinePosition = reader.LinePosition;
xmlSchemaNotation.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaNotation.Id = reader.Value;
}
else if (reader.Name == "name")
{
xmlSchemaNotation.name = reader.Value;
}
else if (reader.Name == "public")
{
xmlSchemaNotation.pub = reader.Value;
}
else if (reader.Name == "system")
{
xmlSchemaNotation.system = reader.Value;
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for notation", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaNotation);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaNotation);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "notation")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaNotation.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaNotation.Annotation = xmlSchemaAnnotation;
}
}
else
{
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaNotation);
}
//<selector
// id = ID
// xpath = a subset of XPath expression, see below
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</selector>
internal static XmlSchemaXPath Read(XmlSchemaReader reader, ValidationEventHandler h, string name)
{
XmlSchemaXPath path = new XmlSchemaXPath();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != name)
{
error(h, "Should not happen :1: XmlSchemaComplexContentRestriction.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
path.LineNumber = reader.LineNumber;
path.LinePosition = reader.LinePosition;
path.SourceUri = reader.BaseURI;
XmlNamespaceManager currentMgr = XmlSchemaUtil.GetParserContext(reader.Reader).NamespaceManager;
if (currentMgr != null)
{
path.nsmgr = new XmlNamespaceManager(reader.NameTable);
IEnumerator e = currentMgr.GetEnumerator();
while (e.MoveNext())
{
string prefix = e.Current as string;
switch (prefix)
{
case "xml":
case "xmlns":
continue;
default:
path.nsmgr.AddNamespace(prefix, currentMgr.LookupNamespace(prefix, false));
break;
}
}
}
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
path.Id = reader.Value;
}
else if (reader.Name == "xpath")
{
path.xpath = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for " + name, null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, path);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(path);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != name)
{
error(h, "Should not happen :2: XmlSchemaXPath.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
path.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(path);
}
//<minLength
// fixed = boolean : false
// id = ID
// value = nonNegativeInteger
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</minLength>
internal static XmlSchemaMinLengthFacet Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaMinLengthFacet length = new XmlSchemaMinLengthFacet();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaMinLengthFacet.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
length.LineNumber = reader.LineNumber;
length.LinePosition = reader.LinePosition;
length.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
length.Id = reader.Value;
}
else if (reader.Name == "fixed")
{
Exception innerex;
length.IsFixed = XmlSchemaUtil.ReadBoolAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for fixed attribute", innerex);
}
}
else if (reader.Name == "value")
{
length.Value = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for " + xmlname, null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, length);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(length);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaMinLengthFacet.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
length.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(length);
}
//<redefine
// id = ID
// schemaLocation = anyURI
// {any attributes with non-schema namespace . . .}>
// Content: (annotation | (simpleType | complexType | group | attributeGroup))*
//</redefine>
internal static XmlSchemaRedefine Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaRedefine redefine = new XmlSchemaRedefine();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaRedefine.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
redefine.LineNumber = reader.LineNumber;
redefine.LinePosition = reader.LinePosition;
redefine.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
redefine.Id = reader.Value;
}
else if (reader.Name == "schemaLocation")
{
redefine.SchemaLocation = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for redefine", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, redefine);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(redefine);
}
//(annotation | (simpleType | complexType | group | attributeGroup))*
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaRedefine.Read, name=" + reader.Name, null);
}
break;
}
if (reader.LocalName == "annotation")
{
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
redefine.items.Add(annotation);
}
continue;
}
if (reader.LocalName == "simpleType")
{
XmlSchemaSimpleType simpleType = XmlSchemaSimpleType.Read(reader, h);
if (simpleType != null)
{
redefine.items.Add(simpleType);
}
continue;
}
if (reader.LocalName == "complexType")
{
XmlSchemaComplexType complexType = XmlSchemaComplexType.Read(reader, h);
if (complexType != null)
{
redefine.items.Add(complexType);
}
continue;
}
if (reader.LocalName == "group")
{
XmlSchemaGroup group = XmlSchemaGroup.Read(reader, h);
if (group != null)
{
redefine.items.Add(group);
}
continue;
}
if (reader.LocalName == "attributeGroup")
{
XmlSchemaAttributeGroup attributeGroup = XmlSchemaAttributeGroup.Read(reader, h);
if (attributeGroup != null)
{
redefine.items.Add(attributeGroup);
}
continue;
}
reader.RaiseInvalidElementError();
}
return(redefine);
}
//<extension
// base = QName
// id = ID
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?)))
//</extension>
internal static XmlSchemaComplexContentExtension Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaComplexContentExtension extension = new XmlSchemaComplexContentExtension();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaComplexContentExtension.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
extension.LineNumber = reader.LineNumber;
extension.LinePosition = reader.LinePosition;
extension.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "base")
{
Exception innerex;
extension.baseTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for base attribute", innerex);
}
}
else if (reader.Name == "id")
{
extension.Id = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for extension", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, extension);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(extension);
}
//Content: 1. annotation?,
// (2.(group | all | choice | sequence)?, (3.(attribute | attributeGroup)*, 4.anyAttribute?)))
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaComplexContentExtension.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
extension.Annotation = annotation;
}
continue;
}
if (level <= 2)
{
if (reader.LocalName == "group")
{
level = 3;
XmlSchemaGroupRef group = XmlSchemaGroupRef.Read(reader, h);
if (group != null)
{
extension.particle = group;
}
continue;
}
if (reader.LocalName == "all")
{
level = 3;
XmlSchemaAll all = XmlSchemaAll.Read(reader, h);
if (all != null)
{
extension.particle = all;
}
continue;
}
if (reader.LocalName == "choice")
{
level = 3;
XmlSchemaChoice choice = XmlSchemaChoice.Read(reader, h);
if (choice != null)
{
extension.particle = choice;
}
continue;
}
if (reader.LocalName == "sequence")
{
level = 3;
XmlSchemaSequence sequence = XmlSchemaSequence.Read(reader, h);
if (sequence != null)
{
extension.particle = sequence;
}
continue;
}
}
if (level <= 3)
{
if (reader.LocalName == "attribute")
{
level = 3;
XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader, h);
if (attr != null)
{
extension.Attributes.Add(attr);
}
continue;
}
if (reader.LocalName == "attributeGroup")
{
level = 3;
XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader, h);
if (attr != null)
{
extension.attributes.Add(attr);
}
continue;
}
}
if (level <= 4 && reader.LocalName == "anyAttribute")
{
level = 5;
XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader, h);
if (anyattr != null)
{
extension.AnyAttribute = anyattr;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(extension);
}
//<restriction
// base = QName
// id = ID
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (simpleType?, (minExclusive | minInclusive | maxExclusive | maxInclusive | totalDigits | fractionDigits | length | minLength | maxLength | enumeration | whiteSpace | pattern)*))
//</restriction>
internal static XmlSchemaSimpleTypeRestriction Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaSimpleTypeRestriction.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
restriction.LineNumber = reader.LineNumber;
restriction.LinePosition = reader.LinePosition;
restriction.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
restriction.Id = reader.Value;
}
else if(reader.Name == "base")
{
Exception innerex;
restriction.baseTypeName = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for base attribute",innerex);
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for restriction",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,restriction);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return restriction;
// Content: annotation?, simpleType?, (minExclusive |. .. | pattern)*
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaSimpleTypeRestriction.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
restriction.Annotation = annotation;
continue;
}
if(level <= 2 && reader.LocalName == "simpleType")
{
level = 3;
XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader,h);
if(stype != null)
restriction.baseType = stype;
continue;
}
if(level <= 3)
{
if(reader.LocalName == "minExclusive")
{
level = 3;
XmlSchemaMinExclusiveFacet minex = XmlSchemaMinExclusiveFacet.Read(reader,h);
if(minex != null)
restriction.facets.Add(minex);
continue;
}
else if(reader.LocalName == "minInclusive")
{
level = 3;
XmlSchemaMinInclusiveFacet mini = XmlSchemaMinInclusiveFacet.Read(reader,h);
if(mini != null)
restriction.facets.Add(mini);
continue;
}
else if(reader.LocalName == "maxExclusive")
{
level = 3;
XmlSchemaMaxExclusiveFacet maxex = XmlSchemaMaxExclusiveFacet.Read(reader,h);
if(maxex != null)
restriction.facets.Add(maxex);
continue;
}
else if(reader.LocalName == "maxInclusive")
{
level = 3;
XmlSchemaMaxInclusiveFacet maxi = XmlSchemaMaxInclusiveFacet.Read(reader,h);
if(maxi != null)
restriction.facets.Add(maxi);
continue;
}
else if(reader.LocalName == "totalDigits")
{
level = 3;
XmlSchemaTotalDigitsFacet total = XmlSchemaTotalDigitsFacet.Read(reader,h);
if(total != null)
restriction.facets.Add(total);
continue;
}
else if(reader.LocalName == "fractionDigits")
{
level = 3;
XmlSchemaFractionDigitsFacet fraction = XmlSchemaFractionDigitsFacet.Read(reader,h);
if(fraction != null)
restriction.facets.Add(fraction);
continue;
}
else if(reader.LocalName == "length")
{
level = 3;
XmlSchemaLengthFacet length = XmlSchemaLengthFacet.Read(reader,h);
if(length != null)
restriction.facets.Add(length);
continue;
}
else if(reader.LocalName == "minLength")
{
level = 3;
XmlSchemaMinLengthFacet minlen = XmlSchemaMinLengthFacet.Read(reader,h);
if(minlen != null)
restriction.facets.Add(minlen);
continue;
}
else if(reader.LocalName == "maxLength")
{
level = 3;
XmlSchemaMaxLengthFacet maxlen = XmlSchemaMaxLengthFacet.Read(reader,h);
if(maxlen != null)
restriction.facets.Add(maxlen);
continue;
}
else if(reader.LocalName == "enumeration")
{
level = 3;
XmlSchemaEnumerationFacet enumeration = XmlSchemaEnumerationFacet.Read(reader,h);
if(enumeration != null)
restriction.facets.Add(enumeration);
continue;
}
else if(reader.LocalName == "whiteSpace")
{
level = 3;
XmlSchemaWhiteSpaceFacet ws = XmlSchemaWhiteSpaceFacet.Read(reader,h);
if(ws != null)
restriction.facets.Add(ws);
continue;
}
else if(reader.LocalName == "pattern")
{
level = 3;
XmlSchemaPatternFacet pattern = XmlSchemaPatternFacet.Read(reader,h);
if(pattern != null)
restriction.facets.Add(pattern);
continue;
}
}
reader.RaiseInvalidElementError();
}
return restriction;
}
//<attribute
// default = string
// fixed = string
// form = (qualified | unqualified)
// id = ID
// name = NCName
// ref = QName
// type = QName
// use = (optional | prohibited | required) : optional
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (simpleType?))
//</attribute>
internal static XmlSchemaAttribute Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAttribute attribute = new XmlSchemaAttribute();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaAttribute.Read, name="+reader.Name,null);
reader.SkipToEnd();
return null;
}
attribute.LineNumber = reader.LineNumber;
attribute.LinePosition = reader.LinePosition;
attribute.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "default")
{
attribute.defaultValue = reader.Value;
}
else if(reader.Name == "fixed")
{
attribute.fixedValue = reader.Value;
}
else if(reader.Name == "form")
{
Exception innerex;
attribute.form = XmlSchemaUtil.ReadFormAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for form attribute", innerex);
}
else if(reader.Name == "id")
{
attribute.Id = reader.Value;
}
else if(reader.Name == "name")
{
attribute.name = reader.Value;
}
else if(reader.Name == "ref")
{
Exception innerex;
attribute.refName = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for ref attribute",innerex);
}
else if(reader.Name == "type")
{
Exception innerex;
attribute.schemaTypeName = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for type attribute",innerex);
}
else if(reader.Name == "use")
{
Exception innerex;
attribute.use = XmlSchemaUtil.ReadUseAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for use attribute", innerex);
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for attribute",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,attribute);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return attribute;
// Content: (annotation?, (simpleType?))
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaAttribute.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
attribute.Annotation = annotation;
continue;
}
if(level <=2 && reader.LocalName == "simpleType")
{
level = 3;
XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader,h);
if(stype != null)
attribute.schemaType = stype;
continue;
}
reader.RaiseInvalidElementError();
}
return attribute;
}
//<anyAttribute
// id = ID
// namespace = ((##any | ##other) | List of (anyURI | (##targetNamespace | ##local)) ) : ##any
// processContents = (lax | skip | strict) : strict
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</anyAttribute>
internal static XmlSchemaAnyAttribute Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAnyAttribute any = new XmlSchemaAnyAttribute();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaAnyAttribute.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
any.LineNumber = reader.LineNumber;
any.LinePosition = reader.LinePosition;
any.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
any.Id = reader.Value;
}
else if (reader.Name == "namespace")
{
any.nameSpace = reader.Value;
}
else if (reader.Name == "processContents")
{
Exception innerex;
any.processing = XmlSchemaUtil.ReadProcessingAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for processContents", innerex);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for anyAttribute", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, any);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(any);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaAnyAttribute.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
any.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(any);
}
//<choice
// id = ID
// maxOccurs = (nonNegativeInteger | unbounded) : 1
// minOccurs = nonNegativeInteger : 1
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (element | group | choice | sequence | any)*)
//</choice>
internal static XmlSchemaChoice Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaChoice choice = new XmlSchemaChoice();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaChoice.Read, name="+reader.Name,null);
reader.SkipToEnd();
return null;
}
choice.LineNumber = reader.LineNumber;
choice.LinePosition = reader.LinePosition;
choice.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
choice.Id = reader.Value;
}
else if(reader.Name == "maxOccurs")
{
try
{
choice.MaxOccursString = reader.Value;
}
catch(Exception e)
{
error(h,reader.Value + " is an invalid value for maxOccurs",e);
}
}
else if(reader.Name == "minOccurs")
{
try
{
choice.MinOccursString = reader.Value;
}
catch(Exception e)
{
error(h,reader.Value + " is an invalid value for minOccurs",e);
}
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for choice",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,choice);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return choice;
// Content: (annotation?, (element | group | choice | sequence | any)*)
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaChoice.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
choice.Annotation = annotation;
continue;
}
if(level <=2)
{
if(reader.LocalName == "element")
{
level = 2;
XmlSchemaElement element = XmlSchemaElement.Read(reader,h);
if(element != null)
choice.items.Add(element);
continue;
}
if(reader.LocalName == "group")
{
level = 2;
XmlSchemaGroupRef group = XmlSchemaGroupRef.Read(reader,h);
if(group != null)
choice.items.Add(group);
continue;
}
if(reader.LocalName == "choice")
{
level = 2;
XmlSchemaChoice ch = XmlSchemaChoice.Read(reader,h);
if(ch != null)
choice.items.Add(ch);
continue;
}
if(reader.LocalName == "sequence")
{
level = 2;
XmlSchemaSequence sequence = XmlSchemaSequence.Read(reader,h);
if(sequence != null)
choice.items.Add(sequence);
continue;
}
if(reader.LocalName == "any")
{
level = 2;
XmlSchemaAny any = XmlSchemaAny.Read(reader,h);
if(any != null)
choice.items.Add(any);
continue;
}
}
reader.RaiseInvalidElementError();
}
return choice;
}
internal static XmlSchemaMinInclusiveFacet Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaMinInclusiveFacet xmlSchemaMinInclusiveFacet = new XmlSchemaMinInclusiveFacet();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "minInclusive")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaMinInclusiveFacet.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
xmlSchemaMinInclusiveFacet.LineNumber = reader.LineNumber;
xmlSchemaMinInclusiveFacet.LinePosition = reader.LinePosition;
xmlSchemaMinInclusiveFacet.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaMinInclusiveFacet.Id = reader.Value;
}
else if (reader.Name == "fixed")
{
Exception ex;
xmlSchemaMinInclusiveFacet.IsFixed = XmlSchemaUtil.ReadBoolAttribute(reader, out ex);
if (ex != null)
{
XmlSchemaObject.error(h, reader.Value + " is not a valid value for fixed attribute", ex);
}
}
else if (reader.Name == "value")
{
xmlSchemaMinInclusiveFacet.Value = reader.Value;
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for minInclusive", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaMinInclusiveFacet);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaMinInclusiveFacet);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "minInclusive")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaMinInclusiveFacet.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaMinInclusiveFacet.Annotation = xmlSchemaAnnotation;
}
}
else
{
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaMinInclusiveFacet);
}
//From the Errata
//<group
// id = ID
// name = NCName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (all | choice | sequence)?)
//</group>
internal static XmlSchemaGroup Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaGroup group = new XmlSchemaGroup();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaGroup.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
group.LineNumber = reader.LineNumber;
group.LinePosition = reader.LinePosition;
group.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
group.Id = reader.Value;
}
else if(reader.Name == "name")
{
group.name = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for group",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,group);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return group;
// Content: (annotation?, (all | choice | sequence)?)
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaGroup.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
group.Annotation = annotation;
continue;
}
if(level <= 2)
{
if(reader.LocalName == "all")
{
level = 3;
XmlSchemaAll all = XmlSchemaAll.Read(reader,h);
if(all != null)
group.Particle = all;
continue;
}
if(reader.LocalName == "choice")
{
level = 3;
XmlSchemaChoice choice = XmlSchemaChoice.Read(reader,h);
if(choice != null)
group.Particle = choice;
continue;
}
if(reader.LocalName == "sequence")
{
level = 3;
XmlSchemaSequence sequence = XmlSchemaSequence.Read(reader,h);
if(sequence != null)
group.Particle = sequence;
continue;
}
}
reader.RaiseInvalidElementError();
}
return group;
}
//<all
// id = ID
// maxOccurs = 1 : 1
// minOccurs = (0 | 1) : 1
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, element*)
//</all>
internal static XmlSchemaAll Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAll all = new XmlSchemaAll();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaAll.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
all.LineNumber = reader.LineNumber;
all.LinePosition = reader.LinePosition;
all.SourceUri = reader.BaseURI;
//Read Attributes
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
all.Id = reader.Value;
}
else if (reader.Name == "maxOccurs")
{
try
{
all.MaxOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for maxOccurs", e);
}
}
else if (reader.Name == "minOccurs")
{
try
{
all.MinOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for minOccurs", e);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for all", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, all);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(all);
}
//Content: (annotation?, element*)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaAll.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
all.Annotation = annotation;
}
continue;
}
if (level <= 2 && reader.LocalName == "element")
{
level = 2;
XmlSchemaElement element = XmlSchemaElement.Read(reader, h);
if (element != null)
{
all.items.Add(element);
}
continue;
}
reader.RaiseInvalidElementError();
}
return(all);
}
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();
}
}
//<documentation
// source = anyURI
// xml:lang = language>
// Content: ({any})*
//</documentation>
internal static XmlSchemaDocumentation Read(XmlSchemaReader reader, ValidationEventHandler h, out bool skip)
{
skip = false;
XmlSchemaDocumentation doc = new XmlSchemaDocumentation();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != "documentation")
{
error(h, "Should not happen :1: XmlSchemaDocumentation.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
doc.LineNumber = reader.LineNumber;
doc.LinePosition = reader.LinePosition;
doc.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "source")
{
doc.source = reader.Value;
}
else if (reader.Name == "xml:lang")
{
doc.language = reader.Value;
}
else
{
error(h, reader.Name + " is not a valid attribute for documentation", null);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
doc.Markup = new XmlNode[0];
return(doc);
}
//Content {any}*
XmlDocument xmldoc = new XmlDocument();
xmldoc.AppendChild(xmldoc.ReadNode(reader));
XmlNode root = xmldoc.FirstChild;
if (root != null && root.ChildNodes != null)
{
doc.Markup = new XmlNode[root.ChildNodes.Count];
for (int i = 0; i < root.ChildNodes.Count; i++)
{
doc.Markup[i] = root.ChildNodes[i];
}
}
if (reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.EndElement)
{
skip = true;
}
return(doc);
}
internal static XmlSchemaSimpleType Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleType xmlSchemaSimpleType = new XmlSchemaSimpleType();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "simpleType")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaGroup.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
xmlSchemaSimpleType.LineNumber = reader.LineNumber;
xmlSchemaSimpleType.LinePosition = reader.LinePosition;
xmlSchemaSimpleType.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "final")
{
Exception ex;
xmlSchemaSimpleType.Final = XmlSchemaUtil.ReadDerivationAttribute(reader, out ex, "final", XmlSchemaUtil.FinalAllowed);
if (ex != null)
{
XmlSchemaObject.error(h, "some invalid values not a valid value for final", ex);
}
}
else if (reader.Name == "id")
{
xmlSchemaSimpleType.Id = reader.Value;
}
else if (reader.Name == "name")
{
xmlSchemaSimpleType.Name = reader.Value;
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for simpleType", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaSimpleType);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaSimpleType);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "simpleType")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaSimpleType.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaSimpleType.Annotation = xmlSchemaAnnotation;
}
}
else
{
if (num <= 2)
{
if (reader.LocalName == "restriction")
{
num = 3;
XmlSchemaSimpleTypeRestriction xmlSchemaSimpleTypeRestriction = XmlSchemaSimpleTypeRestriction.Read(reader, h);
if (xmlSchemaSimpleTypeRestriction != null)
{
xmlSchemaSimpleType.content = xmlSchemaSimpleTypeRestriction;
}
continue;
}
if (reader.LocalName == "list")
{
num = 3;
XmlSchemaSimpleTypeList xmlSchemaSimpleTypeList = XmlSchemaSimpleTypeList.Read(reader, h);
if (xmlSchemaSimpleTypeList != null)
{
xmlSchemaSimpleType.content = xmlSchemaSimpleTypeList;
}
continue;
}
if (reader.LocalName == "union")
{
num = 3;
XmlSchemaSimpleTypeUnion xmlSchemaSimpleTypeUnion = XmlSchemaSimpleTypeUnion.Read(reader, h);
if (xmlSchemaSimpleTypeUnion != null)
{
xmlSchemaSimpleType.content = xmlSchemaSimpleTypeUnion;
}
continue;
}
}
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaSimpleType);
}
internal static XmlSchemaSequence Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "sequence")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaSequence.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
xmlSchemaSequence.LineNumber = reader.LineNumber;
xmlSchemaSequence.LinePosition = reader.LinePosition;
xmlSchemaSequence.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaSequence.Id = reader.Value;
}
else if (reader.Name == "maxOccurs")
{
try
{
xmlSchemaSequence.MaxOccursString = reader.Value;
}
catch (Exception innerException)
{
XmlSchemaObject.error(h, reader.Value + " is an invalid value for maxOccurs", innerException);
}
}
else if (reader.Name == "minOccurs")
{
try
{
xmlSchemaSequence.MinOccursString = reader.Value;
}
catch (Exception innerException2)
{
XmlSchemaObject.error(h, reader.Value + " is an invalid value for minOccurs", innerException2);
}
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for sequence", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaSequence);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaSequence);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "sequence")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaSequence.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaSequence.Annotation = xmlSchemaAnnotation;
}
}
else
{
if (num <= 2)
{
if (reader.LocalName == "element")
{
num = 2;
XmlSchemaElement xmlSchemaElement = XmlSchemaElement.Read(reader, h);
if (xmlSchemaElement != null)
{
xmlSchemaSequence.items.Add(xmlSchemaElement);
}
continue;
}
if (reader.LocalName == "group")
{
num = 2;
XmlSchemaGroupRef xmlSchemaGroupRef = XmlSchemaGroupRef.Read(reader, h);
if (xmlSchemaGroupRef != null)
{
xmlSchemaSequence.items.Add(xmlSchemaGroupRef);
}
continue;
}
if (reader.LocalName == "choice")
{
num = 2;
XmlSchemaChoice xmlSchemaChoice = XmlSchemaChoice.Read(reader, h);
if (xmlSchemaChoice != null)
{
xmlSchemaSequence.items.Add(xmlSchemaChoice);
}
continue;
}
if (reader.LocalName == "sequence")
{
num = 2;
XmlSchemaSequence xmlSchemaSequence2 = XmlSchemaSequence.Read(reader, h);
if (xmlSchemaSequence2 != null)
{
xmlSchemaSequence.items.Add(xmlSchemaSequence2);
}
continue;
}
if (reader.LocalName == "any")
{
num = 2;
XmlSchemaAny xmlSchemaAny = XmlSchemaAny.Read(reader, h);
if (xmlSchemaAny != null)
{
xmlSchemaSequence.items.Add(xmlSchemaAny);
}
continue;
}
}
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaSequence);
}
//<list
// id = ID
// itemType = QName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (simpleType?))
//</list>
internal static XmlSchemaSimpleTypeList Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaSimpleTypeList.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
list.LineNumber = reader.LineNumber;
list.LinePosition = reader.LinePosition;
list.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
list.Id = reader.Value;
}
else if(reader.Name == "itemType")
{
Exception innerex;
list.ItemTypeName = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for itemType attribute",innerex);
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for list",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,list);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return list;
// Content: annotation?, simpleType?
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaSimpleTypeList.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
list.Annotation = annotation;
continue;
}
if(level <= 2 && reader.LocalName == "simpleType")
{
level = 3;
XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader,h);
if(stype != null)
list.itemType = stype;
continue;
}
reader.RaiseInvalidElementError();
}
return list;
}
internal static XmlSchemaXPath Read(XmlSchemaReader reader, ValidationEventHandler h, string name)
{
XmlSchemaXPath xmlSchemaXPath = new XmlSchemaXPath();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != name)
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaComplexContentRestriction.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
xmlSchemaXPath.LineNumber = reader.LineNumber;
xmlSchemaXPath.LinePosition = reader.LinePosition;
xmlSchemaXPath.SourceUri = reader.BaseURI;
XmlNamespaceManager namespaceManager = XmlSchemaUtil.GetParserContext(reader.Reader).NamespaceManager;
if (namespaceManager != null)
{
xmlSchemaXPath.nsmgr = new XmlNamespaceManager(reader.NameTable);
foreach (object obj in namespaceManager)
{
string text = obj as string;
string text2 = text;
if (text2 != null)
{
if (XmlSchemaXPath.< > f__switch$map3C == null)
{
XmlSchemaXPath.< > f__switch$map3C = new Dictionary <string, int>(2)
{
{
"xml",
0
},
{
"xmlns",
0
}
};
}
int num;
if (XmlSchemaXPath.< > f__switch$map3C.TryGetValue(text2, out num))
{
if (num == 0)
{
continue;
}
}
}
xmlSchemaXPath.nsmgr.AddNamespace(text, namespaceManager.LookupNamespace(text, false));
}
}
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaXPath.Id = reader.Value;
}
else if (reader.Name == "xpath")
{
xmlSchemaXPath.xpath = reader.Value;
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for " + name, null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaXPath);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaXPath);
}
int num2 = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != name)
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaXPath.Read, name=" + reader.Name, null);
}
break;
}
if (num2 <= 1 && reader.LocalName == "annotation")
{
num2 = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaXPath.Annotation = xmlSchemaAnnotation;
}
}
else
{
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaXPath);
}
//<restriction
// base = QName
// id = ID
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?)))
//</restriction>
internal static XmlSchemaComplexContentRestriction Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaComplexContentRestriction restriction = new XmlSchemaComplexContentRestriction();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaComplexContentRestriction.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
restriction.LineNumber = reader.LineNumber;
restriction.LinePosition = reader.LinePosition;
restriction.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "base")
{
Exception innerex;
restriction.baseTypeName = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for base attribute",innerex);
}
else if(reader.Name == "id")
{
restriction.Id = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for restriction",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,restriction);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return restriction;
//Content: 1. annotation?,
// (2.(group | all | choice | sequence)?, (3.(attribute | attributeGroup)*, 4.anyAttribute?)))
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaComplexContentRestriction.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
restriction.Annotation = annotation;
continue;
}
if(level <= 2)
{
if(reader.LocalName == "group")
{
level = 3;
XmlSchemaGroupRef group = XmlSchemaGroupRef.Read(reader,h);
if(group != null)
restriction.particle = group;
continue;
}
if(reader.LocalName == "all")
{
level = 3;
XmlSchemaAll all = XmlSchemaAll.Read(reader,h);
if(all != null)
restriction.particle = all;
continue;
}
if(reader.LocalName == "choice")
{
level = 3;
XmlSchemaChoice choice = XmlSchemaChoice.Read(reader,h);
if(choice != null)
restriction.particle = choice;
continue;
}
if(reader.LocalName == "sequence")
{
level = 3;
XmlSchemaSequence sequence = XmlSchemaSequence.Read(reader,h);
if(sequence != null)
restriction.particle = sequence;
continue;
}
}
if(level <= 3)
{
if(reader.LocalName == "attribute")
{
level = 3;
XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader,h);
if(attr != null)
restriction.Attributes.Add(attr);
continue;
}
if(reader.LocalName == "attributeGroup")
{
level = 3;
XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader,h);
if(attr != null)
restriction.attributes.Add(attr);
continue;
}
}
if(level <= 4 && reader.LocalName == "anyAttribute")
{
level = 5;
XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader,h);
if(anyattr != null)
restriction.AnyAttribute = anyattr;
continue;
}
reader.RaiseInvalidElementError();
}
return restriction;
}
internal static XmlSchemaAny Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "any")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaAny.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
xmlSchemaAny.LineNumber = reader.LineNumber;
xmlSchemaAny.LinePosition = reader.LinePosition;
xmlSchemaAny.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaAny.Id = reader.Value;
}
else if (reader.Name == "maxOccurs")
{
try
{
xmlSchemaAny.MaxOccursString = reader.Value;
}
catch (Exception innerException)
{
XmlSchemaObject.error(h, reader.Value + " is an invalid value for maxOccurs", innerException);
}
}
else if (reader.Name == "minOccurs")
{
try
{
xmlSchemaAny.MinOccursString = reader.Value;
}
catch (Exception innerException2)
{
XmlSchemaObject.error(h, reader.Value + " is an invalid value for minOccurs", innerException2);
}
}
else if (reader.Name == "namespace")
{
xmlSchemaAny.nameSpace = reader.Value;
}
else if (reader.Name == "processContents")
{
Exception ex;
xmlSchemaAny.processing = XmlSchemaUtil.ReadProcessingAttribute(reader, out ex);
if (ex != null)
{
XmlSchemaObject.error(h, reader.Value + " is not a valid value for processContents", ex);
}
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for any", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaAny);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaAny);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "any")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaAny.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaAny.Annotation = xmlSchemaAnnotation;
}
}
else
{
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaAny);
}
//<all
// id = ID
// maxOccurs = 1 : 1
// minOccurs = (0 | 1) : 1
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, element*)
//</all>
internal static XmlSchemaAll Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAll all = new XmlSchemaAll();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaAll.Read, name="+reader.Name,null);
reader.SkipToEnd();
return null;
}
all.LineNumber = reader.LineNumber;
all.LinePosition = reader.LinePosition;
all.SourceUri = reader.BaseURI;
//Read Attributes
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
all.Id = reader.Value;
}
else if(reader.Name == "maxOccurs")
{
try
{
all.MaxOccursString = reader.Value;
}
catch(Exception e)
{
error(h,reader.Value + " is an invalid value for maxOccurs",e);
}
}
else if(reader.Name == "minOccurs")
{
try
{
all.MinOccursString = reader.Value;
}
catch(Exception e)
{
error(h,reader.Value + " is an invalid value for minOccurs",e);
}
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for all",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,all);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return all;
//Content: (annotation?, element*)
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaAll.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
all.Annotation = annotation;
continue;
}
if(level <=2 && reader.LocalName == "element")
{
level = 2;
XmlSchemaElement element = XmlSchemaElement.Read(reader,h);
if(element != null)
all.items.Add(element);
continue;
}
reader.RaiseInvalidElementError();
}
return all;
}
// <group
// id = ID
// ref = QName
// minOccurs = ? : 1
// maxOccurs = ? : 1>
// Content: (annotation?)
// </group>
internal static XmlSchemaGroupRef Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaGroupRef groupref = new XmlSchemaGroupRef();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaGroup.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
groupref.LineNumber = reader.LineNumber;
groupref.LinePosition = reader.LinePosition;
groupref.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
groupref.Id = reader.Value;
}
else if (reader.Name == "ref")
{
Exception innerex;
groupref.refName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for ref attribute", innerex);
}
}
else if (reader.Name == "maxOccurs")
{
try
{
groupref.MaxOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for maxOccurs", e);
}
}
else if (reader.Name == "minOccurs")
{
try
{
groupref.MinOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for minOccurs", e);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for group", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, groupref);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(groupref);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaGroupRef.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
groupref.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(groupref);
}
/*
internal new void error(ValidationEventHandler handle, string message)
{
errorCount++;
ValidationHandler.RaiseValidationError(handle, this, message);
}
*/
//<key
// id = ID
// name = NCName
// refer = QName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (selector, field+))
//</key>
internal static XmlSchemaKeyref Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaKeyref keyref = new XmlSchemaKeyref();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaKeyref.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
keyref.LineNumber = reader.LineNumber;
keyref.LinePosition = reader.LinePosition;
keyref.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
keyref.Id = reader.Value;
}
else if(reader.Name == "name")
{
keyref.Name = reader.Value;
}
else if(reader.Name == "refer")
{
Exception innerex;
keyref.refer = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for refer attribute",innerex);
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for keyref",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,keyref);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return keyref;
// Content: annotation?, selector, field+
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaKeyref.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
keyref.Annotation = annotation;
continue;
}
if(level <= 2 && reader.LocalName == "selector")
{
level = 3;
XmlSchemaXPath selector = XmlSchemaXPath.Read(reader,h,"selector");
if(selector != null)
keyref.Selector = selector;
continue;
}
if(level <= 3 && reader.LocalName == "field")
{
level = 3;
if(keyref.Selector == null)
error(h,"selector must be defined before field declarations",null);
XmlSchemaXPath field = XmlSchemaXPath.Read(reader,h,"field");
if(field != null)
keyref.Fields.Add(field);
continue;
}
reader.RaiseInvalidElementError();
}
return keyref;
}
//<choice
// id = ID
// maxOccurs = (nonNegativeInteger | unbounded) : 1
// minOccurs = nonNegativeInteger : 1
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (element | group | choice | sequence | any)*)
//</choice>
internal static XmlSchemaChoice Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaChoice choice = new XmlSchemaChoice();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaChoice.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
choice.LineNumber = reader.LineNumber;
choice.LinePosition = reader.LinePosition;
choice.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
choice.Id = reader.Value;
}
else if (reader.Name == "maxOccurs")
{
try
{
choice.MaxOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for maxOccurs", e);
}
}
else if (reader.Name == "minOccurs")
{
try
{
choice.MinOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for minOccurs", e);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for choice", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, choice);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(choice);
}
// Content: (annotation?, (element | group | choice | sequence | any)*)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaChoice.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
choice.Annotation = annotation;
}
continue;
}
if (level <= 2)
{
if (reader.LocalName == "element")
{
level = 2;
XmlSchemaElement element = XmlSchemaElement.Read(reader, h);
if (element != null)
{
choice.items.Add(element);
}
continue;
}
if (reader.LocalName == "group")
{
level = 2;
XmlSchemaGroupRef group = XmlSchemaGroupRef.Read(reader, h);
if (group != null)
{
choice.items.Add(group);
}
continue;
}
if (reader.LocalName == "choice")
{
level = 2;
XmlSchemaChoice ch = XmlSchemaChoice.Read(reader, h);
if (ch != null)
{
choice.items.Add(ch);
}
continue;
}
if (reader.LocalName == "sequence")
{
level = 2;
XmlSchemaSequence sequence = XmlSchemaSequence.Read(reader, h);
if (sequence != null)
{
choice.items.Add(sequence);
}
continue;
}
if (reader.LocalName == "any")
{
level = 2;
XmlSchemaAny any = XmlSchemaAny.Read(reader, h);
if (any != null)
{
choice.items.Add(any);
}
continue;
}
}
reader.RaiseInvalidElementError();
}
return(choice);
}
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;
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();
}
}
//<complexType
// abstract = boolean : false
// block = (#all | List of (extension | restriction))
// final = (#all | List of (extension | restriction))
// id = ID
// mixed = boolean : false
// name = NCName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (simpleContent | complexContent | ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?))))
//</complexType>
internal static XmlSchemaComplexType Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaComplexType ctype = new XmlSchemaComplexType();
reader.MoveToElement();
Exception innerex;
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaComplexType.Read, name="+reader.Name,null);
reader.SkipToEnd();
return null;
}
ctype.LineNumber = reader.LineNumber;
ctype.LinePosition = reader.LinePosition;
ctype.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "abstract")
{
ctype.IsAbstract = XmlSchemaUtil.ReadBoolAttribute(reader,out innerex);
if(innerex != null)
error(h,reader.Value + " is invalid value for abstract",innerex);
}
else if(reader.Name == "block")
{
ctype.block = XmlSchemaUtil.ReadDerivationAttribute(reader,out innerex, "block",
XmlSchemaUtil.ComplexTypeBlockAllowed);
if(innerex != null)
error (h,"some invalid values for block attribute were found",innerex);
}
else if(reader.Name == "final")
{
ctype.Final = XmlSchemaUtil.ReadDerivationAttribute(reader,out innerex, "final",
XmlSchemaUtil.FinalAllowed);
if(innerex != null)
error (h,"some invalid values for final attribute were found",innerex);
}
else if(reader.Name == "id")
{
ctype.Id = reader.Value;
}
else if(reader.Name == "mixed")
{
ctype.isMixed = XmlSchemaUtil.ReadBoolAttribute(reader,out innerex);
if(innerex != null)
error(h,reader.Value + " is invalid value for mixed",innerex);
}
else if(reader.Name == "name")
{
ctype.Name = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for complexType",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,ctype);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return ctype;
//Content: 1. annotation?,
// 2. simpleContent | 2. complexContent |
// (3.(group | all | choice | sequence)?, (4.(attribute | attributeGroup)*, 5.anyAttribute?)))
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaComplexType.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
ctype.Annotation = annotation;
continue;
}
if(level <=2)
{
if(reader.LocalName == "simpleContent")
{
level = 6;
XmlSchemaSimpleContent simple = XmlSchemaSimpleContent.Read(reader,h);
if(simple != null)
ctype.ContentModel = simple;
continue;
}
if(reader.LocalName == "complexContent")
{
level = 6;
XmlSchemaComplexContent complex = XmlSchemaComplexContent.Read(reader,h);
if(complex != null)
ctype.contentModel = complex;
continue;
}
}
if(level <= 3)
{
if(reader.LocalName == "group")
{
level = 4;
XmlSchemaGroupRef group = XmlSchemaGroupRef.Read(reader,h);
if(group != null)
ctype.particle = group;
continue;
}
if(reader.LocalName == "all")
{
level = 4;
XmlSchemaAll all = XmlSchemaAll.Read(reader,h);
if(all != null)
ctype.particle = all;
continue;
}
if(reader.LocalName == "choice")
{
level = 4;
XmlSchemaChoice choice = XmlSchemaChoice.Read(reader,h);
if(choice != null)
ctype.particle = choice;
continue;
}
if(reader.LocalName == "sequence")
{
level = 4;
XmlSchemaSequence sequence = XmlSchemaSequence.Read(reader,h);
if(sequence != null)
ctype.particle = sequence;
continue;
}
}
if(level <= 4)
{
if(reader.LocalName == "attribute")
{
level = 4;
XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader,h);
if(attr != null)
ctype.Attributes.Add(attr);
continue;
}
if(reader.LocalName == "attributeGroup")
{
level = 4;
XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader,h);
if(attr != null)
ctype.attributes.Add(attr);
continue;
}
}
if(level <= 5 && reader.LocalName == "anyAttribute")
{
level = 6;
XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader,h);
if(anyattr != null)
ctype.AnyAttribute = anyattr;
continue;
}
reader.RaiseInvalidElementError();
}
return ctype;
}
//<notation
// id = ID
// name = NCName
// public = anyURI
// system = anyURI
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</notation>
internal static XmlSchemaNotation Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaNotation notation = new XmlSchemaNotation();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaInclude.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
notation.LineNumber = reader.LineNumber;
notation.LinePosition = reader.LinePosition;
notation.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
notation.Id = reader.Value;
}
else if (reader.Name == "name")
{
notation.name = reader.Value;
}
else if (reader.Name == "public")
{
notation.pub = reader.Value;
}
else if (reader.Name == "system")
{
notation.system = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for notation", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, notation);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(notation);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaNotation.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
notation.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(notation);
}
//<include
// id = ID
// schemaLocation = anyURI
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</include>
internal static XmlSchemaInclude Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaInclude include = new XmlSchemaInclude();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaInclude.Read, name="+reader.Name,null);
reader.SkipToEnd();
return null;
}
include.LineNumber = reader.LineNumber;
include.LinePosition = reader.LinePosition;
include.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
include.Id = reader.Value;
}
else if(reader.Name == "schemaLocation")
{
include.SchemaLocation = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for include",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,include);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return include;
// Content: (annotation?)
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaInclude.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
include.Annotation = annotation;
continue;
}
reader.RaiseInvalidElementError();
}
return include;
}
//<list
// id = ID
// itemType = QName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (simpleType?))
//</list>
internal static XmlSchemaSimpleTypeList Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaSimpleTypeList.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
list.LineNumber = reader.LineNumber;
list.LinePosition = reader.LinePosition;
list.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
list.Id = reader.Value;
}
else if (reader.Name == "itemType")
{
Exception innerex;
list.ItemTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for itemType attribute", innerex);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for list", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, list);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(list);
}
// Content: annotation?, simpleType?
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaSimpleTypeList.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
list.Annotation = annotation;
}
continue;
}
if (level <= 2 && reader.LocalName == "simpleType")
{
level = 3;
XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader, h);
if (stype != null)
{
list.itemType = stype;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(list);
}
//<simpleContent
// id = ID
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (restriction | extension))
//</simpleContent>
internal static XmlSchemaSimpleContent Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleContent simple = new XmlSchemaSimpleContent();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaComplexContent.Read, name="+reader.Name,null);
reader.SkipToEnd();
return null;
}
simple.LineNumber = reader.LineNumber;
simple.LinePosition = reader.LinePosition;
simple.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
simple.Id = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for simpleContent",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,simple);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return simple;
//Content: (annotation?, (restriction | extension))
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaSimpleContent.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
simple.Annotation = annotation;
continue;
}
if(level <=2)
{
if(reader.LocalName == "restriction")
{
level = 3;
XmlSchemaSimpleContentRestriction restriction = XmlSchemaSimpleContentRestriction.Read(reader,h);
if(restriction != null)
simple.content = restriction;
continue;
}
if(reader.LocalName == "extension")
{
level = 3;
XmlSchemaSimpleContentExtension extension = XmlSchemaSimpleContentExtension.Read(reader,h);
if(extension != null)
simple.content = extension;
continue;
}
}
reader.RaiseInvalidElementError();
}
return simple;
}
//<simpleContent
// id = ID
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (restriction | extension))
//</simpleContent>
internal static XmlSchemaSimpleContent Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleContent simple = new XmlSchemaSimpleContent();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaComplexContent.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
simple.LineNumber = reader.LineNumber;
simple.LinePosition = reader.LinePosition;
simple.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
simple.Id = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for simpleContent", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, simple);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(simple);
}
//Content: (annotation?, (restriction | extension))
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaSimpleContent.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
simple.Annotation = annotation;
}
continue;
}
if (level <= 2)
{
if (reader.LocalName == "restriction")
{
level = 3;
XmlSchemaSimpleContentRestriction restriction = XmlSchemaSimpleContentRestriction.Read(reader, h);
if (restriction != null)
{
simple.content = restriction;
}
continue;
}
if (reader.LocalName == "extension")
{
level = 3;
XmlSchemaSimpleContentExtension extension = XmlSchemaSimpleContentExtension.Read(reader, h);
if (extension != null)
{
simple.content = extension;
}
continue;
}
}
reader.RaiseInvalidElementError();
}
return(simple);
}
//<maxExclusive
// fixed = boolean : false
// id = ID
// value = anySimpleType
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</maxExclusive>
internal static XmlSchemaMaxExclusiveFacet Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaMaxExclusiveFacet maxex = new XmlSchemaMaxExclusiveFacet();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaMaxExclusiveFacet.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
maxex.LineNumber = reader.LineNumber;
maxex.LinePosition = reader.LinePosition;
maxex.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
maxex.Id = reader.Value;
}
else if(reader.Name == "fixed")
{
Exception innerex;
maxex.IsFixed = XmlSchemaUtil.ReadBoolAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for fixed attribute",innerex);
}
else if(reader.Name == "value")
{
maxex.Value = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for "+xmlname,null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,maxex);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return maxex;
// Content: (annotation?)
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaMaxExclusiveFacet.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
maxex.Annotation = annotation;
continue;
}
reader.RaiseInvalidElementError();
}
return maxex;
}
//<annotation
// id = ID
// {any attributes with non-schema namespace . . .}>
// Content: (appinfo | documentation)*
//</annotation>
internal static XmlSchemaAnnotation Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAnnotation annotation = new XmlSchemaAnnotation();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaAnnotation.Read, name="+reader.Name,null);
reader.SkipToEnd();
return null;
}
annotation.LineNumber = reader.LineNumber;
annotation.LinePosition = reader.LinePosition;
annotation.SourceUri = reader.BaseURI;
//Read Attributes
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
annotation.Id = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for annotation",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,annotation);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return annotation;
//Content: (appinfo | documentation)*
bool skip = false;
string expectedEnd = null;
while(!reader.EOF)
{
if(skip)
skip=false;
else
reader.ReadNextElement();
if(reader.NodeType == XmlNodeType.EndElement)
{
bool end = true;
string expected = xmlname;
if(expectedEnd != null)
{
expected = expectedEnd;
expectedEnd = null;
end = false;
}
if(reader.LocalName != expected)
error(h,"Should not happen :2: XmlSchemaAnnotation.Read, name="+reader.Name+",expected="+expected,null);
if (end)
break;
else
continue;
}
if(reader.LocalName == "appinfo")
{
XmlSchemaAppInfo appinfo = XmlSchemaAppInfo.Read(reader,h,out skip);
if(appinfo != null)
annotation.items.Add(appinfo);
continue;
}
if(reader.LocalName == "documentation")
{
XmlSchemaDocumentation documentation = XmlSchemaDocumentation.Read(reader,h, out skip);
if(documentation != null)
annotation.items.Add(documentation);
continue;
}
reader.RaiseInvalidElementError();
}
return annotation;
}
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;
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;
}
}
}
//<simpleType
// final = (#all | (list | union | restriction))
// id = ID
// name = NCName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (restriction | list | union))
//</simpleType>
internal static XmlSchemaSimpleType Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleType stype = new XmlSchemaSimpleType();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaGroup.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
stype.LineNumber = reader.LineNumber;
stype.LinePosition = reader.LinePosition;
stype.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "final")
{
Exception innerex;
stype.Final = XmlSchemaUtil.ReadDerivationAttribute(reader, out innerex, "final",
XmlSchemaUtil.FinalAllowed);
if(innerex != null)
error(h, "some invalid values not a valid value for final", innerex);
}
else if(reader.Name == "id")
{
stype.Id = reader.Value;
}
else if(reader.Name == "name")
{
stype.Name = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for simpleType",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,stype);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return stype;
// Content: (annotation?, (restriction | list | union))
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaSimpleType.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
stype.Annotation = annotation;
continue;
}
if(level <= 2)
{
if(reader.LocalName == "restriction")
{
level = 3;
XmlSchemaSimpleTypeRestriction restriction = XmlSchemaSimpleTypeRestriction.Read(reader,h);
if(restriction != null)
stype.content = restriction;
continue;
}
if(reader.LocalName == "list")
{
level = 3;
XmlSchemaSimpleTypeList list = XmlSchemaSimpleTypeList.Read(reader,h);
if(list != null)
stype.content = list;
continue;
}
if(reader.LocalName == "union")
{
level = 3;
XmlSchemaSimpleTypeUnion union = XmlSchemaSimpleTypeUnion.Read(reader,h);
if(union != null)
stype.content = union;
continue;
}
}
reader.RaiseInvalidElementError();
}
return stype;
}
//<extension
//base = QName
//id = ID
//{any attributes with non-schema namespace . . .}>
//Content: (annotation?, ((attribute | attributeGroup)*, anyAttribute?))
//</extension>
internal static XmlSchemaSimpleContentExtension Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleContentExtension extension = new XmlSchemaSimpleContentExtension();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaAttributeGroup.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
extension.LineNumber = reader.LineNumber;
extension.LinePosition = reader.LinePosition;
extension.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "base")
{
Exception innerex;
extension.baseTypeName= XmlSchemaUtil.ReadQNameAttribute(reader,out innerex);
if(innerex != null)
error(h, reader.Value + " is not a valid value for base attribute",innerex);
}
else if(reader.Name == "id")
{
extension.Id = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for extension in this context",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,extension);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return extension;
//Content: 1.annotation?, 2.(attribute | attributeGroup)*, 3.anyAttribute?
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaSimpleContentExtension.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
extension.Annotation = annotation;
continue;
}
if(level <= 2)
{
if(reader.LocalName == "attribute")
{
level = 2;
XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader,h);
if(attr != null)
extension.Attributes.Add(attr);
continue;
}
if(reader.LocalName == "attributeGroup")
{
level = 2;
XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader,h);
if(attr != null)
extension.attributes.Add(attr);
continue;
}
}
if(level <= 3 && reader.LocalName == "anyAttribute")
{
level = 4;
XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader,h);
if(anyattr != null)
extension.AnyAttribute = anyattr;
continue;
}
reader.RaiseInvalidElementError();
}
return extension;
}
//<union
// id = ID
// memberTypes = List of QName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (simpleType*))
//</union>
internal static XmlSchemaSimpleTypeUnion Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleTypeUnion union = new XmlSchemaSimpleTypeUnion();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaSimpleTypeUnion.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
union.LineNumber = reader.LineNumber;
union.LinePosition = reader.LinePosition;
union.SourceUri = reader.BaseURI;
//Read Attributes
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
union.Id = reader.Value;
}
else if(reader.Name == "memberTypes")
{
Exception innerEx;
string[] names = XmlSchemaUtil.SplitList(reader.Value);
union.memberTypes = new XmlQualifiedName[names.Length];
for(int i=0;i<names.Length;i++)
{
union.memberTypes[i] = XmlSchemaUtil.ToQName(reader,names[i],out innerEx);
if(innerEx != null)
error(h,"'"+names[i] + "' is not a valid memberType",innerEx);
}
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for union",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,union);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return union;
// Content: annotation?, simpleType*
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaSimpleTypeUnion.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
union.Annotation = annotation;
continue;
}
if(level <=2 && reader.LocalName == "simpleType")
{
level = 2;
XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader,h);
if(stype != null)
union.baseTypes.Add(stype);
continue;
}
reader.RaiseInvalidElementError();
}
return union;
}
//<selector
// id = ID
// xpath = a subset of XPath expression, see below
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</selector>
internal static XmlSchemaXPath Read(XmlSchemaReader reader, ValidationEventHandler h,string name)
{
XmlSchemaXPath path = new XmlSchemaXPath();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != name)
{
error(h,"Should not happen :1: XmlSchemaComplexContentRestriction.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
path.LineNumber = reader.LineNumber;
path.LinePosition = reader.LinePosition;
path.SourceUri = reader.BaseURI;
XmlNamespaceManager currentMgr = XmlSchemaUtil.GetParserContext (reader.Reader).NamespaceManager;
if (currentMgr != null) {
path.nsmgr = new XmlNamespaceManager (reader.NameTable);
IEnumerator e = currentMgr.GetEnumerator ();
while (e.MoveNext ()) {
string prefix = e.Current as string;
switch (prefix) {
case "xml":
case "xmlns":
continue;
default:
path.nsmgr.AddNamespace (prefix, currentMgr.LookupNamespace (prefix, false));
break;
}
}
}
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
path.Id = reader.Value;
}
else if(reader.Name == "xpath")
{
path.xpath = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for "+name,null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,path);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return path;
// Content: (annotation?)
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != name)
error(h,"Should not happen :2: XmlSchemaXPath.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
path.Annotation = annotation;
continue;
}
reader.RaiseInvalidElementError();
}
return path;
}
internal static XmlSchemaSimpleTypeUnion Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleTypeUnion xmlSchemaSimpleTypeUnion = new XmlSchemaSimpleTypeUnion();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "union")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaSimpleTypeUnion.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
xmlSchemaSimpleTypeUnion.LineNumber = reader.LineNumber;
xmlSchemaSimpleTypeUnion.LinePosition = reader.LinePosition;
xmlSchemaSimpleTypeUnion.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaSimpleTypeUnion.Id = reader.Value;
}
else if (reader.Name == "memberTypes")
{
string[] array = XmlSchemaUtil.SplitList(reader.Value);
xmlSchemaSimpleTypeUnion.memberTypes = new XmlQualifiedName[array.Length];
for (int i = 0; i < array.Length; i++)
{
Exception ex;
xmlSchemaSimpleTypeUnion.memberTypes[i] = XmlSchemaUtil.ToQName(reader, array[i], out ex);
if (ex != null)
{
XmlSchemaObject.error(h, "'" + array[i] + "' is not a valid memberType", ex);
}
}
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for union", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaSimpleTypeUnion);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaSimpleTypeUnion);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "union")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaSimpleTypeUnion.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaSimpleTypeUnion.Annotation = xmlSchemaAnnotation;
}
}
else if (num <= 2 && reader.LocalName == "simpleType")
{
num = 2;
XmlSchemaSimpleType xmlSchemaSimpleType = XmlSchemaSimpleType.Read(reader, h);
if (xmlSchemaSimpleType != null)
{
xmlSchemaSimpleTypeUnion.baseTypes.Add(xmlSchemaSimpleType);
}
}
else
{
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaSimpleTypeUnion);
}
