Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/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 13 matching lines @@
 #include <libxml/parserInternals.h>
 #include <libxml/xmlerror.h>
 #include <libxml/list.h>
 #include <libxml/globals.h>
 
 static xmlElementPtr xmlGetDtdElementDesc2(xmlDtdPtr dtd, const xmlChar *name,
                                    int create);
 /* #define DEBUG_VALID_ALGO */
 /* #define DEBUG_REGEXP_ALGO */
 
-#define TODO                                                            \
+#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
 /************************************************************************
@@ skipping 249 matching lines @@
         ctxt->vstateMax *= 2;
         ctxt->vstateTab = tmp;
     }
     ctxt->vstate = &ctxt->vstateTab[ctxt->vstateNr];
     ctxt->vstateTab[ctxt->vstateNr].elemDecl = elemDecl;
     ctxt->vstateTab[ctxt->vstateNr].node = node;
     if ((elemDecl != NULL) && (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT)) {
         if (elemDecl->contModel == NULL)
             xmlValidBuildContentModel(ctxt, elemDecl);
         if (elemDecl->contModel != NULL) {
-            ctxt->vstateTab[ctxt->vstateNr].exec = 
+            ctxt->vstateTab[ctxt->vstateNr].exec =
                 xmlRegNewExecCtxt(elemDecl->contModel, NULL, NULL);
         } else {
             ctxt->vstateTab[ctxt->vstateNr].exec = NULL;
             xmlErrValidNode(ctxt, (xmlNodePtr) elemDecl,
                             XML_ERR_INTERNAL_ERROR,
                             "Failed to build content model regexp for %s\n",
                             node->name, NULL, NULL);
         }
     }
     return(ctxt->vstateNr++);
@@ skipping 301 matching lines @@
     xmlGenericError(xmlGenericErrorContext, "\n");
 }
 
 /*****
 #define DEBUG_VALID_STATE(n,c) xmlValidDebug(n,c);
  *****/
 
 #define DEBUG_VALID_STATE(n,c) xmlValidStateDebug(ctxt);
 #define DEBUG_VALID_MSG(m)                                      \
     xmlGenericError(xmlGenericErrorContext, "%s\n", m);
-        
+
 #else
 #define DEBUG_VALID_STATE(n,c)
 #define DEBUG_VALID_MSG(m)
 #endif
 
 /* TODO: use hash table for accesses to elem and attribute definitions */
 
 
 #define CHECK_DTD                                               \
    if (doc == NULL) return(0);                                  \
@@ skipping 32 matching lines @@
         case XML_ELEMENT_CONTENT_PCDATA:
             xmlErrValidNode(ctxt, NULL, XML_ERR_INTERNAL_ERROR,
                             "Found PCDATA in content model of %s\n",
                             name, NULL, NULL);
             return(0);
             break;
         case XML_ELEMENT_CONTENT_ELEMENT: {
             xmlAutomataStatePtr oldstate = ctxt->state;
             xmlChar fn[50];
             xmlChar *fullname;
-            
+
             fullname = xmlBuildQName(content->name, content->prefix, fn, 50);
             if (fullname == NULL) {
                 xmlVErrMemory(ctxt, "Building content model");
                 return(0);
             }
 
             switch (content->ocur) {
                 case XML_ELEMENT_CONTENT_ONCE:
                     ctxt->state = xmlAutomataNewTransition(ctxt->am,
                             ctxt->state, NULL, fullname, NULL);
                     break;
                 case XML_ELEMENT_CONTENT_OPT:
                     ctxt->state = xmlAutomataNewTransition(ctxt->am,
                             ctxt->state, NULL, fullname, NULL);
                     xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
                     break;
                 case XML_ELEMENT_CONTENT_PLUS:
                     ctxt->state = xmlAutomataNewTransition(ctxt->am,
                             ctxt->state, NULL, fullname, NULL);
                     xmlAutomataNewTransition(ctxt->am, ctxt->state,
                                              ctxt->state, fullname, NULL);
                     break;
                 case XML_ELEMENT_CONTENT_MULT:
                     ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
-                                            ctxt->state, NULL);
+                                            ctxt->state, NULL);
                     xmlAutomataNewTransition(ctxt->am,
-                            ctxt->state, ctxt->state, fullname, NULL);
+                            ctxt->state, ctxt->state, fullname, NULL);
                     break;
             }
             if ((fullname != fn) && (fullname != content->name))
                 xmlFree(fullname);
             break;
         }
         case XML_ELEMENT_CONTENT_SEQ: {
             xmlAutomataStatePtr oldstate, oldend;
             xmlElementContentOccur ocur;
 
@@ skipping 28 matching lines @@
                     xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
                     break;
             }
             break;
         }
         case XML_ELEMENT_CONTENT_OR: {
             xmlAutomataStatePtr oldstate, oldend;
             xmlElementContentOccur ocur;
 
             ocur = content->ocur;
-            if ((ocur == XML_ELEMENT_CONTENT_PLUS) || 
+            if ((ocur == XML_ELEMENT_CONTENT_PLUS) ||
                 (ocur == XML_ELEMENT_CONTENT_MULT)) {
                 ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
                         ctxt->state, NULL);
             }
             oldstate = ctxt->state;
             oldend = xmlAutomataNewState(ctxt->am);
 
             /*
              * iterate over the subtypes and remerge the end with an
              * epsilon transition
@@ skipping 171 matching lines @@
         case XML_ELEMENT_CONTENT_PCDATA:
         case XML_ELEMENT_CONTENT_SEQ:
         case XML_ELEMENT_CONTENT_OR:
             if (name != NULL) {
                 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
                         "xmlNewElementContent : name != NULL !\n",
                         NULL);
             }
             break;
         default:
-            xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR, 
+            xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
                     "Internal: ELEMENT content corrupted invalid type\n",
                     NULL);
             return(NULL);
     }
     ret = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
     if (ret == NULL) {
         xmlVErrMemory(NULL, "malloc failed");
         return(NULL);
     }
     memset(ret, 0, sizeof(xmlElementContent));
@@ skipping 36 matching lines @@
 xmlNewElementContent(const xmlChar *name, xmlElementContentType type) {
     return(xmlNewDocElementContent(NULL, name, type));
 }
 
 /**
  * xmlCopyDocElementContent:
  * @doc:  the document owning the element declaration
  * @cur:  An element content pointer.
  *
  * Build a copy of an element content description.
- * 
+ *
  * Returns the new xmlElementContentPtr or NULL in case of error.
  */
 xmlElementContentPtr
 xmlCopyDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur) {
     xmlElementContentPtr ret = NULL, prev = NULL, tmp;
     xmlDictPtr dict = NULL;
 
     if (cur == NULL) return(NULL);
 
     if (doc != NULL)
         dict = doc->dict;
 
     ret = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
     if (ret == NULL) {
         xmlVErrMemory(NULL, "malloc failed");
         return(NULL);
     }
     memset(ret, 0, sizeof(xmlElementContent));
     ret->type = cur->type;
     ret->ocur = cur->ocur;
     if (cur->name != NULL) {
         if (dict)
             ret->name = xmlDictLookup(dict, cur->name, -1);
         else
             ret->name = xmlStrdup(cur->name);
     }
-    
+
     if (cur->prefix != NULL) {
         if (dict)
             ret->prefix = xmlDictLookup(dict, cur->prefix, -1);
         else
             ret->prefix = xmlStrdup(cur->prefix);
     }
     if (cur->c1 != NULL)
         ret->c1 = xmlCopyDocElementContent(doc, cur->c1);
     if (ret->c1 != NULL)
         ret->c1->parent = ret;
     if (cur->c2 != NULL) {
         prev = ret;
         cur = cur->c2;
         while (cur != NULL) {
             tmp = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
             if (tmp == NULL) {
                 xmlVErrMemory(NULL, "malloc failed");
                 return(ret);
             }
             memset(tmp, 0, sizeof(xmlElementContent));
             tmp->type = cur->type;
             tmp->ocur = cur->ocur;
             prev->c2 = tmp;
             if (cur->name != NULL) {
                 if (dict)
                     tmp->name = xmlDictLookup(dict, cur->name, -1);
                 else
                     tmp->name = xmlStrdup(cur->name);
             }
-            
+
             if (cur->prefix != NULL) {
                 if (dict)
                     tmp->prefix = xmlDictLookup(dict, cur->prefix, -1);
                 else
                     tmp->prefix = xmlStrdup(cur->prefix);
             }
             if (cur->c1 != NULL)
                 tmp->c1 = xmlCopyDocElementContent(doc,cur->c1);
             if (tmp->c1 != NULL)
                 tmp->c1->parent = ret;
             prev = tmp;
             cur = cur->c2;
         }
     }
     return(ret);
 }
 
 /**
  * xmlCopyElementContent:
  * @cur:  An element content pointer.
  *
  * Build a copy of an element content description.
  * Deprecated, use xmlCopyDocElementContent instead
- * 
+ *
  * Returns the new xmlElementContentPtr or NULL in case of error.
  */
 xmlElementContentPtr
 xmlCopyElementContent(xmlElementContentPtr cur) {
     return(xmlCopyDocElementContent(NULL, cur));
 }
 
 /**
  * xmlFreeDocElementContent:
  * @doc: the document owning the element declaration
@@ skipping 11 matching lines @@
 
     while (cur != NULL) {
         next = cur->c2;
         switch (cur->type) {
             case XML_ELEMENT_CONTENT_PCDATA:
             case XML_ELEMENT_CONTENT_ELEMENT:
             case XML_ELEMENT_CONTENT_SEQ:
             case XML_ELEMENT_CONTENT_OR:
                 break;
             default:
-                xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR, 
+                xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
                         "Internal: ELEMENT content corrupted invalid type\n",
                         NULL);
                 return;
         }
         if (cur->c1 != NULL) xmlFreeDocElementContent(doc, cur->c1);
         if (dict) {
             if ((cur->name != NULL) && (!xmlDictOwns(dict, cur->name)))
                 xmlFree((xmlChar *) cur->name);
             if ((cur->prefix != NULL) && (!xmlDictOwns(dict, cur->prefix)))
                 xmlFree((xmlChar *) cur->prefix);
@@ skipping 65 matching lines @@
                 xmlDumpElementContent(buf, content->c1, 0);
             xmlBufferWriteChar(buf, " | ");
             if ((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
                 ((content->c2->type == XML_ELEMENT_CONTENT_OR) &&
                  (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)))
                 xmlDumpElementContent(buf, content->c2, 1);
             else
                 xmlDumpElementContent(buf, content->c2, 0);
             break;
         default:
-            xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR, 
+            xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
                     "Internal: ELEMENT content corrupted invalid type\n",
                     NULL);
     }
     if (glob)
         xmlBufferWriteChar(buf, ")");
     switch (content->ocur) {
         case XML_ELEMENT_CONTENT_ONCE:
             break;
         case XML_ELEMENT_CONTENT_OPT:
             xmlBufferWriteChar(buf, "?");
@@ skipping 176 matching lines @@
     if (dtd == NULL) {
         return(NULL);
     }
     if (name == NULL) {
         return(NULL);
     }
 
     switch (type) {
         case XML_ELEMENT_TYPE_EMPTY:
             if (content != NULL) {
-                xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR, 
+                xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
                         "xmlAddElementDecl: content != NULL for EMPTY\n",
                         NULL);
                 return(NULL);
             }
             break;
         case XML_ELEMENT_TYPE_ANY:
             if (content != NULL) {
-                xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR, 
+                xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
                         "xmlAddElementDecl: content != NULL for ANY\n",
                         NULL);
                 return(NULL);
             }
             break;
         case XML_ELEMENT_TYPE_MIXED:
             if (content == NULL) {
-                xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR, 
+                xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
                         "xmlAddElementDecl: content == NULL for MIXED\n",
                         NULL);
                 return(NULL);
             }
             break;
         case XML_ELEMENT_TYPE_ELEMENT:
             if (content == NULL) {
-                xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR, 
+                xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
                         "xmlAddElementDecl: content == NULL for ELEMENT\n",
                         NULL);
                 return(NULL);
             }
             break;
         default:
-            xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR, 
+            xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
                     "Internal: ELEMENT decl corrupted invalid type\n",
                     NULL);
             return(NULL);
     }
 
     /*
      * check if name is a QName
      */
     uqname = xmlSplitQName2(name, &ns);
     if (uqname != NULL)
