Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/SAX2.c

 /*
  * SAX2.c : Default SAX2 handler to build a tree.
  *
  * See Copyright for the status of this software.
  *
  * Daniel Veillard <daniel@veillard.com>
  */
 
 
 #define IN_LIBXML
@@ skipping 27 matching lines @@
 /**
  * TODO:
  *
  * macro to flag unimplemented blocks
  * XML_CATALOG_PREFER user env to select between system/public prefered
  * option. C.f. Richard Tobin <richard@cogsci.ed.ac.uk>
  *> Just FYI, I am using an environment variable XML_CATALOG_PREFER with
  *> values "system" and "public".  I have made the default be "system" to
  *> match yours.
  */
-#define TODO                                                            \
+#define TODO                                                            \
     xmlGenericError(xmlGenericErrorContext,                             \
             "Unimplemented block at %s:%d\n",                           \
             __FILE__, __LINE__);
 
 /*
  * xmlSAX2ErrMemory:
  * @ctxt:  an XML validation parser context
  * @msg:   a string to accompany the error message
  */
 static void
 xmlSAX2ErrMemory(xmlParserCtxtPtr ctxt, const char *msg) {
+    xmlStructuredErrorFunc schannel = NULL;
+    const char *str1 = "out of memory\n";
+
     if (ctxt != NULL) {
-        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
-            ctxt->sax->error(ctxt->userData, "%s: out of memory\n", msg);
+        ctxt->errNo = XML_ERR_NO_MEMORY;
+        if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
+            schannel = ctxt->sax->serror;
+        __xmlRaiseError(schannel,
+                        ctxt->vctxt.error, ctxt->vctxt.userData,
+                        ctxt, NULL, XML_FROM_PARSER, XML_ERR_NO_MEMORY,
+                        XML_ERR_ERROR, NULL, 0, (const char *) str1,
+                        NULL, NULL, 0, 0,
+                        msg, (const char *) str1, NULL);
         ctxt->errNo = XML_ERR_NO_MEMORY;
         ctxt->instate = XML_PARSER_EOF;
         ctxt->disableSAX = 1;
+    } else {
+        __xmlRaiseError(schannel,
+                        NULL, NULL,
+                        ctxt, NULL, XML_FROM_PARSER, XML_ERR_NO_MEMORY,
+                        XML_ERR_ERROR, NULL, 0, (const char *) str1,
+                        NULL, NULL, 0, 0,
+                        msg, (const char *) str1, NULL);
     }
 }
 
 /**
  * xmlValidError:
  * @ctxt:  an XML validation parser context
  * @error:  the error number
  * @msg:  the error message
  * @str1:  extra data
  * @str2:  extra data
@@ skipping 43 matching lines @@
 static void
 xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
                const char *msg, const xmlChar *str1, const xmlChar *str2)
 {
     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
         (ctxt->instate == XML_PARSER_EOF))
         return;
     if (ctxt != NULL)
         ctxt->errNo = error;
     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
-                    XML_ERR_FATAL, NULL, 0, 
+                    XML_ERR_FATAL, NULL, 0,
                     (const char *) str1, (const char *) str2,
                     NULL, 0, 0, msg, str1, str2);
     if (ctxt != NULL) {
         ctxt->wellFormed = 0;
         ctxt->valid = 0;
         if (ctxt->recovery == 0)
             ctxt->disableSAX = 1;
     }
 }
 
@@ skipping 10 matching lines @@
 static void
 xmlWarnMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
                const char *msg, const xmlChar *str1)
 {
     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
         (ctxt->instate == XML_PARSER_EOF))
         return;
     if (ctxt != NULL)
         ctxt->errNo = error;
     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
-                    XML_ERR_WARNING, NULL, 0, 
+                    XML_ERR_WARNING, NULL, 0,
                     (const char *) str1, NULL,
                     NULL, 0, 0, msg, str1);
 }
 
 /**
  * xmlNsErrMsg:
  * @ctxt:  an XML parser context
  * @error:  the error number
  * @msg:  the error message
  * @str1:  an error string
  * @str2:  an error string
  *
  * Handle a namespace error
  */
 static void
 xmlNsErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
             const char *msg, const xmlChar *str1, const xmlChar *str2)
 {
     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
         (ctxt->instate == XML_PARSER_EOF))
         return;
     if (ctxt != NULL)
         ctxt->errNo = error;
     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
-                    XML_ERR_ERROR, NULL, 0, 
+                    XML_ERR_ERROR, NULL, 0,
                     (const char *) str1, (const char *) str2,
                     NULL, 0, 0, msg, str1, str2);
 }
 
 /**
  * xmlNsWarnMsg:
  * @ctxt:  an XML parser context
  * @error:  the error number
  * @msg:  the error message
  * @str1:  an error string
  *
  * Handle a namespace warning
  */
 static void
 xmlNsWarnMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
              const char *msg, const xmlChar *str1, const xmlChar *str2)
 {
     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
         (ctxt->instate == XML_PARSER_EOF))
         return;
     if (ctxt != NULL)
         ctxt->errNo = error;
     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
-                    XML_ERR_WARNING, NULL, 0, 
+                    XML_ERR_WARNING, NULL, 0,
                     (const char *) str1, (const char *) str2,
                     NULL, 0, 0, msg, str1, str2);
 }
 
 /**
  * xmlSAX2GetPublicId:
  * @ctx: the user data (XML parser context)
  *
  * Provides the public ID e.g. "-//SGMLSOURCE//DTD DEMO//EN"
  *
@@ skipping 13 matching lines @@
  * Provides the system ID, basically URL or filename e.g.
  * http://www.sgmlsource.com/dtds/memo.dtd
  *
  * Returns a xmlChar *
  */
 const xmlChar *
 xmlSAX2GetSystemId(void *ctx)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     if ((ctx == NULL) || (ctxt->input == NULL)) return(NULL);
