Update libxml to 2.7.7.

third_party/libxml/valid.c

 /*
  * valid.c : part of the code use to do the DTD handling and the validity
  *           checking
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
 
 #define IN_LIBXML
@@ skipping 18 matching lines @@
 static xmlElementPtr xmlGetDtdElementDesc2(xmlDtdPtr dtd, const xmlChar *name,
                                    int create);
 /* #define DEBUG_VALID_ALGO */
 /* #define DEBUG_REGEXP_ALGO */
 
 #define TODO                                                            \
     xmlGenericError(xmlGenericErrorContext,                             \
             "Unimplemented block at %s:%d\n",                           \
             __FILE__, __LINE__);
 
+#ifdef LIBXML_VALID_ENABLED
+static int
+xmlValidateAttributeValueInternal(xmlDocPtr doc, xmlAttributeType type,
+                                  const xmlChar *value);
+#endif
 /************************************************************************
  *                                                                      *
  *                      Error handling routines                         *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlVErrMemory:
  * @ctxt:  an XML validation parser context
  * @extra:  extra informations
@@ skipping 61 matching lines @@
     }
     if (extra)
         __xmlRaiseError(NULL, channel, data,
                         pctxt, NULL, XML_FROM_VALID, error,
                         XML_ERR_ERROR, NULL, 0, extra, NULL, NULL, 0, 0,
                         msg, extra);
     else
         __xmlRaiseError(NULL, channel, data,
                         pctxt, NULL, XML_FROM_VALID, error,
                         XML_ERR_ERROR, NULL, 0, NULL, NULL, NULL, 0, 0,
-                        msg);
+                        "%s", msg);
 }
 
 #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
 /**
  * xmlErrValidNode:
  * @ctxt:  an XML validation parser context
  * @node:  the node raising the error
  * @error:  the error number
  * @str1:  extra informations
  * @str2:  extra informations
@@ skipping 494 matching lines @@
 #endif
 
 /* TODO: use hash table for accesses to elem and attribute definitions */
 
 
 #define CHECK_DTD                                               \
    if (doc == NULL) return(0);                                  \
    else if ((doc->intSubset == NULL) &&                         \
             (doc->extSubset == NULL)) return(0)
 
-xmlAttributePtr xmlScanAttributeDecl(xmlDtdPtr dtd, const xmlChar *elem);
-
 #ifdef LIBXML_REGEXP_ENABLED
 
 /************************************************************************
  *                                                                      *
  *              Content model validation based on the regexps           *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlValidBuildAContentModel:
@@ skipping 1174 matching lines @@
         xmlBufferWriteChar(buf, ")");
     else {
         xmlBufferWriteChar(buf, " | ");
         xmlDumpEnumeration(buf, cur->next);
     }
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 #ifdef LIBXML_VALID_ENABLED
 /**
- * xmlScanAttributeDeclCallback:
- * @attr:  the attribute decl
- * @list:  the list to update
- *
- * Callback called by xmlScanAttributeDecl when a new attribute
- * has to be entered in the list.
- */
-static void
-xmlScanAttributeDeclCallback(xmlAttributePtr attr, xmlAttributePtr *list,
-                             const xmlChar* name ATTRIBUTE_UNUSED) {
-    attr->nexth = *list;
-    *list = attr;
-}
-
-/**
- * xmlScanAttributeDecl:
- * @dtd:  pointer to the DTD
- * @elem:  the element name
- *
- * When inserting a new element scan the DtD for existing attributes
- * for that element and initialize the Attribute chain
- *
- * Returns the pointer to the first attribute decl in the chain,
- *         possibly NULL.
- */
-xmlAttributePtr
-xmlScanAttributeDecl(xmlDtdPtr dtd, const xmlChar *elem) {
-    xmlAttributePtr ret = NULL;
-    xmlAttributeTablePtr table;
-
-    if (dtd == NULL) {
-        return(NULL);
-    }
-    if (elem == NULL) {
-        return(NULL);
-    }
-    table = (xmlAttributeTablePtr) dtd->attributes;
-    if (table == NULL) 
-        return(NULL);
-
-    /* WRONG !!! */
-    xmlHashScan3(table, NULL, NULL, elem,
-                (xmlHashScanner) xmlScanAttributeDeclCallback, &ret);
-    return(ret);
-}
-
-/**
  * xmlScanIDAttributeDecl:
  * @ctxt:  the validation context
  * @elem:  the element name
  * @err: whether to raise errors here
  *
  * Verify that the element don't have too many ID attributes
  * declared.
  *
  * Returns the number of ID attributes found.
  */