@@ skipping 159 matching lines @@
 xmlFreeElementTable(xmlElementTablePtr table) {
     xmlHashFree(table, (xmlHashDeallocator) xmlFreeElement);
 }
 
 #ifdef LIBXML_TREE_ENABLED
 /**
  * xmlCopyElement:
  * @elem:  An element
  *
  * Build a copy of an element.
- * 
+ *
  * Returns the new xmlElementPtr or NULL in case of error.
  */
 static xmlElementPtr
 xmlCopyElement(xmlElementPtr elem) {
     xmlElementPtr cur;
 
     cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
     if (cur == NULL) {
         xmlVErrMemory(NULL, "malloc failed");
         return(NULL);
@@ skipping 13 matching lines @@
     /* TODO : rebuild the attribute list on the copy */
     cur->attributes = NULL;
     return(cur);
 }
 
 /**
  * xmlCopyElementTable:
  * @table:  An element table
  *
  * Build a copy of an element table.
- * 
+ *
  * Returns the new xmlElementTablePtr or NULL in case of error.
  */
 xmlElementTablePtr
 xmlCopyElementTable(xmlElementTablePtr table) {
     return((xmlElementTablePtr) xmlHashCopy(table,
                                             (xmlHashCopier) xmlCopyElement));
 }
 #endif /* LIBXML_TREE_ENABLED */
 
 #ifdef LIBXML_OUTPUT_ENABLED
@@ skipping 44 matching lines @@
             if (elem->prefix != NULL) {
                 xmlBufferWriteCHAR(buf, elem->prefix);
                 xmlBufferWriteChar(buf, ":");
             }
             xmlBufferWriteCHAR(buf, elem->name);
             xmlBufferWriteChar(buf, " ");
             xmlDumpElementContent(buf, elem->content, 1);
             xmlBufferWriteChar(buf, ">\n");
             break;
         default:
-            xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR, 
+            xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
                     "Internal: ELEMENT struct corrupted invalid type\n",
                     NULL);
     }
 }
 
 /**
  * xmlDumpElementDeclScan:
  * @elem:  An element table
  * @buf:  the XML buffer output
  *
@@ skipping 70 matching lines @@
  *
  * Returns the xmlEnumerationPtr just created or NULL in case
  *                of error.
  */
 xmlEnumerationPtr
 xmlCopyEnumeration(xmlEnumerationPtr cur) {
     xmlEnumerationPtr ret;
 
     if (cur == NULL) return(NULL);
     ret = xmlCreateEnumeration((xmlChar *) cur->name);
+    if (ret == NULL) return(NULL);
 
     if (cur->next != NULL) ret->next = xmlCopyEnumeration(cur->next);
     else ret->next = NULL;
 
     return(ret);
 }
 #endif /* LIBXML_TREE_ENABLED */
 
 #ifdef LIBXML_OUTPUT_ENABLED
 /**
  * xmlDumpEnumeration:
  * @buf:  the XML buffer output
  * @enum:  An enumeration
  *
  * This will dump the content of the enumeration
  */
 static void
 xmlDumpEnumeration(xmlBufferPtr buf, xmlEnumerationPtr cur) {
     if ((buf == NULL) || (cur == NULL))
         return;
-    
+
     xmlBufferWriteCHAR(buf, cur->name);
     if (cur->next == NULL)
         xmlBufferWriteChar(buf, ")");
     else {
         xmlBufferWriteChar(buf, " | ");
         xmlDumpEnumeration(buf, cur->next);
     }
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 
@@ skipping 134 matching lines @@
             break;
         case XML_ATTRIBUTE_NMTOKEN:
             break;
         case XML_ATTRIBUTE_NMTOKENS:
             break;
         case XML_ATTRIBUTE_ENUMERATION:
             break;
         case XML_ATTRIBUTE_NOTATION:
             break;
         default:
-            xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR, 
+            xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
                     "Internal: ATTRIBUTE struct corrupted invalid type\n",
                     NULL);
             xmlFreeEnumeration(tree);
             return(NULL);
     }