-    return((const xmlChar *) ctxt->input->filename); 
+    return((const xmlChar *) ctxt->input->filename);
 }
 
 /**
  * xmlSAX2GetLineNumber:
  * @ctx: the user data (XML parser context)
  *
  * Provide the line number of the current parsing point.
  *
  * Returns an int
  */
@@ skipping 94 matching lines @@
     if (ctxt->myDoc == NULL)
         return;
     dtd = xmlGetIntSubset(ctxt->myDoc);
     if (dtd != NULL) {
         if (ctxt->html)
             return;
         xmlUnlinkNode((xmlNodePtr) dtd);
         xmlFreeDtd(dtd);
         ctxt->myDoc->intSubset = NULL;
     }
-    ctxt->myDoc->intSubset = 
+    ctxt->myDoc->intSubset =
         xmlCreateIntSubset(ctxt->myDoc, name, ExternalID, SystemID);
     if (ctxt->myDoc->intSubset == NULL)
         xmlSAX2ErrMemory(ctxt, "xmlSAX2InternalSubset");
 }
 
 /**
  * xmlSAX2ExternalSubset:
  * @ctx: the user data (XML parser context)
  * @name:  the root element name
  * @ExternalID:  the external ID
@@ skipping 18 matching lines @@
         /*
          * Try to fetch and parse the external subset.
          */
         xmlParserInputPtr oldinput;
         int oldinputNr;
         int oldinputMax;
         xmlParserInputPtr *oldinputTab;
         xmlParserInputPtr input = NULL;
         xmlCharEncoding enc;
         int oldcharset;
+        const xmlChar *oldencoding;
 
         /*
          * Ask the Entity resolver to load the damn thing
          */
         if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
             input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
                                                 SystemID);
         if (input == NULL) {
             return;
         }
 
         xmlNewDtd(ctxt->myDoc, name, ExternalID, SystemID);
 
         /*
          * make sure we won't destroy the main document context
          */
         oldinput = ctxt->input;
         oldinputNr = ctxt->inputNr;
         oldinputMax = ctxt->inputMax;
         oldinputTab = ctxt->inputTab;
         oldcharset = ctxt->charset;
+        oldencoding = ctxt->encoding;
+        ctxt->encoding = NULL;
 
         ctxt->inputTab = (xmlParserInputPtr *)
                          xmlMalloc(5 * sizeof(xmlParserInputPtr));
         if (ctxt->inputTab == NULL) {
             xmlSAX2ErrMemory(ctxt, "xmlSAX2ExternalSubset");
             ctxt->input = oldinput;
             ctxt->inputNr = oldinputNr;
             ctxt->inputMax = oldinputMax;
             ctxt->inputTab = oldinputTab;
             ctxt->charset = oldcharset;
+            ctxt->encoding = oldencoding;
             return;
         }
         ctxt->inputNr = 0;
         ctxt->inputMax = 5;
         ctxt->input = NULL;
         xmlPushInput(ctxt, input);
 
         /*
          * On the fly encoding conversion if needed
          */
@@ skipping 25 matching lines @@
         xmlFree(ctxt->inputTab);
 
         /*
          * Restore the parsing context of the main entity
          */
         ctxt->input = oldinput;
         ctxt->inputNr = oldinputNr;
         ctxt->inputMax = oldinputMax;
         ctxt->inputTab = oldinputTab;
         ctxt->charset = oldcharset;
+        if ((ctxt->encoding != NULL) &&
+            ((ctxt->dict == NULL) ||
+             (!xmlDictOwns(ctxt->dict, ctxt->encoding))))
+            xmlFree((xmlChar *) ctxt->encoding);
+        ctxt->encoding = oldencoding;
         /* ctxt->wellFormed = oldwellFormed; */
     }
 }
 
 /**
  * xmlSAX2ResolveEntity:
  * @ctx: the user data (XML parser context)
  * @publicId: The public ID of the entity
  * @systemId: The system ID of the entity
  *
@@ skipping 84 matching lines @@
         ((ctxt->validate) || (ctxt->replaceEntities)) &&
         (ret->children == NULL) &&
         (ret->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
         int val;
 
         /*
          * for validation purposes we really need to fetch and
          * parse the external entity
          */
         xmlNodePtr children;
+        unsigned long oldnbent = ctxt->nbentities;
 
         val = xmlParseCtxtExternalEntity(ctxt, ret->URI,
                                          ret->ExternalID, &children);
         if (val == 0) {
             xmlAddChildList((xmlNodePtr) ret, children);
         } else {
             xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_PROCESSING,
                            "Failure to process entity %s\n", name, NULL);
             ctxt->validate = 0;
             return(NULL);
         }
         ret->owner = 1;