@@ skipping 129 matching lines @@
         case XML_ATTRIBUTE_NOTATION:
             break;
         default:
             xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR, 
                     "Internal: ATTRIBUTE struct corrupted invalid type\n",
                     NULL);
             xmlFreeEnumeration(tree);
             return(NULL);
     }
     if ((defaultValue != NULL) && 
-        (!xmlValidateAttributeValue(type, defaultValue))) {
+        (!xmlValidateAttributeValueInternal(dtd->doc, type, defaultValue))) {
         xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_DEFAULT,
                         "Attribute %s of %s: invalid default value\n",
                         elem, name, defaultValue);
         defaultValue = NULL;
         if (ctxt != NULL)
             ctxt->valid = 0;
     }
 #endif /* LIBXML_VALID_ENABLED */
 
     /*
      * Check first that an attribute defined in the external subset wasn't
      * already defined in the internal subset
      */
     if ((dtd->doc != NULL) && (dtd->doc->extSubset == dtd) &&
         (dtd->doc->intSubset != NULL) &&
         (dtd->doc->intSubset->attributes != NULL)) {
         ret = xmlHashLookup3(dtd->doc->intSubset->attributes, name, ns, elem);
-        if (ret != NULL)
+        if (ret != NULL) {
+            xmlFreeEnumeration(tree);
             return(NULL);
+        }
     }
 
     /*
      * Create the Attribute table if needed.
      */
     table = (xmlAttributeTablePtr) dtd->attributes;
     if (table == NULL) {
         table = xmlHashCreateDict(0, dict);
         dtd->attributes = (void *) table;
     }
     if (table == NULL) {
         xmlVErrMemory(ctxt,
             "xmlAddAttributeDecl: Table creation failed!\n");
+        xmlFreeEnumeration(tree);
         return(NULL);
     }
 
 
     ret = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
     if (ret == NULL) {
         xmlVErrMemory(ctxt, "malloc failed");
+        xmlFreeEnumeration(tree);
         return(NULL);
     }
     memset(ret, 0, sizeof(xmlAttribute));
     ret->type = XML_ATTRIBUTE_DECL;
 
     /*
      * fill the structure.
      */
     ret->atype = type;
     /*
@@ skipping 635 matching lines @@
  * Returns 0 or 1 depending on the lookup result
  */
 int
 xmlIsID(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
     if ((attr == NULL) || (attr->name == NULL)) return(0);
     if ((attr->ns != NULL) && (attr->ns->prefix != NULL) &&
         (!strcmp((char *) attr->name, "id")) &&
         (!strcmp((char *) attr->ns->prefix, "xml")))
         return(1);
     if (doc == NULL) return(0);
-    if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
+    if ((doc->intSubset == NULL) && (doc->extSubset == NULL) &&
+        (doc->type != XML_HTML_DOCUMENT_NODE)) {
         return(0);
     } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
         if ((xmlStrEqual(BAD_CAST "id", attr->name)) ||
             ((xmlStrEqual(BAD_CAST "name", attr->name)) &&
             ((elem == NULL) || (xmlStrEqual(elem->name, BAD_CAST "a")))))
             return(1);
         return(0);    
     } else if (elem == NULL) {
         return(0);
     } else {
@@ skipping 650 matching lines @@
  * Validate that the given name match a notation declaration.
  * - [ VC: Notation Declared ]
  *
  * returns 1 if valid or 0 otherwise
  */
 
 int
 xmlValidateNotationUse(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
                        const xmlChar *notationName) {
     xmlNotationPtr notaDecl;
-    if ((doc == NULL) || (doc->intSubset == NULL)) return(-1);
+    if ((doc == NULL) || (doc->intSubset == NULL) ||
+        (notationName == NULL)) return(-1);
 
     notaDecl = xmlGetDtdNotationDesc(doc->intSubset, notationName);
     if ((notaDecl == NULL) && (doc->extSubset != NULL))
         notaDecl = xmlGetDtdNotationDesc(doc->extSubset, notationName);
 
     if ((notaDecl == NULL) && (ctxt != NULL)) {
         xmlErrValidNode(ctxt, (xmlNodePtr) doc, XML_DTD_UNKNOWN_NOTATION,
                         "NOTATION %s is not declared\n",
                         notationName, NULL, NULL);
         return(0);
@@ skipping 34 matching lines @@
              * on <empty>     </empty> for example
              */
         case XML_ELEMENT_TYPE_ANY:
         case XML_ELEMENT_TYPE_MIXED:
             return(1);
     }
     return(1);
 }
 
 #ifdef LIBXML_VALID_ENABLED
+
+static int
+xmlIsDocNameStartChar(xmlDocPtr doc, int c) {
+    if ((doc == NULL) || (doc->properties & XML_DOC_OLD10) == 0) {
+        /*
+         * Use the new checks of production [4] [4a] amd [5] of the
+         * Update 5 of XML-1.0
+         */
+        if (((c >= 'a') && (c <= 'z')) ||
+            ((c >= 'A') && (c <= 'Z')) ||
+            (c == '_') || (c == ':') ||
+            ((c >= 0xC0) && (c <= 0xD6)) ||
+            ((c >= 0xD8) && (c <= 0xF6)) ||
+            ((c >= 0xF8) && (c <= 0x2FF)) ||
+            ((c >= 0x370) && (c <= 0x37D)) ||
+            ((c >= 0x37F) && (c <= 0x1FFF)) ||
+            ((c >= 0x200C) && (c <= 0x200D)) ||
+            ((c >= 0x2070) && (c <= 0x218F)) ||
+            ((c >= 0x2C00) && (c <= 0x2FEF)) ||
+            ((c >= 0x3001) && (c <= 0xD7FF)) ||
+            ((c >= 0xF900) && (c <= 0xFDCF)) ||
+            ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
+            ((c >= 0x10000) && (c <= 0xEFFFF)))
+            return(1);
+    } else {
+        if (IS_LETTER(c) || (c == '_') || (c == ':'))
+            return(1);
+    }
+    return(0);
+}
+
+static int
+xmlIsDocNameChar(xmlDocPtr doc, int c) {
+    if ((doc == NULL) || (doc->properties & XML_DOC_OLD10) == 0) {
+        /*
+         * Use the new checks of production [4] [4a] amd [5] of the
+         * Update 5 of XML-1.0
+         */
+        if (((c >= 'a') && (c <= 'z')) ||
+            ((c >= 'A') && (c <= 'Z')) ||
+            ((c >= '0') && (c <= '9')) || /* !start */
+            (c == '_') || (c == ':') ||
+            (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
+            ((c >= 0xC0) && (c <= 0xD6)) ||
+            ((c >= 0xD8) && (c <= 0xF6)) ||
+            ((c >= 0xF8) && (c <= 0x2FF)) ||
+            ((c >= 0x300) && (c <= 0x36F)) || /* !start */
+            ((c >= 0x370) && (c <= 0x37D)) ||
+            ((c >= 0x37F) && (c <= 0x1FFF)) ||
+            ((c >= 0x200C) && (c <= 0x200D)) ||
+            ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
+            ((c >= 0x2070) && (c <= 0x218F)) ||
+            ((c >= 0x2C00) && (c <= 0x2FEF)) ||
+            ((c >= 0x3001) && (c <= 0xD7FF)) ||
+            ((c >= 0xF900) && (c <= 0xFDCF)) ||
+            ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
+            ((c >= 0x10000) && (c <= 0xEFFFF)))
+             return(1);
+    } else {
+        if ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
+            (c == '.') || (c == '-') ||
+            (c == '_') || (c == ':') ||
+            (IS_COMBINING(c)) ||
+            (IS_EXTENDER(c)))
+            return(1);
+    }
+    return(0);
+}
+
 /**
  * xmlValidateNameValue:
+ * @doc:  pointer to the document or NULL
  * @value:  an Name value
  *
  * Validate that the given value match Name production
  *
  * returns 1 if valid or 0 otherwise
  */
 
-int
-xmlValidateNameValue(const xmlChar *value) {
+static int
+xmlValidateNameValueInternal(xmlDocPtr doc, const xmlChar *value) {
     const xmlChar *cur;
     int val, len;
 
     if (value == NULL) return(0);
     cur = value;
     val = xmlStringCurrentChar(NULL, cur, &len);
     cur += len;
-    if (!IS_LETTER(val) && (val != '_') &&
-        (val != ':')) {
+    if (!xmlIsDocNameStartChar(doc, val))
         return(0);
-    }
 
     val = xmlStringCurrentChar(NULL, cur, &len);
     cur += len;
-    while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
-           (val == '.') || (val == '-') ||
-           (val == '_') || (val == ':') || 
-           (IS_COMBINING(val)) ||
-           (IS_EXTENDER(val))) {
+    while (xmlIsDocNameChar(doc, val)) {
         val = xmlStringCurrentChar(NULL, cur, &len);
         cur += len;
     }
 
     if (val != 0) return(0);
 
     return(1);
 }
 
 /**
- * xmlValidateNamesValue:
+ * xmlValidateNameValue:
+ * @value:  an Name value
+ *
+ * Validate that the given value match Name production
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateNameValue(const xmlChar *value) {
+    return(xmlValidateNameValueInternal(NULL, value));
+}
+
+/**
+ * xmlValidateNamesValueInternal:
+ * @doc:  pointer to the document or NULL
  * @value:  an Names value
  *
  * Validate that the given value match Names production
  *
  * returns 1 if valid or 0 otherwise
  */
 
-int
-xmlValidateNamesValue(const xmlChar *value) {
+static int
+xmlValidateNamesValueInternal(xmlDocPtr doc, const xmlChar *value) {
     const xmlChar *cur;
     int val, len;
 
     if (value == NULL) return(0);
     cur = value;
     val = xmlStringCurrentChar(NULL, cur, &len);
     cur += len;
-    
-    if (!IS_LETTER(val) && (val != '_') &&
-        (val != ':')) {
+
+    if (!xmlIsDocNameStartChar(doc, val))
         return(0);
-    }
 
     val = xmlStringCurrentChar(NULL, cur, &len);
     cur += len;
-    while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
-           (val == '.') || (val == '-') ||
-           (val == '_') || (val == ':') || 
-           (IS_COMBINING(val)) ||
-           (IS_EXTENDER(val))) {
+    while (xmlIsDocNameChar(doc, val)) {
         val = xmlStringCurrentChar(NULL, cur, &len);
         cur += len;
     }
 
     /* Should not test IS_BLANK(val) here -- see erratum E20*/
     while (val == 0x20) {
         while (val == 0x20) {
             val = xmlStringCurrentChar(NULL, cur, &len);
             cur += len;
         }
 
-        if (!IS_LETTER(val) && (val != '_') &&
-            (val != ':')) {
+        if (!xmlIsDocNameStartChar(doc, val))
             return(0);
-        }
+
         val = xmlStringCurrentChar(NULL, cur, &len);
         cur += len;
 
-        while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
-               (val == '.') || (val == '-') ||
-               (val == '_') || (val == ':') || 
-               (IS_COMBINING(val)) ||
-               (IS_EXTENDER(val))) {
+        while (xmlIsDocNameChar(doc, val)) {
             val = xmlStringCurrentChar(NULL, cur, &len);
             cur += len;
         }
     }
 
     if (val != 0) return(0);
 
     return(1);
 }
 
 /**
- * xmlValidateNmtokenValue:
+ * xmlValidateNamesValue:
+ * @value:  an Names value
+ *
+ * Validate that the given value match Names production
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateNamesValue(const xmlChar *value) {
+    return(xmlValidateNamesValueInternal(NULL, value));
+}
+
+/**
+ * xmlValidateNmtokenValueInternal:
+ * @doc:  pointer to the document or NULL
  * @value:  an Nmtoken value
  *
  * Validate that the given value match Nmtoken production
  *
  * [ VC: Name Token ]
- * 
+ *
  * returns 1 if valid or 0 otherwise
  */
 
-int
-xmlValidateNmtokenValue(const xmlChar *value) {
+static int
+xmlValidateNmtokenValueInternal(xmlDocPtr doc, const xmlChar *value) {
     const xmlChar *cur;
     int val, len;
 
     if (value == NULL) return(0);
     cur = value;
     val = xmlStringCurrentChar(NULL, cur, &len);
     cur += len;
-    
-    if (!IS_LETTER(val) && !IS_DIGIT(val) &&
-        (val != '.') && (val != '-') &&
-        (val != '_') && (val != ':') && 
-        (!IS_COMBINING(val)) &&
-        (!IS_EXTENDER(val)))
+
+    if (!xmlIsDocNameChar(doc, val))
         return(0);
 
-    while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
-           (val == '.') || (val == '-') ||
-           (val == '_') || (val == ':') || 
-           (IS_COMBINING(val)) ||
-           (IS_EXTENDER(val))) {
+    val = xmlStringCurrentChar(NULL, cur, &len);
+    cur += len;
+    while (xmlIsDocNameChar(doc, val)) {
         val = xmlStringCurrentChar(NULL, cur, &len);
         cur += len;
     }
 
     if (val != 0) return(0);
 
     return(1);
 }
 
 /**
- * xmlValidateNmtokensValue:
+ * xmlValidateNmtokenValue:
+ * @value:  an Nmtoken value
+ *
+ * Validate that the given value match Nmtoken production
+ *
+ * [ VC: Name Token ]
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateNmtokenValue(const xmlChar *value) {
+    return(xmlValidateNmtokenValueInternal(NULL, value));
+}
+
+/**
+ * xmlValidateNmtokensValueInternal:
+ * @doc:  pointer to the document or NULL
  * @value:  an Nmtokens value
  *
  * Validate that the given value match Nmtokens production
  *
  * [ VC: Name Token ]
- * 
+ *
  * returns 1 if valid or 0 otherwise
  */
 
-int
-xmlValidateNmtokensValue(const xmlChar *value) {
+static int
+xmlValidateNmtokensValueInternal(xmlDocPtr doc, const xmlChar *value) {
     const xmlChar *cur;
     int val, len;
 
     if (value == NULL) return(0);
     cur = value;
     val = xmlStringCurrentChar(NULL, cur, &len);
     cur += len;
-    
+
     while (IS_BLANK(val)) {
         val = xmlStringCurrentChar(NULL, cur, &len);
         cur += len;
     }
 
-    if (!IS_LETTER(val) && !IS_DIGIT(val) &&
-        (val != '.') && (val != '-') &&
-        (val != '_') && (val != ':') && 
-        (!IS_COMBINING(val)) &&
-        (!IS_EXTENDER(val)))
+    if (!xmlIsDocNameChar(doc, val))
         return(0);
 
-    while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
-           (val == '.') || (val == '-') ||
-           (val == '_') || (val == ':') || 
-           (IS_COMBINING(val)) ||
-           (IS_EXTENDER(val))) {
+    while (xmlIsDocNameChar(doc, val)) {
         val = xmlStringCurrentChar(NULL, cur, &len);
         cur += len;
     }
 
     /* Should not test IS_BLANK(val) here -- see erratum E20*/
     while (val == 0x20) {
         while (val == 0x20) {
             val = xmlStringCurrentChar(NULL, cur, &len);
             cur += len;
         }
         if (val == 0) return(1);
 
-        if (!IS_LETTER(val) && !IS_DIGIT(val) &&
-            (val != '.') && (val != '-') &&
-            (val != '_') && (val != ':') && 
-            (!IS_COMBINING(val)) &&
-            (!IS_EXTENDER(val)))
+        if (!xmlIsDocNameChar(doc, val))
             return(0);
 
-        while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
-               (val == '.') || (val == '-') ||
-               (val == '_') || (val == ':') || 
-               (IS_COMBINING(val)) ||
-               (IS_EXTENDER(val))) {
+        val = xmlStringCurrentChar(NULL, cur, &len);
+        cur += len;
+
+        while (xmlIsDocNameChar(doc, val)) {
             val = xmlStringCurrentChar(NULL, cur, &len);
             cur += len;
         }
     }
 
     if (val != 0) return(0);
 
     return(1);
 }
 
 /**
+ * xmlValidateNmtokensValue:
+ * @value:  an Nmtokens value
+ *
+ * Validate that the given value match Nmtokens production
+ *
+ * [ VC: Name Token ]
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+int
+xmlValidateNmtokensValue(const xmlChar *value) {
+    return(xmlValidateNmtokensValueInternal(NULL, value));
+}
+
+/**
  * xmlValidateNotationDecl:
  * @ctxt:  the validation context
  * @doc:  a document instance
  * @nota:  a notation definition
  *
  * Try to validate a single notation definition
  * basically it does the following checks as described by the
  * XML-1.0 recommendation:
  *  - it seems that no validity constraint exists on notation declarations
  * But this function get called anyway ...
  *
  * returns 1 if valid or 0 otherwise
  */
 
 int
 xmlValidateNotationDecl(xmlValidCtxtPtr ctxt ATTRIBUTE_UNUSED, xmlDocPtr doc ATTRIBUTE_UNUSED,
                          xmlNotationPtr nota ATTRIBUTE_UNUSED) {
     int ret = 1;
 
     return(ret);
 }
 
 /**
+ * xmlValidateAttributeValueInternal:
+ * @doc: the document
+ * @type:  an attribute type
+ * @value:  an attribute value
+ *
+ * Validate that the given attribute value match  the proper production
+ *
+ * returns 1 if valid or 0 otherwise
+ */
+
+static int
+xmlValidateAttributeValueInternal(xmlDocPtr doc, xmlAttributeType type,
+                                  const xmlChar *value) {
+    switch (type) {
+        case XML_ATTRIBUTE_ENTITIES:
+        case XML_ATTRIBUTE_IDREFS:
+            return(xmlValidateNamesValueInternal(doc, value));
+        case XML_ATTRIBUTE_ENTITY:
+        case XML_ATTRIBUTE_IDREF:
+        case XML_ATTRIBUTE_ID:
+        case XML_ATTRIBUTE_NOTATION:
+            return(xmlValidateNameValueInternal(doc, value));
+        case XML_ATTRIBUTE_NMTOKENS:
+        case XML_ATTRIBUTE_ENUMERATION:
+            return(xmlValidateNmtokensValueInternal(doc, value));
+        case XML_ATTRIBUTE_NMTOKEN:
+            return(xmlValidateNmtokenValueInternal(doc, value));
+        case XML_ATTRIBUTE_CDATA:
+            break;
+    }
+    return(1);
+}
+
+/**
  * xmlValidateAttributeValue:
  * @type:  an attribute type
  * @value:  an attribute value
  *
  * Validate that the given attribute value match  the proper production
  *
  * [ VC: ID ]
  * Values of type ID must match the Name production....
  *
  * [ VC: IDREF ]
  * Values of type IDREF must match the Name production, and values
  * of type IDREFS must match Names ...
  *
  * [ VC: Entity Name ]
  * Values of type ENTITY must match the Name production, values
  * of type ENTITIES must match Names ...
  *
  * [ VC: Name Token ]
  * Values of type NMTOKEN must match the Nmtoken production; values
  * of type NMTOKENS must match Nmtokens. 
  *
  * returns 1 if valid or 0 otherwise
  */
-
 int
 xmlValidateAttributeValue(xmlAttributeType type, const xmlChar *value) {
-    switch (type) {
-        case XML_ATTRIBUTE_ENTITIES:
-        case XML_ATTRIBUTE_IDREFS:
-            return(xmlValidateNamesValue(value));
-        case XML_ATTRIBUTE_ENTITY:
-        case XML_ATTRIBUTE_IDREF:
-        case XML_ATTRIBUTE_ID:
-        case XML_ATTRIBUTE_NOTATION:
-            return(xmlValidateNameValue(value));
-        case XML_ATTRIBUTE_NMTOKENS:
-        case XML_ATTRIBUTE_ENUMERATION:
-            return(xmlValidateNmtokensValue(value));
-        case XML_ATTRIBUTE_NMTOKEN:
-            return(xmlValidateNmtokenValue(value));
-        case XML_ATTRIBUTE_CDATA:
-            break;
-    }
-    return(1);
+    return(xmlValidateAttributeValueInternal(NULL, type, value));
 }
 
 /**
  * xmlValidateAttributeValue2:
  * @ctxt:  the validation context
  * @doc:  the document
  * @name:  the attribute name (used for error reporting only)
  * @type:  the attribute type
  * @value:  the attribute value
  *
@@ skipping 228 matching lines @@
     xmlAttributePtr attrDecl = NULL;
 
     if (doc == NULL) return(NULL);
     if (elem == NULL) return(NULL);
     if (name == NULL) return(NULL);
     if (value == NULL) return(NULL);
 
     if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
         xmlChar fn[50];
         xmlChar *fullname;
-        
+
         fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
         if (fullname == NULL)
             return(NULL);
-        attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, name);
-        if ((attrDecl == NULL) && (doc->extSubset != NULL))
-            attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname, name);
         if ((fullname != fn) && (fullname != elem->name))
             xmlFree(fullname);
     }
     attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, name);
     if ((attrDecl == NULL) && (doc->extSubset != NULL))
         attrDecl = xmlGetDtdAttrDesc(doc->extSubset, elem->name, name);
 
     if (attrDecl == NULL)
         return(NULL);
     if (attrDecl->atype == XML_ATTRIBUTE_CDATA)
@@ skipping 42 matching lines @@
  * returns 1 if valid or 0 otherwise
  */
 
 int
 xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
                          xmlAttributePtr attr) {
     int ret = 1;
     int val;
     CHECK_DTD;
     if(attr == NULL) return(1);
-    
+
     /* Attribute Default Legal */
     /* Enumeration */
     if (attr->defaultValue != NULL) {
-        val = xmlValidateAttributeValue(attr->atype, attr->defaultValue);
+        val = xmlValidateAttributeValueInternal(doc, attr->atype,
+                                                attr->defaultValue);
         if (val == 0) {
             xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ATTRIBUTE_DEFAULT,
                "Syntax of default value for attribute %s of %s is not valid\n",
                    attr->name, attr->elem, NULL);
         }
         ret &= val;
     }
 
     /* ID Attribute Default */
     if ((attr->atype == XML_ATTRIBUTE_ID)&&
@@ skipping 110 matching lines @@
         cur = elem->content;
         while (cur != NULL) {
             if (cur->type != XML_ELEMENT_CONTENT_OR) break;
             if (cur->c1 == NULL) break;
             if (cur->c1->type == XML_ELEMENT_CONTENT_ELEMENT) {
                 name = cur->c1->name;
                 next = cur->c2;
                 while (next != NULL) {
                     if (next->type == XML_ELEMENT_CONTENT_ELEMENT) {
                         if ((xmlStrEqual(next->name, name)) &&
-                            (xmlStrEqual(next->prefix, cur->prefix))) {
-                            if (cur->prefix == NULL) {
+                            (xmlStrEqual(next->prefix, cur->c1->prefix))) {
+                            if (cur->c1->prefix == NULL) {
                                 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
                    "Definition of %s has duplicate references of %s\n",
                                        elem->name, name, NULL);
                             } else {
                                 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
                    "Definition of %s has duplicate references of %s:%s\n",
-                                       elem->name, cur->prefix, name);
+                                       elem->name, cur->c1->prefix, name);
                             }
                             ret = 0;
                         }
                         break;
                     }
                     if (next->c1 == NULL) break;
                     if (next->c1->type != XML_ELEMENT_CONTENT_ELEMENT) break;
                     if ((xmlStrEqual(next->c1->name, name)) &&
-                        (xmlStrEqual(next->c1->prefix, cur->prefix))) {
-                        if (cur->prefix == NULL) {
+                        (xmlStrEqual(next->c1->prefix, cur->c1->prefix))) {
+                        if (cur->c1->prefix == NULL) {
                             xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
                "Definition of %s has duplicate references to %s\n",
                                    elem->name, name, NULL);
                         } else {
                             xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
                "Definition of %s has duplicate references to %s:%s\n",
-                                   elem->name, cur->prefix, name);
+                                   elem->name, cur->c1->prefix, name);
                         }
                         ret = 0;
                     }
                     next = next->c2;
                 }
             }
             cur = cur->c2;
         }
     }
 