-    if ((defaultValue != NULL) && 
+    if ((defaultValue != NULL) &&
         (!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 */
 
@@ skipping 153 matching lines @@
 xmlFreeAttributeTable(xmlAttributeTablePtr table) {
     xmlHashFree(table, (xmlHashDeallocator) xmlFreeAttribute);
 }
 
 #ifdef LIBXML_TREE_ENABLED
 /**
  * xmlCopyAttribute:
  * @attr:  An attribute
  *
  * Build a copy of an attribute.
- * 
+ *
  * Returns the new xmlAttributePtr or NULL in case of error.
  */
 static xmlAttributePtr
 xmlCopyAttribute(xmlAttributePtr attr) {
     xmlAttributePtr cur;
 
     cur = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
     if (cur == NULL) {
         xmlVErrMemory(NULL, "malloc failed");
         return(NULL);
@@ skipping 12 matching lines @@
     if (attr->defaultValue != NULL)
         cur->defaultValue = xmlStrdup(attr->defaultValue);
     return(cur);
 }
 
 /**
  * xmlCopyAttributeTable:
  * @table:  An attribute table
  *
  * Build a copy of an attribute table.
- * 
+ *
  * Returns the new xmlAttributeTablePtr or NULL in case of error.
  */
 xmlAttributeTablePtr
 xmlCopyAttributeTable(xmlAttributeTablePtr table) {
     return((xmlAttributeTablePtr) xmlHashCopy(table,
                                     (xmlHashCopier) xmlCopyAttribute));
 }
 #endif /* LIBXML_TREE_ENABLED */
 
 #ifdef LIBXML_OUTPUT_ENABLED
@@ skipping 44 matching lines @@
             break;
         case XML_ATTRIBUTE_ENUMERATION:
             xmlBufferWriteChar(buf, " (");
             xmlDumpEnumeration(buf, attr->tree);
             break;
         case XML_ATTRIBUTE_NOTATION:
             xmlBufferWriteChar(buf, " NOTATION (");
             xmlDumpEnumeration(buf, attr->tree);
             break;
         default:
-            xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR, 
+            xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
                     "Internal: ATTRIBUTE struct corrupted invalid type\n",
                     NULL);
     }
     switch (attr->def) {
         case XML_ATTRIBUTE_NONE:
             break;
         case XML_ATTRIBUTE_REQUIRED:
             xmlBufferWriteChar(buf, " #REQUIRED");
             break;
         case XML_ATTRIBUTE_IMPLIED:
             xmlBufferWriteChar(buf, " #IMPLIED");
             break;
         case XML_ATTRIBUTE_FIXED:
             xmlBufferWriteChar(buf, " #FIXED");
             break;
         default:
-            xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR, 
+            xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
                     "Internal: ATTRIBUTE struct corrupted invalid def\n",
                     NULL);
     }
     if (attr->defaultValue != NULL) {
         xmlBufferWriteChar(buf, " ");
         xmlBufferWriteQuotedString(buf, attr->defaultValue);
     }
     xmlBufferWriteChar(buf, ">\n");
 }
 