-        if (ret->checked == 0)
-            ret->checked = 1;
+        if (ret->checked == 0) {
+            ret->checked = (ctxt->nbentities - oldnbent + 1) * 2;
+            if ((ret->content != NULL) && (xmlStrchr(ret->content, '<')))
+                ret->checked |= 1;
+        }
     }
     return(ret);
 }
 
 /**
  * xmlSAX2GetParameterEntity:
  * @ctx: the user data (XML parser context)
  * @name: The entity name
  *
  * Get a parameter entity by name
@@ skipping 13 matching lines @@
 #endif
 
     ret = xmlGetParameterEntity(ctxt->myDoc, name);
     return(ret);
 }
 
 
 /**
  * xmlSAX2EntityDecl:
  * @ctx: the user data (XML parser context)
- * @name:  the entity name 
- * @type:  the entity type 
+ * @name:  the entity name
+ * @type:  the entity type
  * @publicId: The public ID of the entity
  * @systemId: The system ID of the entity
  * @content: the entity value (without processing).
  *
  * An entity definition has been parsed
  */
 void
 xmlSAX2EntityDecl(void *ctx, const xmlChar *name, int type,
           const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
 {
@@ skipping 14 matching lines @@
              "Entity(%s) already defined in the internal subset\n",
                        name);
         if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
             xmlChar *URI;
             const char *base = NULL;
 
             if (ctxt->input != NULL)
                 base = ctxt->input->filename;
             if (base == NULL)
                 base = ctxt->directory;
-        
+
             URI = xmlBuildURI(systemId, (const xmlChar *) base);
             ent->URI = URI;
         }
     } else if (ctxt->inSubset == 2) {
         ent = xmlAddDtdEntity(ctxt->myDoc, name, type, publicId,
                               systemId, content);
         if ((ent == NULL) && (ctxt->pedantic) &&
             (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
-            ctxt->sax->warning(ctxt->userData, 
+            ctxt->sax->warning(ctxt->userData,
              "Entity(%s) already defined in the external subset\n", name);
         if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
             xmlChar *URI;
             const char *base = NULL;
 
             if (ctxt->input != NULL)
                 base = ctxt->input->filename;
             if (base == NULL)
                 base = ctxt->directory;
-        
+
             URI = xmlBuildURI(systemId, (const xmlChar *) base);
             ent->URI = URI;
         }
     } else {
         xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_PROCESSING,
                        "SAX.xmlSAX2EntityDecl(%s) called while not in subset\n",
                        name, NULL);
     }
 }
 
 /**
  * xmlSAX2AttributeDecl:
  * @ctx: the user data (XML parser context)
  * @elem:  the name of the element
- * @fullname:  the attribute name 
- * @type:  the attribute type 
+ * @fullname:  the attribute name
+ * @type:  the attribute type
  * @def:  the type of default value
  * @defaultValue: the attribute default value
  * @tree:  the tree of enumerated value set
  *
  * An attribute definition has been parsed
  */
 void
 xmlSAX2AttributeDecl(void *ctx, const xmlChar *elem, const xmlChar *fullname,
               int type, int def, const xmlChar *defaultValue,
               xmlEnumerationPtr tree)
@@ skipping 22 matching lines @@
     }
     /* TODO: optimize name/prefix allocation */
     name = xmlSplitQName(ctxt, fullname, &prefix);
     ctxt->vctxt.valid = 1;
     if (ctxt->inSubset == 1)
         attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, elem,
                name, prefix, (xmlAttributeType) type,
                (xmlAttributeDefault) def, defaultValue, tree);
     else if (ctxt->inSubset == 2)
         attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, elem,
-           name, prefix, (xmlAttributeType) type, 
+           name, prefix, (xmlAttributeType) type,
            (xmlAttributeDefault) def, defaultValue, tree);
     else {
         xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
              "SAX.xmlSAX2AttributeDecl(%s) called while not in subset\n",
                        name, NULL);
         xmlFreeEnumeration(tree);
         return;
     }
 #ifdef LIBXML_VALID_ENABLED
     if (ctxt->vctxt.valid == 0)
         ctxt->valid = 0;
     if ((attr != NULL) && (ctxt->validate) && (ctxt->wellFormed) &&
         (ctxt->myDoc->intSubset != NULL))
         ctxt->valid &= xmlValidateAttributeDecl(&ctxt->vctxt, ctxt->myDoc,
                                                 attr);
 #endif /* LIBXML_VALID_ENABLED */
     if (prefix != NULL)
         xmlFree(prefix);
     if (name != NULL)
         xmlFree(name);
 }
 
 /**
  * xmlSAX2ElementDecl:
  * @ctx: the user data (XML parser context)
- * @name:  the element name 
- * @type:  the element type 
+ * @name:  the element name
+ * @type:  the element type
  * @content: the element value tree
  *
  * An element definition has been parsed
  */
 void
 xmlSAX2ElementDecl(void *ctx, const xmlChar * name, int type,
             xmlElementContentPtr content)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     xmlElementPtr elem = NULL;
