//<enumeration
// id = ID
// value = anySimpleType
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</enumeration>
internal static XmlSchemaEnumerationFacet Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaEnumerationFacet enumeration = new XmlSchemaEnumerationFacet();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaEnumerationFacet.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
enumeration.LineNumber = reader.LineNumber;
enumeration.LinePosition = reader.LinePosition;
enumeration.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
enumeration.Id = reader.Value;
}
else if (reader.Name == "value")
{
enumeration.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, enumeration);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(enumeration);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaEnumerationFacet.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)
{
enumeration.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(enumeration);
}
//<maxInclusive
// fixed = boolean : false
// id = ID
// value = anySimpleType
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</maxInclusive>
internal static XmlSchemaMaxInclusiveFacet Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaMaxInclusiveFacet maxi = new XmlSchemaMaxInclusiveFacet();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaMaxInclusiveFacet.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
maxi.LineNumber = reader.LineNumber;
maxi.LinePosition = reader.LinePosition;
maxi.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
maxi.Id = reader.Value;
}
else if (reader.Name == "fixed")
{
Exception innerex;
maxi.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")
{
maxi.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, maxi);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(maxi);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaMaxInclusiveFacet.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)
{
maxi.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(maxi);
}
/*
* internal new void error(ValidationEventHandler handle, string message)
* {
* errorCount++;
* ValidationHandler.RaiseValidationError(handle, this, message);
* }
*/
//<unique
// id = ID
// name = NCName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (selector, field+))
//</unique>
internal static XmlSchemaUnique Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaUnique unique = new XmlSchemaUnique();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaUnique.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
unique.LineNumber = reader.LineNumber;
unique.LinePosition = reader.LinePosition;
unique.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
unique.Id = reader.Value;
}
else if (reader.Name == "name")
{
unique.Name = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for unique", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, unique);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(unique);
}
// 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: XmlSchemaUnion.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)
{
unique.Annotation = annotation;
}
continue;
}
if (level <= 2 && reader.LocalName == "selector")
{
level = 3;
XmlSchemaXPath selector = XmlSchemaXPath.Read(reader, h, "selector");
if (selector != null)
{
unique.Selector = selector;
}
continue;
}
if (level <= 3 && reader.LocalName == "field")
{
level = 3;
if (unique.Selector == null)
{
error(h, "selector must be defined before field declarations", null);
}
XmlSchemaXPath field = XmlSchemaXPath.Read(reader, h, "field");
if (field != null)
{
unique.Fields.Add(field);
}
continue;
}
reader.RaiseInvalidElementError();
}
return(unique);
}
//<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);
}
//<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);
}
//<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);
}
//<complexContent
// id = ID
// mixed = boolean
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (restriction | extension))
//</complexContent>
internal static XmlSchemaComplexContent Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaComplexContent complex = new XmlSchemaComplexContent();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaComplexContent.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
complex.LineNumber = reader.LineNumber;
complex.LinePosition = reader.LinePosition;
complex.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
complex.Id = reader.Value;
}
else if (reader.Name == "mixed")
{
Exception innerex;
complex.isMixed = XmlSchemaUtil.ReadBoolAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is an invalid value for mixed", innerex);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for complexContent", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, complex);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(complex);
}
//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: XmlSchemaComplexContent.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)
{
complex.Annotation = annotation;
}
continue;
}
if (level <= 2)
{
if (reader.LocalName == "restriction")
{
level = 3;
XmlSchemaComplexContentRestriction restriction = XmlSchemaComplexContentRestriction.Read(reader, h);
if (restriction != null)
{
complex.content = restriction;
}
continue;
}
if (reader.LocalName == "extension")
{
level = 3;
XmlSchemaComplexContentExtension extension = XmlSchemaComplexContentExtension.Read(reader, h);
if (extension != null)
{
complex.content = extension;
}
continue;
}
}
reader.RaiseInvalidElementError();
}
return(complex);
}
//<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);
}
//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);
}
//<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);
}
//<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);
}
// <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);
}
//<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);
}
//<sequence
// id = ID
// maxOccurs = (nonNegativeInteger | unbounded) : 1
// minOccurs = nonNegativeInteger : 1
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (element | group | choice | sequence | any)*)
//</sequence>
internal static XmlSchemaSequence Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSequence sequence = new XmlSchemaSequence();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaSequence.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
sequence.LineNumber = reader.LineNumber;
sequence.LinePosition = reader.LinePosition;
sequence.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
sequence.Id = reader.Value;
}
else if (reader.Name == "maxOccurs")
{
try
{
sequence.MaxOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for maxOccurs", e);
}
}
else if (reader.Name == "minOccurs")
{
try
{
sequence.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 sequence", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, sequence);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(sequence);
}
// 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: XmlSchemaSequence.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)
{
sequence.Annotation = annotation;
}
continue;
}
if (level <= 2)
{
if (reader.LocalName == "element")
{
level = 2;
XmlSchemaElement element = XmlSchemaElement.Read(reader, h);
if (element != null)
{
sequence.items.Add(element);
}
continue;
}
if (reader.LocalName == "group")
{
level = 2;
XmlSchemaGroupRef group = XmlSchemaGroupRef.Read(reader, h);
if (group != null)
{
sequence.items.Add(group);
}
continue;
}
if (reader.LocalName == "choice")
{
level = 2;
XmlSchemaChoice choice = XmlSchemaChoice.Read(reader, h);
if (choice != null)
{
sequence.items.Add(choice);
}
continue;
}
if (reader.LocalName == "sequence")
{
level = 2;
XmlSchemaSequence seq = XmlSchemaSequence.Read(reader, h);
if (seq != null)
{
sequence.items.Add(seq);
}
continue;
}
if (reader.LocalName == "any")
{
level = 2;
XmlSchemaAny any = XmlSchemaAny.Read(reader, h);
if (any != null)
{
sequence.items.Add(any);
}
continue;
}
}
reader.RaiseInvalidElementError();
}
return(sequence);
}