@@ skipping 109 matching lines @@
         ret->SystemID = xmlStrdup(SystemID);
     if (PublicID != NULL)
         ret->PublicID = xmlStrdup(PublicID);
 
     /*
      * Validity Check:
      * Check the DTD for previous declarations of the ATTLIST
      */
     if (xmlHashAddEntry(table, name, ret)) {
 #ifdef LIBXML_VALID_ENABLED
-        xmlErrValid(NULL, XML_DTD_NOTATION_REDEFINED, 
+        xmlErrValid(NULL, XML_DTD_NOTATION_REDEFINED,
                     "xmlAddNotationDecl: %s already defined\n",
                     (const char *) name);
 #endif /* LIBXML_VALID_ENABLED */
         xmlFreeNotation(ret);
         return(NULL);
     }
     return(ret);
 }
 
 /**
  * xmlFreeNotationTable:
  * @table:  An notation table
  *
  * Deallocate the memory used by an entities hash table.
  */
 void
 xmlFreeNotationTable(xmlNotationTablePtr table) {
     xmlHashFree(table, (xmlHashDeallocator) xmlFreeNotation);
 }
 
 #ifdef LIBXML_TREE_ENABLED
 /**
  * xmlCopyNotation:
  * @nota:  A notation
  *
  * Build a copy of a notation.
- * 
+ *
  * Returns the new xmlNotationPtr or NULL in case of error.
  */
 static xmlNotationPtr
 xmlCopyNotation(xmlNotationPtr nota) {
     xmlNotationPtr cur;
 
     cur = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
     if (cur == NULL) {
         xmlVErrMemory(NULL, "malloc failed");
         return(NULL);
@@ skipping 11 matching lines @@
     else
         cur->SystemID = NULL;
     return(cur);
 }
 
 /**
  * xmlCopyNotationTable:
  * @table:  A notation table
  *
  * Build a copy of a notation table.
- * 
+ *
  * Returns the new xmlNotationTablePtr or NULL in case of error.
  */
 xmlNotationTablePtr
 xmlCopyNotationTable(xmlNotationTablePtr table) {
     return((xmlNotationTablePtr) xmlHashCopy(table,
                                     (xmlHashCopier) xmlCopyNotation));
 }
 #endif /* LIBXML_TREE_ENABLED */
 
 #ifdef LIBXML_OUTPUT_ENABLED
@@ skipping 57 matching lines @@
  *                                                                      *
  ************************************************************************/
 /**
  * DICT_FREE:
  * @str:  a string
  *
  * Free a string if it is not owned by the "dict" dictionnary in the
  * current scope
  */
 #define DICT_FREE(str)                                          \
-        if ((str) && ((!dict) ||                                \
+        if ((str) && ((!dict) ||                                \
             (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))  \
             xmlFree((char *)(str));
 
 /**
  * xmlFreeID:
  * @not:  A id
  *
  * Deallocate the memory used by an id definition
  */
 static void
@@ skipping 17 matching lines @@
  * xmlAddID:
  * @ctxt:  the validation context
  * @doc:  pointer to the document
  * @value:  the value name
  * @attr:  the attribute holding the ID
  *
  * Register a new id declaration
  *
  * Returns NULL if not, otherwise the new xmlIDPtr
  */
-xmlIDPtr 
+xmlIDPtr
 xmlAddID(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
          xmlAttrPtr attr) {
     xmlIDPtr ret;
     xmlIDTablePtr table;
 
     if (doc == NULL) {
         return(NULL);
     }
     if (value == NULL) {
         return(NULL);
@@ skipping 39 matching lines @@
         ret->attr = attr;
         ret->name = NULL;
     }
     ret->lineno = xmlGetLineNo(attr->parent);
 
     if (xmlHashAddEntry(table, value, ret) < 0) {
 #ifdef LIBXML_VALID_ENABLED
         /*
          * The id is already defined in this DTD.
          */
-        if ((ctxt != NULL) && (ctxt->error != NULL)) {
-            xmlErrValidNode(ctxt, attr->parent, XML_DTD_ID_REDEFINED,
-                            "ID %s already defined\n",
-                            value, NULL, NULL);
-        }
+        xmlErrValidNode(ctxt, attr->parent, XML_DTD_ID_REDEFINED,
+                        "ID %s already defined\n", value, NULL, NULL);
 #endif /* LIBXML_VALID_ENABLED */
         xmlFreeID(ret);
         return(NULL);
     }
     if (attr != NULL)
         attr->atype = XML_ATTRIBUTE_ID;
     return(ret);
 }
 
 /**
@@ skipping 29 matching lines @@
         return(1);
     if (doc == NULL) return(0);
     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);    
+        return(0);
     } else if (elem == NULL) {
         return(0);
     } else {
         xmlAttributePtr attrDecl = NULL;
 
         xmlChar felem[50], fattr[50];
         xmlChar *fullelemname, *fullattrname;
 
         fullelemname = (elem->ns != NULL && elem->ns->prefix != NULL) ?
             xmlBuildQName(elem->name, elem->ns->prefix, felem, 50) :
@@ skipping 32 matching lines @@
  * Returns -1 if the lookup failed and 0 otherwise
  */
 int
 xmlRemoveID(xmlDocPtr doc, xmlAttrPtr attr) {
     xmlIDTablePtr table;
     xmlIDPtr id;
     xmlChar *ID;
 
     if (doc == NULL) return(-1);
     if (attr == NULL) return(-1);
+
     table = (xmlIDTablePtr) doc->ids;
-    if (table == NULL) 
+    if (table == NULL)
         return(-1);
 
-    if (attr == NULL)
-        return(-1);
     ID = xmlNodeListGetString(doc, attr->children, 1);
     if (ID == NULL)
-        return(-1);
+        return(-1);
+
     id = xmlHashLookup(table, ID);
     if (id == NULL || id->attr != attr) {
-        xmlFree(ID);
-        return(-1);
+        xmlFree(ID);
+        return(-1);
     }
+
     xmlHashRemoveEntry(table, ID, (xmlHashDeallocator) xmlFreeID);
     xmlFree(ID);
-        attr->atype = 0;
+    attr->atype = 0;
     return(0);
 }
 
 /**
  * xmlGetID:
  * @doc:  pointer to the document
  * @ID:  the ID value
  *
  * Search the attribute declaring the given ID
  *
  * Returns NULL if not found, otherwise the xmlAttrPtr defining the ID
  */
-xmlAttrPtr 
+xmlAttrPtr
 xmlGetID(xmlDocPtr doc, const xmlChar *ID) {
     xmlIDTablePtr table;
     xmlIDPtr id;
 
     if (doc == NULL) {
         return(NULL);
     }
 
     if (ID == NULL) {
         return(NULL);
     }
 
     table = (xmlIDTablePtr) doc->ids;
-    if (table == NULL) 
+    if (table == NULL)
         return(NULL);
 
     id = xmlHashLookup(table, ID);
     if (id == NULL)
         return(NULL);
     if (id->attr == NULL) {
         /*
          * We are operating on a stream, return a well known reference
          * since the attribute node doesn't exist anymore
          */
         return((xmlAttrPtr) doc);
     }
     return(id->attr);
 }
 
 /************************************************************************
  *                                                                      *
  *                              Refs                                    *
  *                                                                      *
  ************************************************************************/
-typedef struct xmlRemoveMemo_t 
+typedef struct xmlRemoveMemo_t
 {
         xmlListPtr l;
         xmlAttrPtr ap;
 } xmlRemoveMemo;
 
 typedef xmlRemoveMemo *xmlRemoveMemoPtr;
 
-typedef struct xmlValidateMemo_t 
+typedef struct xmlValidateMemo_t
 {
     xmlValidCtxtPtr ctxt;
     const xmlChar *name;
 } xmlValidateMemo;
 
 typedef xmlValidateMemo *xmlValidateMemoPtr;
 
 /**
  * xmlFreeRef:
  * @lk:  A list link
@@ skipping 62 matching lines @@
  * xmlAddRef:
  * @ctxt:  the validation context
  * @doc:  pointer to the document
  * @value:  the value name
  * @attr:  the attribute holding the Ref
  *
  * Register a new ref declaration
  *
  * Returns NULL if not, otherwise the new xmlRefPtr
  */
-xmlRefPtr 
+xmlRefPtr
 xmlAddRef(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
     xmlAttrPtr attr) {
     xmlRefPtr ret;
     xmlRefTablePtr table;
     xmlListPtr ref_list;
 
     if (doc == NULL) {
         return(NULL);
     }
     if (value == NULL) {
@@ skipping 107 matching lines @@
         return(0);
     if (doc == NULL) {
         doc = attr->doc;
         if (doc == NULL) return(0);
     }
 
     if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
         return(0);
     } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
         /* TODO @@@ */
-        return(0);    
+        return(0);
     } else {
         xmlAttributePtr attrDecl;
 
         if (elem == NULL) return(0);
         attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, attr->name);
         if ((attrDecl == NULL) && (doc->extSubset != NULL))
             attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
                                          elem->name, attr->name);
 
         if ((attrDecl != NULL) &&
@@ skipping 15 matching lines @@
  */
 int
 xmlRemoveRef(xmlDocPtr doc, xmlAttrPtr attr) {
     xmlListPtr ref_list;
     xmlRefTablePtr table;
     xmlChar *ID;
     xmlRemoveMemo target;
 
     if (doc == NULL) return(-1);
     if (attr == NULL) return(-1);
+
     table = (xmlRefTablePtr) doc->refs;
-    if (table == NULL) 
+    if (table == NULL)
         return(-1);
 
-    if (attr == NULL)
-        return(-1);
     ID = xmlNodeListGetString(doc, attr->children, 1);
     if (ID == NULL)
         return(-1);
+
     ref_list = xmlHashLookup(table, ID);
-
     if(ref_list == NULL) {
         xmlFree(ID);
         return (-1);
     }
+
     /* At this point, ref_list refers to a list of references which
      * have the same key as the supplied attr. Our list of references
      * is ordered by reference address and we don't have that information
      * here to use when removing. We'll have to walk the list and
      * check for a matching attribute, when we find one stop the walk
      * and remove the entry.
      * The list is ordered by reference, so that means we don't have the
      * key. Passing the list and the reference to the walker means we
      * will have enough data to be able to remove the entry.
      */
     target.l = ref_list;
     target.ap = attr;
-    
+
     /* Remove the supplied attr from our list */
     xmlListWalk(ref_list, xmlWalkRemoveRef, &target);
 
     /*If the list is empty then remove the list entry in the hash */
     if (xmlListEmpty(ref_list))
         xmlHashUpdateEntry(table, ID, NULL, (xmlHashDeallocator)
         xmlFreeRefList);
     xmlFree(ID);
     return(0);
 }
 
 /**
  * xmlGetRefs:
  * @doc:  pointer to the document
  * @ID:  the ID value
  *
- * Find the set of references for the supplied ID. 
+ * Find the set of references for the supplied ID.
  *
  * Returns NULL if not found, otherwise node set for the ID.
  */
-xmlListPtr 
+xmlListPtr
 xmlGetRefs(xmlDocPtr doc, const xmlChar *ID) {
     xmlRefTablePtr table;
 
     if (doc == NULL) {
         return(NULL);
     }
 
     if (ID == NULL) {
         return(NULL);
     }
 
     table = (xmlRefTablePtr) doc->refs;
-    if (table == NULL) 
+    if (table == NULL)
         return(NULL);
 
     return (xmlHashLookup(table, ID));
 }
 
 /************************************************************************
  *                                                                      *
  *              Routines for validity checking                          *
  *                                                                      *
  ************************************************************************/
@@ skipping 44 matching lines @@
     xmlElementPtr cur;
     xmlChar *uqname = NULL, *prefix = NULL;
 
     if (dtd == NULL) return(NULL);
     if (dtd->elements == NULL) {
         xmlDictPtr dict = NULL;
 
         if (dtd->doc != NULL)
             dict = dtd->doc->dict;
 
-        if (!create) 
+        if (!create)
             return(NULL);
         /*
          * Create the Element table if needed.
          */
         table = (xmlElementTablePtr) dtd->elements;
         if (table == NULL) {
             table = xmlHashCreateDict(0, dict);
             dtd->elements = (void *) table;
         }
         if (table == NULL) {
@@ skipping 592 matching lines @@
  * [ 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. 
+ * of type NMTOKENS must match Nmtokens.
  *
  * returns 1 if valid or 0 otherwise
  */
 int
 xmlValidateAttributeValue(xmlAttributeType type, const xmlChar *value) {
     return(xmlValidateAttributeValueInternal(NULL, type, value));
 }
 
 /**
  * xmlValidateAttributeValue2:
@@ skipping 38 matching lines @@
         case XML_ATTRIBUTE_CDATA:
             break;
         case XML_ATTRIBUTE_ENTITY: {
             xmlEntityPtr ent;
 
             ent = xmlGetDocEntity(doc, value);
             /* yeah it's a bit messy... */
             if ((ent == NULL) && (doc->standalone == 1)) {
                 doc->standalone = 0;
                 ent = xmlGetDocEntity(doc, value);
-            } 
+            }
             if (ent == NULL) {
                 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
                                 XML_DTD_UNKNOWN_ENTITY,
    "ENTITY attribute %s reference an unknown entity \"%s\"\n",
                        name, value, NULL);
                 ret = 0;
             } else if (ent->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
                 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
                                 XML_DTD_ENTITY_TYPE,
    "ENTITY attribute %s reference an entity \"%s\" of wrong type\n",
@@ skipping 90 matching lines @@
     int extsubset = 0;
 
     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 (attrDecl != NULL)
                 extsubset = 1;
         }
         if ((fullname != fn) && (fullname != elem->name))
@@ skipping 178 matching lines @@
              * element in the external subset.
              */
             nbId = 0;
             if (doc->intSubset != NULL) {
                 table = (xmlAttributeTablePtr) doc->intSubset->attributes;
                 xmlHashScan3(table, NULL, NULL, attr->elem, (xmlHashScanner)
                              xmlValidateAttributeIdCallback, &nbId);
             }
         }
         if (nbId > 1) {
-            
+
             xmlErrValidNodeNr(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
        "Element %s has %d ID attribute defined in the internal subset : %s\n",
                    attr->elem, nbId, attr->name);
         } else if (doc->extSubset != NULL) {
             int extId = 0;
             elem = xmlGetDtdElementDesc(doc->extSubset, attr->elem);
             if (elem != NULL) {
                 extId = xmlScanIDAttributeDecl(NULL, elem, 0);
             }
             if (extId > 1) {
@@ skipping 42 matching lines @@
  * returns 1 if valid or 0 otherwise
  */
 
 int
 xmlValidateElementDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
                        xmlElementPtr elem) {
     int ret = 1;
     xmlElementPtr tst;
 
     CHECK_DTD;
-    
+
     if (elem == NULL) return(1);
 
 #if 0
 #ifdef LIBXML_REGEXP_ENABLED
     /* Build the regexp associated to the content model */
     ret = xmlValidBuildContentModel(ctxt, elem);
 #endif
 #endif
 
     /* No Duplicate Types */
@@ skipping 96 matching lines @@
  *  - [ VC: Entity Name ]
  *  - [ VC: Notation Attributes ]
  *
  * The ID/IDREF uniqueness and matching are done separately
  *
  * returns 1 if valid or 0 otherwise
  */
 
 int
 xmlValidateOneAttribute(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
-                        xmlNodePtr elem, xmlAttrPtr attr, const xmlChar *value) 
+                        xmlNodePtr elem, xmlAttrPtr attr, const xmlChar *value)
 {
     xmlAttributePtr attrDecl =  NULL;
     int val;
     int ret = 1;
 
     CHECK_DTD;
     if ((elem == NULL) || (elem->name == NULL)) return(0);
     if ((attr == NULL) || (attr->name == NULL)) return(0);
 
     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(0);
         if (attr->ns != NULL) {
             attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, fullname,
                                           attr->name, attr->ns->prefix);
             if ((attrDecl == NULL) && (doc->extSubset != NULL))
                 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, fullname,
                                               attr->name, attr->ns->prefix);
         } else {
@@ skipping 63 matching lines @@
 
     /* Validity Constraint: Notation Attributes */
     if (attrDecl->atype == XML_ATTRIBUTE_NOTATION) {
         xmlEnumerationPtr tree = attrDecl->tree;
         xmlNotationPtr nota;
 
         /* First check that the given NOTATION was declared */
         nota = xmlGetDtdNotationDesc(doc->intSubset, value);
         if (nota == NULL)
             nota = xmlGetDtdNotationDesc(doc->extSubset, value);
-        
+
         if (nota == NULL) {
             xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
        "Value \"%s\" for attribute %s of %s is not a declared Notation\n",
                    value, attr->name, elem->name);
             ret = 0;
         }
 
         /* Second, verify that it's among the list */
         while (tree != NULL) {
             if (xmlStrEqual(tree->name, value)) break;
@@ skipping 72 matching lines @@
     int val;
     int ret = 1;
 
     CHECK_DTD;
     if ((elem == NULL) || (elem->name == NULL)) return(0);
     if ((ns == NULL) || (ns->href == NULL)) return(0);
 
     if (prefix != NULL) {
         xmlChar fn[50];
         xmlChar *fullname;
-        
+
         fullname = xmlBuildQName(elem->name, prefix, fn, 50);
         if (fullname == NULL) {
             xmlVErrMemory(ctxt, "Validating namespace");
             return(0);
         }
         if (ns->prefix != NULL) {
             attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, fullname,
                                           ns->prefix, BAD_CAST "xmlns");
             if ((attrDecl == NULL) && (doc->extSubset != NULL))
                 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, fullname,
@@ skipping 83 matching lines @@
 
     /* Validity Constraint: Notation Attributes */
     if (attrDecl->atype == XML_ATTRIBUTE_NOTATION) {
         xmlEnumerationPtr tree = attrDecl->tree;
         xmlNotationPtr nota;
 
         /* First check that the given NOTATION was declared */
         nota = xmlGetDtdNotationDesc(doc->intSubset, value);
         if (nota == NULL)
             nota = xmlGetDtdNotationDesc(doc->extSubset, value);
-        
+
         if (nota == NULL) {
             if (ns->prefix != NULL) {
                 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
        "Value \"%s\" for attribute xmlns:%s of %s is not a declared Notation\n",
                        value, ns->prefix, elem->name);
             } else {
                 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
        "Value \"%s\" for attribute xmlns of %s is not a declared Notation\n",
                        value, elem->name, NULL);
             }
@@ skipping 115 matching lines @@
  */
 
 static int
 xmlValidateElementType(xmlValidCtxtPtr ctxt) {
     int ret = -1;
     int determinist = 1;
 
     NODE = xmlValidateSkipIgnorable(NODE);
     if ((NODE == NULL) && (CONT == NULL))
         return(1);
-    if ((NODE == NULL) && 
+    if ((NODE == NULL) &&
         ((CONT->ocur == XML_ELEMENT_CONTENT_MULT) ||
          (CONT->ocur == XML_ELEMENT_CONTENT_OPT))) {
         return(1);
     }
     if (CONT == NULL) return(-1);
     if ((NODE != NULL) && (NODE->type == XML_ENTITY_REF_NODE))
         return(-2);
 
     /*
      * We arrive here when more states need to be examined
@@ skipping 438 matching lines @@
 xmlValidateElementContent(xmlValidCtxtPtr ctxt, xmlNodePtr child,
        xmlElementPtr elemDecl, int warn, xmlNodePtr parent) {
     int ret = 1;
 #ifndef  LIBXML_REGEXP_ENABLED
     xmlNodePtr repl = NULL, last = NULL, tmp;
 #endif
     xmlNodePtr cur;
     xmlElementContentPtr cont;
     const xmlChar *name;
 
-    if (elemDecl == NULL)
+    if ((elemDecl == NULL) || (parent == NULL) || (ctxt == NULL))
         return(-1);
     cont = elemDecl->content;
     name = elemDecl->name;
 
 #ifdef LIBXML_REGEXP_ENABLED
     /* Build the regexp associated to the content model */
     if (elemDecl->contModel == NULL)
         ret = xmlValidBuildContentModel(ctxt, elemDecl);
     if (elemDecl->contModel == NULL) {
         return(-1);
@@ skipping 29 matching lines @@
                         ret = 0;
                         goto fail;
                     case XML_CDATA_SECTION_NODE:
                         /* TODO */
                         ret = 0;
                         goto fail;
                     case XML_ELEMENT_NODE:
                         if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
                             xmlChar fn[50];
                             xmlChar *fullname;
-                            
+
                             fullname = xmlBuildQName(cur->name,
                                                      cur->ns->prefix, fn, 50);
                             if (fullname == NULL) {
                                 ret = -1;
                                 goto fail;
                             }
                             ret = xmlRegExecPushString(exec, fullname, NULL);
                             if ((fullname != fn) && (fullname != cur->name))
                                 xmlFree(fullname);
                         } else {
@@ skipping 93 matching lines @@
                     tmp->ns = cur->ns;
                     tmp->next = NULL;
                     tmp->content = NULL;
                     if (repl == NULL)
                         repl = last = tmp;
                     else {
                         last->next = tmp;
                         last = tmp;
                     }
                     if (cur->type == XML_CDATA_SECTION_NODE) {
-                        /* 
+                        /*
                          * E59 spaces in CDATA does not match the
                          * nonterminal S
                          */
                         tmp->content = xmlStrdup(BAD_CAST "CDATA");
                     }
                     break;
                 default:
                     break;
             }
             /*
@@ skipping 96 matching lines @@
  * Check that an element follows #CDATA
  *
  * returns 1 if valid or 0 otherwise
  */
 static int
 xmlValidateOneCdataElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
                            xmlNodePtr elem) {
     int ret = 1;
     xmlNodePtr cur, child;
 
-    if ((ctxt == NULL) || (doc == NULL) || (elem == NULL))
+    if ((ctxt == NULL) || (doc == NULL) || (elem == NULL) ||
+        (elem->type != XML_ELEMENT_NODE))
         return(0);
 
     child = elem->children;
 
     cur = child;
     while (cur != NULL) {
         switch (cur->type) {
             case XML_ENTITY_REF_NODE:
                 /*
                  * Push the current node to be able to roll back
@@ skipping 60 matching lines @@
                     return(1);
             } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
                (cont->c1 != NULL) &&
                (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
                 if ((cont->c1->prefix == NULL) &&
                     (xmlStrEqual(cont->c1->name, qname)))
                     return(1);
             } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
                 (cont->c1 == NULL) ||
                 (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
-                xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT, 
+                xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT,
                         "Internal: MIXED struct corrupted\n",
                         NULL);
                 break;
             }
             cont = cont->c2;
         }
     } else {
         while (cont != NULL) {
             if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
                 if ((cont->prefix != NULL) &&
                     (xmlStrncmp(cont->prefix, qname, plen) == 0) &&
                     (xmlStrEqual(cont->name, name)))
                     return(1);
             } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
                (cont->c1 != NULL) &&
                (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
                 if ((cont->c1->prefix != NULL) &&
                     (xmlStrncmp(cont->c1->prefix, qname, plen) == 0) &&
                     (xmlStrEqual(cont->c1->name, name)))
                     return(1);
             } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
                 (cont->c1 == NULL) ||
                 (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
-                xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT, 
+                xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT,
                         "Internal: MIXED struct corrupted\n",
                         NULL);
                 break;
             }
             cont = cont->c2;
         }
     }
     return(0);
 }
 
 /**
  * xmlValidGetElemDecl:
  * @ctxt:  the validation context
  * @doc:  a document instance
  * @elem:  an element instance
  * @extsubset:  pointer, (out) indicate if the declaration was found
  *              in the external subset.
  *
  * Finds a declaration associated to an element in the document.
  *
  * returns the pointer to the declaration or NULL if not found.
  */
 static xmlElementPtr
 xmlValidGetElemDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
                     xmlNodePtr elem, int *extsubset) {
     xmlElementPtr elemDecl = NULL;
     const xmlChar *prefix = NULL;
 
-    if ((ctxt == NULL) || (doc == NULL) || 
+    if ((ctxt == NULL) || (doc == NULL) ||
         (elem == NULL) || (elem->name == NULL))
         return(NULL);
     if (extsubset != NULL)
         *extsubset = 0;
 
     /*
      * Fetch the declaration for the qualified name
      */
     if ((elem->ns != NULL) && (elem->ns->prefix != NULL))
         prefix = elem->ns->prefix;
@@ skipping 123 matching lines @@
     }
     eDecl = xmlValidGetElemDecl(ctxt, doc, elem, &extsubset);
     vstateVPush(ctxt, eDecl, elem);
     return(ret);
 }
 
 /**
  * xmlValidatePushCData:
  * @ctxt:  the validation context
  * @data:  some character data read
- * @len:  the lenght of the data
+ * @len:  the length of the data
  *
  * check the CData parsed for validation in the current stack
  *
  * returns 1 if no validation problem was found or 0 otherwise
  */
 int
 xmlValidatePushCData(xmlValidCtxtPtr ctxt, const xmlChar *data, int len) {
     int ret = 1;
 
 /* printf("CDATA %s %d\n", data, len); */
@@ skipping 201 matching lines @@
     }
 
     /*
      * Fetch the declaration
      */
     elemDecl = xmlValidGetElemDecl(ctxt, doc, elem, &extsubset);
     if (elemDecl == NULL)
         return(0);
 
     /*
-     * If vstateNr is not zero that means continuous validation is 
+     * If vstateNr is not zero that means continuous validation is
      * activated, do not try to check the content model at that level.
      */
     if (ctxt->vstateNr == 0) {
     /* Check that the element content matches the definition */
     switch (elemDecl->etype) {
         case XML_ELEMENT_TYPE_UNDEFINED:
             xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ELEM,
                             "No declaration for element %s\n",
                    elem->name, NULL, NULL);
             return(0);
@@ skipping 22 matching lines @@
                 break;
             }
             child = elem->children;
             /* Hum, this start to get messy */
             while (child != NULL) {
                 if (child->type == XML_ELEMENT_NODE) {
                     name = child->name;
                     if ((child->ns != NULL) && (child->ns->prefix != NULL)) {
                         xmlChar fn[50];
                         xmlChar *fullname;
-                        
+
                         fullname = xmlBuildQName(child->name, child->ns->prefix,
                                                  fn, 50);
                         if (fullname == NULL)
                             return(0);
                         cont = elemDecl->content;
                         while (cont != NULL) {
                             if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
                                 if (xmlStrEqual(cont->name, fullname))
                                     break;
                             } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
                                (cont->c1 != NULL) &&
                                (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
                                 if (xmlStrEqual(cont->c1->name, fullname))
                                     break;
                             } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
                                 (cont->c1 == NULL) ||
                                 (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
-                                xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT, 
+                                xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT,
                                         "Internal: MIXED struct corrupted\n",
                                         NULL);
                                 break;
                             }
                             cont = cont->c2;
                         }
                         if ((fullname != fn) && (fullname != child->name))
                             xmlFree(fullname);
                         if (cont != NULL)
                             goto child_ok;
                     }
                     cont = elemDecl->content;
                     while (cont != NULL) {
                         if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
                             if (xmlStrEqual(cont->name, name)) break;
                         } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
                            (cont->c1 != NULL) &&
                            (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)) {
                             if (xmlStrEqual(cont->c1->name, name)) break;
                         } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
                             (cont->c1 == NULL) ||
                             (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)) {
-                            xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT, 
+                            xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT,
                                     "Internal: MIXED struct corrupted\n",
                                     NULL);
                             break;
                         }
                         cont = cont->c2;
                     }
                     if (cont == NULL) {
                         xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_CHILD,
                "Element %s is not declared in %s list of possible children\n",
                                name, elem->name, NULL);
@@ skipping 59 matching lines @@
                 xmlNsPtr ns;
 
                 ns = elem->nsDef;
                 while (ns != NULL) {
                     if (xmlStrEqual(attr->name, ns->prefix))
                         goto found;
                     ns = ns->next;
                 }
             } else {
                 xmlAttrPtr attrib;
-                
+
                 attrib = elem->properties;
                 while (attrib != NULL) {
                     if (xmlStrEqual(attrib->name, attr->name)) {
                         if (attr->prefix != NULL) {
                             xmlNsPtr nameSpace = attrib->ns;
 
                             if (nameSpace == NULL)
                                 nameSpace = elem->ns;
                             /*
                              * qualified names handling is problematic, having a
                              * different prefix should be possible but DTDs don't
                              * allow to define the URI instead of the prefix :-(
                              */
                             if (nameSpace == NULL) {
-                                if (qualified < 0) 
+                                if (qualified < 0)
                                     qualified = 0;
                             } else if (!xmlStrEqual(nameSpace->prefix,
                                                     attr->prefix)) {
-                                if (qualified < 1) 
+                                if (qualified < 1)
                                     qualified = 1;
                             } else
                                 goto found;
                         } else {
                             /*
                              * We should allow applications to define namespaces
-                             * for their application even if the DTD doesn't 
+                             * for their application even if the DTD doesn't
                              * carry one, otherwise, basically we would always
                              * break.
                              */
                             goto found;
                         }
                     }
                     attrib = attrib->next;
                 }
             }
             if (qualified == -1) {
@@ skipping 52 matching lines @@
                    "Element %s namespace name for %s does not match the DTD\n",
                                    elem->name, ns->prefix, NULL);
                             ret = 0;
                         }
                         goto found;
                     }
                     ns = ns->next;
                 }
             }
         }
