internal ConstraintStruct(CompiledIdentityConstraint constraint)
 {
     this.constraint     = constraint;
     this.tableDim       = constraint.Fields.Length;
     this.axisFields     = new ArrayList();          // empty fields
     this.axisSelector   = new SelectorActiveAxis(constraint.Selector, this);
     this.qualifiedTable = new Hashtable();
 }
 internal ConstraintStruct (CompiledIdentityConstraint constraint) {
     this.constraint = constraint;
     this.tableDim = constraint.Fields.Length;
     this.axisFields = new ArrayList();              // empty fields
     this.axisSelector = new SelectorActiveAxis (constraint.Selector, this);
     if (this.constraint.Role != CompiledIdentityConstraint.ConstraintRole.Keyref) {
         this.qualifiedTable = new Hashtable();
     }
 }
예제 #3
0
 internal ConstraintStruct (CompiledIdentityConstraint constraint) {
     this.constraint = constraint;
     this.tableDim = constraint.Fields.Length;
     this.constraintTable = new ArrayList();         // empty table
     this.currentRow = 0;
     this.axisFields = new ArrayList();              // empty fields
     this.axisSelector = new ActiveAxis (constraint.Selector);
     this.qualifiedTable = new Hashtable();
 
 }
 private void CompileIdentityConstraint(XmlSchemaIdentityConstraint xi)
 {
     if (xi.IsProcessing)
     {
         xi.CompiledConstraint = CompiledIdentityConstraint.Empty;
         base.SendValidationEvent("Sch_IdentityConstraintCircularRef", xi);
     }
     else if (xi.CompiledConstraint == null)
     {
         xi.IsProcessing = true;
         CompiledIdentityConstraint constraint = null;
         try
         {
             SchemaNamespaceManager nsmgr = new SchemaNamespaceManager(xi);
             constraint = new CompiledIdentityConstraint(xi, nsmgr);
             if (xi is XmlSchemaKeyref)
             {
                 XmlSchemaIdentityConstraint constraint2 = (XmlSchemaIdentityConstraint) this.schema.IdentityConstraints[((XmlSchemaKeyref) xi).Refer];
                 if (constraint2 == null)
                 {
                     throw new XmlSchemaException("Sch_UndeclaredIdentityConstraint", ((XmlSchemaKeyref) xi).Refer.ToString(), xi);
                 }
                 this.CompileIdentityConstraint(constraint2);
                 if (constraint2.CompiledConstraint == null)
                 {
                     throw new XmlSchemaException("Sch_RefInvalidIdentityConstraint", ((XmlSchemaKeyref) xi).Refer.ToString(), xi);
                 }
                 if (constraint2.Fields.Count != xi.Fields.Count)
                 {
                     throw new XmlSchemaException("Sch_RefInvalidCardin", xi.QualifiedName.ToString(), xi);
                 }
                 if (constraint2.CompiledConstraint.Role == CompiledIdentityConstraint.ConstraintRole.Keyref)
                 {
                     throw new XmlSchemaException("Sch_ReftoKeyref", xi.QualifiedName.ToString(), xi);
                 }
             }
             xi.CompiledConstraint = constraint;
         }
         catch (XmlSchemaException exception)
         {
             if (exception.SourceSchemaObject == null)
             {
                 exception.SetSource(xi);
             }
             base.SendValidationEvent(exception);
             xi.CompiledConstraint = CompiledIdentityConstraint.Empty;
         }
         finally
         {
             xi.IsProcessing = false;
         }
     }
 }
 private void CompileElement(XmlSchemaElement xe)
 {
     if (xe.IsProcessing)
     {
         base.SendValidationEvent("Sch_ElementCircularRef", xe);
     }
     else if (xe.ElementDecl == null)
     {
         xe.IsProcessing = true;
         SchemaElementDecl decl = null;
         try
         {
             if (!xe.RefName.IsEmpty)
             {
                 XmlSchemaElement element = (XmlSchemaElement) this.schema.Elements[xe.RefName];
                 if (element == null)
                 {
                     throw new XmlSchemaException("Sch_UndeclaredElement", xe.RefName.ToString(), xe);
                 }
                 this.CompileElement(element);
                 if (element.ElementDecl == null)
                 {
                     throw new XmlSchemaException("Sch_RefInvalidElement", xe.RefName.ToString(), xe);
                 }
                 xe.SetElementType(element.ElementSchemaType);
                 decl = element.ElementDecl.Clone();
             }
             else
             {
                 if (xe.SchemaType != null)
                 {
                     xe.SetElementType(xe.SchemaType);
                 }
                 else if (!xe.SchemaTypeName.IsEmpty)
                 {
                     xe.SetElementType(this.GetAnySchemaType(xe.SchemaTypeName));
                     if (xe.ElementSchemaType == null)
                     {
                         throw new XmlSchemaException("Sch_UndeclaredType", xe.SchemaTypeName.ToString(), xe);
                     }
                 }
                 else if (!xe.SubstitutionGroup.IsEmpty)
                 {
                     XmlSchemaElement element2 = (XmlSchemaElement) this.schema.Elements[xe.SubstitutionGroup];
                     if (element2 == null)
                     {
                         throw new XmlSchemaException("Sch_UndeclaredEquivClass", xe.SubstitutionGroup.Name.ToString(CultureInfo.InvariantCulture), xe);
                     }
                     if (element2.IsProcessing)
                     {
                         return;
                     }
                     this.CompileElement(element2);
                     if (element2.ElementDecl == null)
                     {
                         xe.SetElementType(XmlSchemaComplexType.AnyType);
                         decl = XmlSchemaComplexType.AnyType.ElementDecl.Clone();
                     }
                     else
                     {
                         xe.SetElementType(element2.ElementSchemaType);
                         decl = element2.ElementDecl.Clone();
                     }
                 }
                 else
                 {
                     xe.SetElementType(XmlSchemaComplexType.AnyType);
                     decl = XmlSchemaComplexType.AnyType.ElementDecl.Clone();
                 }
                 if (decl == null)
                 {
                     if (xe.ElementSchemaType is XmlSchemaComplexType)
                     {
                         XmlSchemaComplexType complexType = (XmlSchemaComplexType) xe.ElementSchemaType;
                         this.CompileComplexType(complexType);
                         if (complexType.ElementDecl != null)
                         {
                             decl = complexType.ElementDecl.Clone();
                         }
                     }
                     else if (xe.ElementSchemaType is XmlSchemaSimpleType)
                     {
                         XmlSchemaSimpleType simpleType = (XmlSchemaSimpleType) xe.ElementSchemaType;
                         this.CompileSimpleType(simpleType);
                         if (simpleType.ElementDecl != null)
                         {
                             decl = simpleType.ElementDecl.Clone();
                         }
                     }
                 }
                 decl.Name = xe.QualifiedName;
                 decl.IsAbstract = xe.IsAbstract;
                 XmlSchemaComplexType elementSchemaType = xe.ElementSchemaType as XmlSchemaComplexType;
                 if (elementSchemaType != null)
                 {
                     decl.IsAbstract |= elementSchemaType.IsAbstract;
                 }
                 decl.IsNillable = xe.IsNillable;
                 decl.Block |= xe.BlockResolved;
             }
             if (decl.Datatype != null)
             {
                 decl.Datatype.VerifySchemaValid(this.schema.Notations, xe);
             }
             if (((xe.DefaultValue != null) || (xe.FixedValue != null)) && (decl.ContentValidator != null))
             {
                 if (decl.ContentValidator.ContentType == XmlSchemaContentType.TextOnly)
                 {
                     if (xe.DefaultValue != null)
                     {
                         decl.Presence = SchemaDeclBase.Use.Default;
                         decl.DefaultValueRaw = xe.DefaultValue;
                     }
                     else
                     {
                         decl.Presence = SchemaDeclBase.Use.Fixed;
                         decl.DefaultValueRaw = xe.FixedValue;
                     }
                     if (decl.Datatype != null)
                     {
                         decl.DefaultValueTyped = decl.Datatype.ParseValue(decl.DefaultValueRaw, base.NameTable, new SchemaNamespaceManager(xe), true);
                     }
                 }
                 else if ((decl.ContentValidator.ContentType != XmlSchemaContentType.Mixed) || !decl.ContentValidator.IsEmptiable)
                 {
                     throw new XmlSchemaException("Sch_ElementCannotHaveValue", xe);
                 }
             }
             if (xe.HasConstraints)
             {
                 XmlSchemaObjectCollection constraints = xe.Constraints;
                 CompiledIdentityConstraint[] constraintArray = new CompiledIdentityConstraint[constraints.Count];
                 int num = 0;
                 for (int i = 0; i < constraints.Count; i++)
                 {
                     XmlSchemaIdentityConstraint xi = (XmlSchemaIdentityConstraint) constraints[i];
                     this.CompileIdentityConstraint(xi);
                     constraintArray[num++] = xi.CompiledConstraint;
                 }
                 decl.Constraints = constraintArray;
             }
             decl.SchemaElement = xe;
             xe.ElementDecl = decl;
         }
         catch (XmlSchemaException exception)
         {
             if (exception.SourceSchemaObject == null)
             {
                 exception.SetSource(xe);
             }
             base.SendValidationEvent(exception);
             xe.ElementDecl = SchemaElementDecl.Empty;
         }
         finally
         {
             xe.IsProcessing = false;
         }
     }
 }
        private void CompileElement(XmlSchemaElement xe) {
            if (xe.IsProcessing) {
                SendValidationEvent(Res.Sch_ElementCircularRef, xe);
                return;
            }
            if (xe.ElementDecl != null) {
                return;
            }
            xe.IsProcessing = true;
            SchemaElementDecl decl = null;
            try {
                if (!xe.RefName.IsEmpty) {
                    XmlSchemaElement e = (XmlSchemaElement)elements[xe.RefName];
                    if (e == null) {
                        throw new XmlSchemaException(Res.Sch_UndeclaredElement, xe.RefName.ToString(), xe);
                    }  
                    CompileElement(e);
                    if (e.ElementDecl == null) {
                        throw new XmlSchemaException(Res.Sch_RefInvalidElement, xe.RefName.ToString(), xe);
                    }
                    xe.SetElementType(e.ElementSchemaType);
                    decl = e.ElementDecl.Clone();
                }
                else {
                    if (xe.SchemaType != null) {
                        xe.SetElementType(xe.SchemaType);
                    }
                    else if (!xe.SchemaTypeName.IsEmpty) {
                        xe.SetElementType(GetAnySchemaType(xe.SchemaTypeName));
                        if (xe.ElementSchemaType == null) {
                            throw new XmlSchemaException(Res.Sch_UndeclaredType, xe.SchemaTypeName.ToString(), xe);   
                        }
                    }
                    else  if (!xe.SubstitutionGroup.IsEmpty) {
                        XmlSchemaElement examplar = (XmlSchemaElement)elements[xe.SubstitutionGroup];
                        if (examplar == null) {
                            throw new XmlSchemaException(Res.Sch_UndeclaredEquivClass, xe.SubstitutionGroup.Name.ToString(CultureInfo.InvariantCulture), xe);   
                        }
                        if (examplar.IsProcessing) { //Circular subst group; already detected by now
                            return;
                        }
                        CompileElement(examplar);
                        if (examplar.ElementDecl == null) { //If head is invalid, fall back to AnyType
                            xe.SetElementType(XmlSchemaComplexType.AnyType);
                            decl = XmlSchemaComplexType.AnyType.ElementDecl.Clone();
                        }
                        else {
                            xe.SetElementType(examplar.ElementSchemaType);
                            decl = examplar.ElementDecl.Clone();
                        }
                    }
                    else {
                        xe.SetElementType(XmlSchemaComplexType.AnyType);
                        decl = XmlSchemaComplexType.AnyType.ElementDecl.Clone();
                    }
            
                    if (decl == null) {
                        Debug.Assert(xe.ElementSchemaType != null);
                        if (xe.ElementSchemaType is XmlSchemaComplexType) {
                            XmlSchemaComplexType complexType = (XmlSchemaComplexType)xe.ElementSchemaType;
                            CompileComplexType(complexType);
                            if (complexType.ElementDecl != null) {
                                decl = complexType.ElementDecl.Clone();
//                                decl.LocalElements = complexType.LocalElementDecls;
                            }
                        } 
                        else if (xe.ElementSchemaType is XmlSchemaSimpleType) {
                            XmlSchemaSimpleType simpleType = (XmlSchemaSimpleType)xe.ElementSchemaType;
                            CompileSimpleType(simpleType);
                            if (simpleType.ElementDecl != null) {
                                decl = simpleType.ElementDecl.Clone();
                            }
                        } 
                    }
                    Debug.Assert(decl != null);
                    decl.Name = xe.QualifiedName;
                    decl.IsAbstract = xe.IsAbstract;
                    XmlSchemaComplexType ct = xe.ElementSchemaType as XmlSchemaComplexType;
                    if (ct != null) {
                        decl.IsAbstract |= ct.IsAbstract; 
                    }
                    decl.IsNillable = xe.IsNillable;
                    decl.Block |= xe.BlockResolved;
                }
                if (decl.Datatype != null) {
                    decl.Datatype.VerifySchemaValid(notations, xe);
                }

                if (xe.DefaultValue != null || xe.FixedValue != null) {
                    if (decl.ContentValidator != null) {
                        if (decl.ContentValidator.ContentType == XmlSchemaContentType.TextOnly || (decl.ContentValidator.ContentType == XmlSchemaContentType.Mixed && decl.ContentValidator.IsEmptiable)) {
                            if (xe.DefaultValue != null) {
                                decl.Presence = SchemaDeclBase.Use.Default; 
                                decl.DefaultValueRaw = xe.DefaultValue;
                            }
                            else {
                                decl.Presence = SchemaDeclBase.Use.Fixed; 
                                decl.DefaultValueRaw = xe.FixedValue;
                            }
                            if (decl.Datatype != null) {
                                if (decl.Datatype.TypeCode == XmlTypeCode.Id) {
                                    SendValidationEvent(Res.Sch_DefaultIdValue, xe);
                                }
                                else {
                                    decl.DefaultValueTyped = decl.Datatype.ParseValue(decl.DefaultValueRaw, NameTable, new SchemaNamespaceManager(xe), true);
                                }
                            }
                            else { //Mixed with emptiable particle
                                decl.DefaultValueTyped = DatatypeImplementation.AnySimpleType.Datatype.ParseValue(decl.DefaultValueRaw, NameTable, new SchemaNamespaceManager(xe));
                            }
                        }
                        else {
                            throw new XmlSchemaException(Res.Sch_ElementCannotHaveValue, xe);
                        }
                    }
                }
                if (xe.HasConstraints) {
                    XmlSchemaObjectCollection constraints = xe.Constraints;
                    CompiledIdentityConstraint[] compiledConstraints = new CompiledIdentityConstraint[constraints.Count];
                    int idx = 0;
                    for (int i = 0; i < constraints.Count; ++i) {
                        XmlSchemaIdentityConstraint constraint = (XmlSchemaIdentityConstraint)constraints[i];
                        CompileIdentityConstraint(constraint);
                        compiledConstraints[idx ++] = constraint.CompiledConstraint;
                    }
                    decl.Constraints = compiledConstraints;
                }
                decl.SchemaElement = xe; //So this is available for PSVI
                xe.ElementDecl = decl;
            } 
            catch (XmlSchemaException e) {
                if (e.SourceSchemaObject == null) {
                    e.SetSource(xe);
                }
                SendValidationEvent(e);
                xe.ElementDecl = SchemaElementDecl.Empty;
            } 
            finally {
                xe.IsProcessing = false;
            }
        }
        private void CompileIdentityConstraint (XmlSchemaIdentityConstraint xi) { 
            if (xi.IsProcessing) {
                xi.CompiledConstraint = CompiledIdentityConstraint.Empty;       
                SendValidationEvent(Res.Sch_IdentityConstraintCircularRef, xi);
                return;
            }

            if (xi.CompiledConstraint != null) {
                return;
            }
            
            xi.IsProcessing = true;
            CompiledIdentityConstraint compic = null;
            try {
                SchemaNamespaceManager xnmgr = new SchemaNamespaceManager(xi);
                compic = new CompiledIdentityConstraint(xi, xnmgr);
                if (xi is XmlSchemaKeyref) {
                    XmlSchemaIdentityConstraint ic = (XmlSchemaIdentityConstraint)this.identityConstraints[((XmlSchemaKeyref)xi).Refer];
                    if (ic == null) {
                        throw new XmlSchemaException(Res.Sch_UndeclaredIdentityConstraint, ((XmlSchemaKeyref)xi).Refer.ToString(), xi);
                    }     
                    CompileIdentityConstraint(ic);
                    if (ic.CompiledConstraint == null) {
                        throw new XmlSchemaException(Res.Sch_RefInvalidIdentityConstraint, ((XmlSchemaKeyref)xi).Refer.ToString(), xi);
                    }
                    // keyref has the different cardinality with the key it referred
                    if (ic.Fields.Count != xi.Fields.Count) {
                        throw new XmlSchemaException(Res.Sch_RefInvalidCardin, xi.QualifiedName.ToString(), xi);
                    }
                    // keyref can only refer to key/unique
                    if (ic.CompiledConstraint.Role == CompiledIdentityConstraint.ConstraintRole.Keyref) {
                        throw new XmlSchemaException(Res.Sch_ReftoKeyref, xi.QualifiedName.ToString(), xi);
                    }
                }
                xi.CompiledConstraint = compic;
            }
            catch (XmlSchemaException e) {
                if (e.SourceSchemaObject == null) {
                    e.SetSource(xi);
                }
                SendValidationEvent(e);
                xi.CompiledConstraint = CompiledIdentityConstraint.Empty;       
                // empty is better than null here, stop quickly when circle referencing
            } 
            finally {
                xi.IsProcessing = false;
            }

        }