@@ skipping 100 matching lines @@
     xmlGenericError(xmlGenericErrorContext,
             "SAX.xmlSAX2UnparsedEntityDecl(%s, %s, %s, %s)\n",
             name, publicId, systemId, notationName);
 #endif
     if (ctxt->inSubset == 1) {
         ent = xmlAddDocEntity(ctxt->myDoc, name,
                         XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
                         publicId, systemId, notationName);
         if ((ent == NULL) && (ctxt->pedantic) &&
             (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
-            ctxt->sax->warning(ctxt->userData, 
+            ctxt->sax->warning(ctxt->userData,
              "Entity(%s) already defined in the internal subset\n", name);
         if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
             xmlChar *URI;
             const char *base = NULL;
 
             if (ctxt->input != NULL)
                 base = ctxt->input->filename;
             if (base == NULL)
                 base = ctxt->directory;
-        
+
             URI = xmlBuildURI(systemId, (const xmlChar *) base);
             ent->URI = URI;
         }
     } else if (ctxt->inSubset == 2) {
         ent = xmlAddDtdEntity(ctxt->myDoc, name,
                         XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
                         publicId, systemId, notationName);
         if ((ent == NULL) && (ctxt->pedantic) &&
             (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
-            ctxt->sax->warning(ctxt->userData, 
+            ctxt->sax->warning(ctxt->userData,
              "Entity(%s) already defined in the external subset\n", name);
         if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
             xmlChar *URI;
             const char *base = NULL;
 
             if (ctxt->input != NULL)
                 base = ctxt->input->filename;
             if (base == NULL)
                 base = ctxt->directory;
-        
+
             URI = xmlBuildURI(systemId, (const xmlChar *) base);
             ent->URI = URI;
         }
     } else {
         xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
              "SAX.xmlSAX2UnparsedEntityDecl(%s) called while not in subset\n",
                        name, NULL);
     }
 }
 
@@ skipping 30 matching lines @@
     if (ctx == NULL) return;
 
 #ifdef DEBUG_SAX
     xmlGenericError(xmlGenericErrorContext,
             "SAX.xmlSAX2StartDocument()\n");
 #endif
     if (ctxt->html) {
 #ifdef LIBXML_HTML_ENABLED
         if (ctxt->myDoc == NULL)
             ctxt->myDoc = htmlNewDocNoDtD(NULL, NULL);
-        ctxt->myDoc->properties = XML_DOC_HTML;
-        ctxt->myDoc->parseFlags = ctxt->options;
         if (ctxt->myDoc == NULL) {
             xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
             return;
         }
+        ctxt->myDoc->properties = XML_DOC_HTML;
+        ctxt->myDoc->parseFlags = ctxt->options;
 #else
         xmlGenericError(xmlGenericErrorContext,
                 "libxml2 built without HTML support\n");
         ctxt->errNo = XML_ERR_INTERNAL_ERROR;
         ctxt->instate = XML_PARSER_EOF;
         ctxt->disableSAX = 1;
         return;
 #endif
     } else {
         doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
@@ skipping 58 matching lines @@
         (ctxt->inputTab[0]->encoding != NULL) && (ctxt->myDoc != NULL) &&
         (ctxt->myDoc->encoding == NULL)) {
         ctxt->myDoc->encoding = xmlStrdup(ctxt->inputTab[0]->encoding);
     }
     if ((ctxt->charset != XML_CHAR_ENCODING_NONE) && (ctxt->myDoc != NULL) &&
         (ctxt->myDoc->charset == XML_CHAR_ENCODING_NONE)) {
         ctxt->myDoc->charset = ctxt->charset;
     }
 }
 
-#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
+#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) || defined(LIBXML_LEGACY_ENABLED)
 /**
  * xmlSAX2AttributeInternal:
  * @ctx: the user data (XML parser context)
  * @fullname:  The attribute name, including namespace prefix
  * @value:  The attribute value
  * @prefix: the prefix on the element node
  *
  * Handle an attribute that has been read by the parser.
  * The default handling is to convert the attribute into an
  * DOM subtree and past it in a new xmlAttr element added to
@@ skipping 78 matching lines @@
         (name[0] == 'x') && (name[1] == 'm') && (name[2] == 'l') &&
         (name[3] == 'n') && (name[4] == 's') && (name[5] == 0)) {
         xmlNsPtr nsret;
         xmlChar *val;
 
         if (!ctxt->replaceEntities) {
             ctxt->depth++;
             val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
                                           0,0,0);
             ctxt->depth--;
+            if (val == NULL) {
+                xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
+                if (name != NULL)
+                    xmlFree(name);
+                return;
+            }
         } else {
             val = (xmlChar *) value;
         }
 
         if (val[0] != 0) {
             xmlURIPtr uri;
 
             uri = xmlParseURI((const char *)val);
             if (uri == NULL) {
                 if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
-                    ctxt->sax->warning(ctxt->userData, 
+                    ctxt->sax->warning(ctxt->userData,
                          "xmlns: %s not a valid URI\n", val);
             } else {
                 if (uri->scheme == NULL) {
                     if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
-                        ctxt->sax->warning(ctxt->userData, 
+                        ctxt->sax->warning(ctxt->userData,
                              "xmlns: URI %s is not absolute\n", val);
                 }
                 xmlFreeURI(uri);
             }
         }
 
         /* a default namespace definition */
         nsret = xmlNewNs(ctxt->node, val, NULL);
 
 #ifdef LIBXML_VALID_ENABLED
         /*
          * Validate also for namespace decls, they are attributes from
          * an XML-1.0 perspective
          */
         if (nsret != NULL && ctxt->validate && ctxt->wellFormed &&
             ctxt->myDoc && ctxt->myDoc->intSubset)
             ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
                                            ctxt->node, prefix, nsret, val);
 #endif /* LIBXML_VALID_ENABLED */
-        if (name != NULL) 
+        if (name != NULL)
             xmlFree(name);
         if (nval != NULL)
             xmlFree(nval);
         if (val != value)
             xmlFree(val);
         return;
     }
     if ((!ctxt->html) &&
         (ns != NULL) && (ns[0] == 'x') && (ns[1] == 'm') && (ns[2] == 'l') &&
         (ns[3] == 'n') && (ns[4] == 's') && (ns[5] == 0)) {
         xmlNsPtr nsret;
         xmlChar *val;
 
         if (!ctxt->replaceEntities) {
             ctxt->depth++;
             val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
                                           0,0,0);
             ctxt->depth--;
             if (val == NULL) {
                 xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
                 xmlFree(ns);
-                if (name != NULL) 
+                if (name != NULL)
                     xmlFree(name);
                 return;
             }
         } else {
             val = (xmlChar *) value;
         }
 
         if (val[0] == 0) {
             xmlNsErrMsg(ctxt, XML_NS_ERR_EMPTY,
                         "Empty namespace name for prefix %s\n", name, NULL);
@@ skipping 20 matching lines @@
 #ifdef LIBXML_VALID_ENABLED
         /*
          * Validate also for namespace decls, they are attributes from
          * an XML-1.0 perspective
          */
         if (nsret != NULL && ctxt->validate && ctxt->wellFormed &&
             ctxt->myDoc && ctxt->myDoc->intSubset)
             ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
                                            ctxt->node, prefix, nsret, value);
 #endif /* LIBXML_VALID_ENABLED */