@@ skipping 104 matching lines @@
 
     /* Validity Constraint: Attribute Value Type */
     if (attrDecl == NULL) {
         xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
                "No declaration for attribute %s of element %s\n",
                attr->name, elem->name, NULL);
         return(0);
     }
     attr->atype = attrDecl->atype;
 
-    val = xmlValidateAttributeValue(attrDecl->atype, value);
+    val = xmlValidateAttributeValueInternal(doc, attrDecl->atype, value);
     if (val == 0) {
             xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
            "Syntax of value for attribute %s of %s is not valid\n",
                attr->name, elem->name, NULL);
         ret = 0;
     }
 
     /* Validity constraint: Fixed Attribute Default */
     if (attrDecl->def == XML_ATTRIBUTE_FIXED) {
         if (!xmlStrEqual(value, attrDecl->defaultValue)) {
@@ skipping 164 matching lines @@
                    "No declaration for attribute xmlns:%s of element %s\n",
                    ns->prefix, elem->name, NULL);
         } else {
             xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
                    "No declaration for attribute xmlns of element %s\n",
                    elem->name, NULL, NULL);
         }
         return(0);
     }
 
-    val = xmlValidateAttributeValue(attrDecl->atype, value);
+    val = xmlValidateAttributeValueInternal(doc, attrDecl->atype, value);
     if (val == 0) {
         if (ns->prefix != NULL) {
             xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_DEFAULT,
                "Syntax of value for attribute xmlns:%s of %s is not valid\n",
                    ns->prefix, elem->name, NULL);
         } else {
             xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_DEFAULT,
                "Syntax of value for attribute xmlns of %s is not valid\n",
                    elem->name, NULL, NULL);
         }
@@ skipping 2135 matching lines @@
  *
  * returns 1 if valid or 0 if invalid and -1 if not well-formed
  */
 
 int
 xmlValidateDtdFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
     xmlDtdPtr dtd;
     xmlAttributeTablePtr table;
     xmlEntitiesTablePtr entities;
 
-    if (doc == NULL) return(0);
+    if ((doc == NULL) || (ctxt == NULL)) return(0);
     if ((doc->intSubset == NULL) && (doc->extSubset == NULL))
         return(0);
     ctxt->doc = doc;
     ctxt->valid = 1;
     dtd = doc->intSubset;
     if ((dtd != NULL) && (dtd->attributes != NULL)) {
         table = (xmlAttributeTablePtr) dtd->attributes;
         xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
     }
     if ((dtd != NULL) && (dtd->entities != NULL)) {
@@ skipping 272 matching lines @@
      */
     test_node->name = name;
     xmlFreeNode(test_node);
 
     return(nb_valid_elements);
 }
 #endif /* LIBXML_VALID_ENABLED */
 
 #define bottom_valid
 #include "elfgcchack.h"