void AddExternalComponentsTo(XmlSchema s, XmlSchemaObjectCollection items, ValidationEventHandler handler, List <CompiledSchemaMemo> handledUris, XmlResolver resolver, XmlSchemaSet col)
{
foreach (XmlSchemaExternal ext in s.Includes)
{
s.ProcessExternal(handler, handledUris, resolver, ext, col);
}
foreach (XmlSchemaObject obj in s.compilationItems)
{
items.Add(obj);
}
// Items might be already resolved (recursive schema imports), or might not be (other cases), so we add items only when appropriate here. (duplicate check is anyways done elsewhere)
foreach (XmlSchemaObject obj in s.Items)
{
if (!items.Contains(obj))
{
items.Add(obj);
}
}
}
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle,
ValidationEventHandler h, XmlSchema schema, bool raiseError)
{
if (this == baseParticle) // quick check
{
return(true);
}
XmlSchemaElement el = baseParticle as XmlSchemaElement;
if (el != null)
{
// Forbidden
if (raiseError)
{
error(h, "Invalid sequence paricle derivation.");
}
return(false);
}
XmlSchemaSequence seq = baseParticle as XmlSchemaSequence;
if (seq != null)
{
// Recurse
if (!ValidateOccurenceRangeOK(seq, h, schema, raiseError))
{
return(false);
}
// If it is totally optional, then ignore their contents.
if (seq.ValidatedMinOccurs == 0 && seq.ValidatedMaxOccurs == 0 &&
this.ValidatedMinOccurs == 0 && this.ValidatedMaxOccurs == 0)
{
return(true);
}
return(ValidateRecurse(seq, h, schema, raiseError));
}
XmlSchemaAll all = baseParticle as XmlSchemaAll;
if (all != null)
{
// RecurseUnordered
XmlSchemaObjectCollection already = new XmlSchemaObjectCollection();
for (int i = 0; i < this.Items.Count; i++)
{
XmlSchemaElement de = this.Items [i] as XmlSchemaElement;
if (de == null)
{
if (raiseError)
{
error(h, "Invalid sequence particle derivation by restriction from all.");
}
return(false);
}
foreach (XmlSchemaElement e in all.Items)
{
if (e.QualifiedName == de.QualifiedName)
{
if (already.Contains(e))
{
if (raiseError)
{
error(h, "Base element particle is mapped to the derived element particle in a sequence two or more times.");
}
return(false);
}
else
{
already.Add(e);
if (!de.ValidateDerivationByRestriction(e, h, schema, raiseError))
{
return(false);
}
}
}
}
}
foreach (XmlSchemaElement e in all.Items)
{
if (!already.Contains(e))
{
if (!e.ValidateIsEmptiable())
{
if (raiseError)
{
error(h, "In base -all- particle, mapping-skipped base element which is not emptiable was found.");
}
return(false);
}
}
}
return(true);
}
XmlSchemaAny any = baseParticle as XmlSchemaAny;
if (any != null)
{
// NSRecurseCheckCardinality
return(ValidateNSRecurseCheckCardinality(any, h, schema, raiseError));
}
XmlSchemaChoice choice = baseParticle as XmlSchemaChoice;
if (choice != null)
{
// MapAndSum
// In fact it is not Recurse, but it looks almost common.
return(ValidateSeqRecurseMapSumCommon(choice, h, schema, false, true, raiseError));
}
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);
}
}
}
private void InferAttributes(Element el, string ns, bool isNew)
{
// Now this element is going to have complexType.
// It currently not, then we have to replace it.
ComplexType ct = null;
SOMList attList = null;
Hashtable table = null;
do
{
switch (source.NamespaceURI)
{
case NamespaceXml:
if (schemas.Schemas(
NamespaceXml).Count == 0)
{
IncludeXmlAttributes();
}
break;
case XmlSchema.InstanceNamespace:
if (source.LocalName == "nil")
{
el.IsNillable = true;
}
// all other xsi:* atts are ignored
continue;
case NamespaceXmlns:
continue;
}
if (ct == null)
{
ct = ToComplexType(el);
attList = GetAttributes(ct);
table = CollectAttrTable(attList);
}
QName attrName = new QName(
source.LocalName, source.NamespaceURI);
Attr attr = table [attrName] as Attr;
if (attr == null)
{
attList.Add(InferNewAttribute(
attrName, isNew, ns));
}
else
{
table.Remove(attrName);
if (attr.RefName != null &&
attr.RefName != QName.Empty)
{
continue; // just a reference
}
InferMergedAttribute(attr);
}
} while (source.MoveToNextAttribute());
// mark all attr definitions that did not appear
// as optional.
if (table != null)
{
foreach (Attr attr in table.Values)
{
attr.Use = Use.Optional;
}
}
}