-        if (name != NULL) 
+        if (name != NULL)
             xmlFree(name);
         if (nval != NULL)
             xmlFree(nval);
         if (val != value)
             xmlFree(val);
         return;
     }
 
     if (ns != NULL) {
         namespace = xmlSearchNs(ctxt->myDoc, ctxt->node, ns);
@@ skipping 45 matching lines @@
             ret->children = xmlNewDocText(ctxt->myDoc, value);
             ret->last = ret->children;
             if (ret->children != NULL)
                 ret->children->parent = (xmlNodePtr) ret;
         }
     }
 
 #ifdef LIBXML_VALID_ENABLED
     if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
         ctxt->myDoc && ctxt->myDoc->intSubset) {
-        
+
         /*
          * If we don't substitute entities, the validation should be
          * done on a value with replaced entities anyway.
          */
         if (!ctxt->replaceEntities) {
             xmlChar *val;
 
             ctxt->depth++;
             val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
                                           0,0,0);
             ctxt->depth--;
-            
+
             if (val == NULL)
                 ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
                                 ctxt->myDoc, ctxt->node, ret, value);
             else {
                 xmlChar *nvalnorm;
 
                 /*
                  * Do the last stage of the attribute normalization
                  * It need to be done twice ... it's an extra burden related
                  * to the ability to keep xmlSAX2References in attributes
@@ skipping 36 matching lines @@
             xmlAddID(&ctxt->vctxt, ctxt->myDoc, value, ret);
         } else if (xmlIsID(ctxt->myDoc, ctxt->node, ret))
             xmlAddID(&ctxt->vctxt, ctxt->myDoc, value, ret);
         else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret))
             xmlAddRef(&ctxt->vctxt, ctxt->myDoc, value, ret);
     }
 
 error:
     if (nval != NULL)
         xmlFree(nval);
-    if (ns != NULL) 
+    if (ns != NULL)
         xmlFree(ns);
 }
 
 /*
  * xmlCheckDefaultedAttributes:
  *
  * Check defaulted attributes from the DTD
  */
 static void
 xmlCheckDefaultedAttributes(xmlParserCtxtPtr ctxt, const xmlChar *name,
@@ skipping 78 matching lines @@
              * Make sure that attributes redefinition occuring in the
              * internal subset are not overriden by definitions in the
              * external subset.
              */
             if (attr->defaultValue != NULL) {
                 /*
                  * the element should be instantiated in the tree if:
                  *  - this is a namespace prefix
                  *  - the user required for completion in the tree
                  *    like XSLT
-                 *  - there isn't already an attribute definition 
+                 *  - there isn't already an attribute definition
                  *    in the internal subset overriding it.
                  */
                 if (((attr->prefix != NULL) &&
                      (xmlStrEqual(attr->prefix, BAD_CAST "xmlns"))) ||
                     ((attr->prefix == NULL) &&
                      (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) ||
                     (ctxt->loadsubset & XML_COMPLETE_ATTRS)) {
                     xmlAttributePtr tst;
 
                     tst = xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
@@ skipping 68 matching lines @@
     if ((ctx == NULL) || (fullname == NULL) || (ctxt->myDoc == NULL)) return;
     parent = ctxt->node;
 #ifdef DEBUG_SAX
     xmlGenericError(xmlGenericErrorContext,
             "SAX.xmlSAX2StartElement(%s)\n", fullname);
 #endif
 
     /*
      * First check on validity:
      */
-    if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) && 
+    if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) &&
         ((ctxt->myDoc->intSubset == NULL) ||
-         ((ctxt->myDoc->intSubset->notations == NULL) && 
+         ((ctxt->myDoc->intSubset->notations == NULL) &&
           (ctxt->myDoc->intSubset->elements == NULL) &&
-          (ctxt->myDoc->intSubset->attributes == NULL) && 
+          (ctxt->myDoc->intSubset->attributes == NULL) &&
           (ctxt->myDoc->intSubset->entities == NULL)))) {
         xmlErrValid(ctxt, XML_ERR_NO_DTD,
           "Validation failed: no DTD found !", NULL, NULL);
         ctxt->validate = 0;
     }
-       
+
 
     /*
      * Split the full name into a namespace prefix and the tag name
      */
     name = xmlSplitQName(ctxt, fullname, &prefix);
 
 
     /*
      * Note : the namespace resolution is deferred until the end of the
      *        attributes parsing, since local namespace can be defined as
@@ skipping 157 matching lines @@
  * xmlSAX2EndElement:
  * @ctx: the user data (XML parser context)
  * @name:  The element name
  *
  * called when the end of an element has been detected.
  */
 void
 xmlSAX2EndElement(void *ctx, const xmlChar *name ATTRIBUTE_UNUSED)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
-    xmlParserNodeInfo node_info;
     xmlNodePtr cur;
 
     if (ctx == NULL) return;
     cur = ctxt->node;
 #ifdef DEBUG_SAX
     if (name == NULL)
         xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(NULL)\n");
     else
         xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(%s)\n", name);
 #endif
-    
+
     /* Capture end position and add node */
     if (cur != NULL && ctxt->record_info) {
-      node_info.end_pos = ctxt->input->cur - ctxt->input->base;
-      node_info.end_line = ctxt->input->line;
-      node_info.node = cur;
-      xmlParserAddNodeInfo(ctxt, &node_info);
+      ctxt->nodeInfo->end_pos = ctxt->input->cur - ctxt->input->base;
+      ctxt->nodeInfo->end_line = ctxt->input->line;
+      ctxt->nodeInfo->node = cur;
+      xmlParserAddNodeInfo(ctxt, ctxt->nodeInfo);
     }
     ctxt->nodemem = -1;
 
 #ifdef LIBXML_VALID_ENABLED
     if (ctxt->validate && ctxt->wellFormed &&
         ctxt->myDoc && ctxt->myDoc->intSubset)
         ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc,
                                              cur);
 #endif /* LIBXML_VALID_ENABLED */
 
-    
+
     /*
      * end of parsing of this node.
      */
 #ifdef DEBUG_SAX_TREE
     xmlGenericError(xmlGenericErrorContext, "popping(%s)\n", cur->name);
 #endif
     nodePop(ctxt);
 }
-#endif /* LIBXML_SAX1_ENABLED || LIBXML_HTML_ENABLE */
+#endif /* LIBXML_SAX1_ENABLED || LIBXML_HTML_ENABLED || LIBXML_LEGACY_ENABLED */
 
 /*
  * xmlSAX2TextNode:
  * @ctxt:  the parser context
  * @str:  the input string
  * @len: the string length
- * 
- * Remove the entities from an attribute value
+ *
+ * Callback for a text node
  *
  * Returns the newly allocated string or NULL if not needed or error
  */
 static xmlNodePtr
 xmlSAX2TextNode(xmlParserCtxtPtr ctxt, const xmlChar *str, int len) {
     xmlNodePtr ret;
     const xmlChar *intern = NULL;
 
     /*
      * Allocate
@@ skipping 12 matching lines @@
     memset(ret, 0, sizeof(xmlNode));
     /*
      * intern the formatting blanks found between tags, or the
      * very short strings
      */
     if (ctxt->dictNames) {
         xmlChar cur = str[len];
 
         if ((len < (int) (2 * sizeof(void *))) &&
             (ctxt->options & XML_PARSE_COMPACT)) {
-            /* store the string in the node overrithing properties and nsDef */
+            /* store the string in the node overriding properties and nsDef */
             xmlChar *tmp = (xmlChar *) &(ret->properties);
             memcpy(tmp, str, len);
             tmp[len] = 0;
             intern = tmp;
         } else if ((len <= 3) && ((cur == '"') || (cur == '\'') ||
             ((cur == '<') && (str[len + 1] != '!')))) {
             intern = xmlDictLookup(ctxt->dict, str, len);
         } else if (IS_BLANK_CH(*str) && (len < 60) && (cur == '<') &&
                    (str[len + 1] != '!')) {
             int i;
@@ skipping 11 matching lines @@
     if (intern == NULL) {
         ret->content = xmlStrndup(str, len);
         if (ret->content == NULL) {
             xmlSAX2ErrMemory(ctxt, "xmlSAX2TextNode");
             xmlFree(ret);
             return(NULL);
         }
     } else
         ret->content = (xmlChar *) intern;
 
-    if (ctxt->input != NULL)
-        ret->line = ctxt->input->line;
+    if (ctxt->linenumbers) {
+        if (ctxt->input != NULL) {
+            if (ctxt->input->line < 65535)
+                ret->line = (short) ctxt->input->line;
+            else {
+                ret->line = 65535;
+                if (ctxt->options & XML_PARSE_BIG_LINES)
+                    ret->psvi = (void *) (long) ctxt->input->line;
+            }
+        }
+    }
 
     if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
         xmlRegisterNodeDefaultValue(ret);
     return(ret);
 }
 
 #ifdef LIBXML_VALID_ENABLED
 /*
  * xmlSAX2DecodeAttrEntities:
  * @ctxt:  the parser context
  * @str:  the input string
  * @len: the string length
- * 
+ *
  * Remove the entities from an attribute value
  *
  * Returns the newly allocated string or NULL if not needed or error
  */
 static xmlChar *
 xmlSAX2DecodeAttrEntities(xmlParserCtxtPtr ctxt, const xmlChar *str,
                           const xmlChar *end) {
     const xmlChar *in;
     xmlChar *ret;
 
@@ skipping 45 matching lines @@
     /*
      * allocate the node
      */
     if (ctxt->freeAttrs != NULL) {
         ret = ctxt->freeAttrs;
         ctxt->freeAttrs = ret->next;
         ctxt->freeAttrsNr--;
         memset(ret, 0, sizeof(xmlAttr));
         ret->type = XML_ATTRIBUTE_NODE;
 
-        ret->parent = ctxt->node; 
+        ret->parent = ctxt->node;
         ret->doc = ctxt->myDoc;
         ret->ns = namespace;
 
         if (ctxt->dictNames)
             ret->name = localname;
         else
             ret->name = xmlStrdup(localname);
 
         /* link at the end to preserv order, TODO speed up with a last */
         if (ctxt->node->properties == NULL) {
             ctxt->node->properties = ret;
         } else {
             xmlAttrPtr prev = ctxt->node->properties;
 
             while (prev->next != NULL) prev = prev->next;
             prev->next = ret;
             ret->prev = prev;
         }
 
         if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
             xmlRegisterNodeDefaultValue((xmlNodePtr)ret);
     } else {
         if (ctxt->dictNames)
-            ret = xmlNewNsPropEatName(ctxt->node, namespace, 
+            ret = xmlNewNsPropEatName(ctxt->node, namespace,
                                       (xmlChar *) localname, NULL);
         else
             ret = xmlNewNsProp(ctxt->node, namespace, localname, NULL);
         if (ret == NULL) {
             xmlErrMemory(ctxt, "xmlSAX2AttributeNs");
             return;
         }
     }
 
     if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
@@ skipping 65 matching lines @@
                  * dup now contains a string of the flattened attribute
                  * content with entities substitued. Check if we need to
                  * apply an extra layer of normalization.
                  * It need to be done twice ... it's an extra burden related
                  * to the ability to keep references in attributes
                  */
                 if (ctxt->attsSpecial != NULL) {
                     xmlChar *nvalnorm;
                     xmlChar fn[50];
                     xmlChar *fullname;
-                    
+
                     fullname = xmlBuildQName(localname, prefix, fn, 50);
                     if (fullname != NULL) {
                         ctxt->vctxt.valid = 1;
                         nvalnorm = xmlValidCtxtNormalizeAttributeValue(
                                          &ctxt->vctxt, ctxt->myDoc,
                                          ctxt->node, fullname, dup);
                         if (ctxt->vctxt.valid != 1)
                             ctxt->valid = 0;
 
                         if ((fullname != fn) && (fullname != localname))
@@ skipping 30 matching lines @@
         if ((prefix == ctxt->str_xml) &&
                    (localname[0] == 'i') && (localname[1] == 'd') &&
                    (localname[2] == 0)) {
             /*
              * Add the xml:id value
              *
              * Open issue: normalization of the value.
              */
             if (dup == NULL)
                 dup = xmlStrndup(value, valueend - value);
+#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) || defined(LIBXML_LEGACY_ENABLED)
 #ifdef LIBXML_VALID_ENABLED
             if (xmlValidateNCName(dup, 1) != 0) {
                 xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
                       "xml:id : attribute value %s is not an NCName\n",
                             (const char *) dup, NULL);
             }
 #endif
+#endif
             xmlAddID(&ctxt->vctxt, ctxt->myDoc, dup, ret);
         } else if (xmlIsID(ctxt->myDoc, ctxt->node, ret)) {
             /* might be worth duplicate entry points and not copy */
             if (dup == NULL)
                 dup = xmlStrndup(value, valueend - value);
             xmlAddID(&ctxt->vctxt, ctxt->myDoc, dup, ret);
         } else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret)) {
             if (dup == NULL)
                 dup = xmlStrndup(value, valueend - value);
             xmlAddRef(&ctxt->vctxt, ctxt->myDoc, dup, ret);
@@ skipping 29 matching lines @@
                       const xmlChar **namespaces,
                       int nb_attributes,
                       int nb_defaulted,
                       const xmlChar **attributes)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     xmlNodePtr ret;
     xmlNodePtr parent;
     xmlNsPtr last = NULL, ns;
     const xmlChar *uri, *pref;
+    xmlChar *lname = NULL;
     int i, j;
 
     if (ctx == NULL) return;
     parent = ctxt->node;
     /*
      * First check on validity:
      */
-    if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) && 
+    if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) &&
         ((ctxt->myDoc->intSubset == NULL) ||
-         ((ctxt->myDoc->intSubset->notations == NULL) && 
+         ((ctxt->myDoc->intSubset->notations == NULL) &&
           (ctxt->myDoc->intSubset->elements == NULL) &&
-          (ctxt->myDoc->intSubset->attributes == NULL) && 
+          (ctxt->myDoc->intSubset->attributes == NULL) &&
           (ctxt->myDoc->intSubset->entities == NULL)))) {
-        xmlErrValid(ctxt, XML_ERR_NO_DTD,
+        xmlErrValid(ctxt, XML_DTD_NO_DTD,
           "Validation failed: no DTD found !", NULL, NULL);
         ctxt->validate = 0;
     }
 
     /*
+     * Take care of the rare case of an undefined namespace prefix
+     */
+    if ((prefix != NULL) && (URI == NULL)) {
+        if (ctxt->dictNames) {
+            const xmlChar *fullname;
+
+            fullname = xmlDictQLookup(ctxt->dict, prefix, localname);
+            if (fullname != NULL)
+                localname = fullname;
+        } else {
+            lname = xmlBuildQName(localname, prefix, NULL, 0);
+        }
+    }
+    /*
      * allocate the node
      */
     if (ctxt->freeElems != NULL) {
         ret = ctxt->freeElems;
         ctxt->freeElems = ret->next;
         ctxt->freeElemsNr--;
         memset(ret, 0, sizeof(xmlNode));
         ret->type = XML_ELEMENT_NODE;
 
         if (ctxt->dictNames)
             ret->name = localname;
         else {
-            ret->name = xmlStrdup(localname);
+            if (lname == NULL)
+                ret->name = xmlStrdup(localname);
+            else
+                ret->name = lname;
             if (ret->name == NULL) {
                 xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
                 return;
             }
         }
         if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
             xmlRegisterNodeDefaultValue(ret);
     } else {
         if (ctxt->dictNames)
-            ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL, 
+            ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
                                        (xmlChar *) localname, NULL);
+        else if (lname == NULL)
+            ret = xmlNewDocNode(ctxt->myDoc, NULL, localname, NULL);
         else
-            ret = xmlNewDocNode(ctxt->myDoc, NULL, localname, NULL);
+            ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
+                                       (xmlChar *) lname, NULL);
         if (ret == NULL) {
             xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
             return;
         }
     }
     if (ctxt->linenumbers) {
         if (ctxt->input != NULL) {
             if (ctxt->input->line < 65535)
                 ret->line = (short) ctxt->input->line;
             else
                 ret->line = 65535;
         }
     }
 
-    if ((ctxt->myDoc->children == NULL) || (parent == NULL)) {
+    if (parent == NULL) {
         xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
     }
     /*
      * Build the namespace list
      */
     for (i = 0,j = 0;j < nb_namespaces;j++) {
         pref = namespaces[i++];
         uri = namespaces[i++];
         ns = xmlNewNs(NULL, uri, pref);
         if (ns != NULL) {
             if (last == NULL) {
                 ret->nsDef = last = ns;
             } else {
                 last->next = ns;
                 last = ns;
             }
             if ((URI != NULL) && (prefix == pref))
                 ret->ns = ns;
         } else {
-            xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
-            return;
+            /*
+             * any out of memory error would already have been raised
+             * but we can't be garanteed it's the actual error due to the
+             * API, best is to skip in this case
+             */
+            continue;
         }
 #ifdef LIBXML_VALID_ENABLED
         if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
             ctxt->myDoc && ctxt->myDoc->intSubset) {
             ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
                                                    ret, prefix, ns, uri);
         }
 #endif /* LIBXML_VALID_ENABLED */
     }
     ctxt->nodemem = -1;
