diff --git a/ChangeLog b/ChangeLog index 453079f4..ace413d7 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,16 @@ +Fri Sep 3 20:29:59 CEST 2004 Kasimier Buchcik + + * xmlschemas.c include/libxml/schemasInternals.h + include/libxml/xmlerror.h: Fixed a seg fault in xmlGetQNameProp: + a format argument was missing. + Fixed wrong assignment of the owner of a wildcard in + xmlSchemaBuildAttributeValidation (in the shorthandform of + ; this caused a seg fault, due to a double-free + of the wildcard. + Added a check for circular attribute group references. + Added a check for circular model group definition references. + Fixed a dublicate xmlParserErrors enum value - see bug #151738. + Fri Sep 3 10:08:13 PDT 2004 William Brack * xmlstring.c: modified comments on xmlGetUTF8Char in diff --git a/include/libxml/schemasInternals.h b/include/libxml/schemasInternals.h index 6aa8dd60..0f326918 100644 --- a/include/libxml/schemasInternals.h +++ b/include/libxml/schemasInternals.h @@ -318,6 +318,12 @@ struct _xmlSchemaWildcard { * The attribute wildcard has been already builded. */ #define XML_SCHEMAS_ATTRGROUP_GLOBAL 1 << 1 +/** + * XML_SCHEMAS_ATTRGROUP_MARKED: + * + * Marks the attr group as marked; used for circular checks. + */ +#define XML_SCHEMAS_ATTRGROUP_MARKED 1 << 2 /** * An attribute group definition. @@ -341,6 +347,7 @@ struct _xmlSchemaAttributeGroup { int flags; xmlSchemaWildcardPtr attributeWildcard; const xmlChar *refPrefix; + xmlSchemaAttributeGroupPtr refItem; /* The referenced attribute group */ }; /** @@ -457,6 +464,12 @@ struct _xmlSchemaFacetLink { * the simpleType has a final of "union". */ #define XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE 1 << 14 +/** + * XML_SCHEMAS_TYPE_MARKED + * + * Marks the item as marked; used for circular checks. + */ +#define XML_SCHEMAS_TYPE_MARKED 1 << 16 /** * _xmlSchemaType: diff --git a/include/libxml/xmlerror.h b/include/libxml/xmlerror.h index 2b72abc1..5a9cf71f 100644 --- a/include/libxml/xmlerror.h +++ b/include/libxml/xmlerror.h @@ -530,122 +530,122 @@ typedef enum { XML_SCHEMAP_UNKNOWN_UNION_CHILD, /* 1754 */ XML_SCHEMAP_ELEM_DEFAULT_FIXED, /* 1755 */ XML_SCHEMAP_REGEXP_INVALID, /* 1756 */ - XML_SCHEMAP_FAILED_LOAD, /* 1756 */ - XML_SCHEMAP_NOTHING_TO_PARSE, /* 1757 */ - XML_SCHEMAP_NOROOT, /* 1758 */ - XML_SCHEMAP_REDEFINED_GROUP, /* 1759 */ - XML_SCHEMAP_REDEFINED_TYPE, /* 1760 */ - XML_SCHEMAP_REDEFINED_ELEMENT, /* 1761 */ - XML_SCHEMAP_REDEFINED_ATTRGROUP, /* 1762 */ - XML_SCHEMAP_REDEFINED_ATTR, /* 1763 */ - XML_SCHEMAP_REDEFINED_NOTATION, /* 1764 */ - XML_SCHEMAP_FAILED_PARSE, /* 1765 */ - XML_SCHEMAP_UNKNOWN_PREFIX, /* 1766 */ - XML_SCHEMAP_DEF_AND_PREFIX, /* 1767 */ - XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD, /* 1768 */ - XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI, /* 1769 */ - XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI, /* 1770 */ - XML_SCHEMAP_NOT_SCHEMA, /* 1771 */ - XML_SCHEMAP_UNKNOWN_MEMBER_TYPE, /* 1772 */ - XML_SCHEMAP_INVALID_ATTR_USE, /* 1773 */ - XML_SCHEMAP_RECURSIVE, /* 1774 */ - XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE, /* 1775 */ - XML_SCHEMAP_INVALID_ATTR_COMBINATION, /* 1776 */ - XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION, /* 1777 */ - XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD, /* 1778 */ - XML_SCHEMAP_INVALID_ATTR_NAME, /* 1779 */ - XML_SCHEMAP_REF_AND_CONTENT, /* 1780 */ - XML_SCHEMAP_CT_PROPS_CORRECT_1, /* 1781 */ - XML_SCHEMAP_CT_PROPS_CORRECT_2, /* 1782 */ - XML_SCHEMAP_CT_PROPS_CORRECT_3, /* 1783 */ - XML_SCHEMAP_CT_PROPS_CORRECT_4, /* 1784 */ - XML_SCHEMAP_CT_PROPS_CORRECT_5, /* 1785 */ - XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1, /* 1786 */ - XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1, /* 1787 */ - XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2, /* 1788 */ - XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2, /* 1789 */ - XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3, /* 1790 */ - XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER, /* 1791 */ - XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE, /* 1792 */ - XML_SCHEMAP_UNION_NOT_EXPRESSIBLE, /* 1793 */ - XML_SCHEMAP_SRC_IMPORT_3_1, /* 1794 */ - XML_SCHEMAP_SRC_IMPORT_3_2, /* 1795 */ - XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1, /* 1796 */ - XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2, /* 1797 */ - XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3, /* 1798 */ - XML_SCHEMAP_COS_CT_EXTENDS_1_3, /* 1799 */ - XML_SCHEMAV_NOROOT = 1800, - XML_SCHEMAV_UNDECLAREDELEM, /* 1801 */ - XML_SCHEMAV_NOTTOPLEVEL, /* 1802 */ - XML_SCHEMAV_MISSING, /* 1803 */ - XML_SCHEMAV_WRONGELEM, /* 1804 */ - XML_SCHEMAV_NOTYPE, /* 1805 */ - XML_SCHEMAV_NOROLLBACK, /* 1806 */ - XML_SCHEMAV_ISABSTRACT, /* 1807 */ - XML_SCHEMAV_NOTEMPTY, /* 1808 */ - XML_SCHEMAV_ELEMCONT, /* 1809 */ - XML_SCHEMAV_HAVEDEFAULT, /* 1810 */ - XML_SCHEMAV_NOTNILLABLE, /* 1811 */ - XML_SCHEMAV_EXTRACONTENT, /* 1812 */ - XML_SCHEMAV_INVALIDATTR, /* 1813 */ - XML_SCHEMAV_INVALIDELEM, /* 1814 */ - XML_SCHEMAV_NOTDETERMINIST, /* 1815 */ - XML_SCHEMAV_CONSTRUCT, /* 1816 */ - XML_SCHEMAV_INTERNAL, /* 1817 */ - XML_SCHEMAV_NOTSIMPLE, /* 1818 */ - XML_SCHEMAV_ATTRUNKNOWN, /* 1819 */ - XML_SCHEMAV_ATTRINVALID, /* 1820 */ - XML_SCHEMAV_VALUE, /* 1821 */ - XML_SCHEMAV_FACET, /* 1822 */ - XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1, /* 1823 */ - XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2, /* 1824 */ - XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3, /* 1825 */ - XML_SCHEMAV_CVC_TYPE_3_1_1, /* 1826 */ - XML_SCHEMAV_CVC_TYPE_3_1_2, /* 1827 */ - XML_SCHEMAV_CVC_FACET_VALID, /* 1828 */ - XML_SCHEMAV_CVC_LENGTH_VALID, /* 1829 */ - XML_SCHEMAV_CVC_MINLENGTH_VALID, /* 1830 */ - XML_SCHEMAV_CVC_MAXLENGTH_VALID, /* 1831 */ - XML_SCHEMAV_CVC_MININCLUSIVE_VALID, /* 1832 */ - XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID, /* 1833 */ - XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID, /* 1834 */ - XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID, /* 1835 */ - XML_SCHEMAV_CVC_TOTALDIGITS_VALID, /* 1836 */ - XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID, /* 1837 */ - XML_SCHEMAV_CVC_PATTERN_VALID, /* 1838 */ - XML_SCHEMAV_CVC_ENUMERATION_VALID, /* 1839 */ - XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1, /* 1840 */ - XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2, /* 1841 */ - XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3, /* 1842 */ - XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4, /* 1843 */ - XML_SCHEMAV_CVC_ELT_1, /* 1844 */ - XML_SCHEMAV_CVC_ELT_2, /* 1845 */ - XML_SCHEMAV_CVC_ELT_3_1, - XML_SCHEMAV_CVC_ELT_3_2_1, - XML_SCHEMAV_CVC_ELT_3_2_2, - XML_SCHEMAV_CVC_ELT_4_1, - XML_SCHEMAV_CVC_ELT_4_2, - XML_SCHEMAV_CVC_ELT_4_3, - XML_SCHEMAV_CVC_ELT_5_1_1, - XML_SCHEMAV_CVC_ELT_5_1_2, - XML_SCHEMAV_CVC_ELT_5_2_1, - XML_SCHEMAV_CVC_ELT_5_2_2_1, - XML_SCHEMAV_CVC_ELT_5_2_2_2_1, - XML_SCHEMAV_CVC_ELT_5_2_2_2_2, - XML_SCHEMAV_CVC_ELT_6, - XML_SCHEMAV_CVC_ELT_7, - XML_SCHEMAV_CVC_ATTRIBUTE_1, - XML_SCHEMAV_CVC_ATTRIBUTE_2, - XML_SCHEMAV_CVC_ATTRIBUTE_3, - XML_SCHEMAV_CVC_ATTRIBUTE_4, - XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1, - XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1, - XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2, - XML_SCHEMAV_CVC_COMPLEX_TYPE_4, - XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1, - XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2, - XML_SCHEMAV_ELEMENT_CONTENT, /* 1846 non-W3C */ - XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING, /* non-W3C */ + XML_SCHEMAP_FAILED_LOAD, /* 1757 */ + XML_SCHEMAP_NOTHING_TO_PARSE, /* 1758 */ + XML_SCHEMAP_NOROOT, /* 1759 */ + XML_SCHEMAP_REDEFINED_GROUP, /* 1760 */ + XML_SCHEMAP_REDEFINED_TYPE, /* 1761 */ + XML_SCHEMAP_REDEFINED_ELEMENT, /* 1762 */ + XML_SCHEMAP_REDEFINED_ATTRGROUP, /* 1763 */ + XML_SCHEMAP_REDEFINED_ATTR, /* 1764 */ + XML_SCHEMAP_REDEFINED_NOTATION, /* 1765 */ + XML_SCHEMAP_FAILED_PARSE, /* 1766 */ + XML_SCHEMAP_UNKNOWN_PREFIX, /* 1767 */ + XML_SCHEMAP_DEF_AND_PREFIX, /* 1768 */ + XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD, /* 1769 */ + XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI, /* 1770 */ + XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI, /* 1771 */ + XML_SCHEMAP_NOT_SCHEMA, /* 1772 */ + XML_SCHEMAP_UNKNOWN_MEMBER_TYPE, /* 1773 */ + XML_SCHEMAP_INVALID_ATTR_USE, /* 1774 */ + XML_SCHEMAP_RECURSIVE, /* 1775 */ + XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE, /* 1776 */ + XML_SCHEMAP_INVALID_ATTR_COMBINATION, /* 1777 */ + XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION, /* 1778 */ + XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD, /* 1779 */ + XML_SCHEMAP_INVALID_ATTR_NAME, /* 1780 */ + XML_SCHEMAP_REF_AND_CONTENT, /* 1781 */ + XML_SCHEMAP_CT_PROPS_CORRECT_1, /* 1782 */ + XML_SCHEMAP_CT_PROPS_CORRECT_2, /* 1783 */ + XML_SCHEMAP_CT_PROPS_CORRECT_3, /* 1784 */ + XML_SCHEMAP_CT_PROPS_CORRECT_4, /* 1785 */ + XML_SCHEMAP_CT_PROPS_CORRECT_5, /* 1786 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1, /* 1787 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1, /* 1788 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2, /* 1789 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2, /* 1790 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3, /* 1791 */ + XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER, /* 1792 */ + XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE, /* 1793 */ + XML_SCHEMAP_UNION_NOT_EXPRESSIBLE, /* 1794 */ + XML_SCHEMAP_SRC_IMPORT_3_1, /* 1795 */ + XML_SCHEMAP_SRC_IMPORT_3_2, /* 1796 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1, /* 1797 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2, /* 1798 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3, /* 1799 */ + XML_SCHEMAP_COS_CT_EXTENDS_1_3, /* 1800 */ + XML_SCHEMAV_NOROOT = 1801, + XML_SCHEMAV_UNDECLAREDELEM, /* 1802 */ + XML_SCHEMAV_NOTTOPLEVEL, /* 1803 */ + XML_SCHEMAV_MISSING, /* 1804 */ + XML_SCHEMAV_WRONGELEM, /* 1805 */ + XML_SCHEMAV_NOTYPE, /* 1806 */ + XML_SCHEMAV_NOROLLBACK, /* 1807 */ + XML_SCHEMAV_ISABSTRACT, /* 1808 */ + XML_SCHEMAV_NOTEMPTY, /* 1809 */ + XML_SCHEMAV_ELEMCONT, /* 1810 */ + XML_SCHEMAV_HAVEDEFAULT, /* 1811 */ + XML_SCHEMAV_NOTNILLABLE, /* 1812 */ + XML_SCHEMAV_EXTRACONTENT, /* 1813 */ + XML_SCHEMAV_INVALIDATTR, /* 1814 */ + XML_SCHEMAV_INVALIDELEM, /* 1815 */ + XML_SCHEMAV_NOTDETERMINIST, /* 1816 */ + XML_SCHEMAV_CONSTRUCT, /* 1817 */ + XML_SCHEMAV_INTERNAL, /* 1818 */ + XML_SCHEMAV_NOTSIMPLE, /* 1819 */ + XML_SCHEMAV_ATTRUNKNOWN, /* 1820 */ + XML_SCHEMAV_ATTRINVALID, /* 1821 */ + XML_SCHEMAV_VALUE, /* 1822 */ + XML_SCHEMAV_FACET, /* 1823 */ + XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1, /* 1824 */ + XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2, /* 1825 */ + XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3, /* 1826 */ + XML_SCHEMAV_CVC_TYPE_3_1_1, /* 1827 */ + XML_SCHEMAV_CVC_TYPE_3_1_2, /* 1828 */ + XML_SCHEMAV_CVC_FACET_VALID, /* 1829 */ + XML_SCHEMAV_CVC_LENGTH_VALID, /* 1830 */ + XML_SCHEMAV_CVC_MINLENGTH_VALID, /* 1831 */ + XML_SCHEMAV_CVC_MAXLENGTH_VALID, /* 1832 */ + XML_SCHEMAV_CVC_MININCLUSIVE_VALID, /* 1833 */ + XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID, /* 1834 */ + XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID, /* 1835 */ + XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID, /* 1836 */ + XML_SCHEMAV_CVC_TOTALDIGITS_VALID, /* 1837 */ + XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID, /* 1838 */ + XML_SCHEMAV_CVC_PATTERN_VALID, /* 1839 */ + XML_SCHEMAV_CVC_ENUMERATION_VALID, /* 1840 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1, /* 1841 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2, /* 1842 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3, /* 1843 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4, /* 1844 */ + XML_SCHEMAV_CVC_ELT_1, /* 1845 */ + XML_SCHEMAV_CVC_ELT_2, /* 1846 */ + XML_SCHEMAV_CVC_ELT_3_1, /* 1847 */ + XML_SCHEMAV_CVC_ELT_3_2_1, /* 1848 */ + XML_SCHEMAV_CVC_ELT_3_2_2, /* 1849 */ + XML_SCHEMAV_CVC_ELT_4_1, /* 1850 */ + XML_SCHEMAV_CVC_ELT_4_2, /* 1851 */ + XML_SCHEMAV_CVC_ELT_4_3, /* 1852 */ + XML_SCHEMAV_CVC_ELT_5_1_1, /* 1853 */ + XML_SCHEMAV_CVC_ELT_5_1_2, /* 1854 */ + XML_SCHEMAV_CVC_ELT_5_2_1, /* 1855 */ + XML_SCHEMAV_CVC_ELT_5_2_2_1, /* 1856 */ + XML_SCHEMAV_CVC_ELT_5_2_2_2_1, /* 1857 */ + XML_SCHEMAV_CVC_ELT_5_2_2_2_2, /* 1858 */ + XML_SCHEMAV_CVC_ELT_6, /* 1859 */ + XML_SCHEMAV_CVC_ELT_7, /* 1860 */ + XML_SCHEMAV_CVC_ATTRIBUTE_1, /* 1861 */ + XML_SCHEMAV_CVC_ATTRIBUTE_2, /* 1862 */ + XML_SCHEMAV_CVC_ATTRIBUTE_3, /* 1863 */ + XML_SCHEMAV_CVC_ATTRIBUTE_4, /* 1864 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1, /* 1865 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1, /* 1866 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2, /* 1867 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_4, /* 1868 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1, /* 1869 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2, /* 1870 */ + XML_SCHEMAV_ELEMENT_CONTENT, /* 1871 */ + XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING, /* 1872 */ XML_XPTR_UNKNOWN_SCHEME = 1900, XML_XPTR_CHILDSEQ_START, /* 1901 */ XML_XPTR_EVAL_FAILED, /* 1902 */ @@ -718,19 +718,24 @@ typedef enum { XML_SCHEMAP_SRC_ATTRIBUTE_4, /* 3055 */ XML_SCHEMAP_NO_XMLNS, /* 3056 */ XML_SCHEMAP_NO_XSI, /* 3057 */ - XML_SCHEMAP_COS_VALID_DEFAULT_1, - XML_SCHEMAP_COS_VALID_DEFAULT_2_1, - XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1, - XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2, - XML_SCHEMAP_CVC_SIMPLE_TYPE, - XML_SCHEMAP_COS_CT_EXTENDS_1_1, - XML_SCHEMAP_SRC_IMPORT_1_1, - XML_SCHEMAP_SRC_IMPORT_1_2, - XML_SCHEMAP_SRC_IMPORT_2, - XML_SCHEMAP_SRC_IMPORT_2_1, - XML_SCHEMAP_SRC_IMPORT_2_2, - XML_SCHEMAP_INTERNAL, /* non-W3C */ - XML_SCHEMAP_NOT_DETERMINISTIC /* non-W3C */ + XML_SCHEMAP_COS_VALID_DEFAULT_1, /* 3058 */ + XML_SCHEMAP_COS_VALID_DEFAULT_2_1, /* 3059 */ + XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1, /* 3060 */ + XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2, /* 3061 */ + XML_SCHEMAP_CVC_SIMPLE_TYPE, /* 3062 */ + XML_SCHEMAP_COS_CT_EXTENDS_1_1, /* 3063 */ + XML_SCHEMAP_SRC_IMPORT_1_1, /* 3064 */ + XML_SCHEMAP_SRC_IMPORT_1_2, /* 3065 */ + XML_SCHEMAP_SRC_IMPORT_2, /* 3066 */ + XML_SCHEMAP_SRC_IMPORT_2_1, /* 3067 */ + XML_SCHEMAP_SRC_IMPORT_2_2, /* 3068 */ + XML_SCHEMAP_INTERNAL, /* 3069 non-W3C */ + XML_SCHEMAP_NOT_DETERMINISTIC, /* 3070 non-W3C */ + XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1, /* 3071 */ + XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2, /* 3072 */ + XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3, /* 3073 */ + XML_SCHEMAP_MG_PROPS_CORRECT_1, /* 3074 */ + XML_SCHEMAP_MG_PROPS_CORRECT_2 /* 3075 */ } xmlParserErrors; /** diff --git a/xmlschemas.c b/xmlschemas.c index a7e8d5e7..ce4b5589 100644 --- a/xmlschemas.c +++ b/xmlschemas.c @@ -3243,9 +3243,16 @@ xmlGetQNameProp(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, xmlNsPtr ns; const xmlChar *ret, *prefix; int len; + xmlAttrPtr attr; *namespace = NULL; - val = xmlSchemaGetProp(ctxt, node, name); + attr = xmlSchemaGetPropNode(node, name); + if (attr == NULL) + return (NULL); + val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr); + /* + * TODO: Is the empty value valid for QNames? + */ if (val == NULL) return (NULL); @@ -3265,10 +3272,12 @@ xmlGetQNameProp(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, ns = xmlSearchNs(node->doc, node, prefix); if (ns == NULL) { - xmlSchemaPErr(ctxt, node, XML_SCHEMAP_PREFIX_UNDEFINED, - "Attribute '%s': The prefix '%s' of the QName " - "'%s' has no corresponding namespace declaration is scope.\n", - (const xmlChar *) name, prefix); + xmlSchemaPSimpleTypeErr(ctxt, XML_SCHEMAP_PREFIX_UNDEFINED, + NULL, NULL, (xmlNodePtr) attr, + xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME), NULL, val, + "The prefix '%s' of the QName value " + "'%s' has no corresponding namespace declaration in scope", + prefix, val); } else { *namespace = xmlDictLookup(ctxt->dict, ns->href, -1); } @@ -5708,11 +5717,19 @@ xmlSchemaParseGroup(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema, const xmlChar *name; const xmlChar *ref = NULL, *refNs = NULL; char buf[100]; + int minOccurs, maxOccurs; if ((ctxt == NULL) || (schema == NULL) || (node == NULL)) return (NULL); - - + /* + * TODO: Validate the element even if no item is created + * (i.e. min/maxOccurs == 0). + */ + minOccurs = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "nonNegativeInteger"); + maxOccurs = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1, "(nonNegativeInteger | unbounded)"); + if ((minOccurs == 0) && (maxOccurs == 0)) { + return (NULL); + } name = xmlSchemaGetProp(ctxt, node, "name"); if (name == NULL) { ref = xmlGetQNameProp(ctxt, node, "ref", &refNs); @@ -5738,10 +5755,9 @@ xmlSchemaParseGroup(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema, type->id = xmlSchemaGetProp(ctxt, node, "id"); type->ref = ref; type->refNs = refNs; - - type->minOccurs = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "nonNegativeInteger"); - type->maxOccurs = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1, "(nonNegativeInteger | unbounded)"); - xmlSchemaPCheckParticleCorrect_2(ctxt, type, + type->minOccurs = minOccurs; + type->maxOccurs = maxOccurs; + xmlSchemaPCheckParticleCorrect_2(ctxt, type, node, type->minOccurs, type->maxOccurs); child = node->children; @@ -8137,23 +8153,50 @@ xmlSchemaBuildAContentModel(xmlSchemaTypePtr type, xmlSchemaBuildAContentModel(type->subtypes, ctxt, name); break; case XML_SCHEMA_TYPE_GROUP: - if (type->subtypes == NULL) { - xmlSchemaTypePtr rgroup; - if (type->ref != NULL) { - rgroup = xmlSchemaGetGroup(ctxt->schema, type->ref, - type->refNs); - if (rgroup == NULL) { - xmlSchemaPResCompAttrErr(ctxt, - XML_SCHEMAP_SRC_RESOLVE, - NULL, type, NULL, - "ref", type->ref, type->refNs, - XML_SCHEMA_TYPE_GROUP, NULL); - return; - } - xmlSchemaBuildAContentModel(rgroup, ctxt, name); - break; - } - } + /* + * Handle model group definition references. + * NOTE: type->subtypes is the referenced model grop definition; + * and type->subtypes->subtypes is the model group (i.e. or + * or ). + */ + if ((type->ref != NULL) && (type->subtypes != NULL) && + (type->subtypes->subtypes != NULL)) { + xmlSchemaTypePtr modelGr; + xmlAutomataStatePtr start, end; + + modelGr = type->subtypes->subtypes; + start = ctxt->state; + end = xmlAutomataNewState(ctxt->am); + if (type->maxOccurs == 1) { + ctxt->state = start; + xmlSchemaBuildAContentModel(modelGr, ctxt, name); + xmlAutomataNewEpsilon(ctxt->am, ctxt->state, end); + } else { + int counter; + xmlAutomataStatePtr hop; + int maxOccurs = type->maxOccurs == UNBOUNDED ? + UNBOUNDED : type->maxOccurs - 1; + int minOccurs = + type->minOccurs < 1 ? 0 : type->minOccurs - 1; + + counter = + xmlAutomataNewCounter(ctxt->am, minOccurs, maxOccurs); + hop = xmlAutomataNewState(ctxt->am); + ctxt->state = start; + xmlSchemaBuildAContentModel(modelGr, ctxt, name); + xmlAutomataNewEpsilon(ctxt->am, ctxt->state, hop); + xmlAutomataNewCountedTrans(ctxt->am, hop, start, + counter); + xmlAutomataNewCounterTrans(ctxt->am, hop, end, + counter); + } + if (type->minOccurs == 0) { + xmlAutomataNewEpsilon(ctxt->am, start, end); + } + ctxt->state = end; + break; + } + break; case XML_SCHEMA_TYPE_COMPLEX: case XML_SCHEMA_TYPE_COMPLEX_CONTENT: if (type->subtypes != NULL) @@ -9295,6 +9338,7 @@ xmlSchemaBuildAttributeValidation(xmlSchemaParserCtxtPtr ctxt, xmlSchemaTypePtr xmlSchemaTypePtr anyType; int baseIsAnyType = 0; xmlChar *str = NULL; + int err = 0; anyType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE); /* @@ -9357,27 +9401,32 @@ xmlSchemaBuildAttributeValidation(xmlSchemaParserCtxtPtr ctxt, xmlSchemaTypePtr /* * Handle attribute wildcards. */ - if (xmlSchemaBuildCompleteAttributeWildcard(ctxt, - attrs, &type->attributeWildcard) == -1) { - if ((type->attributeWildcard != NULL) && - /* Either we used the short hand form... */ - ((type->subtypes == NULL) || - /* Or complexType -> restriction/extension */ - (type->attributeWildcard != type->subtypes->subtypes->attributeWildcard))) - type->flags |= XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD; - return (-1); - } + err = xmlSchemaBuildCompleteAttributeWildcard(ctxt, + attrs, &type->attributeWildcard); /* * TODO: This "onwed_attr_wildcard" is quite sensless: we should * create the wildcard right from the start on the complexType, * rather than on the /. + * + * This here simply checks if ->| + * does exist and its wildcard is used or not. */ - if ((type->attributeWildcard != NULL) && - /* Either we used the short hand form... */ - ((type->subtypes == NULL) || - /* Or complexType -> restriction/extension */ - (type->attributeWildcard != type->subtypes->subtypes->attributeWildcard))) - type->flags |= XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD; + if (type->attributeWildcard != NULL) { + if ((type->subtypes == NULL) || + ((type->subtypes->type != XML_SCHEMA_TYPE_COMPLEX_CONTENT) && + (type->subtypes->type != XML_SCHEMA_TYPE_SIMPLE_CONTENT)) || + (type->subtypes->subtypes == NULL) || + (type->attributeWildcard != type->subtypes->subtypes->attributeWildcard)) { + type->flags |= XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD; + } + } + /* + * Note that an error for the above call to + * xmlSchemaBuildCompleteAttributeWildcard is processed here, since we + * needed to set XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD beforehand. + */ + if (err == -1) + return (-1); if ((type->flags & XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION) && ((baseIsAnyType) || @@ -10956,6 +11005,38 @@ xmlSchemaCheckCOSCTExtends(xmlSchemaParserCtxtPtr ctxt, #endif +/** + * xmlSchemaGroupDefFixup: + * @typeDecl: the schema model group definition + * @ctxt: the schema parser context + * + * Fixes model group definitions. + */ +static void +xmlSchemaGroupDefFixup(xmlSchemaTypePtr group, + xmlSchemaParserCtxtPtr ctxt, + const xmlChar * name ATTRIBUTE_UNUSED) +{ + group->contentType = XML_SCHEMA_CONTENT_ELEMENTS; + if ((group->ref != NULL) && (group->subtypes == NULL)) { + xmlSchemaTypePtr groupDef; + /* + * Resolve the reference. + */ + groupDef = xmlSchemaGetGroup(ctxt->schema, group->ref, + group->refNs); + if (groupDef == NULL) { + xmlSchemaPResCompAttrErr(ctxt, + XML_SCHEMAP_SRC_RESOLVE, + NULL, group, NULL, + "ref", group->ref, group->refNs, + XML_SCHEMA_TYPE_GROUP, NULL); + return; + } + group->subtypes = groupDef; + } +} + /** * xmlSchemaTypeFixup: * @typeDecl: the schema type definition @@ -11341,12 +11422,16 @@ xmlSchemaTypeFixup(xmlSchemaTypePtr typeDecl, xmlSchemaCheckSRCSimpleType(ctxt, typeDecl); ctxt->ctxtType = ctxtType; break; - case XML_SCHEMA_TYPE_SEQUENCE: - case XML_SCHEMA_TYPE_GROUP: + case XML_SCHEMA_TYPE_SEQUENCE: case XML_SCHEMA_TYPE_ALL: case XML_SCHEMA_TYPE_CHOICE: typeDecl->contentType = XML_SCHEMA_CONTENT_ELEMENTS; break; + case XML_SCHEMA_TYPE_GROUP: + /* + * TODO: Handling was moved to xmlSchemaGroupDefFixup. + */ + break; case XML_SCHEMA_TYPE_LIST: xmlSchemaParseListRefFixup(typeDecl, ctxt); typeDecl->contentType = XML_SCHEMA_CONTENT_SIMPLE; @@ -11622,6 +11707,234 @@ xmlSchemaCheckDefaults(xmlSchemaTypePtr typeDecl, } } +/** + * xmlSchemaGetCircModelGrDefRef: + * @ctxtGr: the searched model group + * @list: the list of model groups to be processed + * + * This one is intended to be used by + * xmlSchemaCheckGroupDefCircular only. + * + * Returns the circular model group definition reference, otherwise NULL. + */ +static xmlSchemaTypePtr +xmlSchemaGetCircModelGrDefRef(xmlSchemaTypePtr ctxtGrDef, + xmlSchemaTypePtr gr) +{ + xmlSchemaTypePtr circ = NULL; + int marked; + /* + * We will search for an model group reference which + * references the context model group definition. + */ + while (gr != NULL) { + if (((gr->type == XML_SCHEMA_TYPE_GROUP) || + (gr->type == XML_SCHEMA_TYPE_ALL) || + (gr->type == XML_SCHEMA_TYPE_SEQUENCE) || + (gr->type == XML_SCHEMA_TYPE_CHOICE)) && + (gr->subtypes != NULL)) { + marked = 0; + if ((gr->type == XML_SCHEMA_TYPE_GROUP) && + (gr->ref != NULL)) { + if (gr->subtypes == ctxtGrDef) + return (gr); + else if (gr->subtypes->flags & + XML_SCHEMAS_TYPE_MARKED) { + gr = gr->next; + continue; + } else { + /* + * Mark to avoid infinite recursion on + * circular references not yet examined. + */ + gr->subtypes->flags |= XML_SCHEMAS_TYPE_MARKED; + marked = 1; + } + if (gr->subtypes->subtypes != NULL) + circ = xmlSchemaGetCircModelGrDefRef(ctxtGrDef, + gr->subtypes->subtypes); + /* + * Unmark the visited model group definition. + */ + if (marked) + gr->subtypes->flags ^= XML_SCHEMAS_TYPE_MARKED; + if (circ != NULL) + return (circ); + } else { + circ = xmlSchemaGetCircModelGrDefRef(ctxtGrDef, + (xmlSchemaTypePtr) gr->subtypes); + if (circ != NULL) + return (circ); + } + + } + gr = gr->next; + } + return (NULL); +} + +/** + * xmlSchemaCheckGroupDefCircular: + * attrGr: the model group definition + * @ctxt: the parser context + * @name: the name + * + * Checks for circular references to model group definitions. + */ +static void +xmlSchemaCheckGroupDefCircular(xmlSchemaTypePtr modelGrDef, + xmlSchemaParserCtxtPtr ctxt, + const xmlChar * name ATTRIBUTE_UNUSED) +{ + /* + * Schema Component Constraint: Model Group Correct + * 2 Circular groups are disallowed. That is, within the {particles} + * of a group there must not be at any depth a particle whose {term} + * is the group itself. + */ + /* + * NOTE: "gr->subtypes" holds the referenced group. + */ + if ((modelGrDef->type != XML_SCHEMA_TYPE_GROUP) || + ((modelGrDef->flags & XML_SCHEMAS_TYPE_GLOBAL) == 0) || + (modelGrDef->subtypes == NULL)) + return; + else { + xmlSchemaTypePtr circ; + + circ = xmlSchemaGetCircModelGrDefRef(modelGrDef, modelGrDef->subtypes); + if (circ != NULL) { + /* + * TODO: Report the referenced attr group as QName. + */ + xmlSchemaPCustomErr(ctxt, + XML_SCHEMAP_MG_PROPS_CORRECT_2, + NULL, NULL, circ->node, + "Circular reference to the model group definition '%s' " + "defined", modelGrDef->name); + /* + * NOTE: We will cut the reference to avoid further + * confusion of the processor. + * TODO: SPEC: Does the spec define how to process here? + */ + circ->subtypes = NULL; + } + } +} + + +/** + * xmlSchemaGetCircAttrGrRef: + * @ctxtGr: the searched attribute group + * @attr: the current attribute list to be processed + * + * This one is intended to be used by + * xmlSchemaCheckSRCAttributeGroupCircular only. + * + * Returns the circular attribute grou reference, otherwise NULL. + */ +static xmlSchemaAttributeGroupPtr +xmlSchemaGetCircAttrGrRef(xmlSchemaAttributeGroupPtr ctxtGr, + xmlSchemaAttributePtr attr) +{ + xmlSchemaAttributeGroupPtr circ = NULL, gr; + int marked; + /* + * We will search for an attribute group reference which + * references the context attribute group. + */ + while (attr != NULL) { + marked = 0; + if (attr->type == XML_SCHEMA_TYPE_ATTRIBUTEGROUP) { + gr = (xmlSchemaAttributeGroupPtr) attr; + if (gr->refItem != NULL) { + if (gr->refItem == ctxtGr) + return (gr); + else if (gr->refItem->flags & + XML_SCHEMAS_ATTRGROUP_MARKED) { + attr = attr->next; + continue; + } else { + /* + * Mark as visited to avoid infinite recursion on + * circular references not yet examined. + */ + gr->refItem->flags |= XML_SCHEMAS_ATTRGROUP_MARKED; + marked = 1; + } + } + if (gr->attributes != NULL) + circ = xmlSchemaGetCircAttrGrRef(ctxtGr, gr->attributes); + /* + * Unmark the visited group's attributes. + */ + if (marked) + gr->refItem->flags ^= XML_SCHEMAS_ATTRGROUP_MARKED; + if (circ != NULL) + return (circ); + } + attr = attr->next; + } + return (NULL); +} + +/** + * xmlSchemaCheckSRCAttributeGroupCircular: + * attrGr: the attribute group definition + * @ctxt: the parser context + * @name: the name + * + * Checks for circular references of attribute groups. + */ +static void +xmlSchemaCheckAttributeGroupCircular(xmlSchemaAttributeGroupPtr attrGr, + xmlSchemaParserCtxtPtr ctxt, + const xmlChar * name ATTRIBUTE_UNUSED) +{ + /* + * Schema Representation Constraint: + * Attribute Group Definition Representation OK + * 3 Circular group reference is disallowed outside . + * That is, unless this element information item's parent is + * , then among the [children], if any, there must + * not be an with ref [attribute] which resolves + * to the component corresponding to this . Indirect + * circularity is also ruled out. That is, when QName resolution + * (Schema Document) (§3.15.3) is applied to a ·QName· arising from + * any s with a ref [attribute] among the [children], + * it must not be the case that a ·QName· is encountered at any depth + * which resolves to the component corresponding to this . + */ + /* + * Only global components can be referenced. + */ + if (((attrGr->flags & XML_SCHEMAS_ATTRGROUP_GLOBAL) == 0) || + (attrGr->attributes == NULL)) + return; + else { + xmlSchemaAttributeGroupPtr circ; + + circ = xmlSchemaGetCircAttrGrRef(attrGr, attrGr->attributes); + if (circ != NULL) { + /* + * TODO: Report the referenced attr group as QName. + */ + xmlSchemaPCustomErr(ctxt, + XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3, + NULL, NULL, circ->node, + "Circular reference to the attribute group '%s' " + "defined", attrGr->name); + /* + * NOTE: We will cut the reference to avoid further + * confusion of the processor. + * BADSPEC: The spec should define how to process in this case. + */ + circ->attributes = NULL; + circ->refItem = NULL; + } + } +} + /** * xmlSchemaAttrGrpFixup: * @attrgrpDecl: the schema attribute definition @@ -11651,6 +11964,10 @@ xmlSchemaAttrGrpFixup(xmlSchemaAttributeGroupPtr attrgrp, XML_SCHEMA_TYPE_ATTRIBUTEGROUP, NULL); return; } + attrgrp->refItem = ref; + /* + * Check for self reference! + */ xmlSchemaAttrGrpFixup(ref, ctxt, NULL); attrgrp->attributes = ref->attributes; attrgrp->attributeWildcard = ref->attributeWildcard; @@ -11833,10 +12150,21 @@ xmlSchemaParse(xmlSchemaParserCtxtPtr ctxt) xmlHashScan(ret->attrgrpDecl, (xmlHashScanner) xmlSchemaAttrGrpFixup, ctxt); + /* + * Check attribute groups for circular references. + */ + xmlHashScan(ret->attrgrpDecl, (xmlHashScanner) + xmlSchemaCheckAttributeGroupCircular, ctxt); + + /* + * Then fixup all model group definitions. + */ + xmlHashScan(ret->groupDecl, (xmlHashScanner) xmlSchemaGroupDefFixup, ctxt); + /* * Then fixup all types properties */ - xmlHashScan(ret->typeDecl, (xmlHashScanner) xmlSchemaTypeFixup, ctxt); + xmlHashScan(ret->typeDecl, (xmlHashScanner) xmlSchemaTypeFixup, ctxt); /* * Then fix references of element declaration; apply constraints. @@ -11844,6 +12172,13 @@ xmlSchemaParse(xmlSchemaParserCtxtPtr ctxt) xmlHashScanFull(ret->elemDecl, (xmlHashScannerFull) xmlSchemaRefFixupCallback, ctxt); + /* + * Check model groups defnitions for circular references. + */ + xmlHashScan(ret->groupDecl, (xmlHashScanner) + xmlSchemaCheckGroupDefCircular, ctxt); + + /* * Then build the content model for all elements */