private QName InferMergedType(string value, QName typeName)
{
// examine value against specified type and
// if unacceptable, then return a relaxed type.
SimpleType st = XmlSchemaType.GetBuiltInSimpleType(
typeName);
if (st == null) // non-primitive type => see above.
{
return(QNameString);
}
do
{
try {
st.Datatype.ParseValue(value,
source.NameTable,
source as IXmlNamespaceResolver);
return(typeName);
} catch {
st = st.BaseXmlSchemaType as XmlSchemaSimpleType;
typeName = st != null ? st.QualifiedName : QName.Empty;
}
} while (typeName != QName.Empty);
return(QNameString);
}
private SimpleType MakeBaseTypeAsEmptiable(SimpleType st)
{
switch (st.QualifiedName.Namespace)
{
case XmlSchema.Namespace:
case XdtNamespace:
// If a primitive type
return(XmlSchemaType.GetBuiltInSimpleType(
XmlTypeCode.String));
}
SimpleTypeRst str = st.Content as SimpleTypeRst;
if (str != null)
{
ArrayList al = null;
foreach (SchemaFacet f in str.Facets)
{
if (f is LengthFacet ||
f is MinLengthFacet)
{
if (al == null)
{
al = new ArrayList();
}
al.Add(f);
}
}
foreach (SchemaFacet f in al)
{
str.Facets.Remove(f);
}
if (str.BaseType != null)
{
str.BaseType =
MakeBaseTypeAsEmptiable(st);
}
else
{
// It might have a reference to an
// external simple type, but there is
// no assurance that any of those
// external types allow an empty
// string. So just set base type as
// xs:string.
str.BaseTypeName = QNameString;
}
} // union/list can have empty string value.
return(st);
}
private void InferAsEmptyElement(Element el, string ns,
bool isNew)
{
ComplexType ct = el.SchemaType as ComplexType;
if (ct != null)
{
SimpleModel sm =
ct.ContentModel as SimpleModel;
if (sm != null)
{
ToEmptiableSimpleContent(sm, isNew);
return;
}
ComplexModel cm = ct.ContentModel
as ComplexModel;
if (cm != null)
{
ToEmptiableComplexContent(cm, isNew);
return;
}
if (ct.Particle != null)
{
ct.Particle.MinOccurs = 0;
}
return;
}
SimpleType st = el.SchemaType as SimpleType;
if (st != null)
{
st = MakeBaseTypeAsEmptiable(st);
switch (st.QualifiedName.Namespace)
{
case XmlSchema.Namespace:
case XdtNamespace:
el.SchemaTypeName = st.QualifiedName;
break;
default:
el.SchemaType = st;
break;
}
}
}
internal override int Validate(ValidationEventHandler h, XmlSchema schema)
{
// 3.14.6 Properties Correct.
//
// 1. Post Compilation Properties
// {name}, {target namespace} => QNameInternal. Already Compile()d.
// {base type definition} => baseSchemaTypeInternal
// {final} => finalResolved. Already Compile()d.
// {variety} => resolvedDerivedBy. Already Compile()d.
//
// 2. Should be checked by "recursed" field.
if (IsValidated(schema.ValidationId))
{
return(errorCount);
}
if (recursed)
{
error(h, "Circular type reference was found.");
return(errorCount);
}
recursed = true;
CollectBaseType(h, schema);
if (content != null)
{
errorCount += content.Validate(h, schema);
}
/*
* // BaseSchemaType property
* BaseXmlSchemaTypeInternal = content.ActualBaseSchemaType as XmlSchemaType;
* if (this.BaseXmlSchemaTypeInternal == null)
* this.DatatypeInternal = content.ActualBaseSchemaType as XmlSchemaDatatype;
*/
// Datatype property
XmlSchemaSimpleType simple = BaseXmlSchemaType as XmlSchemaSimpleType;
if (simple != null)
{
this.DatatypeInternal = simple.Datatype;
}
// else
// DatatypeInternal = BaseSchemaType as XmlSchemaDatatype;
// 3.
XmlSchemaSimpleType baseSType = BaseXmlSchemaType as XmlSchemaSimpleType;
if (baseSType != null)
{
if ((baseSType.FinalResolved & this.resolvedDerivedBy) != 0)
{
error(h, "Specified derivation is prohibited by the base simple type.");
}
}
// {variety}
if (this.resolvedDerivedBy == XmlSchemaDerivationMethod.Restriction &&
baseSType != null)
{
this.variety = baseSType.Variety;
}
else
{
this.variety = this.resolvedDerivedBy;
}
// 3.14.6 Derivation Valid (Restriction, Simple)
XmlSchemaSimpleTypeRestriction r = Content as XmlSchemaSimpleTypeRestriction;
object baseType = BaseXmlSchemaType != null ? (object)BaseXmlSchemaType : Datatype;
if (r != null)
{
ValidateDerivationValid(baseType, r.Facets, h, schema);
}
// TODO: describe which validation term this belongs to.
XmlSchemaSimpleTypeList l = Content as XmlSchemaSimpleTypeList;
if (l != null)
{
XmlSchemaSimpleType itemSimpleType = l.ValidatedListItemType as XmlSchemaSimpleType;
if (itemSimpleType != null && itemSimpleType.Content is XmlSchemaSimpleTypeList)
{
error(h, "List type must not be derived from another list type.");
}
}
recursed = false;
ValidationId = schema.ValidationId;
return(errorCount);
}
static XmlSchemaSimpleType()
{
// This is not used in the meantime.
XmlSchemaSimpleType st = new XmlSchemaSimpleType();
XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList();
list.ItemTypeName = new XmlQualifiedName("anyURI", XmlSchema.Namespace);
st.Content = list;
st.BaseXmlSchemaTypeInternal = null;
st.variety = XmlSchemaDerivationMethod.List;
schemaLocationType = st;
#if NET_2_0
// Built-In schema types
XsAnySimpleType = BuildSchemaType("anySimpleType", null);
XsString = BuildSchemaType("string", "anySimpleType");
XsBoolean = BuildSchemaType("boolean", "anySimpleType");
XsDecimal = BuildSchemaType("decimal", "anySimpleType");
XsFloat = BuildSchemaType("float", "anySimpleType");
XsDouble = BuildSchemaType("double", "anySimpleType");
XsDuration = BuildSchemaType("duration", "anySimpleType");
XsDateTime = BuildSchemaType("dateTime", "anySimpleType");
XsTime = BuildSchemaType("time", "anySimpleType");
XsDate = BuildSchemaType("date", "anySimpleType");
XsGYearMonth = BuildSchemaType("gYearMonth", "anySimpleType");
XsGYear = BuildSchemaType("gYear", "anySimpleType");
XsGMonthDay = BuildSchemaType("gMonthDay", "anySimpleType");
XsGDay = BuildSchemaType("gDay", "anySimpleType");
XsGMonth = BuildSchemaType("gMonth", "anySimpleType");
XsHexBinary = BuildSchemaType("hexBinary", "anySimpleType");
XsBase64Binary = BuildSchemaType("base64Binary", "anySimpleType");
XsAnyUri = BuildSchemaType("anyURI", "anySimpleType");
XsQName = BuildSchemaType("QName", "anySimpleType");
XsNotation = BuildSchemaType("NOTATION", "anySimpleType");
// derived types
XsNormalizedString = BuildSchemaType("normalizedString", "string");
XsToken = BuildSchemaType("token", "normalizedString");
XsLanguage = BuildSchemaType("language", "token");
XsNMToken = BuildSchemaType("NMTOKEN", "token");
XsName = BuildSchemaType("Name", "token");
XsNCName = BuildSchemaType("NCName", "Name");
XsID = BuildSchemaType("ID", "NCName");
XsIDRef = BuildSchemaType("IDREF", "NCName");
XsEntity = BuildSchemaType("ENTITY", "NCName");
XsInteger = BuildSchemaType("integer", "decimal");
XsNonPositiveInteger = BuildSchemaType("nonPositiveInteger", "integer");
XsNegativeInteger = BuildSchemaType("negativeInteger", "nonPositiveInteger");
XsLong = BuildSchemaType("long", "integer");
XsInt = BuildSchemaType("int", "long");
XsShort = BuildSchemaType("short", "int");
XsByte = BuildSchemaType("byte", "short");
XsNonNegativeInteger = BuildSchemaType("nonNegativeInteger", "integer");
XsUnsignedLong = BuildSchemaType("unsignedLong", "nonNegativeInteger");
XsUnsignedInt = BuildSchemaType("unsignedInt", "unsignedLong");
XsUnsignedShort = BuildSchemaType("unsignedShort", "unsignedInt");
XsUnsignedByte = BuildSchemaType("unsignedByte", "unsignedShort");
XsPositiveInteger = BuildSchemaType("positiveInteger", "nonNegativeInteger");
// xdt:*
XdtAnyAtomicType = BuildSchemaType("anyAtomicType", "anySimpleType", true, false);
XdtUntypedAtomic = BuildSchemaType("untypedAtomic", "anyAtomicType", true, true);
XdtDayTimeDuration = BuildSchemaType("dayTimeDuration", "duration", true, false);
XdtYearMonthDuration = BuildSchemaType("yearMonthDuration", "duration", true, false);
// NMTOKENS, IDREFS, ENTITIES - lists
XsIDRefs = new XmlSchemaSimpleType();
XmlSchemaSimpleTypeList sl = new XmlSchemaSimpleTypeList();
sl.ItemType = XsIDRef;
XsIDRefs.Content = sl;
XsEntities = new XmlSchemaSimpleType();
sl = new XmlSchemaSimpleTypeList();
sl.ItemType = XsEntity;
XsEntities.Content = sl;
XsNMTokens = new XmlSchemaSimpleType();
sl = new XmlSchemaSimpleTypeList();
sl.ItemType = XsNMToken;
XsNMTokens.Content = sl;
#endif
}
//<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);
}
internal override int Validate(ValidationEventHandler h, XmlSchema schema)
{
if (IsValidated(schema.ValidationId))
{
return(errorCount);
}
ArrayList al = new ArrayList();
// Validate MemberTypes
if (MemberTypes != null)
{
foreach (XmlQualifiedName memberTypeName in MemberTypes)
{
object type = null;
XmlSchemaType xstype = schema.FindSchemaType(memberTypeName) as XmlSchemaSimpleType;
if (xstype != null)
{
errorCount += xstype.Validate(h, schema);
type = xstype;
}
else if (memberTypeName == XmlSchemaComplexType.AnyTypeName)
{
type = XmlSchemaSimpleType.AnySimpleType;
}
else if (memberTypeName.Namespace == XmlSchema.Namespace ||
memberTypeName.Namespace == XmlSchema.XdtNamespace)
{
type = XmlSchemaDatatype.FromName(memberTypeName);
if (type == null)
{
error(h, "Invalid schema type name was specified: " + memberTypeName);
}
}
// otherwise, it might be missing sub components.
else if (!schema.IsNamespaceAbsent(memberTypeName.Namespace))
{
error(h, "Referenced base schema type " + memberTypeName + " was not found in the corresponding schema.");
}
al.Add(type);
}
}
if (BaseTypes != null)
{
foreach (XmlSchemaSimpleType st in BaseTypes)
{
st.Validate(h, schema);
al.Add(st);
}
}
this.validatedTypes = al.ToArray();
#if NET_2_0
if (validatedTypes != null)
{
validatedSchemaTypes = new XmlSchemaSimpleType [validatedTypes.Length];
for (int i = 0; i < validatedTypes.Length; i++)
{
object t = validatedTypes [i];
XmlSchemaSimpleType st = t as XmlSchemaSimpleType;
if (st == null && t != null)
{
st = XmlSchemaType.GetBuiltInSimpleType(((XmlSchemaDatatype)t).TypeCode);
}
validatedSchemaTypes [i] = st;
}
}
#endif
ValidationId = schema.ValidationId;
return(errorCount);
}
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();
}
}
private ComplexType ToComplexType(Element el)
{
QName name = el.SchemaTypeName;
XmlSchemaType type = el.SchemaType;
// 1. element type is complex.
ComplexType ct = type as ComplexType;
if (ct != null)
{
return(ct);
}
// 2. reference to global complexType.
XmlSchemaType globalType = schemas.GlobalTypes [name]
as XmlSchemaType;
ct = globalType as ComplexType;
if (ct != null)
{
return(ct);
}
ct = new ComplexType();
el.SchemaType = ct;
el.SchemaTypeName = QName.Empty;
// 3. base type name is xs:anyType or no specification.
// <xs:complexType />
if (name == QNameAnyType)
{
return(ct);
}
else if (type == null && name == QName.Empty)
{
return(ct);
}
SimpleModel sc = new SimpleModel();
ct.ContentModel = sc;
// 4. type is simpleType
// -> extension of existing simple type.
SimpleType st = type as SimpleType;
if (st != null)
{
SimpleRst scr = new SimpleRst();
scr.BaseType = st;
sc.Content = scr;
return(ct);
}
SimpleExt sce = new SimpleExt();
sc.Content = sce;
// 5. type name points to primitive type
// -> simple extension of a primitive type
st = XmlSchemaType.GetBuiltInSimpleType(name);
if (st != null)
{
sce.BaseTypeName = name;
return(ct);
}
// 6. type name points to global simpleType.
st = globalType as SimpleType;
if (st != null)
{
sce.BaseTypeName = name;
return(ct);
}
throw Error(el, "Unexpected schema component that contains simpleTypeName that could not be resolved.");
}
//<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);
}
//<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);
}
//<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);
}
/// <summary>
/// Schema Component:
/// QName, SimpleType, Scope, Default|Fixed, annotation
/// </summary>
internal override int Validate(ValidationEventHandler h, XmlSchema schema)
{
if (IsValidated(schema.ValidationId))
{
return(errorCount);
}
// -- Attribute Declaration Schema Component --
// {name}, {target namespace} -> QualifiedName. Already Compile()d.
// {type definition} -> attributeType. From SchemaType or SchemaTypeName.
// {scope} -> ParentIsSchema | isRedefineChild.
// {value constraint} -> ValidatedFixedValue, ValidatedDefaultValue.
// {annotation}
// -- Attribute Use Schema Component --
// {required}
// {attribute declaration}
// {value constraint}
// First, fill type information for type reference
if (SchemaType != null)
{
SchemaType.Validate(h, schema);
attributeType = SchemaType;
}
else if (SchemaTypeName != null && SchemaTypeName != XmlQualifiedName.Empty)
{
// If type is null, then it is missing sub components .
XmlSchemaType type = schema.FindSchemaType(SchemaTypeName);
if (type is XmlSchemaComplexType)
{
error(h, "An attribute can't have complexType Content");
}
else if (type != null) // simple type
{
errorCount += type.Validate(h, schema);
attributeType = type;
}
else if (SchemaTypeName == XmlSchemaComplexType.AnyTypeName)
{
attributeType = XmlSchemaComplexType.AnyType;
}
else if (XmlSchemaUtil.IsBuiltInDatatypeName(SchemaTypeName))
{
attributeType = XmlSchemaDatatype.FromName(SchemaTypeName);
if (attributeType == null)
{
error(h, "Invalid xml schema namespace datatype was specified.");
}
}
// otherwise, it might be missing sub components.
else if (!schema.IsNamespaceAbsent(SchemaTypeName.Namespace))
{
error(h, "Referenced schema type " + SchemaTypeName + " was not found in the corresponding schema.");
}
}
// Then, fill type information for the type references for the referencing attributes
if (RefName != null && RefName != XmlQualifiedName.Empty)
{
referencedAttribute = schema.FindAttribute(RefName);
// If el is null, then it is missing sub components .
if (referencedAttribute != null)
{
errorCount += referencedAttribute.Validate(h, schema);
}
// otherwise, it might be missing sub components.
else if (!schema.IsNamespaceAbsent(RefName.Namespace))
{
error(h, "Referenced attribute " + RefName + " was not found in the corresponding schema.");
}
}
if (attributeType == null)
{
attributeType = XmlSchemaSimpleType.AnySimpleType;
}
// Validate {value constraints}
if (defaultValue != null || fixedValue != null)
{
XmlSchemaDatatype datatype = attributeType as XmlSchemaDatatype;
if (datatype == null)
{
datatype = ((XmlSchemaSimpleType)attributeType).Datatype;
}
if (datatype.TokenizedType == XmlTokenizedType.QName)
{
error(h, "By the defection of the W3C XML Schema specification, it is impossible to supply QName default or fixed values.");
}
else
{
try {
if (defaultValue != null)
{
validatedDefaultValue = datatype.Normalize(defaultValue);
datatype.ParseValue(validatedDefaultValue, null, null);
}
} catch (Exception ex) {
// FIXME: This is not a good way to handle exception.
error(h, "The Attribute's default value is invalid with its type definition.", ex);
}
try {
if (fixedValue != null)
{
validatedFixedValue = datatype.Normalize(fixedValue);
validatedFixedTypedValue = datatype.ParseValue(validatedFixedValue, null, null);
}
} catch (Exception ex) {
// FIXME: This is not a good way to handle exception.
error(h, "The Attribute's fixed value is invalid with its type definition.", ex);
}
}
}
if (Use == XmlSchemaUse.None)
{
validatedUse = XmlSchemaUse.Optional;
}
else
{
validatedUse = Use;
}
#if NET_2_0
if (attributeType != null)
{
attributeSchemaType = attributeType as XmlSchemaSimpleType;
if (attributeType == XmlSchemaSimpleType.AnySimpleType)
{
attributeSchemaType = XmlSchemaSimpleType.XsAnySimpleType;
}
if (attributeSchemaType == null)
{
attributeSchemaType = XmlSchemaType.GetBuiltInSimpleType(SchemaTypeName);
}
}
#endif
ValidationId = schema.ValidationId;
return(errorCount);
}
//<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);
}
private void InferTextContent(Element el, bool isNew)
{
string value = source.ReadString();
if (el.SchemaType == null)
{
if (el.SchemaTypeName == QName.Empty)
{
// no type information -> infer type
if (isNew)
{
el.SchemaTypeName =
InferSimpleType(
value);
}
else
{
el.SchemaTypeName =
QNameString;
}
return;
}
switch (el.SchemaTypeName.Namespace)
{
case XmlSchema.Namespace:
case XdtNamespace:
// existing primitive type
el.SchemaTypeName = InferMergedType(
value, el.SchemaTypeName);
break;
default:
ComplexType ct = schemas.GlobalTypes [
el.SchemaTypeName]
as ComplexType;
// If it is complex, then just set
// mixed='true' (type cannot be set.)
// If it is simple, then we cannot
// make sure that string value is
// valid. So just set as xs:string.
if (ct != null)
{
MarkAsMixed(ct);
}
else
{
el.SchemaTypeName = QNameString;
}
break;
}
return;
}
// simpleType
SimpleType st = el.SchemaType as SimpleType;
if (st != null)
{
// If simple, then (described above)
el.SchemaType = null;
el.SchemaTypeName = QNameString;
return;
}
// complexType
ComplexType ect = el.SchemaType as ComplexType;
SimpleModel sm = ect.ContentModel as SimpleModel;
if (sm == null)
{
// - ComplexContent
MarkAsMixed(ect);
return;
}
// - SimpleContent
SimpleExt se = sm.Content as SimpleExt;
if (se != null)
{
se.BaseTypeName = InferMergedType(value,
se.BaseTypeName);
}
SimpleRst sr = sm.Content as SimpleRst;
if (sr != null)
{
sr.BaseTypeName = InferMergedType(value,
sr.BaseTypeName);
sr.BaseType = null;
}
}
// 3.14.6 Derivation Valid (RestrictionSimple)
internal void ValidateDerivationValid(object baseType, XmlSchemaObjectCollection facets,
ValidationEventHandler h, XmlSchema schema)
{
// TODO
XmlSchemaSimpleType baseSimpleType = baseType as XmlSchemaSimpleType;
switch (this.Variety)
{
// 1. atomic type
case XmlSchemaDerivationMethod.Restriction:
// 1.1
if (baseSimpleType != null && baseSimpleType.resolvedDerivedBy != XmlSchemaDerivationMethod.Restriction)
{
error(h, "Base schema type is not either atomic type or primitive type.");
}
// 1.2
if (baseSimpleType != null &&
(baseSimpleType.FinalResolved & XmlSchemaDerivationMethod.Restriction) != 0)
{
error(h, "Derivation by restriction is prohibited by the base simple type.");
}
// TODO: 1.3 facet restriction valid.
break;
case XmlSchemaDerivationMethod.List:
/*
* XmlSchemaSimpleTypeList thisList = Content as XmlSchemaSimpleTypeList;
* // 2.1 item list type not allowed
* if (baseSimpleType != null && baseSimpleType.resolvedDerivedBy == XmlSchemaDerivationMethod.List)
* error (h, "Base list schema type is not allowed.");
* XmlSchemaSimpleTypeUnion baseUnion = baseSimpleType.Content as XmlSchemaSimpleTypeUnion;
* if (baseUnion != null) {
* bool errorFound = false;
* foreach (object memberType in baseUnion.ValidatedTypes) {
* XmlSchemaSimpleType memberST = memberType as XmlSchemaSimpleType;
* if (memberST != null && memberST.resolvedDerivedBy == XmlSchemaDerivationMethod.List)
* errorFound = true;
* }
* if (errorFound)
* error (h, "Base union schema type should not contain list types.");
* }
*/
// 2.2 facets limited
if (facets != null)
{
foreach (XmlSchemaFacet facet in facets)
{
if (facet is XmlSchemaLengthFacet ||
facet is XmlSchemaMaxLengthFacet ||
facet is XmlSchemaMinLengthFacet ||
facet is XmlSchemaEnumerationFacet ||
facet is XmlSchemaPatternFacet)
{
continue;
}
else
{
error(h, "Not allowed facet was found on this simple type which derives list type.");
}
}
}
break;
case XmlSchemaDerivationMethod.Union:
// 3.1
// 3.2
if (facets != null)
{
foreach (XmlSchemaFacet facet in facets)
{
if (facet is XmlSchemaEnumerationFacet ||
facet is XmlSchemaPatternFacet)
{
continue;
}
else
{
error(h, "Not allowed facet was found on this simple type which derives list type.");
}
}
}
break;
}
}
// 3.14.6 Type Derivation OK (Simple)
internal bool ValidateTypeDerivationOK(object baseType,
ValidationEventHandler h, XmlSchema schema, bool raiseError)
{
// 1
// Note that anyType should also be allowed as anySimpleType.
if (this == baseType || baseType == XmlSchemaSimpleType.AnySimpleType ||
baseType == XmlSchemaComplexType.AnyType)
{
return(true);
}
// 2.1
XmlSchemaSimpleType baseSimpleType = baseType as XmlSchemaSimpleType;
if (baseSimpleType != null &&
(baseSimpleType.FinalResolved & resolvedDerivedBy) != 0)
{
if (raiseError)
{
error(h, "Specified derivation is prohibited by the base type.");
}
return(false);
}
// 2.2.1
if (BaseXmlSchemaType == baseType || Datatype == baseType)
{
return(true);
}
// 2.2.2
XmlSchemaSimpleType thisBaseSimpleType = BaseXmlSchemaType as XmlSchemaSimpleType;
if (thisBaseSimpleType != null)
{
if (thisBaseSimpleType.ValidateTypeDerivationOK(baseType, h, schema, false))
{
return(true);
}
}
// 2.2.3
switch (Variety)
{
case XmlSchemaDerivationMethod.Union:
case XmlSchemaDerivationMethod.List:
if (baseType == XmlSchemaSimpleType.AnySimpleType)
{
return(true);
}
break;
}
// 2.2.4 validly derived from one of the union member type.
if (baseSimpleType != null && baseSimpleType.Variety == XmlSchemaDerivationMethod.Union)
{
foreach (object memberType in ((XmlSchemaSimpleTypeUnion)baseSimpleType.Content).ValidatedTypes)
{
if (this.ValidateTypeDerivationOK(memberType, h, schema, false))
{
return(true);
}
}
}
if (raiseError)
{
error(h, "Invalid simple type derivation was found.");
}
return(false);
}
//<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)*)?, ((attribute | attributeGroup)*, anyAttribute?))
//</restriction>
internal static XmlSchemaSimpleContentRestriction Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleContentRestriction restriction = new XmlSchemaSimpleContentRestriction();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaComplexContentRestriction.Read, name=" + reader.Name, null);
reader.SkipToEnd();
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.simpleType?,
// 3.(minExclusive |...| enumeration | whiteSpace | pattern)*,
// 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: XmlSchemaSimpleContentRestriction.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;
}
}
if (level <= 4)
{
if (reader.LocalName == "attribute")
{
level = 4;
XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader, h);
if (attr != null)
{
restriction.Attributes.Add(attr);
}
continue;
}
if (reader.LocalName == "attributeGroup")
{
level = 4;
XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader, h);
if (attr != null)
{
restriction.attributes.Add(attr);
}
continue;
}
}
if (level <= 5 && reader.LocalName == "anyAttribute")
{
level = 6;
XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader, h);
if (anyattr != null)
{
restriction.AnyAttribute = anyattr;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(restriction);
}
public static bool AreSchemaDatatypeEqual(XmlSchemaSimpleType st1, object v1, XmlSchemaSimpleType st2, object v2)
{
if (st1.Datatype is XsdAnySimpleType)
{
return(AreSchemaDatatypeEqual(st1.Datatype as XsdAnySimpleType, v1, st2.Datatype as XsdAnySimpleType, v2));
}
// otherwise the types are lists of strings.
string [] a1 = v1 as string [];
string [] a2 = v2 as string [];
if (st1 != st2 || a1 == null || a2 == null || a1.Length != a2.Length)
{
return(false);
}
for (int i = 0; i < a1.Length; i++)
{
if (a1 [i] != a2 [i])
{
return(false);
}
}
return(true);
}
void DoCompile(ValidationEventHandler handler, List <CompiledSchemaMemo> handledUris, XmlSchemaSet col, XmlResolver resolver)
{
SetParent();
CompilationId = col.CompilationId;
schemas = col;
if (!schemas.Contains(this)) // e.g. xs:import
{
schemas.Add(this);
}
attributeGroups.Clear();
attributes.Clear();
elements.Clear();
groups.Clear();
notations.Clear();
schemaTypes.Clear();
named_identities.Clear();
ids.Clear();
compilationItems.Clear();
//1. Union and List are not allowed in block default
if (BlockDefault != XmlSchemaDerivationMethod.All)
{
if ((BlockDefault & XmlSchemaDerivationMethod.List) != 0)
{
error(handler, "list is not allowed in blockDefault attribute");
}
if ((BlockDefault & XmlSchemaDerivationMethod.Union) != 0)
{
error(handler, "union is not allowed in blockDefault attribute");
}
}
//2. Substitution is not allowed in finaldefault.
if (FinalDefault != XmlSchemaDerivationMethod.All)
{
if ((FinalDefault & XmlSchemaDerivationMethod.Substitution) != 0)
{
error(handler, "substitution is not allowed in finalDefault attribute");
}
}
//3. id must be of type ID
XmlSchemaUtil.CompileID(Id, this, IDCollection, handler);
//4. targetNamespace should be of type anyURI or absent
if (TargetNamespace != null)
{
if (TargetNamespace.Length == 0)
{
error(handler, "The targetNamespace attribute cannot have have empty string as its value.");
}
if (!XmlSchemaUtil.CheckAnyUri(TargetNamespace))
{
error(handler, TargetNamespace + " is not a valid value for targetNamespace attribute of schema");
}
}
//5. version should be of type normalizedString
if (!XmlSchemaUtil.CheckNormalizedString(Version))
{
error(handler, Version + "is not a valid value for version attribute of schema");
}
// Compile the content of this schema
for (int i = 0; i < Items.Count; i++)
{
compilationItems.Add(Items [i]);
}
// First, we run into inclusion schemas to collect
// compilation target items into compiledItems.
for (int i = 0; i < Includes.Count; i++)
{
ProcessExternal(handler, handledUris, resolver, Includes [i] as XmlSchemaExternal, col);
}
// Compilation phase.
// At least each Compile() must give unique (qualified) name for each component.
// It also checks self-resolvable properties correctness.
// Post compilation schema information contribution is not done here.
// It should be done by Validate().
for (int i = 0; i < compilationItems.Count; i++)
{
XmlSchemaObject obj = compilationItems [i];
if (obj is XmlSchemaAnnotation)
{
int numerr = ((XmlSchemaAnnotation)obj).Compile(handler, this);
errorCount += numerr;
}
else if (obj is XmlSchemaAttribute)
{
XmlSchemaAttribute attr = (XmlSchemaAttribute)obj;
int numerr = attr.Compile(handler, this);
errorCount += numerr;
if (numerr == 0)
{
XmlSchemaUtil.AddToTable(Attributes, attr, attr.QualifiedName, handler);
}
}
else if (obj is XmlSchemaAttributeGroup)
{
XmlSchemaAttributeGroup attrgrp = (XmlSchemaAttributeGroup)obj;
int numerr = attrgrp.Compile(handler, this);
errorCount += numerr;
if (numerr == 0)
{
XmlSchemaUtil.AddToTable(
AttributeGroups,
attrgrp,
attrgrp.QualifiedName,
handler);
}
}
else if (obj is XmlSchemaComplexType)
{
XmlSchemaComplexType ctype = (XmlSchemaComplexType)obj;
int numerr = ctype.Compile(handler, this);
errorCount += numerr;
if (numerr == 0)
{
XmlSchemaUtil.AddToTable(
schemaTypes,
ctype,
ctype.QualifiedName,
handler);
}
}
else if (obj is XmlSchemaSimpleType)
{
XmlSchemaSimpleType stype = (XmlSchemaSimpleType)obj;
stype.islocal = false; //This simple type is toplevel
int numerr = stype.Compile(handler, this);
errorCount += numerr;
if (numerr == 0)
{
XmlSchemaUtil.AddToTable(
SchemaTypes,
stype,
stype.QualifiedName,
handler);
}
}
else if (obj is XmlSchemaElement)
{
XmlSchemaElement elem = (XmlSchemaElement)obj;
elem.parentIsSchema = true;
int numerr = elem.Compile(handler, this);
errorCount += numerr;
if (numerr == 0)
{
XmlSchemaUtil.AddToTable(
Elements,
elem,
elem.QualifiedName,
handler);
}
}
else if (obj is XmlSchemaGroup)
{
XmlSchemaGroup grp = (XmlSchemaGroup)obj;
int numerr = grp.Compile(handler, this);
errorCount += numerr;
if (numerr == 0)
{
XmlSchemaUtil.AddToTable(
Groups,
grp,
grp.QualifiedName,
handler);
}
}
else if (obj is XmlSchemaNotation)
{
XmlSchemaNotation ntn = (XmlSchemaNotation)obj;
int numerr = ntn.Compile(handler, this);
errorCount += numerr;
if (numerr == 0)
{
XmlSchemaUtil.AddToTable(
Notations,
ntn,
ntn.QualifiedName,
handler);
}
}
else
{
ValidationHandler.RaiseValidationEvent(
handler,
null,
String.Format("Object of Type {0} is not valid in Item Property of Schema", obj.GetType().Name),
null,
this,
null,
XmlSeverityType.Error);
}
}
}