@@ skipping 46 matching lines @@
                              "Namespace default prefix was not found\n",
                              NULL, NULL);
         }
     }
 
     /*
      * process all the other attributes
      */
     if (nb_attributes > 0) {
         for (j = 0,i = 0;i < nb_attributes;i++,j+=5) {
+            /*
+             * Handle the rare case of an undefined atribute prefix
+             */
+            if ((attributes[j+1] != NULL) && (attributes[j+2] == NULL)) {
+                if (ctxt->dictNames) {
+                    const xmlChar *fullname;
+
+                    fullname = xmlDictQLookup(ctxt->dict, attributes[j+1],
+                                              attributes[j]);
+                    if (fullname != NULL) {
+                        xmlSAX2AttributeNs(ctxt, fullname, NULL,
+                                           attributes[j+3], attributes[j+4]);
+                        continue;
+                    }
+                } else {
+                    lname = xmlBuildQName(attributes[j], attributes[j+1],
+                                          NULL, 0);
+                    if (lname != NULL) {
+                        xmlSAX2AttributeNs(ctxt, lname, NULL,
+                                           attributes[j+3], attributes[j+4]);
+                        xmlFree(lname);
+                        continue;
+                    }
+                }
+            }
             xmlSAX2AttributeNs(ctxt, attributes[j], attributes[j+1],
-                               attributes[j+3], attributes[j+4]);
+                               attributes[j+3], attributes[j+4]);
         }
     }
 
 #ifdef LIBXML_VALID_ENABLED
     /*
      * If it's the Document root, finish the DTD validation and
      * check the document root element for validity
      */
     if ((ctxt->validate) && (ctxt->vctxt.finishDtd == XML_CTXT_FINISH_DTD_0)) {
         int chk;
@@ skipping 50 matching lines @@
      * end of parsing of this node.
      */
     nodePop(ctxt);
 }
 
 /**
  * xmlSAX2Reference:
  * @ctx: the user data (XML parser context)
  * @name:  The entity name
  *
- * called when an entity xmlSAX2Reference is detected. 
+ * called when an entity xmlSAX2Reference is detected.
  */
 void
 xmlSAX2Reference(void *ctx, const xmlChar *name)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     xmlNodePtr ret;
 
     if (ctx == NULL) return;
 #ifdef DEBUG_SAX
     xmlGenericError(xmlGenericErrorContext,
@@ skipping 79 matching lines @@
              * We try to minimaze realloc() uses and avoid copying
              * and recomputing length over and over.
              */
             if (lastChild->content == (xmlChar *)&(lastChild->properties)) {
                 lastChild->content = xmlStrdup(lastChild->content);
                 lastChild->properties = NULL;
             } else if ((ctxt->nodemem == ctxt->nodelen + 1) &&
                        (xmlDictOwns(ctxt->dict, lastChild->content))) {
                 lastChild->content = xmlStrdup(lastChild->content);
             }
+            if (lastChild->content == NULL) {
+                xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters: xmlStrdup returned NULL");
+                return;
+            }
             if (((size_t)ctxt->nodelen + (size_t)len > XML_MAX_TEXT_LENGTH) &&
                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
                 xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters: huge text node");
                 return;
             }
-            if ((size_t)ctxt->nodelen > SIZE_T_MAX - (size_t)len || 
+            if ((size_t)ctxt->nodelen > SIZE_T_MAX - (size_t)len ||
                 (size_t)ctxt->nodemem + (size_t)len > SIZE_T_MAX / 2) {
                 xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters overflow prevented");
                 return;
             }
             if (ctxt->nodelen + len >= ctxt->nodemem) {
                 xmlChar *newbuf;
                 size_t size;
 
                 size = ctxt->nodemem + len;
                 size *= 2;
@@ skipping 83 matching lines @@
                 ret->line = 65535;
         }
     }
     if (ctxt->inSubset == 1) {
         xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
         return;
     } else if (ctxt->inSubset == 2) {
         xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
         return;
     }
-    if ((ctxt->myDoc->children == NULL) || (parent == NULL)) {
+    if (parent == NULL) {
 #ifdef DEBUG_SAX_TREE
             xmlGenericError(xmlGenericErrorContext,
                     "Setting PI %s as root\n", target);
 #endif
         xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
         return;
     }
     if (parent->type == XML_ELEMENT_NODE) {
 #ifdef DEBUG_SAX_TREE
         xmlGenericError(xmlGenericErrorContext,
@@ skipping 40 matching lines @@
         }
     }
 
     if (ctxt->inSubset == 1) {
         xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
         return;
     } else if (ctxt->inSubset == 2) {
         xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
         return;
     }
-    if ((ctxt->myDoc->children == NULL) || (parent == NULL)) {
+    if (parent == NULL) {
 #ifdef DEBUG_SAX_TREE
             xmlGenericError(xmlGenericErrorContext,
                     "Setting xmlSAX2Comment as root\n");
 #endif
         xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
         return;
     }
     if (parent->type == XML_ELEMENT_NODE) {
 #ifdef DEBUG_SAX_TREE
         xmlGenericError(xmlGenericErrorContext,
@@ skipping 270 matching lines @@
  */
 void
 docbDefaultSAXHandlerInit(void)
 {
     xmlSAX2InitDocbDefaultSAXHandler((xmlSAXHandlerPtr) &docbDefaultSAXHandler);
 }
 
 #endif /* LIBXML_DOCB_ENABLED */
 #define bottom_SAX2
 #include "elfgcchack.h"