-found:      
+found:
         attr = attr->nexth;
     }
     return(ret);
 }
 
 /**
  * xmlValidateRoot:
  * @ctxt:  the validation context
  * @doc:  a document instance
  *
@@ skipping 26 matching lines @@
      */
     if ((doc->intSubset != NULL) &&
         (doc->intSubset->name != NULL)) {
         /*
          * Check first the document root against the NQName
          */
         if (!xmlStrEqual(doc->intSubset->name, root->name)) {
             if ((root->ns != NULL) && (root->ns->prefix != NULL)) {
                 xmlChar fn[50];
                 xmlChar *fullname;
-                
+
                 fullname = xmlBuildQName(root->name, root->ns->prefix, fn, 50);
                 if (fullname == NULL) {
                     xmlVErrMemory(ctxt, NULL);
                     return(0);
                 }
                 ret = xmlStrEqual(doc->intSubset->name, fullname);
                 if ((fullname != fn) && (fullname != root->name))
                     xmlFree(fullname);
                 if (ret == 1)
                     goto name_ok;
-            } 
+            }
             if ((xmlStrEqual(doc->intSubset->name, BAD_CAST "HTML")) &&
                 (xmlStrEqual(root->name, BAD_CAST "html")))
                 goto name_ok;
             xmlErrValidNode(ctxt, root, XML_DTD_ROOT_NAME,
                    "root and DTD name do not match '%s' and '%s'\n",
                    root->name, doc->intSubset->name, NULL);
             return(0);
         }
     }
 name_ok:
     return(1);
 }
 
 
 /**
  * xmlValidateElement:
  * @ctxt:  the validation context
  * @doc:  a document instance
  * @elem:  an element instance
  *
- * Try to validate the subtree under an element 
+ * Try to validate the subtree under an element
  *
  * returns 1 if valid or 0 otherwise
  */
 
 int
 xmlValidateElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem) {
     xmlNodePtr child;
     xmlAttrPtr attr;
     xmlNsPtr ns;
     const xmlChar *value;
     int ret = 1;
 
     if (elem == NULL) return(0);
 
     /*
      * XInclude elements were added after parsing in the infoset,
      * they don't really mean anything validation wise.
      */
     if ((elem->type == XML_XINCLUDE_START) ||
-        (elem->type == XML_XINCLUDE_END))
+        (elem->type == XML_XINCLUDE_END) ||
+        (elem->type == XML_NAMESPACE_DECL))
         return(1);
 
     CHECK_DTD;
 
     /*
      * Entities references have to be handled separately
      */
     if (elem->type == XML_ENTITY_REF_NODE) {
         return(1);
     }
