private void ProcessNewSubstitutionGroups(XmlSchemaObjectTable substitutionGroupsTable, bool resolve)
{
foreach (XmlSchemaSubstitutionGroup group in substitutionGroupsTable.Values)
{
if (resolve)
{
this.ResolveSubstitutionGroup(group, substitutionGroupsTable);
}
XmlQualifiedName examplar = group.Examplar;
XmlSchemaSubstitutionGroup group2 = (XmlSchemaSubstitutionGroup)this.substitutionGroups[examplar];
if (group2 != null)
{
for (int i = 0; i < group.Members.Count; i++)
{
if (!group2.Members.Contains(group.Members[i]))
{
group2.Members.Add(group.Members[i]);
}
}
}
else
{
this.AddToTable(this.substitutionGroups, examplar, group);
}
}
}
private void ResolveSubstitutionGroup(XmlSchemaSubstitutionGroup substitutionGroup, XmlSchemaObjectTable substTable)
{
List <XmlSchemaElement> list = null;
XmlSchemaElement item = (XmlSchemaElement)this.elements[substitutionGroup.Examplar];
if (!substitutionGroup.Members.Contains(item))
{
for (int i = 0; i < substitutionGroup.Members.Count; i++)
{
XmlSchemaElement element2 = (XmlSchemaElement)substitutionGroup.Members[i];
XmlSchemaSubstitutionGroup group = (XmlSchemaSubstitutionGroup)substTable[element2.QualifiedName];
if (group != null)
{
this.ResolveSubstitutionGroup(group, substTable);
for (int j = 0; j < group.Members.Count; j++)
{
XmlSchemaElement element3 = (XmlSchemaElement)group.Members[j];
if (element3 != element2)
{
if (list == null)
{
list = new List <XmlSchemaElement>();
}
list.Add(element3);
}
}
}
}
if (list != null)
{
for (int k = 0; k < list.Count; k++)
{
substitutionGroup.Members.Add(list[k]);
}
}
substitutionGroup.Members.Add(item);
}
}
public static void AddParticleToExpected(XmlSchemaParticle p, XmlSchemaSet schemaSet, ArrayList particles, bool global)
{
if (!particles.Contains(p))
{
particles.Add(p);
}
XmlSchemaElement element = p as XmlSchemaElement;
if ((element != null) && (global || !element.RefName.IsEmpty))
{
XmlSchemaSubstitutionGroup group = (XmlSchemaSubstitutionGroup)schemaSet.SubstitutionGroups[element.QualifiedName];
if (group != null)
{
for (int i = 0; i < group.Members.Count; i++)
{
XmlSchemaElement item = (XmlSchemaElement)group.Members[i];
if (!element.QualifiedName.Equals(item.QualifiedName) && !particles.Contains(item))
{
particles.Add(item);
}
}
}
}
}
private void CheckSubstitutionGroup(XmlSchemaSubstitutionGroup substitutionGroup)
{
XmlSchemaElement element = (XmlSchemaElement) this.schema.Elements[substitutionGroup.Examplar];
if (element != null)
{
for (int i = 0; i < substitutionGroup.Members.Count; i++)
{
XmlSchemaElement source = (XmlSchemaElement) substitutionGroup.Members[i];
if ((source != element) && !XmlSchemaType.IsDerivedFrom(source.ElementSchemaType, element.ElementSchemaType, element.FinalResolved))
{
base.SendValidationEvent("Sch_InvalidSubstitutionMember", source.QualifiedName.ToString(), element.QualifiedName.ToString(), source);
}
}
}
}
private void CompileSubstitutionGroup(XmlSchemaSubstitutionGroup substitutionGroup) {
if (substitutionGroup.IsProcessing && substitutionGroup.Members.Count > 0) {
SendValidationEvent(Res.Sch_SubstitutionCircularRef, (XmlSchemaElement)substitutionGroup.Members[0]);
return;
}
XmlSchemaElement examplar = (XmlSchemaElement)elements[substitutionGroup.Examplar];
Debug.Assert(examplar != null); //Headelement presence is checked while building subst groups
if (substitutionGroup.Members.Contains(examplar)) {// already checked
return;
}
substitutionGroup.IsProcessing = true;
try {
if (examplar.FinalResolved == XmlSchemaDerivationMethod.All) {
SendValidationEvent(Res.Sch_InvalidExamplar, examplar);
}
//Build transitive members
ArrayList newMembers = null;
for (int i = 0; i < substitutionGroup.Members.Count; ++i) {
XmlSchemaElement element = (XmlSchemaElement)substitutionGroup.Members[i];
//Chain to other head's that are members of this head's substGroup
if ((element.ElementDecl.Block & XmlSchemaDerivationMethod.Substitution) == 0) { //Chain only if substitution is not blocked
XmlSchemaSubstitutionGroup g = (XmlSchemaSubstitutionGroup)examplars[element.QualifiedName];
if (g != null) {
CompileSubstitutionGroup(g);
for (int j = 0; j < g.Members.Count; ++j) {
if (g.Members[j] != element) { //Exclude the head
if (newMembers == null) {
newMembers = new ArrayList();
}
newMembers.Add(g.Members[j]);
}
}
}
}
}
if (newMembers != null) {
for (int i = 0; i < newMembers.Count; ++i) {
substitutionGroup.Members.Add(newMembers[i]);
}
}
substitutionGroup.Members.Add(examplar); // Compiled mark
}
finally {
substitutionGroup.IsProcessing = false;
}
}
private void ProcessSubstitutionGroups() {
foreach (XmlSchemaElement element in this.elements.Values) {
if (!element.SubstitutionGroup.IsEmpty) {
XmlSchemaElement headElement = this.elements[element.SubstitutionGroup] as XmlSchemaElement;
if (headElement == null) {
SendValidationEvent(Res.Sch_NoExamplar, element);
continue;
}
//Check derivation of member's type against head's type
if (!XmlSchemaType.IsDerivedFrom(element.ElementSchemaType, headElement.ElementSchemaType, headElement.FinalResolved)) {
SendValidationEvent(Res.Sch_InvalidSubstitutionMember, (element.QualifiedName).ToString(), (headElement.QualifiedName).ToString(), element);
}
//Create substitutionGroup
XmlSchemaSubstitutionGroup substitutionGroup = (XmlSchemaSubstitutionGroup)this.examplars[element.SubstitutionGroup];
if (substitutionGroup == null) {
substitutionGroup = new XmlSchemaSubstitutionGroup();
substitutionGroup.Examplar = element.SubstitutionGroup;
examplars.Add(element.SubstitutionGroup, substitutionGroup);
}
ArrayList members = substitutionGroup.Members;
if (!members.Contains(element)) { //Members might contain element if the same schema is included and imported through different paths. Imp, hence will be added to set directly
members.Add(element);
}
}
}
//Check the subst groups that we just built
foreach (XmlSchemaSubstitutionGroup substitutionGroup in examplars.Values) {
CompileSubstitutionGroup(substitutionGroup);
}
}
private void ProcessSubstitutionGroups()
{
foreach (XmlSchemaElement element in this.elements.Values)
{
if (!element.SubstitutionGroup.IsEmpty)
{
XmlSchemaElement element2 = this.elements[element.SubstitutionGroup] as XmlSchemaElement;
if (element2 == null)
{
base.SendValidationEvent("Sch_NoExamplar", element);
}
else
{
if (!XmlSchemaType.IsDerivedFrom(element.ElementSchemaType, element2.ElementSchemaType, element2.FinalResolved))
{
base.SendValidationEvent("Sch_InvalidSubstitutionMember", element.QualifiedName.ToString(), element2.QualifiedName.ToString(), element);
}
XmlSchemaSubstitutionGroup group = (XmlSchemaSubstitutionGroup) this.examplars[element.SubstitutionGroup];
if (group == null)
{
group = new XmlSchemaSubstitutionGroup {
Examplar = element.SubstitutionGroup
};
this.examplars.Add(element.SubstitutionGroup, group);
}
ArrayList members = group.Members;
if (!members.Contains(element))
{
members.Add(element);
}
}
}
}
foreach (XmlSchemaSubstitutionGroup group2 in this.examplars.Values)
{
this.CompileSubstitutionGroup(group2);
}
}
private void CompileSubstitutionGroup(XmlSchemaSubstitutionGroup substitutionGroup)
{
if (substitutionGroup.IsProcessing && (substitutionGroup.Members.Count > 0))
{
base.SendValidationEvent("Sch_SubstitutionCircularRef", (XmlSchemaElement) substitutionGroup.Members[0]);
}
else
{
XmlSchemaElement item = (XmlSchemaElement) this.elements[substitutionGroup.Examplar];
if (!substitutionGroup.Members.Contains(item))
{
substitutionGroup.IsProcessing = true;
try
{
if (item.FinalResolved == XmlSchemaDerivationMethod.All)
{
base.SendValidationEvent("Sch_InvalidExamplar", item);
}
ArrayList list = null;
for (int i = 0; i < substitutionGroup.Members.Count; i++)
{
XmlSchemaElement element2 = (XmlSchemaElement) substitutionGroup.Members[i];
if ((element2.ElementDecl.Block & XmlSchemaDerivationMethod.Substitution) == XmlSchemaDerivationMethod.Empty)
{
XmlSchemaSubstitutionGroup group = (XmlSchemaSubstitutionGroup) this.examplars[element2.QualifiedName];
if (group != null)
{
this.CompileSubstitutionGroup(group);
for (int j = 0; j < group.Members.Count; j++)
{
if (group.Members[j] != element2)
{
if (list == null)
{
list = new ArrayList();
}
list.Add(group.Members[j]);
}
}
}
}
}
if (list != null)
{
for (int k = 0; k < list.Count; k++)
{
substitutionGroup.Members.Add(list[k]);
}
}
substitutionGroup.Members.Add(item);
}
finally
{
substitutionGroup.IsProcessing = false;
}
}
}
}
private void CheckSubstitutionGroup(XmlSchemaSubstitutionGroup substitutionGroup) {
XmlSchemaElement examplar = (XmlSchemaElement)this.schema.Elements[substitutionGroup.Examplar];
if (examplar != null) {
for (int i = 0; i < substitutionGroup.Members.Count; ++i) {
XmlSchemaElement element = (XmlSchemaElement)substitutionGroup.Members[i];
if (element != examplar) {
if (!XmlSchemaType.IsDerivedFrom(element.ElementSchemaType, examplar.ElementSchemaType, examplar.FinalResolved)) {
SendValidationEvent(Res.Sch_InvalidSubstitutionMember, (element.QualifiedName).ToString(), (examplar.QualifiedName).ToString(), element);
}
}
}
}
}
private void ResolveSubstitutionGroup(XmlSchemaSubstitutionGroup substitutionGroup, XmlSchemaObjectTable substTable) {
ArrayList newMembers = null;
XmlSchemaElement headElement = (XmlSchemaElement)elements[substitutionGroup.Examplar];
if (substitutionGroup.Members.Contains(headElement)) {// already checked
return;
}
foreach (XmlSchemaElement element in substitutionGroup.Members) {
//Chain to other head's that are members of this head's substGroup
XmlSchemaSubstitutionGroup g = (XmlSchemaSubstitutionGroup)substTable[element.QualifiedName];
if (g != null) {
ResolveSubstitutionGroup(g, substTable);
foreach (XmlSchemaElement element1 in g.Members) {
if (element1 != element) { //Exclude the head
if (newMembers == null) {
newMembers = new ArrayList();
}
newMembers.Add(element1);
}
}
}
}
if (newMembers != null) {
foreach (XmlSchemaElement newMember in newMembers) {
substitutionGroup.Members.Add(newMember);
}
}
substitutionGroup.Members.Add(headElement);
}
private void PreprocessElement(XmlSchemaElement element) {
if (element.Name != null) {
ValidateNameAttribute(element);
element.SetQualifiedName(new XmlQualifiedName(element.Name, this.targetNamespace));
}
else {
SendValidationEvent(Res.Sch_MissRequiredAttribute, "name", element);
}
PreprocessElementContent(element);
if (element.Final == XmlSchemaDerivationMethod.All) {
element.SetFinalResolved(XmlSchemaDerivationMethod.All);
}
else if (element.Final == XmlSchemaDerivationMethod.None) {
if (this.finalDefault == XmlSchemaDerivationMethod.All) {
element.SetFinalResolved(XmlSchemaDerivationMethod.All);
}
else {
element.SetFinalResolved(this.finalDefault & elementFinalAllowed);
}
}
else {
if ((element.Final & ~elementFinalAllowed) != 0) {
SendValidationEvent(Res.Sch_InvalidElementFinalValue, element);
}
element.SetFinalResolved(element.Final & elementFinalAllowed);
}
if (element.Form != XmlSchemaForm.None) {
SendValidationEvent(Res.Sch_ForbiddenAttribute, "form", element);
}
if (element.MinOccursString != null) {
SendValidationEvent(Res.Sch_ForbiddenAttribute, "minOccurs", element);
}
if (element.MaxOccursString != null) {
SendValidationEvent(Res.Sch_ForbiddenAttribute, "maxOccurs", element);
}
if (!element.SubstitutionGroup.IsEmpty) {
ValidateQNameAttribute(element, "type", element.SubstitutionGroup);
XmlSchemaSubstitutionGroup substitutionGroup = (XmlSchemaSubstitutionGroup)this.schema.Examplars[element.SubstitutionGroup];
if (substitutionGroup == null) {
substitutionGroup = new XmlSchemaSubstitutionGroup();
substitutionGroup.Examplar = element.SubstitutionGroup;
this.schema.Examplars.Add(element.SubstitutionGroup, substitutionGroup);
}
if (substitutionGroup.Members[element.QualifiedName] == null) {
substitutionGroup.Members.Add(element.QualifiedName, element);
}
}
ValidateIdAttribute(element);
}
private void CompileSubstitutionGroup(XmlSchemaSubstitutionGroup substitutionGroup) {
if (substitutionGroup.Validating) {
foreach (XmlSchemaElement element in substitutionGroup.Members.Values) {
SendValidationEvent(Res.Sch_SubstitutionCircularRef, element);
return;
}
}
if (substitutionGroup.Members[substitutionGroup.Examplar] != null) {// already checked
return;
}
substitutionGroup.Validating = true;
XmlSchemaElement examplar = (XmlSchemaElement)this.schema.Elements[substitutionGroup.Examplar];
if (examplar != null) {
if (examplar.FinalResolved == XmlSchemaDerivationMethod.All) {
SendValidationEvent(Res.Sch_InvalidExamplar, examplar);
}
foreach (XmlSchemaElement element in substitutionGroup.Members.Values) {
XmlSchemaSubstitutionGroup g = (XmlSchemaSubstitutionGroup)this.schema.Examplars[element.QualifiedName];
if (g != null) {
CompileSubstitutionGroup(g);
foreach (XmlSchemaElement element1 in g.Choice.Items) {
substitutionGroup.Choice.Items.Add(element1);
}
}
else {
substitutionGroup.Choice.Items.Add(element);
}
}
substitutionGroup.Choice.Items.Add(examplar);
substitutionGroup.Members.Add(examplar.QualifiedName, examplar); // Compiled mark
}
else {
foreach (XmlSchemaElement element in substitutionGroup.Members.Values) {
SendValidationEvent(Res.Sch_NoExamplar, element);
break;
}
}
substitutionGroup.Validating = false;
}
private void CompileSubstitutionGroup(XmlSchemaSubstitutionGroup substitutionGroup) {
if (substitutionGroup.IsProcessing) {
foreach (XmlSchemaElement element in substitutionGroup.Members) {
SendValidationEvent(Res.Sch_SubstitutionCircularRef, element);
return;
}
}
XmlSchemaElement examplar = (XmlSchemaElement)elements[substitutionGroup.Examplar];
Debug.Assert(examplar != null); //Headelement presence is checked while building subst groups
if (substitutionGroup.Members.Contains(examplar)) {// already checked
return;
}
substitutionGroup.IsProcessing = true;
try {
if (examplar.FinalResolved == XmlSchemaDerivationMethod.All) {
SendValidationEvent(Res.Sch_InvalidExamplar, examplar);
}
//Build transitive members
ArrayList newMembers = null;
foreach (XmlSchemaElement element in substitutionGroup.Members) {
//Chain to other head's that are members of this head's substGroup
XmlSchemaSubstitutionGroup g = (XmlSchemaSubstitutionGroup)examplars[element.QualifiedName];
if (g != null) {
CompileSubstitutionGroup(g);
foreach (XmlSchemaElement element1 in g.Members) {
if (element1 != element) { //Exclude the head
if (newMembers == null) {
newMembers = new ArrayList();
}
newMembers.Add(element1);
}
}
}
}
if (newMembers != null) {
foreach (XmlSchemaElement newMember in newMembers) {
substitutionGroup.Members.Add(newMember);
}
}
substitutionGroup.Members.Add(examplar); // Compiled mark
}
finally {
substitutionGroup.IsProcessing = false;
}
}
private void ResolveSubstitutionGroup(XmlSchemaSubstitutionGroup substitutionGroup, XmlSchemaObjectTable substTable)
{
List<XmlSchemaElement> list = null;
XmlSchemaElement item = (XmlSchemaElement) this.elements[substitutionGroup.Examplar];
if (!substitutionGroup.Members.Contains(item))
{
for (int i = 0; i < substitutionGroup.Members.Count; i++)
{
XmlSchemaElement element2 = (XmlSchemaElement) substitutionGroup.Members[i];
XmlSchemaSubstitutionGroup group = (XmlSchemaSubstitutionGroup) substTable[element2.QualifiedName];
if (group != null)
{
this.ResolveSubstitutionGroup(group, substTable);
for (int j = 0; j < group.Members.Count; j++)
{
XmlSchemaElement element3 = (XmlSchemaElement) group.Members[j];
if (element3 != element2)
{
if (list == null)
{
list = new List<XmlSchemaElement>();
}
list.Add(element3);
}
}
}
}
if (list != null)
{
for (int k = 0; k < list.Count; k++)
{
substitutionGroup.Members.Add(list[k]);
}
}
substitutionGroup.Members.Add(item);
}
}