예제 #8
0
파일: compiler.cs 프로젝트: ArildF/masters
        private void CompileElement(XmlSchemaElement xe) {
            if (xe.Validating) {
                SendValidationEvent(Res.Sch_ElementCircularRef, xe);
                return;
            }
            if (xe.ElementDecl != null) {
                return;
            }
            xe.Validating = true;
            SchemaElementDecl decl = null;
            try {
                if (!xe.RefName.IsEmpty) {
                    XmlSchemaElement e = (XmlSchemaElement)this.schema.Elements[xe.RefName];
                    if (e == null) {
                        throw new XmlSchemaException(Res.Sch_UndeclaredElement, xe.RefName.ToString(), xe);
                    }  
                    CompileElement(e);
                    if (e.ElementDecl == null) {
                        throw new XmlSchemaException(Res.Sch_RefInvalidElement, xe.RefName.ToString(), xe);
                    }
                    xe.SetElementType(e.ElementType);
                    decl = e.ElementDecl.Clone();
                }
                else {
                    if (xe.SchemaType != null) {
                        xe.SetElementType(xe.SchemaType);
                    }
                    else if (!xe.SchemaTypeName.IsEmpty) {
                        XmlSchemaDatatype datatype;
                        xe.SetElementType(GetAnySchemaType(xe.SchemaTypeName, out datatype));
                        if (xe.ElementType == null) {
                            throw new XmlSchemaException(Res.Sch_UndeclaredType, xe.SchemaTypeName.ToString(), xe);   
                        }
                    }
                    else  if (!xe.SubstitutionGroup.IsEmpty) {
                        XmlSchemaElement examplar = (XmlSchemaElement)this.schema.Elements[xe.SubstitutionGroup];
                        if (examplar == null) {
                            throw new XmlSchemaException(Res.Sch_UndeclaredEquivClass, xe.SubstitutionGroup.Name.ToString(), xe);   
                        }
                        CompileElement(examplar);
                        xe.SetElementType(examplar.ElementType);
                        decl = examplar.ElementDecl.Clone();
                    }
                    else {
                        xe.SetElementType(XmlSchemaDatatype.AnyType);
                        decl = SchemaElementDecl.CreateAnyTypeElementDecl();
                    }
            
                    if (decl == null) {
                        Debug.Assert(xe.ElementType != null);
                        if (xe.ElementType is XmlSchemaComplexType) {
                            XmlSchemaComplexType complexType = (XmlSchemaComplexType)xe.ElementType;
                            CompileComplexType(complexType);
                            if (complexType.ElementDecl != null) {
                                decl = complexType.ElementDecl.Clone();
                                decl.LocalElements = complexType.LocalElementDecls;
                            }
                        } 
                        else if (xe.ElementType is XmlSchemaSimpleType) {
                            XmlSchemaSimpleType simpleType = (XmlSchemaSimpleType)xe.ElementType;
                            CompileSimpleType(simpleType);
                            if (simpleType.ElementDecl != null) {
                                decl = simpleType.ElementDecl.Clone();
                            }
                        } 
                        else {
                            decl = new SchemaElementDecl((XmlSchemaDatatype)xe.ElementType, this.schemaNames);
                        }
                    }
                    decl.Name = xe.QualifiedName;
                    decl.IsAbstract = xe.IsAbstract;
                    XmlSchemaComplexType ct = xe.ElementType as XmlSchemaComplexType;
                    if (ct != null) {
                        decl.IsAbstract |= ct.IsAbstract; 
                    }
                    decl.IsNillable = xe.IsNillable;
                    decl.Block |= xe.BlockResolved;
                }
                if (decl.Datatype != null) {
                    decl.Datatype.VerifySchemaValid(this.schema, xe);
                }

                if (xe.DefaultValue != null || xe.FixedValue != null) {
                    if (decl.Content.ContentType == CompiledContentModel.Type.Text) {
                        if (xe.DefaultValue != null) {
                            decl.Presence = SchemaDeclBase.Use.Default; 
                            decl.DefaultValueTyped = decl.Datatype.ParseValue(xe.DefaultValue, this.nameTable, this.namespaceManager);
                        }
                        else {
                            decl.Presence = SchemaDeclBase.Use.Fixed; 
                            decl.DefaultValueTyped = decl.Datatype.ParseValue(xe.FixedValue, this.nameTable, this.namespaceManager);
                        }
                    }
                    else if (decl.Content.ContentType != CompiledContentModel.Type.Mixed || !decl.Content.IsEmptiable) {
                        throw new XmlSchemaException(Res.Sch_ElementCannotHaveValue, xe);
                    }            
                }
                if (xe.HasConstraints) {
                    XmlSchemaObjectCollection constraints = xe.Constraints;
                    CompiledIdentityConstraint[] compiledConstraints = new CompiledIdentityConstraint[constraints.Count];
                    int idx = 0;
                    foreach(XmlSchemaIdentityConstraint constraint in constraints) {
                        CompileIdentityConstraint (constraint);
                        compiledConstraints[idx ++] = constraint.CompiledConstraint;
                    }
                    decl.Constraints = compiledConstraints;
                }
                xe.ElementDecl = decl;
            } 
            catch (XmlSchemaException e) {
                if (e.SourceSchemaObject == null) {
                    e.SetSource(xe);
                }
                SendValidationEvent(e);
                xe.ElementDecl = SchemaElementDecl.Empty;
            } 
            finally {
                xe.Validating = false;
            }
        }