@@ skipping 138 matching lines @@
 xmlValidateCheckRefCallback(xmlListPtr ref_list, xmlValidCtxtPtr ctxt,
                            const xmlChar *name) {
     xmlValidateMemo memo;
 
     if (ref_list == NULL)
         return;
     memo.ctxt = ctxt;
     memo.name = name;
 
     xmlListWalk(ref_list, xmlWalkValidateList, &memo);
-    
+
 }
 
 /**
  * xmlValidateDocumentFinal:
  * @ctxt:  the validation context
  * @doc:  a document instance
  *
  * Does the final step for the document validation once all the
  * incremental validation steps have been completed
  *
  * basically it does the following checks described by the XML Rec
- * 
+ *
  * Check all the IDREF/IDREFS attributes definition for validity
  *
  * returns 1 if valid or 0 otherwise
  */
 
 int
 xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
     xmlRefTablePtr table;
+    unsigned int save;
 
     if (ctxt == NULL)
         return(0);
     if (doc == NULL) {
-        xmlErrValid(ctxt, XML_DTD_NO_DOC, 
+        xmlErrValid(ctxt, XML_DTD_NO_DOC,
                 "xmlValidateDocumentFinal: doc == NULL\n", NULL);
         return(0);
     }
 
+    /* trick to get correct line id report */
+    save = ctxt->finishDtd;
+    ctxt->finishDtd = 0;
+
     /*
      * Check all the NOTATION/NOTATIONS attributes
      */
     /*
      * Check all the ENTITY/ENTITIES attributes definition for validity
      */
     /*
      * Check all the IDREF/IDREFS attributes definition for validity
      */
     table = (xmlRefTablePtr) doc->refs;
     ctxt->doc = doc;
     ctxt->valid = 1;
     xmlHashScan(table, (xmlHashScanner) xmlValidateCheckRefCallback, ctxt);
+
+    ctxt->finishDtd = save;
     return(ctxt->valid);
 }
 
 /**
  * xmlValidateDtd:
  * @ctxt:  the validation context
  * @doc:  a document instance
  * @dtd:  a dtd instance
  *
  * Try to validate the document against the dtd instance
@@ skipping 74 matching lines @@
         case XML_ATTRIBUTE_IDREF        :
         case XML_ATTRIBUTE_IDREFS:
         case XML_ATTRIBUTE_NMTOKEN:
         case XML_ATTRIBUTE_NMTOKENS:
         case XML_ATTRIBUTE_ENUMERATION:
             break;
         case XML_ATTRIBUTE_ENTITY:
         case XML_ATTRIBUTE_ENTITIES:
         case XML_ATTRIBUTE_NOTATION:
             if (cur->defaultValue != NULL) {
-                
+
                 ret = xmlValidateAttributeValue2(ctxt, ctxt->doc, cur->name,
                                                  cur->atype, cur->defaultValue);
                 if ((ret == 0) && (ctxt->valid == 1))
                     ctxt->valid = 0;
             }
             if (cur->tree != NULL) {
                 xmlEnumerationPtr tree = cur->tree;
                 while (tree != NULL) {
                     ret = xmlValidateAttributeValue2(ctxt, ctxt->doc,
                                     cur->name, cur->atype, tree->name);
@@ skipping 36 matching lines @@
 
 /**
  * xmlValidateDtdFinal:
  * @ctxt:  the validation context
  * @doc:  a document instance
  *
  * Does the final step for the dtds validation once all the
  * subsets have been parsed
  *
  * basically it does the following checks described by the XML Rec
- * - check that ENTITY and ENTITIES type attributes default or 
+ * - check that ENTITY and ENTITIES type attributes default or
  *   possible values matches one of the defined entities.
- * - check that NOTATION type attributes default or 
+ * - check that NOTATION type attributes default or
  *   possible values matches one of the defined notations.
  *
  * 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;
@@ skipping 50 matching lines @@
     if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
         xmlErrValid(ctxt, XML_DTD_NO_DTD,
                     "no DTD found!\n", NULL);
         return(0);
     }
     if ((doc->intSubset != NULL) && ((doc->intSubset->SystemID != NULL) ||
         (doc->intSubset->ExternalID != NULL)) && (doc->extSubset == NULL)) {
         xmlChar *sysID;
         if (doc->intSubset->SystemID != NULL) {
             sysID = xmlBuildURI(doc->intSubset->SystemID,
-                        doc->URL);
+                        doc->URL);
             if (sysID == NULL) {
                 xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
                         "Could not build URI for external subset \"%s\"\n",
                         (const char *) doc->intSubset->SystemID);
                 return 0;
             }
         } else
             sysID = NULL;
         doc->extSubset = xmlParseDTD(doc->intSubset->ExternalID,
                         (const xmlChar *)sysID);
@@ skipping 52 matching lines @@
 xmlValidGetPotentialChildren(xmlElementContent *ctree,
                              const xmlChar **names,
                              int *len, int max) {
     int i;
 
     if ((ctree == NULL) || (names == NULL) || (len == NULL))
         return(-1);
     if (*len >= max) return(*len);
 
     switch (ctree->type) {
-        case XML_ELEMENT_CONTENT_PCDATA: 
+        case XML_ELEMENT_CONTENT_PCDATA:
             for (i = 0; i < *len;i++)
                 if (xmlStrEqual(BAD_CAST "#PCDATA", names[i])) return(*len);
             names[(*len)++] = BAD_CAST "#PCDATA";
             break;
-        case XML_ELEMENT_CONTENT_ELEMENT: 
+        case XML_ELEMENT_CONTENT_ELEMENT:
             for (i = 0; i < *len;i++)
                 if (xmlStrEqual(ctree->name, names[i])) return(*len);
             names[(*len)++] = ctree->name;
             break;
-        case XML_ELEMENT_CONTENT_SEQ: 
+        case XML_ELEMENT_CONTENT_SEQ:
             xmlValidGetPotentialChildren(ctree->c1, names, len, max);
             xmlValidGetPotentialChildren(ctree->c2, names, len, max);
             break;
         case XML_ELEMENT_CONTENT_OR:
             xmlValidGetPotentialChildren(ctree->c1, names, len, max);
             xmlValidGetPotentialChildren(ctree->c2, names, len, max);
             break;
    }
-   
+
    return(*len);
 }
 
 /*
  * Dummy function to suppress messages while we try out valid elements
  */
 static void XMLCDECL xmlNoValidityErr(void *ctx ATTRIBUTE_UNUSED,
                                 const char *msg ATTRIBUTE_UNUSED, ...) {
     return;
 }
@@ skipping 21 matching lines @@
  * returns the number of element in the list, or -1 in case of error. If
  *    the function returns the value @max the caller is invited to grow the
  *    receiving array and retry.
  */
 
 int
 xmlValidGetValidElements(xmlNode *prev, xmlNode *next, const xmlChar **names,
                          int max) {
     xmlValidCtxt vctxt;
     int nb_valid_elements = 0;
-    const xmlChar *elements[256];
+    const xmlChar *elements[256]={0};
     int nb_elements = 0, i;
     const xmlChar *name;
-    
+
     xmlNode *ref_node;
     xmlNode *parent;
     xmlNode *test_node;
-    
+
     xmlNode *prev_next;
     xmlNode *next_prev;
     xmlNode *parent_childs;
     xmlNode *parent_last;
-    
+
     xmlElement *element_desc;
 
     if (prev == NULL && next == NULL)
         return(-1);
 
     if (names == NULL) return(-1);
     if (max <= 0) return(-1);
 
     memset(&vctxt, 0, sizeof (xmlValidCtxt));
     vctxt.error = xmlNoValidityErr;     /* this suppresses err/warn output */
 
     nb_valid_elements = 0;
     ref_node = prev ? prev : next;
     parent = ref_node->parent;
 
     /*
      * Retrieves the parent element declaration
      */
     element_desc = xmlGetDtdElementDesc(parent->doc->intSubset,
                                          parent->name);
     if ((element_desc == NULL) && (parent->doc->extSubset != NULL))
         element_desc = xmlGetDtdElementDesc(parent->doc->extSubset,
                                              parent->name);
     if (element_desc == NULL) return(-1);
-        
+
     /*
      * Do a backup of the current tree structure
      */
     prev_next = prev ? prev->next : NULL;
     next_prev = next ? next->prev : NULL;
     parent_childs = parent->children;
     parent_last = parent->last;
 
     /*
      * Creates a dummy node and insert it into the tree
-     */    
+     */
     test_node = xmlNewDocNode (ref_node->doc, NULL, BAD_CAST "<!dummy?>", NULL);
+    if (test_node == NULL)
+        return(-1);
+
     test_node->parent = parent;
     test_node->prev = prev;
     test_node->next = next;
     name = test_node->name;
-    
+
     if (prev) prev->next = test_node;
     else parent->children = test_node;
-                
+
     if (next) next->prev = test_node;
     else parent->last = test_node;
 
     /*
      * Insert each potential child node and check if the parent is
      * still valid
      */
     nb_elements = xmlValidGetPotentialChildren(element_desc->content,
                        elements, &nb_elements, 256);
-    
+
     for (i = 0;i < nb_elements;i++) {
         test_node->name = elements[i];
         if (xmlValidateOneElement(&vctxt, parent->doc, parent)) {
             int j;
 
             for (j = 0; j < nb_valid_elements;j++)
                 if (xmlStrEqual(elements[i], names[j])) break;
             names[nb_valid_elements++] = elements[i];
             if (nb_valid_elements >= max) break;
         }
@@ skipping 12 matching lines @@
      */
     test_node->name = name;
     xmlFreeNode(test_node);
 
     return(nb_valid_elements);
 }
 #endif /* LIBXML_VALID_ENABLED */
 
 #define bottom_valid
 #include "elfgcchack.h"