Update libxml to 2.7.7.

third_party/libxml/parser.c

 /*
  * parser.c : an XML 1.0 parser, namespaces and validity support are mostly
  *            implemented on top of the SAX interfaces
  *
  * References:
  *   The XML specification:
  *     http://www.w3.org/TR/REC-xml
  *   Original 1.0 version:
  *     http://www.w3.org/TR/1998/REC-xml-19980210
  *   XML second edition working draft
@@ skipping 62 matching lines @@
 #ifdef HAVE_FCNTL_H
 #include <fcntl.h>
 #endif
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #ifdef HAVE_ZLIB_H
 #include <zlib.h>
 #endif
 
+static void
+xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info);
+
+static xmlParserCtxtPtr
+xmlCreateEntityParserCtxtInternal(const xmlChar *URL, const xmlChar *ID,
+                          const xmlChar *base, xmlParserCtxtPtr pctx);
+
+/************************************************************************
+ *                                                                      *
+ *      Arbitrary limits set in the parser. See XML_PARSE_HUGE          *
+ *                                                                      *
+ ************************************************************************/
+
+#define XML_PARSER_BIG_ENTITY 1000
+#define XML_PARSER_LOT_ENTITY 5000
+
+/*
+ * XML_PARSER_NON_LINEAR is the threshold where the ratio of parsed entity
+ *    replacement over the size in byte of the input indicates that you have
+ *    and eponential behaviour. A value of 10 correspond to at least 3 entity
+ *    replacement per byte of input.
+ */
+#define XML_PARSER_NON_LINEAR 10
+
+/*
+ * xmlParserEntityCheck
+ *
+ * Function to check non-linear entity expansion behaviour
+ * This is here to detect and stop exponential linear entity expansion
+ * This is not a limitation of the parser but a safety
+ * boundary feature. It can be disabled with the XML_PARSE_HUGE
+ * parser option.
+ */
+static int
+xmlParserEntityCheck(xmlParserCtxtPtr ctxt, unsigned long size,
+                     xmlEntityPtr ent)
+{
+    unsigned long consumed = 0;
+
+    if ((ctxt == NULL) || (ctxt->options & XML_PARSE_HUGE))
+        return (0);
+    if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
+        return (1);
+    if (size != 0) {
+        /*
+         * Do the check based on the replacement size of the entity
+         */
+        if (size < XML_PARSER_BIG_ENTITY)
+            return(0);
+
+        /*
+         * A limit on the amount of text data reasonably used
+         */
+        if (ctxt->input != NULL) {
+            consumed = ctxt->input->consumed +
+                (ctxt->input->cur - ctxt->input->base);
+        }
+        consumed += ctxt->sizeentities;
+
+        if ((size < XML_PARSER_NON_LINEAR * consumed) &&
+            (ctxt->nbentities * 3 < XML_PARSER_NON_LINEAR * consumed))
+            return (0);
+    } else if (ent != NULL) {
+        /*
+         * use the number of parsed entities in the replacement
+         */
+        size = ent->checked;
+
+        /*
+         * The amount of data parsed counting entities size only once
+         */
+        if (ctxt->input != NULL) {
+            consumed = ctxt->input->consumed +
+                (ctxt->input->cur - ctxt->input->base);
+        }
+        consumed += ctxt->sizeentities;
+
+        /*
+         * Check the density of entities for the amount of data
+         * knowing an entity reference will take at least 3 bytes
+         */
+        if (size * 3 < consumed * XML_PARSER_NON_LINEAR)
+            return (0);
+    } else {
+        /*
+         * strange we got no data for checking just return
+         */
+        return (0);
+    }
+
+    xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
+    return (1);
+}
+
 /**
  * xmlParserMaxDepth:
  *
- * arbitrary depth limit for the XML documents that we allow to 
- * process. This is not a limitation of the parser but a safety 
- * boundary feature.
+ * arbitrary depth limit for the XML documents that we allow to
+ * process. This is not a limitation of the parser but a safety
+ * boundary feature. It can be disabled with the XML_PARSE_HUGE
+ * parser option.
  */
-unsigned int xmlParserMaxDepth = 1024;
+unsigned int xmlParserMaxDepth = 256;
+
+
 
 #define SAX2 1
-
 #define XML_PARSER_BIG_BUFFER_SIZE 300
 #define XML_PARSER_BUFFER_SIZE 100
-
 #define SAX_COMPAT_MODE BAD_CAST "SAX compatibility mode document"
 
 /*
  * List of XML prefixed PI allowed by W3C specs
  */
 
 static const char *xmlW3CPIs[] = {
     "xml-stylesheet",
     NULL
 };
 
 
 /* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */
-xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
-                                       const xmlChar **str);
+static xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
+                                              const xmlChar **str);
 
 static xmlParserErrors
 xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
                       xmlSAXHandlerPtr sax,
                       void *user_data, int depth, const xmlChar *URL,
                       const xmlChar *ID, xmlNodePtr *list);
 
+static int
+xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options,
+                          const char *encoding);
 #ifdef LIBXML_LEGACY_ENABLED
 static void
 xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
                       xmlNodePtr lastNode);
 #endif /* LIBXML_LEGACY_ENABLED */
 
 static xmlParserErrors
 xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
                       const xmlChar *string, void *user_data, xmlNodePtr *lst);
 
@@ skipping 16 matching lines @@
  */
 static void
 xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,
                    const xmlChar * localname)
 {
     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
         (ctxt->instate == XML_PARSER_EOF))
         return;
     if (ctxt != NULL)
         ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
+
     if (prefix == NULL)
         __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
-                        ctxt->errNo, XML_ERR_FATAL, NULL, 0,
+                        XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0,
                         (const char *) localname, NULL, NULL, 0, 0,
                         "Attribute %s redefined\n", localname);
     else
         __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
-                        ctxt->errNo, XML_ERR_FATAL, NULL, 0,
+                        XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0,
                         (const char *) prefix, (const char *) localname,
                         NULL, 0, 0, "Attribute %s:%s redefined\n", prefix,
                         localname);
     if (ctxt != NULL) {
         ctxt->wellFormed = 0;
         if (ctxt->recovery == 0)
             ctxt->disableSAX = 1;
     }
 }
 
@@ skipping 215 matching lines @@
 static void
 xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
                const char *msg)
 {
     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, NULL, NULL, NULL, 0, 0, msg);
+                    XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, "%s", msg);
     if (ctxt != NULL) {
         ctxt->wellFormed = 0;
         if (ctxt->recovery == 0)
             ctxt->disableSAX = 1;
     }
 }
 
 /**
  * xmlWarningMsg:
  * @ctxt:  an XML parser context
  * @error:  the error number
  * @msg:  the error message
  * @str1:  extra data
  * @str2:  extra data
  *
  * Handle a warning.
  */
 static void
 xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
               const char *msg, const xmlChar *str1, const xmlChar *str2)
 {
     xmlStructuredErrorFunc schannel = NULL;
-    
+
     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
         (ctxt->instate == XML_PARSER_EOF))
         return;
     if ((ctxt != NULL) && (ctxt->sax != NULL) &&
         (ctxt->sax->initialized == XML_SAX2_MAGIC))
         schannel = ctxt->sax->serror;
-    __xmlRaiseError(schannel,
+    if (ctxt != NULL) {
+        __xmlRaiseError(schannel,
                     (ctxt->sax) ? ctxt->sax->warning : NULL,
                     ctxt->userData,
                     ctxt, NULL, XML_FROM_PARSER, error,
                     XML_ERR_WARNING, NULL, 0,
                     (const char *) str1, (const char *) str2, NULL, 0, 0,
                     msg, (const char *) str1, (const char *) str2);
+    } else {
+        __xmlRaiseError(schannel, NULL, NULL,
+                    ctxt, NULL, XML_FROM_PARSER, error,
+                    XML_ERR_WARNING, NULL, 0,
+                    (const char *) str1, (const char *) str2, NULL, 0, 0,
+                    msg, (const char *) str1, (const char *) str2);
+    }
 }
 
 /**
  * xmlValidityError:
  * @ctxt:  an XML parser context
  * @error:  the error number
  * @msg:  the error message
  * @str1:  extra data
  *
  * Handle a validity error.
  */
 static void
 xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,
-              const char *msg, const xmlChar *str1)
+              const char *msg, const xmlChar *str1, const xmlChar *str2)
 {
     xmlStructuredErrorFunc schannel = NULL;
 
     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
         (ctxt->instate == XML_PARSER_EOF))
         return;
     if (ctxt != NULL) {
         ctxt->errNo = error;
         if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
             schannel = ctxt->sax->serror;
     }
-    __xmlRaiseError(schannel,
+    if (ctxt != NULL) {
+        __xmlRaiseError(schannel,
                     ctxt->vctxt.error, ctxt->vctxt.userData,
                     ctxt, NULL, XML_FROM_DTD, error,
                     XML_ERR_ERROR, NULL, 0, (const char *) str1,
-                    NULL, NULL, 0, 0,
-                    msg, (const char *) str1);
-    if (ctxt != NULL) {
+                    (const char *) str2, NULL, 0, 0,
+                    msg, (const char *) str1, (const char *) str2);
         ctxt->valid = 0;
+    } else {
+        __xmlRaiseError(schannel, NULL, NULL,
+                    ctxt, NULL, XML_FROM_DTD, error,
+                    XML_ERR_ERROR, NULL, 0, (const char *) str1,
+                    (const char *) str2, NULL, 0, 0,
+                    msg, (const char *) str1, (const char *) str2);
     }
 }
 
 /**
  * xmlFatalErrMsgInt:
  * @ctxt:  an XML parser context
  * @error:  the error number
  * @msg:  the error message
  * @val:  an integer value
  *
@@ skipping 125 matching lines @@
     if (ctxt != NULL)
         ctxt->errNo = error;
     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
                     XML_ERR_ERROR, NULL, 0, (const char *) info1,
                     (const char *) info2, (const char *) info3, 0, 0, msg,
                     info1, info2, info3);
     if (ctxt != NULL)
         ctxt->nsWellFormed = 0;
 }
 
+/**
+ * xmlNsWarn
+ * @ctxt:  an XML parser context
+ * @error:  the error number
+ * @msg:  the message
+ * @info1:  extra information string
+ * @info2:  extra information string
+ *
+ * Handle a fatal parser error, i.e. violating Well-Formedness constraints
+ */
+static void
+xmlNsWarn(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+         const char *msg,
+         const xmlChar * info1, const xmlChar * info2,
+         const xmlChar * info3)
+{
+    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+        (ctxt->instate == XML_PARSER_EOF))
+        return;
+    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
+                    XML_ERR_WARNING, NULL, 0, (const char *) info1,
+                    (const char *) info2, (const char *) info3, 0, 0, msg,
+                    info1, info2, info3);
+}
+
 /************************************************************************
  *                                                                      *
  *              Library wide options                                    *
  *                                                                      *
  ************************************************************************/
 
 /**
   * xmlHasFeature:
   * @feature: the feature to be examined
   *
@@ skipping 179 matching lines @@
 #ifdef DEBUG_MEMORY_LOCATION
             return(1);
 #else
             return(0);
 #endif
         case XML_WITH_DEBUG_RUN:
 #ifdef LIBXML_DEBUG_RUNTIME
             return(1);
 #else
             return(0);
-#endif 
+#endif
         case XML_WITH_ZLIB:
 #ifdef LIBXML_ZLIB_ENABLED
             return(1);
 #else
             return(0);
 #endif
         case XML_WITH_ICU:
 #ifdef LIBXML_ICU_ENABLED
             return(1);
 #else
@@ skipping 35 matching lines @@
                 (ctxt->str_xml_ns == NULL)) {
         xmlErrMemory(ctxt, NULL);
     }
 }
 
 typedef struct _xmlDefAttrs xmlDefAttrs;
 typedef xmlDefAttrs *xmlDefAttrsPtr;
 struct _xmlDefAttrs {
     int nbAttrs;        /* number of defaulted attributes on that element */
     int maxAttrs;       /* the size of the array */
-    const xmlChar *values[4]; /* array of localname/prefix/values */
+    const xmlChar *values[5]; /* array of localname/prefix/values/external */
 };
 
 /**
  * xmlAttrNormalizeSpace:
  * @src: the source string
  * @dst: the target string
  *
  * Normalize the space in non CDATA attribute values:
  * If the attribute type is not CDATA, then the XML processor MUST further
  * process the normalized attribute value by discarding any leading and
@@ skipping 33 matching lines @@
  * @src: the source string
  *
  * Normalize the space in non CDATA attribute values, a slightly more complex
  * front end to avoid allocation problems when running on attribute values
  * coming from the input.
  *
  * Returns a pointer to the normalized value (dst) or NULL if no conversion
  *         is needed.
  */
 static const xmlChar *
-xmlAttrNormalizeSpace2(xmlParserCtxtPtr ctxt, const xmlChar *src, int *len)
+xmlAttrNormalizeSpace2(xmlParserCtxtPtr ctxt, xmlChar *src, int *len)
 {
     int i;
     int remove_head = 0;
     int need_realloc = 0;
     const xmlChar *cur;
 
     if ((ctxt == NULL) || (src == NULL) || (len == NULL))
         return(NULL);
     i = *len;
     if (i <= 0)
@@ skipping 20 matching lines @@
         ret = xmlStrndup(src + remove_head, i - remove_head + 1);
         if (ret == NULL) {
             xmlErrMemory(ctxt, NULL);
             return(NULL);
         }
         xmlAttrNormalizeSpace(ret, ret);
         *len = (int) strlen((const char *)ret);
         return(ret);
     } else if (remove_head) {
         *len -= remove_head;
-        return(src + remove_head);
+        memmove(src, src + remove_head, 1 + *len);
+        return(src);
     }
     return(NULL);
 }
 
 /**
  * xmlAddDefAttrs:
  * @ctxt:  an XML parser context
  * @fullname:  the element fullname
  * @fullattr:  the attribute fullname
  * @value:  the attribute value
@@ skipping 36 matching lines @@
         name = xmlDictLookup(ctxt->dict, name, -1);
         prefix = xmlDictLookup(ctxt->dict, fullname, len);
     }
 
     /*
      * make sure there is some storage
      */
     defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
     if (defaults == NULL) {
         defaults = (xmlDefAttrsPtr) xmlMalloc(sizeof(xmlDefAttrs) +
-                           (4 * 4) * sizeof(const xmlChar *));
+                           (4 * 5) * sizeof(const xmlChar *));
         if (defaults == NULL)
             goto mem_error;
         defaults->nbAttrs = 0;
         defaults->maxAttrs = 4;
         if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
                                 defaults, NULL) < 0) {
             xmlFree(defaults);
             goto mem_error;
         }
     } else if (defaults->nbAttrs >= defaults->maxAttrs) {
         xmlDefAttrsPtr temp;
 
         temp = (xmlDefAttrsPtr) xmlRealloc(defaults, sizeof(xmlDefAttrs) +
-                       (2 * defaults->maxAttrs * 4) * sizeof(const xmlChar *));
+                       (2 * defaults->maxAttrs * 5) * sizeof(const xmlChar *));
         if (temp == NULL)
             goto mem_error;
         defaults = temp;
         defaults->maxAttrs *= 2;
         if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
                                 defaults, NULL) < 0) {
             xmlFree(defaults);
             goto mem_error;
         }
     }
 
     /*
      * Split the element name into prefix:localname , the string found
      * are within the DTD and hen not associated to namespace names.
      */
     name = xmlSplitQName3(fullattr, &len);
     if (name == NULL) {
         name = xmlDictLookup(ctxt->dict, fullattr, -1);
         prefix = NULL;
     } else {
         name = xmlDictLookup(ctxt->dict, name, -1);
         prefix = xmlDictLookup(ctxt->dict, fullattr, len);
     }
 
-    defaults->values[4 * defaults->nbAttrs] = name;
-    defaults->values[4 * defaults->nbAttrs + 1] = prefix;
+    defaults->values[5 * defaults->nbAttrs] = name;
+    defaults->values[5 * defaults->nbAttrs + 1] = prefix;
     /* intern the string and precompute the end */
     len = xmlStrlen(value);
     value = xmlDictLookup(ctxt->dict, value, len);
-    defaults->values[4 * defaults->nbAttrs + 2] = value;
-    defaults->values[4 * defaults->nbAttrs + 3] = value + len;
+    defaults->values[5 * defaults->nbAttrs + 2] = value;
+    defaults->values[5 * defaults->nbAttrs + 3] = value + len;
+    if (ctxt->external)
+        defaults->values[5 * defaults->nbAttrs + 4] = BAD_CAST "external";
+    else
+        defaults->values[5 * defaults->nbAttrs + 4] = NULL;
     defaults->nbAttrs++;
 
     return;
 
 mem_error:
     xmlErrMemory(ctxt, NULL);
     return;
 }
 
 /**
@@ skipping 135 matching lines @@
             return (0);
         while (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||  /* non input consuming */
                ((cur[0] >= 'a') && (cur[0] <= 'z')))
             cur++;
     }
     return (1);
 }
 
 /************************************************************************
  *                                                                      *
- *              Parser stacks related functions and macros              *
+ *              Parser stacks related functions and macros              *
  *                                                                      *
  ************************************************************************/
 
-xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
-                                     const xmlChar ** str);
+static xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
+                                            const xmlChar ** str);
 
 #ifdef SAX2
 /**
  * nsPush:
  * @ctxt:  an XML parser context
  * @prefix:  the namespace prefix or NULL
  * @URL:  the namespace name
  *
  * Pushes a new parser namespace on top of the ns stack
  *
@@ skipping 55 matching lines @@
 {
     int i;
 
     if (ctxt->nsTab == NULL) return(0);
     if (ctxt->nsNr < nr) {
         xmlGenericError(xmlGenericErrorContext, "Pbm popping %d NS\n", nr);
         nr = ctxt->nsNr;
     }
     if (ctxt->nsNr <= 0)
         return (0);
-    
+
     for (i = 0;i < nr;i++) {
          ctxt->nsNr--;
          ctxt->nsTab[ctxt->nsNr] = NULL;
     }
     return(nr);
 }
 #endif
 
 static int
 xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
@@ skipping 29 matching lines @@
     return(-1);
 }
 
 /**
  * inputPush:
  * @ctxt:  an XML parser context
  * @value:  the parser input
  *
  * Pushes a new parser input on top of the input stack
  *
- * Returns 0 in case of error, the index in the stack otherwise
+ * Returns -1 in case of error, the index in the stack otherwise
  */
 int
 inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
 {
     if ((ctxt == NULL) || (value == NULL))
-        return(0);
+        return(-1);
     if (ctxt->inputNr >= ctxt->inputMax) {
         ctxt->inputMax *= 2;
         ctxt->inputTab =
             (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
                                              ctxt->inputMax *
                                              sizeof(ctxt->inputTab[0]));
         if (ctxt->inputTab == NULL) {
             xmlErrMemory(ctxt, NULL);
-            return (0);
+            xmlFreeInputStream(value);
+            ctxt->inputMax /= 2;
+            value = NULL;
+            return (-1);
         }
     }
     ctxt->inputTab[ctxt->inputNr] = value;
     ctxt->input = value;
     return (ctxt->inputNr++);
 }
 /**
  * inputPop:
  * @ctxt: an XML parser context
  *
@@ skipping 19 matching lines @@
     ctxt->inputTab[ctxt->inputNr] = NULL;
     return (ret);
 }
 /**
  * nodePush:
  * @ctxt:  an XML parser context
  * @value:  the element node
  *
  * Pushes a new element node on top of the node stack
  *
- * Returns 0 in case of error, the index in the stack otherwise
+ * Returns -1 in case of error, the index in the stack otherwise
  */
 int
 nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
 {
     if (ctxt == NULL) return(0);
     if (ctxt->nodeNr >= ctxt->nodeMax) {
         xmlNodePtr *tmp;
 
         tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
                                       ctxt->nodeMax * 2 *
                                       sizeof(ctxt->nodeTab[0]));
         if (tmp == NULL) {
             xmlErrMemory(ctxt, NULL);
-            return (0);
+            return (-1);
         }
         ctxt->nodeTab = tmp;
         ctxt->nodeMax *= 2;
     }
-    if (((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) {
+    if ((((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) &&
+        ((ctxt->options & XML_PARSE_HUGE) == 0)) {
         xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
-                 "Excessive depth in document: change xmlParserMaxDepth = %d\n",
+                 "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
                           xmlParserMaxDepth);
         ctxt->instate = XML_PARSER_EOF;
-        return(0);
+        return(-1);
     }
     ctxt->nodeTab[ctxt->nodeNr] = value;
     ctxt->node = value;
     return (ctxt->nodeNr++);
 }
+
 /**
  * nodePop:
  * @ctxt: an XML parser context
  *
  * Pops the top element node from the node stack
  *
  * Returns the node just removed
  */
 xmlNodePtr
 nodePop(xmlParserCtxtPtr ctxt)
@@ skipping 146 matching lines @@
 
 static int spacePush(xmlParserCtxtPtr ctxt, int val) {
     if (ctxt->spaceNr >= ctxt->spaceMax) {
         int *tmp;
 
         ctxt->spaceMax *= 2;
         tmp = (int *) xmlRealloc(ctxt->spaceTab,
                                  ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
         if (tmp == NULL) {
             xmlErrMemory(ctxt, NULL);
-            return(0);
+            ctxt->spaceMax /=2;
+            return(-1);
         }
         ctxt->spaceTab = tmp;
     }
     ctxt->spaceTab[ctxt->spaceNr] = val;
     ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
     return(ctxt->spaceNr++);
 }
 
 static int spacePop(xmlParserCtxtPtr ctxt) {
     int ret;
@@ skipping 100 matching lines @@
         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
             xmlPopInput(ctxt);
   }
 
 #define GROW if ((ctxt->progressive == 0) &&                            \
                  (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK))   \
         xmlGROW (ctxt);
 
 static void xmlGROW (xmlParserCtxtPtr ctxt) {
     xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
-    if ((*ctxt->input->cur == 0) &&
+    if ((ctxt->input->cur != NULL) && (*ctxt->input->cur == 0) &&
         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
             xmlPopInput(ctxt);
 }
 
 #define SKIP_BLANKS xmlSkipBlankChars(ctxt)
 
 #define NEXT xmlNextChar(ctxt)
 
 #define NEXT1 {                                                         \
         ctxt->input->col++;                                             \
@@ skipping 106 matching lines @@
     return(CUR);
 }
 
 /**
  * xmlPushInput:
  * @ctxt:  an XML parser context
  * @input:  an XML parser input fragment (entity, XML fragment ...).
  *
  * xmlPushInput: switch to a new input stream which is stacked on top
  *               of the previous one(s).
+ * Returns -1 in case of error or the index in the input stack
  */
-void
+int
 xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
-    if (input == NULL) return;
+    int ret;
+    if (input == NULL) return(-1);
 
     if (xmlParserDebugEntities) {
         if ((ctxt->input != NULL) && (ctxt->input->filename))
             xmlGenericError(xmlGenericErrorContext,
                     "%s(%d): ", ctxt->input->filename,
                     ctxt->input->line);
         xmlGenericError(xmlGenericErrorContext,
                 "Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
     }
-    inputPush(ctxt, input);
+    ret = inputPush(ctxt, input);
     GROW;
+    return(ret);
 }
 
 /**
  * xmlParseCharRef:
  * @ctxt:  an XML parser context
  *
  * parse Reference declarations
  *
  * [66] CharRef ::= '&#' [0-9]+ ';' |
  *                  '&#x' [0-9a-fA-F]+ ';'
@@ skipping 357 matching lines @@
                     /*
                      * [ VC: Entity Declared ]
                      * In a document with an external subset or external
                      * parameter entities with "standalone='no'", ...
                      * ... The declaration of a parameter entity must precede
                      * any reference to it...
                      */
                     if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
                         xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
                                          "PEReference: %%%s; not found\n",
-                                         name);
+                                         name, NULL);
                     } else 
                         xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
                                       "PEReference: %%%s; not found\n",
                                       name, NULL);
                     ctxt->valid = 0;
                 }
             } else if (ctxt->input->free != deallocblankswrapper) {
                     input = xmlNewBlanksWrapperInputStream(ctxt, entity);
-                    xmlPushInput(ctxt, input);
+                    if (xmlPushInput(ctxt, input) < 0)
+                        return;
             } else {
                 if ((entity->etype == XML_INTERNAL_PARAMETER_ENTITY) ||
                     (entity->etype == XML_EXTERNAL_PARAMETER_ENTITY)) {
                     xmlChar start[4];
                     xmlCharEncoding enc;
 
                     /*
                      * handle the extra spaces added before and after
                      * c.f. http://www.w3.org/TR/REC-xml#as-PE
                      * this is done independently.
                      */
                     input = xmlNewEntityInputStream(ctxt, entity);
-                    xmlPushInput(ctxt, input);
+                    if (xmlPushInput(ctxt, input) < 0)
+                        return;
 
                     /* 
                      * Get the 4 first bytes and decode the charset
                      * if enc != XML_CHAR_ENCODING_NONE
                      * plug some encoding conversion routines.
                      * Note that, since we may have some non-UTF8
                      * encoding (like UTF16, bug 135229), the 'length'
                      * is not known, but we can calculate based upon
                      * the amount of data in the buffer.
                      */
@@ skipping 22 matching lines @@
             }
         } else {
             xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
         }
     }
 }
 
 /*
  * Macro used to grow the current buffer.
  */
-#define growBuffer(buffer) {                                            \
+#define growBuffer(buffer, n) {                                         \
     xmlChar *tmp;                                                       \
-    buffer##_size += XML_PARSER_BUFFER_SIZE ;                           \
     buffer##_size *= 2;                                                 \
+    buffer##_size += n;                                                 \
     tmp = (xmlChar *)                                                   \
                 xmlRealloc(buffer, buffer##_size * sizeof(xmlChar));    \
     if (tmp == NULL) goto mem_error;                                    \
     buffer = tmp;                                                       \
 }
 
 /**
  * xmlStringLenDecodeEntities:
  * @ctxt:  the parser context
  * @str:  the input string
@@ skipping 22 matching lines @@
     xmlChar *rep = NULL;
     const xmlChar *last;
     xmlEntityPtr ent;
     int c,l;
     int nbchars = 0;
 
     if ((ctxt == NULL) || (str == NULL) || (len < 0))
         return(NULL);
     last = str + len;
 
-    if (ctxt->depth > 40) {
+    if (((ctxt->depth > 40) &&
+         ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
+        (ctxt->depth > 1024)) {
         xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
         return(NULL);
     }
 
     /*
      * allocate a translation buffer.
      */
     buffer_size = XML_PARSER_BIG_BUFFER_SIZE;
     buffer = (xmlChar *) xmlMallocAtomic(buffer_size * sizeof(xmlChar));
     if (buffer == NULL) goto mem_error;
 
     /*
      * OK loop until we reach one of the ending char or a size limit.
      * we are operating on already parsed values.
      */
     if (str < last)
         c = CUR_SCHAR(str, l);
     else
         c = 0;
     while ((c != 0) && (c != end) && /* non input consuming loop */
            (c != end2) && (c != end3)) {
 
         if (c == 0) break;
         if ((c == '&') && (str[1] == '#')) {
             int val = xmlParseStringCharRef(ctxt, &str);
             if (val != 0) {
                 COPY_BUF(0,buffer,nbchars,val);
             }
             if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
-                growBuffer(buffer);
+                growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
             }
         } else if ((c == '&') && (what & XML_SUBSTITUTE_REF)) {
             if (xmlParserDebugEntities)
                 xmlGenericError(xmlGenericErrorContext,
                         "String decoding Entity Reference: %.30s\n",
                         str);
             ent = xmlParseStringEntityRef(ctxt, &str);
+            if ((ctxt->lastError.code == XML_ERR_ENTITY_LOOP) ||
+                (ctxt->lastError.code == XML_ERR_INTERNAL_ERROR))
+                goto int_error;
+            if (ent != NULL)
+                ctxt->nbentities += ent->checked;
             if ((ent != NULL) &&
                 (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
                 if (ent->content != NULL) {
                     COPY_BUF(0,buffer,nbchars,ent->content[0]);
                     if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
-                        growBuffer(buffer);
+                        growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
                     }
                 } else {
                     xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
                             "predefined entity has no content\n");
                 }
             } else if ((ent != NULL) && (ent->content != NULL)) {
                 ctxt->depth++;
                 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
                                               0, 0, 0);
                 ctxt->depth--;
+
                 if (rep != NULL) {
                     current = rep;
                     while (*current != 0) { /* non input consuming loop */
                         buffer[nbchars++] = *current++;
                         if (nbchars >
                             buffer_size - XML_PARSER_BUFFER_SIZE) {
-                            growBuffer(buffer);
+                            if (xmlParserEntityCheck(ctxt, nbchars, ent))
+                                goto int_error;
+                            growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
                         }
                     }
                     xmlFree(rep);
                     rep = NULL;
                 }
             } else if (ent != NULL) {
                 int i = xmlStrlen(ent->name);
                 const xmlChar *cur = ent->name;
 
                 buffer[nbchars++] = '&';
                 if (nbchars > buffer_size - i - XML_PARSER_BUFFER_SIZE) {
-                    growBuffer(buffer);
+                    growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
                 }
                 for (;i > 0;i--)
                     buffer[nbchars++] = *cur++;
                 buffer[nbchars++] = ';';
             }
         } else if (c == '%' && (what & XML_SUBSTITUTE_PEREF)) {
             if (xmlParserDebugEntities)
                 xmlGenericError(xmlGenericErrorContext,
                         "String decoding PE Reference: %.30s\n", str);
             ent = xmlParseStringPEReference(ctxt, &str);
+            if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
+                goto int_error;
+            if (ent != NULL)
+                ctxt->nbentities += ent->checked;
             if (ent != NULL) {
                 if (ent->content == NULL) {
-                    if (xmlLoadEntityContent(ctxt, ent) < 0) {
-                    }
+                    xmlLoadEntityContent(ctxt, ent);
                 }
                 ctxt->depth++;
                 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
                                               0, 0, 0);
                 ctxt->depth--;
                 if (rep != NULL) {
                     current = rep;
                     while (*current != 0) { /* non input consuming loop */
                         buffer[nbchars++] = *current++;
                         if (nbchars >
                             buffer_size - XML_PARSER_BUFFER_SIZE) {
-                            growBuffer(buffer);
+                            if (xmlParserEntityCheck(ctxt, nbchars, ent))
+                                goto int_error;
+                            growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
                         }
                     }
                     xmlFree(rep);
                     rep = NULL;
                 }
             }
         } else {
             COPY_BUF(l,buffer,nbchars,c);
             str += l;
             if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
-              growBuffer(buffer);
+              growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
             }
         }
         if (str < last)
             c = CUR_SCHAR(str, l);
         else
             c = 0;
     }
-    buffer[nbchars++] = 0;
+    buffer[nbchars] = 0;
     return(buffer);
 
 mem_error:
     xmlErrMemory(ctxt, NULL);
+int_error:
     if (rep != NULL)
         xmlFree(rep);
     if (buffer != NULL)
         xmlFree(buffer);
     return(NULL);
 }
 
 /**
  * xmlStringDecodeEntities:
  * @ctxt:  the parser context
@@ skipping 272 matching lines @@
     return(ret);
 }
 
 /************************************************************************
  *                                                                      *
  *                      The parser itself                               *
  *      Relates to http://www.w3.org/TR/REC-xml                         *
  *                                                                      *
  ************************************************************************/
 
-static const xmlChar * xmlParseNameComplex(xmlParserCtxtPtr ctxt);
+/************************************************************************
+ *                                                                      *
+ *      Routines to parse Name, NCName and NmToken                      *
+ *                                                                      *
+ ************************************************************************/
+#ifdef DEBUG
+static unsigned long nbParseName = 0;
+static unsigned long nbParseNmToken = 0;
+static unsigned long nbParseNCName = 0;
+static unsigned long nbParseNCNameComplex = 0;
+static unsigned long nbParseNameComplex = 0;
+static unsigned long nbParseStringName = 0;
+#endif
+
+/*
+ * The two following functions are related to the change of accepted
+ * characters for Name and NmToken in the Revision 5 of XML-1.0
+ * They correspond to the modified production [4] and the new production [4a]
+ * changes in that revision. Also note that the macros used for the
+ * productions Letter, Digit, CombiningChar and Extender are not needed
+ * anymore.
+ * We still keep compatibility to pre-revision5 parsing semantic if the
+ * new XML_PARSE_OLD10 option is given to the parser.
+ */
+static int
+xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) {
+    if ((ctxt->options & XML_PARSE_OLD10) == 0) {
+        /*
+         * Use the new checks of production [4] [4a] amd [5] of the
+         * Update 5 of XML-1.0
+         */
+        if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
+            (((c >= 'a') && (c <= 'z')) ||
+             ((c >= 'A') && (c <= 'Z')) ||
+             (c == '_') || (c == ':') ||
+             ((c >= 0xC0) && (c <= 0xD6)) ||
+             ((c >= 0xD8) && (c <= 0xF6)) ||
+             ((c >= 0xF8) && (c <= 0x2FF)) ||
+             ((c >= 0x370) && (c <= 0x37D)) ||
+             ((c >= 0x37F) && (c <= 0x1FFF)) ||
+             ((c >= 0x200C) && (c <= 0x200D)) ||
+             ((c >= 0x2070) && (c <= 0x218F)) ||
+             ((c >= 0x2C00) && (c <= 0x2FEF)) ||
+             ((c >= 0x3001) && (c <= 0xD7FF)) ||
+             ((c >= 0xF900) && (c <= 0xFDCF)) ||
+             ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
+             ((c >= 0x10000) && (c <= 0xEFFFF))))
+            return(1);
+    } else {
+        if (IS_LETTER(c) || (c == '_') || (c == ':'))
+            return(1);
+    }
+    return(0);
+}
+
+static int
+xmlIsNameChar(xmlParserCtxtPtr ctxt, int c) {
+    if ((ctxt->options & XML_PARSE_OLD10) == 0) {
+        /*
+         * Use the new checks of production [4] [4a] amd [5] of the
+         * Update 5 of XML-1.0
+         */
+        if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
+            (((c >= 'a') && (c <= 'z')) ||
+             ((c >= 'A') && (c <= 'Z')) ||
+             ((c >= '0') && (c <= '9')) || /* !start */
+             (c == '_') || (c == ':') ||
+             (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
+             ((c >= 0xC0) && (c <= 0xD6)) ||
+             ((c >= 0xD8) && (c <= 0xF6)) ||
+             ((c >= 0xF8) && (c <= 0x2FF)) ||
+             ((c >= 0x300) && (c <= 0x36F)) || /* !start */
+             ((c >= 0x370) && (c <= 0x37D)) ||
+             ((c >= 0x37F) && (c <= 0x1FFF)) ||
+             ((c >= 0x200C) && (c <= 0x200D)) ||
+             ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
+             ((c >= 0x2070) && (c <= 0x218F)) ||
+             ((c >= 0x2C00) && (c <= 0x2FEF)) ||
+             ((c >= 0x3001) && (c <= 0xD7FF)) ||
+             ((c >= 0xF900) && (c <= 0xFDCF)) ||
+             ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
+             ((c >= 0x10000) && (c <= 0xEFFFF))))
+             return(1);
+    } else {
+        if ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
+            (c == '.') || (c == '-') ||
+            (c == '_') || (c == ':') || 
+            (IS_COMBINING(c)) ||
+            (IS_EXTENDER(c)))
+            return(1);
+    }
+    return(0);
+}
+
 static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt,
                                           int *len, int *alloc, int normalize);
 
+static const xmlChar *
+xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
+    int len = 0, l;
+    int c;
+    int count = 0;
+
+#ifdef DEBUG
+    nbParseNameComplex++;
+#endif
+
+    /*
+     * Handler for more complex cases
+     */
+    GROW;
+    c = CUR_CHAR(l);
+    if ((ctxt->options & XML_PARSE_OLD10) == 0) {
+        /*
+         * Use the new checks of production [4] [4a] amd [5] of the
+         * Update 5 of XML-1.0
+         */
+        if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
+            (!(((c >= 'a') && (c <= 'z')) ||
+               ((c >= 'A') && (c <= 'Z')) ||
+               (c == '_') || (c == ':') ||
+               ((c >= 0xC0) && (c <= 0xD6)) ||
+               ((c >= 0xD8) && (c <= 0xF6)) ||
+               ((c >= 0xF8) && (c <= 0x2FF)) ||
+               ((c >= 0x370) && (c <= 0x37D)) ||
+               ((c >= 0x37F) && (c <= 0x1FFF)) ||
+               ((c >= 0x200C) && (c <= 0x200D)) ||
+               ((c >= 0x2070) && (c <= 0x218F)) ||
+               ((c >= 0x2C00) && (c <= 0x2FEF)) ||
+               ((c >= 0x3001) && (c <= 0xD7FF)) ||
+               ((c >= 0xF900) && (c <= 0xFDCF)) ||
+               ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
+               ((c >= 0x10000) && (c <= 0xEFFFF))))) {
+            return(NULL);
+        }
+        len += l;
+        NEXTL(l);
+        c = CUR_CHAR(l);
+        while ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
+               (((c >= 'a') && (c <= 'z')) ||
+                ((c >= 'A') && (c <= 'Z')) ||
+                ((c >= '0') && (c <= '9')) || /* !start */
+                (c == '_') || (c == ':') ||
+                (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
+                ((c >= 0xC0) && (c <= 0xD6)) ||
+                ((c >= 0xD8) && (c <= 0xF6)) ||
+                ((c >= 0xF8) && (c <= 0x2FF)) ||
+                ((c >= 0x300) && (c <= 0x36F)) || /* !start */
+                ((c >= 0x370) && (c <= 0x37D)) ||
+                ((c >= 0x37F) && (c <= 0x1FFF)) ||
+                ((c >= 0x200C) && (c <= 0x200D)) ||
+                ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
+                ((c >= 0x2070) && (c <= 0x218F)) ||
+                ((c >= 0x2C00) && (c <= 0x2FEF)) ||
+                ((c >= 0x3001) && (c <= 0xD7FF)) ||
+                ((c >= 0xF900) && (c <= 0xFDCF)) ||
+                ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
+                ((c >= 0x10000) && (c <= 0xEFFFF))
+                )) {
+            if (count++ > 100) {
+                count = 0;
+                GROW;
+            }
+            len += l;
+            NEXTL(l);
+            c = CUR_CHAR(l);
+        }
+    } else {
+        if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
+            (!IS_LETTER(c) && (c != '_') &&
+             (c != ':'))) {
+            return(NULL);
+        }
+        len += l;
+        NEXTL(l);
+        c = CUR_CHAR(l);
+
+        while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
+               ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
+                (c == '.') || (c == '-') ||
+                (c == '_') || (c == ':') || 
+                (IS_COMBINING(c)) ||
+                (IS_EXTENDER(c)))) {
+            if (count++ > 100) {
+                count = 0;
+                GROW;
+            }
+            len += l;
+            NEXTL(l);
+            c = CUR_CHAR(l);
+        }
+    }
+    if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
+        return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
+    return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
+}
+
 /**
  * xmlParseName:
  * @ctxt:  an XML parser context
  *
  * parse an XML name.
  *
  * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
  *                  CombiningChar | Extender
  *
  * [5] Name ::= (Letter | '_' | ':') (NameChar)*
  *
  * [6] Names ::= Name (#x20 Name)*
  *
  * Returns the Name parsed or NULL
  */
 
 const xmlChar *
 xmlParseName(xmlParserCtxtPtr ctxt) {
     const xmlChar *in;
     const xmlChar *ret;
     int count = 0;
 
     GROW;
 
+#ifdef DEBUG
+    nbParseName++;
+#endif
+
     /*
      * Accelerator for simple ASCII names
      */
     in = ctxt->input->cur;
     if (((*in >= 0x61) && (*in <= 0x7A)) ||
         ((*in >= 0x41) && (*in <= 0x5A)) ||
         (*in == '_') || (*in == ':')) {
         in++;
         while (((*in >= 0x61) && (*in <= 0x7A)) ||
                ((*in >= 0x41) && (*in <= 0x5A)) ||
                ((*in >= 0x30) && (*in <= 0x39)) ||
                (*in == '_') || (*in == '-') ||
                (*in == ':') || (*in == '.'))
             in++;
         if ((*in > 0) && (*in < 0x80)) {
             count = in - ctxt->input->cur;
             ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
             ctxt->input->cur = in;
             ctxt->nbChars += count;
             ctxt->input->col += count;
             if (ret == NULL)
                 xmlErrMemory(ctxt, NULL);
             return(ret);
         }
     }
+    /* accelerator for special cases */
     return(xmlParseNameComplex(ctxt));
 }
 
+static const xmlChar *
+xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
+    int len = 0, l;
+    int c;
+    int count = 0;
+
+#ifdef DEBUG
+    nbParseNCNameComplex++;
+#endif
+
+    /*
+     * Handler for more complex cases
+     */
+    GROW;
+    c = CUR_CHAR(l);
+    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
+        (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) {
+        return(NULL);
+    }
+
+    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
+           (xmlIsNameChar(ctxt, c) && (c != ':'))) {
+        if (count++ > 100) {
+            count = 0;
+            GROW;
+        }
+        len += l;
+        NEXTL(l);
+        c = CUR_CHAR(l);
+    }
+    return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
+}
+
+/**
+ * xmlParseNCName:
+ * @ctxt:  an XML parser context
+ * @len:  lenght of the string parsed
+ *
+ * parse an XML name.
+ *
+ * [4NS] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
+ *                      CombiningChar | Extender
+ *
+ * [5NS] NCName ::= (Letter | '_') (NCNameChar)*
+ *
+ * Returns the Name parsed or NULL
+ */
+
+static const xmlChar *
+xmlParseNCName(xmlParserCtxtPtr ctxt) {
+    const xmlChar *in;
+    const xmlChar *ret;
+    int count = 0;
+
+#ifdef DEBUG
+    nbParseNCName++;
+#endif
+
+    /*
+     * Accelerator for simple ASCII names
+     */
+    in = ctxt->input->cur;
+    if (((*in >= 0x61) && (*in <= 0x7A)) ||
+        ((*in >= 0x41) && (*in <= 0x5A)) ||
+        (*in == '_')) {
+        in++;
+        while (((*in >= 0x61) && (*in <= 0x7A)) ||
+               ((*in >= 0x41) && (*in <= 0x5A)) ||
+               ((*in >= 0x30) && (*in <= 0x39)) ||
+               (*in == '_') || (*in == '-') ||
+               (*in == '.'))
+            in++;
+        if ((*in > 0) && (*in < 0x80)) {
+            count = in - ctxt->input->cur;
+            ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
+            ctxt->input->cur = in;
+            ctxt->nbChars += count;
+            ctxt->input->col += count;
+            if (ret == NULL) {
+                xmlErrMemory(ctxt, NULL);
+            }
+            return(ret);
+        }
+    }
+    return(xmlParseNCNameComplex(ctxt));
+}
+
 /**
  * xmlParseNameAndCompare:
  * @ctxt:  an XML parser context
  *
  * parse an XML name and compares for match
  * (specialized for endtag parsing)
  *
  * Returns NULL for an illegal name, (xmlChar*) 1 for success
  * and the name for mismatch
  */
 
 static const xmlChar *
 xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
     register const xmlChar *cmp = other;
     register const xmlChar *in;
     const xmlChar *ret;
 
     GROW;
-    
+
     in = ctxt->input->cur;
     while (*in != 0 && *in == *cmp) {
-        ++in;
+        ++in;
         ++cmp;
         ctxt->input->col++;
     }
     if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
-        /* success */
+        /* success */
         ctxt->input->cur = in;
         return (const xmlChar*) 1;
     }
     /* failure (or end of input buffer), check with full function */
     ret = xmlParseName (ctxt);
     /* strings coming from the dictionnary direct compare possible */
     if (ret == other) {
         return (const xmlChar*) 1;
     }
     return ret;
 }
 
-static const xmlChar *
-xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
-    int len = 0, l;
-    int c;
-    int count = 0;
-
-    /*
-     * Handler for more complex cases
-     */
-    GROW;
-    c = CUR_CHAR(l);
-    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
-        (!IS_LETTER(c) && (c != '_') &&
-         (c != ':'))) {
-        return(NULL);
-    }
-
-    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
-           ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
-            (c == '.') || (c == '-') ||
-            (c == '_') || (c == ':') || 
-            (IS_COMBINING(c)) ||
-            (IS_EXTENDER(c)))) {
-        if (count++ > 100) {
-            count = 0;
-            GROW;
-        }
-        len += l;
-        NEXTL(l);
-        c = CUR_CHAR(l);
-    }
-    if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
-        return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
-    return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
-}
-
 /**
  * xmlParseStringName:
  * @ctxt:  an XML parser context
  * @str:  a pointer to the string pointer (IN/OUT)
  *
  * parse an XML name.
  *
  * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
  *                  CombiningChar | Extender
  *
  * [5] Name ::= (Letter | '_' | ':') (NameChar)*
  *
  * [6] Names ::= Name (#x20 Name)*
  *
  * Returns the Name parsed or NULL. The @str pointer 
  * is updated to the current location in the string.
  */
 
 static xmlChar *
 xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
     xmlChar buf[XML_MAX_NAMELEN + 5];
     const xmlChar *cur = *str;
     int len = 0, l;
     int c;
 
+#ifdef DEBUG
+    nbParseStringName++;
+#endif
+
     c = CUR_SCHAR(cur, l);
-    if (!IS_LETTER(c) && (c != '_') &&
-        (c != ':')) {
+    if (!xmlIsNameStartChar(ctxt, c)) {
         return(NULL);
     }
 
-    while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigentname.xml */
-           (c == '.') || (c == '-') ||
-           (c == '_') || (c == ':') || 
-           (IS_COMBINING(c)) ||
-           (IS_EXTENDER(c))) {
+    COPY_BUF(l,buf,len,c);
+    cur += l;
+    c = CUR_SCHAR(cur, l);
+    while (xmlIsNameChar(ctxt, c)) {
         COPY_BUF(l,buf,len,c);
         cur += l;
         c = CUR_SCHAR(cur, l);
         if (len >= XML_MAX_NAMELEN) { /* test bigentname.xml */
             /*
              * Okay someone managed to make a huge name, so he's ready to pay
              * for the processing speed.
              */
             xmlChar *buffer;
             int max = len * 2;
-            
+
             buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
             if (buffer == NULL) {
                 xmlErrMemory(ctxt, NULL);
                 return(NULL);
             }
             memcpy(buffer, buf, len);
-            while ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
-                     /* test bigentname.xml */
-                   (c == '.') || (c == '-') ||
-                   (c == '_') || (c == ':') || 
-                   (IS_COMBINING(c)) ||
-                   (IS_EXTENDER(c))) {
+            while (xmlIsNameChar(ctxt, c)) {
                 if (len + 10 > max) {
                     xmlChar *tmp;
                     max *= 2;
                     tmp = (xmlChar *) xmlRealloc(buffer,
                                                     max * sizeof(xmlChar));
                     if (tmp == NULL) {
                         xmlErrMemory(ctxt, NULL);
                         xmlFree(buffer);
                         return(NULL);
                     }
                     buffer = tmp;
                 }
                 COPY_BUF(l,buffer,len,c);
                 cur += l;
                 c = CUR_SCHAR(cur, l);
             }
             buffer[len] = 0;
             *str = cur;
             return(buffer);
         }
     }
     *str = cur;
     return(xmlStrndup(buf, len));
 }
 
 /**
  * xmlParseNmtoken:
  * @ctxt:  an XML parser context
- * 
+ *
  * parse an XML Nmtoken.
  *
  * [7] Nmtoken ::= (NameChar)+
  *
  * [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)*
  *
  * Returns the Nmtoken parsed or NULL
  */
 
 xmlChar *
 xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
     xmlChar buf[XML_MAX_NAMELEN + 5];
     int len = 0, l;
     int c;
     int count = 0;
 
+#ifdef DEBUG
+    nbParseNmToken++;
+#endif
+
     GROW;
     c = CUR_CHAR(l);
 
-    while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigtoken.xml */
-           (c == '.') || (c == '-') ||
-           (c == '_') || (c == ':') || 
-           (IS_COMBINING(c)) ||
-           (IS_EXTENDER(c))) {
+    while (xmlIsNameChar(ctxt, c)) {
         if (count++ > 100) {
             count = 0;
             GROW;
         }
         COPY_BUF(l,buf,len,c);
         NEXTL(l);
         c = CUR_CHAR(l);
         if (len >= XML_MAX_NAMELEN) {
             /*
              * Okay someone managed to make a huge token, so he's ready to pay
              * for the processing speed.
              */
             xmlChar *buffer;
             int max = len * 2;
-            
+
             buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
             if (buffer == NULL) {
                 xmlErrMemory(ctxt, NULL);
                 return(NULL);
             }
             memcpy(buffer, buf, len);
-            while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigtoken.xml */
-                   (c == '.') || (c == '-') ||
-                   (c == '_') || (c == ':') || 
-                   (IS_COMBINING(c)) ||
-                   (IS_EXTENDER(c))) {
+            while (xmlIsNameChar(ctxt, c)) {
                 if (count++ > 100) {
                     count = 0;
                     GROW;
                 }
                 if (len + 10 > max) {
                     xmlChar *tmp;
 
                     max *= 2;
                     tmp = (xmlChar *) xmlRealloc(buffer,
                                                     max * sizeof(xmlChar));
@@ skipping 208 matching lines @@
            (IS_CHAR(c)) && (c != '<')) {
         if (c == 0) break;
         if (c == '&') {
             in_space = 0;
             if (NXT(1) == '#') {
                 int val = xmlParseCharRef(ctxt);
 
                 if (val == '&') {
                     if (ctxt->replaceEntities) {
                         if (len > buf_size - 10) {
-                            growBuffer(buf);
+                            growBuffer(buf, 10);
                         }
                         buf[len++] = '&';
                     } else {
                         /*
                          * The reparsing will be done in xmlStringGetNodeList()
                          * called by the attribute() function in SAX.c
                          */
                         if (len > buf_size - 10) {
-                            growBuffer(buf);
+                            growBuffer(buf, 10);
                         }
                         buf[len++] = '&';
                         buf[len++] = '#';
                         buf[len++] = '3';
                         buf[len++] = '8';
                         buf[len++] = ';';
                     }
                 } else if (val != 0) {
                     if (len > buf_size - 10) {
-                        growBuffer(buf);
+                        growBuffer(buf, 10);
                     }
                     len += xmlCopyChar(0, &buf[len], val);
                 }
             } else {
                 ent = xmlParseEntityRef(ctxt);
+                ctxt->nbentities++;
+                if (ent != NULL)
+                    ctxt->nbentities += ent->owner;
                 if ((ent != NULL) &&
                     (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
                     if (len > buf_size - 10) {
-                        growBuffer(buf);
+                        growBuffer(buf, 10);
                     }
                     if ((ctxt->replaceEntities == 0) &&
                         (ent->content[0] == '&')) {
                         buf[len++] = '&';
                         buf[len++] = '#';
                         buf[len++] = '3';
                         buf[len++] = '8';
                         buf[len++] = ';';
                     } else {
                         buf[len++] = ent->content[0];
                     }
                 } else if ((ent != NULL) && 
                            (ctxt->replaceEntities != 0)) {
                     if (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) {
                         rep = xmlStringDecodeEntities(ctxt, ent->content,
                                                       XML_SUBSTITUTE_REF,
                                                       0, 0, 0);
                         if (rep != NULL) {
                             current = rep;
                             while (*current != 0) { /* non input consuming */
-                                buf[len++] = *current++;
+                                if ((*current == 0xD) || (*current == 0xA) ||
+                                    (*current == 0x9)) {
+                                    buf[len++] = 0x20;
+                                    current++;
+                                } else
+                                    buf[len++] = *current++;
                                 if (len > buf_size - 10) {
-                                    growBuffer(buf);
+                                    growBuffer(buf, 10);
                                 }
                             }
                             xmlFree(rep);
                             rep = NULL;
                         }
                     } else {
                         if (len > buf_size - 10) {
-                            growBuffer(buf);
+                            growBuffer(buf, 10);
                         }
                         if (ent->content != NULL)
                             buf[len++] = ent->content[0];
                     }
                 } else if (ent != NULL) {
                     int i = xmlStrlen(ent->name);
                     const xmlChar *cur = ent->name;
 
                     /*
                      * This may look absurd but is needed to detect
                      * entities problems
                      */
                     if ((ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
                         (ent->content != NULL)) {
                         rep = xmlStringDecodeEntities(ctxt, ent->content,
                                                   XML_SUBSTITUTE_REF, 0, 0, 0);
                         if (rep != NULL) {
                             xmlFree(rep);
                             rep = NULL;
                         }
                     }
 
                     /*
                      * Just output the reference
                      */
                     buf[len++] = '&';
                     while (len > buf_size - i - 10) {
-                        growBuffer(buf);
+                        growBuffer(buf, i + 10);
                     }
                     for (;i > 0;i--)
                         buf[len++] = *cur++;
                     buf[len++] = ';';
                 }
             }
         } else {
             if ((c == 0x20) || (c == 0xD) || (c == 0xA) || (c == 0x9)) {
                 if ((len != 0) || (!normalize)) {
                     if ((!normalize) || (!in_space)) {
                         COPY_BUF(l,buf,len,0x20);
-                        if (len > buf_size - 10) {
-                            growBuffer(buf);
+                        while (len > buf_size - 10) {
+                            growBuffer(buf, 10);
                         }
                     }
                     in_space = 1;
                 }
             } else {
                 in_space = 0;
                 COPY_BUF(l,buf,len,c);
                 if (len > buf_size - 10) {
-                    growBuffer(buf);
+                    growBuffer(buf, 10);
                 }
             }
             NEXTL(l);
         }
         GROW;
         c = CUR_CHAR(l);
     }
     if ((in_space) && (normalize)) {
         while (buf[len - 1] == 0x20) len--;
     }
@@ skipping 209 matching lines @@
     buf[len] = 0;
     if (cur != stop) {
         xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
     } else {
         NEXT;
     }
     ctxt->instate = oldstate;
     return(buf);
 }
 
-void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
+static void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
 
 /*
  * used for the test in the inner loop of the char data testing
  */
 static const unsigned char test_char_data[256] = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x9, CR/LF separated */
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x00, 0x27, /* & */
@@ skipping 143 matching lines @@
                     }
                     line = ctxt->input->line;
                     col = ctxt->input->col;
                 } else if (ctxt->sax != NULL) {
                     if (ctxt->sax->characters != NULL)
                         ctxt->sax->characters(ctxt->userData,
                                               ctxt->input->cur, nbchar);
                     line = ctxt->input->line;
                     col = ctxt->input->col;
                 }
+                /* something really bad happened in the SAX callback */
+                if (ctxt->instate != XML_PARSER_CONTENT)
+                    return;
             }
             ctxt->input->cur = in;
             if (*in == 0xD) {
                 in++;
                 if (*in == 0xA) {
                     ctxt->input->cur = in;
                     in++;
                     ctxt->input->line++; ctxt->input->col = 1;
                     continue; /* while */
                 }
@@ skipping 18 matching lines @@
 
 /**
  * xmlParseCharDataComplex:
  * @ctxt:  an XML parser context
  * @cdata:  int indicating whether we are within a CDATA section
  *
  * parse a CharData section.this is the fallback function
  * of xmlParseCharData() when the parsing requires handling
  * of non-ASCII characters.
  */
-void
+static void
 xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) {
     xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5];
     int nbchar = 0;
     int cur, l;
     int count = 0;
 
     SHRINK;
     GROW;
     cur = CUR_CHAR(l);
     while ((cur != '<') && /* checked */
@@ skipping 21 matching lines @@
                 } else {
                     if (ctxt->sax->characters != NULL)
                         ctxt->sax->characters(ctxt->userData, buf, nbchar);
                     if ((ctxt->sax->characters !=
                          ctxt->sax->ignorableWhitespace) &&
                         (*ctxt->space == -1))
                         *ctxt->space = -2;
                 }
             }
             nbchar = 0;
+            /* something really bad happened in the SAX callback */
+            if (ctxt->instate != XML_PARSER_CONTENT)
+                return;
         }
         count++;
         if (count > 50) {
             GROW;
             count = 0;
         }
         NEXTL(l);
         cur = CUR_CHAR(l);
     }
     if (nbchar != 0) {
@@ skipping 118 matching lines @@
  *  must not occur within comments. "
  * This is the slow routine in case the accelerator for ascii didn't work
  *
  * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
  */
 static void
 xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf, int len, int size) {
     int q, ql;
     int r, rl;
     int cur, l;
-    xmlParserInputPtr input = ctxt->input;
     int count = 0;
+    int inputid;
+
+    inputid = ctxt->input->id;
 
     if (buf == NULL) {
         len = 0;
         size = XML_PARSER_BUFFER_SIZE;
         buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
         if (buf == NULL) {
             xmlErrMemory(ctxt, NULL);
             return;
         }
     }
@@ skipping 61 matching lines @@
     }
     buf[len] = 0;
     if (cur == 0) {
         xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
                              "Comment not terminated \n<!--%.50s\n", buf);
     } else if (!IS_CHAR(cur)) {
         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
                           "xmlParseComment: invalid xmlChar value %d\n",
                           cur);
     } else {
-        if (input != ctxt->input) {
+        if (inputid != ctxt->input->id) {
             xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                 "Comment doesn't start and stop in the same entity\n");
         }
         NEXT;
         if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
             (!ctxt->disableSAX))
             ctxt->sax->comment(ctxt->userData, buf);
     }
     xmlFree(buf);
     return;
@@ skipping 15 matching lines @@
  * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
  */
 void
 xmlParseComment(xmlParserCtxtPtr ctxt) {
     xmlChar *buf = NULL;
     int size = XML_PARSER_BUFFER_SIZE;
     int len = 0;
     xmlParserInputState state;
     const xmlChar *in;
     int nbchar = 0, ccol;
+    int inputid;
 
     /*
      * Check that there is a comment right here.
      */
     if ((RAW != '<') || (NXT(1) != '!') ||
         (NXT(2) != '-') || (NXT(3) != '-')) return;
-
     state = ctxt->instate;
     ctxt->instate = XML_PARSER_COMMENT;
+    inputid = ctxt->input->id;
     SKIP(4);
     SHRINK;
     GROW;
 
     /*
      * Accelerated common case where input don't need to be
      * modified before passing it to the handler.
      */
     in = ctxt->input->cur;
     do {
@@ skipping 70 matching lines @@
                 continue; /* while */
             }
             in--;
         }
         SHRINK;
         GROW;
         in = ctxt->input->cur;
         if (*in == '-') {
             if (in[1] == '-') {
                 if (in[2] == '>') {
+                    if (ctxt->input->id != inputid) {
+                        xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
+                        "comment doesn't start and stop in the same entity\n");
+                    }
                     SKIP(3);
                     if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
                         (!ctxt->disableSAX)) {
                         if (buf != NULL)
                             ctxt->sax->comment(ctxt->userData, buf);
                         else
                             ctxt->sax->comment(ctxt->userData, BAD_CAST "");
                     }
                     if (buf != NULL)
                         xmlFree(buf);
@@ skipping 53 matching lines @@
         }
         for (i = 0;;i++) {
             if (xmlW3CPIs[i] == NULL) break;
             if (xmlStrEqual(name, (const xmlChar *)xmlW3CPIs[i]))
                 return(name);
         }
         xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
                       "xmlParsePITarget: invalid name prefix 'xml'\n",
                       NULL, NULL);
     }
+    if ((name != NULL) && (xmlStrchr(name, ':') != NULL)) {
+        xmlNsErr(ctxt, XML_NS_ERR_COLON, 
+                 "colon are forbidden from PI names '%s'\n", name, NULL, NULL);
+    }
     return(name);
 }
 
 #ifdef LIBXML_CATALOG_ENABLED
 /**
  * xmlParseCatalogPI:
  * @ctxt:  an XML parser context
  * @catalog:  the PI value string
  * 
  * parse an XML Catalog Processing Instruction.
@@ skipping 223 matching lines @@
         name = xmlParseName(ctxt);
         if (name == NULL) {
             xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
             return;
         }
         if (!IS_BLANK_CH(CUR)) {
             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                      "Space required after the NOTATION name'\n");
             return;
         }
+        if (xmlStrchr(name, ':') != NULL) {
+            xmlNsErr(ctxt, XML_NS_ERR_COLON, 
+                     "colon are forbidden from notation names '%s'\n",
+                     name, NULL, NULL);
+        }
         SKIP_BLANKS;
 
         /*
          * Parse the IDs.
          */
         Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
         SKIP_BLANKS;
 
         if (RAW == '>') {
             if (input != ctxt->input) {
@@ skipping 64 matching lines @@
             }
             isParameter = 1;
         }
 
         name = xmlParseName(ctxt);
         if (name == NULL) {
             xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
                            "xmlParseEntityDecl: no name\n");
             return;
         }
+        if (xmlStrchr(name, ':') != NULL) {
+            xmlNsErr(ctxt, XML_NS_ERR_COLON, 
+                     "colon are forbidden from entities names '%s'\n",
+                     name, NULL, NULL);
+        }
         skipped = SKIP_BLANKS;
         if (skipped == 0) {
             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                            "Space required after the entity name\n");
         }
 
         ctxt->instate = XML_PARSER_ENTITY_DECL;
         /*
          * handle the various case of definitions...
          */
@@ skipping 55 matching lines @@
                  * For expat compatibility in SAX mode.
                  */
                 if ((ctxt->myDoc == NULL) ||
                     (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
                     if (ctxt->myDoc == NULL) {
                         ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
                         if (ctxt->myDoc == NULL) {
                             xmlErrMemory(ctxt, "New Doc failed");
                             return;
                         }
+                        ctxt->myDoc->properties = XML_DOC_INTERNAL;
                     }
                     if (ctxt->myDoc->intSubset == NULL)
                         ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
                                             BAD_CAST "fake", NULL, NULL);
 
                     xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
                                       NULL, NULL, value);
                 }
             } else {
                 URI = xmlParseExternalID(ctxt, &literal, 1);
@@ skipping 52 matching lines @@
                      */
                     if ((ctxt->replaceEntities != 0) &&
                         ((ctxt->myDoc == NULL) ||
                         (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
                         if (ctxt->myDoc == NULL) {
                             ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
                             if (ctxt->myDoc == NULL) {
                                 xmlErrMemory(ctxt, "New Doc failed");
                                 return;
                             }
+                            ctxt->myDoc->properties = XML_DOC_INTERNAL;
                         }
 
                         if (ctxt->myDoc->intSubset == NULL)
                             ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
                                                 BAD_CAST "fake", NULL, NULL);
                         xmlSAX2EntityDecl(ctxt, name,
                                           XML_EXTERNAL_GENERAL_PARSED_ENTITY,
                                           literal, URI, NULL);
                     }
                 }
@@ skipping 118 matching lines @@
  * [ VC: Notation Attributes ]
  * Values of this type must match one of the notation names included
  * in the declaration; all notation names in the declaration must be declared. 
  *
  * Returns: the notation attribute tree built while parsing
  */
 
 xmlEnumerationPtr
 xmlParseNotationType(xmlParserCtxtPtr ctxt) {
     const xmlChar *name;
-    xmlEnumerationPtr ret = NULL, last = NULL, cur;
+    xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
 
     if (RAW != '(') {
         xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
         return(NULL);
     }
     SHRINK;
     do {
         NEXT;
         SKIP_BLANKS;
         name = xmlParseName(ctxt);
         if (name == NULL) {
             xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
                            "Name expected in NOTATION declaration\n");
             xmlFreeEnumeration(ret);
-      return(NULL);
+            return(NULL);
         }
-        cur = xmlCreateEnumeration(name);
-  if (cur == NULL) {
-            xmlFreeEnumeration(ret);
-            return(NULL);
-        }
-        if (last == NULL) ret = last = cur;
-        else {
-            last->next = cur;
-            last = cur;
+        tmp = ret;
+        while (tmp != NULL) {
+            if (xmlStrEqual(name, tmp->name)) {
+                xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
+          "standalone: attribute notation value token %s duplicated\n",
+                                 name, NULL);
+                if (!xmlDictOwns(ctxt->dict, name))
+                    xmlFree((xmlChar *) name);
+                break;
+            }
+            tmp = tmp->next;
+        }
+        if (tmp == NULL) {
+            cur = xmlCreateEnumeration(name);
+            if (cur == NULL) {
+                xmlFreeEnumeration(ret);
+                return(NULL);
+            }
+            if (last == NULL) ret = last = cur;
+            else {
+                last->next = cur;
+                last = cur;
+            }
         }
         SKIP_BLANKS;
     } while (RAW == '|');
     if (RAW != ')') {
         xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
         xmlFreeEnumeration(ret);
-  return(NULL);
+        return(NULL);
     }
     NEXT;
     return(ret);
 }
 
 /**
  * xmlParseEnumerationType:
  * @ctxt:  an XML parser context
  *
  * parse an Enumeration attribute type.
  *
  * [59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'
  *
  * [ VC: Enumeration ]
  * Values of this type must match one of the Nmtoken tokens in
  * the declaration
  *
  * Returns: the enumeration attribute tree built while parsing
  */
 
 xmlEnumerationPtr
 xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
     xmlChar *name;
-    xmlEnumerationPtr ret = NULL, last = NULL, cur;
+    xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
 
     if (RAW != '(') {
         xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
         return(NULL);
     }
     SHRINK;
     do {
         NEXT;
         SKIP_BLANKS;
         name = xmlParseNmtoken(ctxt);
         if (name == NULL) {
             xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
             return(ret);
         }
-        cur = xmlCreateEnumeration(name);
-        xmlFree(name);
-  if (cur == NULL) {
-            xmlFreeEnumeration(ret);
-            return(NULL);
-        }
-        if (last == NULL) ret = last = cur;
-        else {
-            last->next = cur;
-            last = cur;
+        tmp = ret;
+        while (tmp != NULL) {
+            if (xmlStrEqual(name, tmp->name)) {
+                xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
+          "standalone: attribute enumeration value token %s duplicated\n",
+                                 name, NULL);
+                if (!xmlDictOwns(ctxt->dict, name))
+                    xmlFree(name);
+                break;
+            }
+            tmp = tmp->next;
+        }
+        if (tmp == NULL) {
+            cur = xmlCreateEnumeration(name);
+            if (!xmlDictOwns(ctxt->dict, name))
+                xmlFree(name);
+            if (cur == NULL) {
+                xmlFreeEnumeration(ret);
+                return(NULL);
+            }
+            if (last == NULL) ret = last = cur;
+            else {
+                last->next = cur;
+                last = cur;
+            }
         }
         SKIP_BLANKS;
     } while (RAW == '|');
     if (RAW != ')') {
         xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
         return(ret);
     }
     NEXT;
     return(ret);
 }
@@ skipping 226 matching lines @@
             }
             if (ctxt->sax2) {
                 xmlAddSpecialAttr(ctxt, elemName, attrName, type);
             }
             if (defaultValue != NULL)
                 xmlFree(defaultValue);
             GROW;
         }
         if (RAW == '>') {
             if (input != ctxt->input) {
-                xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
-    "Attribute list declaration doesn't start and stop in the same entity\n");
+                xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
+    "Attribute list declaration doesn't start and stop in the same entity\n",
+                                 NULL, NULL);
             }
             NEXT;
         }
     }
 }
 
 /**
  * xmlParseElementMixedContentDecl:
  * @ctxt:  an XML parser context
  * @inputchk:  the input used for the current entity, needed for boundary checks
@@ skipping 19 matching lines @@
 
     GROW;
     if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
         SKIP(7);
         SKIP_BLANKS;
         SHRINK;
         if (RAW == ')') {
             if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
 "Element content declaration doesn't start and stop in the same entity\n",
-                                 NULL);
+                                 NULL, NULL);
             }
             NEXT;
             ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
             if (ret == NULL)
                 return(NULL);
             if (RAW == '*') {
                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
                 NEXT;
             }
             return(ret);
@@ skipping 33 matching lines @@
             SKIP_BLANKS;
             GROW;
         }
         if ((RAW == ')') && (NXT(1) == '*')) {
             if (elem != NULL) {
                 cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
                                                XML_ELEMENT_CONTENT_ELEMENT);
                 if (cur->c2 != NULL)
                     cur->c2->parent = cur;
             }
-            ret->ocur = XML_ELEMENT_CONTENT_MULT;
+            if (ret != NULL)
+                ret->ocur = XML_ELEMENT_CONTENT_MULT;
             if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
 "Element content declaration doesn't start and stop in the same entity\n",
-                                 NULL);
+                                 NULL, NULL);
             }
             SKIP(2);
         } else {
             xmlFreeDocElementContent(ctxt->myDoc, ret);
             xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
             return(NULL);
         }
 
     } else {
         xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
     }
     return(ret);
 }
 
 /**
- * xmlParseElementChildrenContentDecl:
+ * xmlParseElementChildrenContentDeclPriv:
  * @ctxt:  an XML parser context
  * @inputchk:  the input used for the current entity, needed for boundary checks
+ * @depth: the level of recursion
  *
  * parse the declaration for a Mixed Element content
  * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
  * 
  *
  * [47] children ::= (choice | seq) ('?' | '*' | '+')?
  *
  * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?
  *
  * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
  *
  * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
  *
  * [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
  * TODO Parameter-entity replacement text must be properly nested
  *      with parenthesized groups. That is to say, if either of the
  *      opening or closing parentheses in a choice, seq, or Mixed
  *      construct is contained in the replacement text for a parameter
  *      entity, both must be contained in the same replacement text. For
  *      interoperability, if a parameter-entity reference appears in a
  *      choice, seq, or Mixed construct, its replacement text should not
  *      be empty, and neither the first nor last non-blank character of
  *      the replacement text should be a connector (| or ,).
  *
  * Returns the tree of xmlElementContentPtr describing the element 
  *          hierarchy.
  */
-xmlElementContentPtr
-xmlParseElementChildrenContentDecl (xmlParserCtxtPtr ctxt, int inputchk) {
+static xmlElementContentPtr
+xmlParseElementChildrenContentDeclPriv(xmlParserCtxtPtr ctxt, int inputchk,
+                                       int depth) {
     xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL;
     const xmlChar *elem;
     xmlChar type = 0;
 
-    if (ctxt->depth > 128) {
+    if (((depth > 128) && ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
+        (depth >  2048)) {
         xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED,
-                "xmlParseElementChildrenContentDecl : depth %d too deep\n",
-                          ctxt->depth);
-  return(NULL);
+"xmlParseElementChildrenContentDecl : depth %d too deep, use XML_PARSE_HUGE\n",
+                          depth);
+        return(NULL);
     }
     SKIP_BLANKS;
     GROW;
     if (RAW == '(') {
         int inputid = ctxt->input->id;
 
         /* Recurse on first child */
         NEXT;
         SKIP_BLANKS;
-        ctxt->depth++;
-        cur = ret = xmlParseElementChildrenContentDecl(ctxt, inputid);
-        ctxt->depth--;
+        cur = ret = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
+                                                           depth + 1);
         SKIP_BLANKS;
         GROW;
     } else {
         elem = xmlParseName(ctxt);
         if (elem == NULL) {
             xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
             return(NULL);
         }
         cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
         if (cur == NULL) {
@@ skipping 111 matching lines @@
             return(NULL);
         }
         GROW;
         SKIP_BLANKS;
         GROW;
         if (RAW == '(') {
             int inputid = ctxt->input->id;
             /* Recurse on second child */
             NEXT;
             SKIP_BLANKS;
-            ctxt->depth++;
-            last = xmlParseElementChildrenContentDecl(ctxt, inputid);
-            ctxt->depth--;
+            last = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
+                                                          depth + 1);
             SKIP_BLANKS;
         } else {
             elem = xmlParseName(ctxt);
             if (elem == NULL) {
                 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
                 if (ret != NULL)
                     xmlFreeDocElementContent(ctxt->myDoc, ret);
                 return(NULL);
             }
             last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
@@ skipping 19 matching lines @@
         GROW;
     }
     if ((cur != NULL) && (last != NULL)) {
         cur->c2 = last;
         if (last != NULL)
             last->parent = cur;
     }
     if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
         xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
 "Element content declaration doesn't start and stop in the same entity\n",
-                         NULL);
+                         NULL, NULL);
     }
     NEXT;
     if (RAW == '?') {
         if (ret != NULL) {
             if ((ret->ocur == XML_ELEMENT_CONTENT_PLUS) ||
                 (ret->ocur == XML_ELEMENT_CONTENT_MULT))
                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
             else
                 ret->ocur = XML_ELEMENT_CONTENT_OPT;
         }
@@ skipping 50 matching lines @@
             }
             if (found)
                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
         }
         NEXT;
     }
     return(ret);
 }
 
 /**
+ * xmlParseElementChildrenContentDecl:
+ * @ctxt:  an XML parser context
+ * @inputchk:  the input used for the current entity, needed for boundary checks
+ *
+ * parse the declaration for a Mixed Element content
+ * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
+ *
+ * [47] children ::= (choice | seq) ('?' | '*' | '+')?
+ *
+ * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?
+ *
+ * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
+ *
+ * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
+ *
+ * [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
+ * TODO Parameter-entity replacement text must be properly nested
+ *      with parenthesized groups. That is to say, if either of the
+ *      opening or closing parentheses in a choice, seq, or Mixed
+ *      construct is contained in the replacement text for a parameter
+ *      entity, both must be contained in the same replacement text. For
+ *      interoperability, if a parameter-entity reference appears in a
+ *      choice, seq, or Mixed construct, its replacement text should not
+ *      be empty, and neither the first nor last non-blank character of
+ *      the replacement text should be a connector (| or ,).
+ *
+ * Returns the tree of xmlElementContentPtr describing the element
+ *          hierarchy.
+ */
+xmlElementContentPtr
+xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
+    /* stub left for API/ABI compat */
+    return(xmlParseElementChildrenContentDeclPriv(ctxt, inputchk, 1));
+}
+
+/**
  * xmlParseElementContentDecl:
  * @ctxt:  an XML parser context
  * @name:  the name of the element being defined.
  * @result:  the Element Content pointer will be stored here if any
  *
  * parse the declaration for an Element content either Mixed or Children,
  * the cases EMPTY and ANY are handled directly in xmlParseElementDecl
  * 
  * [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children
  *
@@ skipping 15 matching lines @@
                 "xmlParseElementContentDecl : %s '(' expected\n", name);
         return(-1);
     }
     NEXT;
     GROW;
     SKIP_BLANKS;
     if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
         tree = xmlParseElementMixedContentDecl(ctxt, inputid);
         res = XML_ELEMENT_TYPE_MIXED;
     } else {
-        tree = xmlParseElementChildrenContentDecl(ctxt, inputid);
+        tree = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 1);
         res = XML_ELEMENT_TYPE_ELEMENT;
     }
     SKIP_BLANKS;
     *result = tree;
     return(res);
 }
 
 /**
  * xmlParseElementDecl:
  * @ctxt:  an XML parser context
@@ skipping 115 matching lines @@
  *
  * [61] conditionalSect ::= includeSect | ignoreSect 
  * [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>' 
  * [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'
  * [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)*
  * [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*)
  */
 
 static void
 xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
+    int id = ctxt->input->id;
+
     SKIP(3);
     SKIP_BLANKS;
     if (CMP7(CUR_PTR, 'I', 'N', 'C', 'L', 'U', 'D', 'E')) {
         SKIP(7);
         SKIP_BLANKS;
         if (RAW != '[') {
             xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
         } else {
+            if (ctxt->input->id != id) {
+                xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
+            "All markup of the conditional section is not in the same entity\n",
+                                     NULL, NULL);
+            }
             NEXT;
         }
         if (xmlParserDebugEntities) {
             if ((ctxt->input != NULL) && (ctxt->input->filename))
                 xmlGenericError(xmlGenericErrorContext,
                         "%s(%d): ", ctxt->input->filename,
                         ctxt->input->line);
             xmlGenericError(xmlGenericErrorContext,
                     "Entering INCLUDE Conditional Section\n");
         }
@@ skipping 35 matching lines @@
     } else if (CMP6(CUR_PTR, 'I', 'G', 'N', 'O', 'R', 'E')) {
         int state;
         xmlParserInputState instate;
         int depth = 0;
 
         SKIP(6);
         SKIP_BLANKS;
         if (RAW != '[') {
             xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
         } else {
+            if (ctxt->input->id != id) {
+                xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
+            "All markup of the conditional section is not in the same entity\n",
+                                     NULL, NULL);
+            }
             NEXT;
         }
         if (xmlParserDebugEntities) {
             if ((ctxt->input != NULL) && (ctxt->input->filename))
                 xmlGenericError(xmlGenericErrorContext,
                         "%s(%d): ", ctxt->input->filename,
                         ctxt->input->line);
             xmlGenericError(xmlGenericErrorContext,
                     "Entering IGNORE Conditional Section\n");
         }
@@ skipping 36 matching lines @@
     } else {
         xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
     }
 
     if (RAW == 0)
         SHRINK;
 
     if (RAW == 0) {
         xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
     } else {
+        if (ctxt->input->id != id) {
+            xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
+        "All markup of the conditional section is not in the same entity\n",
+                                 NULL, NULL);
+        }
         SKIP(3);
     }
 }
 
 /**
  * xmlParseMarkupDecl:
  * @ctxt:  an XML parser context
  * 
  * parse Markup declarations
  *
@@ skipping 58 matching lines @@
             xmlParseConditionalSections(ctxt);
         }
     }
 
     ctxt->instate = XML_PARSER_DTD;
 }
 
 /**
  * xmlParseTextDecl:
  * @ctxt:  an XML parser context
- * 
+ *
  * parse an XML declaration header for external entities
  *
  * [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
- *
- * Question: Seems that EncodingDecl is mandatory ? Is that a typo ?
  */
 
 void
 xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
     xmlChar *version;
     const xmlChar *encoding;
 
     /*
      * We know that '<?xml' is here.
      */
@@ skipping 90 matching lines @@
         if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
             /*
              * The XML REC instructs us to stop parsing right here
              */
             ctxt->instate = XML_PARSER_EOF;
             return;
         }
     }
     if (ctxt->myDoc == NULL) {
         ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
+        if (ctxt->myDoc == NULL) {
+            xmlErrMemory(ctxt, "New Doc failed");
+            return;
+        }
+        ctxt->myDoc->properties = XML_DOC_INTERNAL;
     }
     if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
         xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
 
     ctxt->instate = XML_PARSER_DTD;
     ctxt->external = 1;
     while (((RAW == '<') && (NXT(1) == '?')) ||
            ((RAW == '<') && (NXT(1) == '!')) ||
            (RAW == '%') || IS_BLANK_CH(CUR)) {
         const xmlChar *check = CUR_PTR;
@@ skipping 23 matching lines @@
     
     if (RAW != 0) {
         xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
     }
 
 }
 
 /**
  * xmlParseReference:
  * @ctxt:  an XML parser context
- * 
+ *
  * parse and handle entity references in content, depending on the SAX
  * interface, this may end-up in a call to character() if this is a
  * CharRef, a predefined entity, if there is no reference() callback.
  * or if the parser was asked to switch to that mode.
  *
  * [67] Reference ::= EntityRef | CharRef
  */
 void
 xmlParseReference(xmlParserCtxtPtr ctxt) {
     xmlEntityPtr ent;
     xmlChar *val;
-    if (RAW != '&') return;
+    int was_checked;
+    xmlNodePtr list = NULL;
+    xmlParserErrors ret = XML_ERR_OK;
 
+
+    if (RAW != '&')
+        return;
+
+    /*
+     * Simple case of a CharRef
+     */
     if (NXT(1) == '#') {
         int i = 0;
         xmlChar out[10];
         int hex = NXT(2);
         int value = xmlParseCharRef(ctxt);
-        
+
         if (value == 0)
             return;
         if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
             /*
              * So we are using non-UTF-8 buffers
              * Check that the char fit on 8bits, if not
              * generate a CharRef.
              */
             if (value <= 0xFF) {
                 out[0] = value;
@@ skipping 13 matching lines @@
         } else {
             /*
              * Just encode the value in UTF-8
              */
             COPY_BUF(0 ,out, i, value);
             out[i] = 0;
             if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
                 (!ctxt->disableSAX))
                 ctxt->sax->characters(ctxt->userData, out, i);
         }
-    } else {
-        int was_checked;
-
-        ent = xmlParseEntityRef(ctxt);
-        if (ent == NULL) return;
-        if (!ctxt->wellFormed)
+        return;
+    }
+
+    /*
+     * We are seeing an entity reference
+     */
+    ent = xmlParseEntityRef(ctxt);
+    if (ent == NULL) return;
+    if (!ctxt->wellFormed)
+        return;
+    was_checked = ent->checked;
+
+    /* special case of predefined entities */
+    if ((ent->name == NULL) ||
+        (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
+        val = ent->content;
+        if (val == NULL) return;
+        /*
+         * inline the entity.
+         */
+        if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
+            (!ctxt->disableSAX))
+            ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
+        return;
+    }
+
+    /*
+     * The first reference to the entity trigger a parsing phase
+     * where the ent->children is filled with the result from
+     * the parsing.
+     */
+    if (ent->checked == 0) {
+        unsigned long oldnbent = ctxt->nbentities;
+
+        /*
+         * This is a bit hackish but this seems the best
+         * way to make sure both SAX and DOM entity support
+         * behaves okay.
+         */
+        void *user_data;
+        if (ctxt->userData == ctxt)
+            user_data = NULL;
+        else
+            user_data = ctxt->userData;
+
+        /*
+         * Check that this entity is well formed
+         * 4.3.2: An internal general parsed entity is well-formed
+         * if its replacement text matches the production labeled
+         * content.
+         */
+        if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
+            ctxt->depth++;
+            ret = xmlParseBalancedChunkMemoryInternal(ctxt, ent->content,
+                                                      user_data, &list);
+            ctxt->depth--;
+
+        } else if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
+            ctxt->depth++;
+            ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, ctxt->sax,
+                                           user_data, ctxt->depth, ent->URI,
+                                           ent->ExternalID, &list);
+            ctxt->depth--;
+        } else {
+            ret = XML_ERR_ENTITY_PE_INTERNAL;
+            xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
+                         "invalid entity type found\n", NULL);
+        }
+
+        /*
+         * Store the number of entities needing parsing for this entity
+         * content and do checkings
+         */
+        ent->checked = ctxt->nbentities - oldnbent;
+        if (ret == XML_ERR_ENTITY_LOOP) {
+            xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
+            xmlFreeNodeList(list);
             return;
-        was_checked = ent->checked;
-        if ((ent->name != NULL) && 
-            (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY)) {
-            xmlNodePtr list = NULL;
-            xmlParserErrors ret = XML_ERR_OK;
-
-
+        }
+        if (xmlParserEntityCheck(ctxt, 0, ent)) {
+            xmlFreeNodeList(list);
+            return;
+        }
+
+        if ((ret == XML_ERR_OK) && (list != NULL)) {
+            if (((ent->etype == XML_INTERNAL_GENERAL_ENTITY) ||
+             (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))&&
+                (ent->children == NULL)) {
+                ent->children = list;
+                if (ctxt->replaceEntities) {
+                    /*
+                     * Prune it directly in the generated document
+                     * except for single text nodes.
+                     */
+                    if (((list->type == XML_TEXT_NODE) &&
+                         (list->next == NULL)) ||
+                        (ctxt->parseMode == XML_PARSE_READER)) {
+                        list->parent = (xmlNodePtr) ent;
+                        list = NULL;
+                        ent->owner = 1;
+                    } else {
+                        ent->owner = 0;
+                        while (list != NULL) {
+                            list->parent = (xmlNodePtr) ctxt->node;
+                            list->doc = ctxt->myDoc;
+                            if (list->next == NULL)
+                                ent->last = list;
+                            list = list->next;
+                        }
+                        list = ent->children;
+#ifdef LIBXML_LEGACY_ENABLED
+                        if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
+                          xmlAddEntityReference(ent, list, NULL);
+#endif /* LIBXML_LEGACY_ENABLED */
+                    }
+                } else {
+                    ent->owner = 1;
+                    while (list != NULL) {
+                        list->parent = (xmlNodePtr) ent;
+                        if (list->next == NULL)
+                            ent->last = list;
+                        list = list->next;
+                    }
+                }
+            } else {
+                xmlFreeNodeList(list);
+                list = NULL;
+            }
+        } else if ((ret != XML_ERR_OK) &&
+                   (ret != XML_WAR_UNDECLARED_ENTITY)) {
+            xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
+                     "Entity '%s' failed to parse\n", ent->name);
+        } else if (list != NULL) {
+            xmlFreeNodeList(list);
+            list = NULL;
+        }
+        if (ent->checked == 0)
+            ent->checked = 1;
+    } else if (ent->checked != 1) {
+        ctxt->nbentities += ent->checked;
+    }
+
+    /*
+     * Now that the entity content has been gathered
+     * provide it to the application, this can take different forms based
+     * on the parsing modes.
+     */
+    if (ent->children == NULL) {
+        /*
+         * Probably running in SAX mode and the callbacks don't
+         * build the entity content. So unless we already went
+         * though parsing for first checking go though the entity
+         * content to generate callbacks associated to the entity
+         */
+        if (was_checked != 0) {
+            void *user_data;
             /*
-             * The first reference to the entity trigger a parsing phase
-             * where the ent->children is filled with the result from
-             * the parsing.
+             * This is a bit hackish but this seems the best
+             * way to make sure both SAX and DOM entity support
+             * behaves okay.
              */
-            if (ent->checked == 0) {
-                xmlChar *value;
-
-                value = ent->content;
-
-                /*
-                 * Check that this entity is well formed
-                 */
-                if ((value != NULL) && (value[0] != 0) &&
-                    (value[1] == 0) && (value[0] == '<') &&
-                    (xmlStrEqual(ent->name, BAD_CAST "lt"))) {
-                    /*
-                     * DONE: get definite answer on this !!!
-                     * Lots of entity decls are used to declare a single
-                     * char 
-                     *    <!ENTITY lt     "<">
-                     * Which seems to be valid since
-                     * 2.4: The ampersand character (&) and the left angle
-                     * bracket (<) may appear in their literal form only
-                     * when used ... They are also legal within the literal
-                     * entity value of an internal entity declaration;i
-                     * see "4.3.2 Well-Formed Parsed Entities". 
-                     * IMHO 2.4 and 4.3.2 are directly in contradiction.
-                     * Looking at the OASIS test suite and James Clark 
-                     * tests, this is broken. However the XML REC uses
-                     * it. Is the XML REC not well-formed ????
-                     * This is a hack to avoid this problem
-                     *
-                     * ANSWER: since lt gt amp .. are already defined,
-                     *   this is a redefinition and hence the fact that the
-                     *   content is not well balanced is not a Wf error, this
-                     *   is lousy but acceptable.
-                     */
-                    list = xmlNewDocText(ctxt->myDoc, value);
-                    if (list != NULL) {
-                        if ((ent->etype == XML_INTERNAL_GENERAL_ENTITY) &&
-                            (ent->children == NULL)) {
-                            ent->children = list;
-                            ent->last = list;
-                            ent->owner = 1;
-                            list->parent = (xmlNodePtr) ent;
-                        } else {
-                            xmlFreeNodeList(list);
-                        }
-                    } else if (list != NULL) {
-                        xmlFreeNodeList(list);
-                    }
-                } else {
-                    /*
-                     * 4.3.2: An internal general parsed entity is well-formed
-                     * if its replacement text matches the production labeled
-                     * content.
-                     */
-
-                    void *user_data;
-                    /*
-                     * This is a bit hackish but this seems the best
-                     * way to make sure both SAX and DOM entity support
-                     * behaves okay.
-                     */
-                    if (ctxt->userData == ctxt)
-                        user_data = NULL;
-                    else
-                        user_data = ctxt->userData;
-
-                    if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
-                        ctxt->depth++;
-                        ret = xmlParseBalancedChunkMemoryInternal(ctxt,
-                                           value, user_data, &list);
-                        ctxt->depth--;
-                    } else if (ent->etype ==
-                               XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
-                        ctxt->depth++;
-                        ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
-                                   ctxt->sax, user_data, ctxt->depth,
-                                   ent->URI, ent->ExternalID, &list);
-                        ctxt->depth--;
-                    } else {
-                        ret = XML_ERR_ENTITY_PE_INTERNAL;
-                        xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
-                                     "invalid entity type found\n", NULL);
-                    }
-                    if (ret == XML_ERR_ENTITY_LOOP) {
-                        xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
-                        return;
-                    } else if ((ret == XML_ERR_OK) && (list != NULL)) {
-                        if (((ent->etype == XML_INTERNAL_GENERAL_ENTITY) ||
-                         (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))&&
-                            (ent->children == NULL)) {
-                            ent->children = list;
-                            if (ctxt->replaceEntities) {
-                                /*
-                                 * Prune it directly in the generated document
-                                 * except for single text nodes.
-                                 */
-                                if (((list->type == XML_TEXT_NODE) &&
-                                     (list->next == NULL)) ||
-                                    (ctxt->parseMode == XML_PARSE_READER)) {
-                                    list->parent = (xmlNodePtr) ent;
-                                    list = NULL;
-                                    ent->owner = 1;
-                                } else {
-                                    ent->owner = 0;
-                                    while (list != NULL) {
-                                        list->parent = (xmlNodePtr) ctxt->node;
-                                        list->doc = ctxt->myDoc;
-                                        if (list->next == NULL)
-                                            ent->last = list;
-                                        list = list->next;
-                                    }
-                                    list = ent->children;
-#ifdef LIBXML_LEGACY_ENABLED
-                                    if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
-                                      xmlAddEntityReference(ent, list, NULL);
-#endif /* LIBXML_LEGACY_ENABLED */
-                                }
-                            } else {
-                                ent->owner = 1;
-                                while (list != NULL) {
-                                    list->parent = (xmlNodePtr) ent;
-                                    if (list->next == NULL)
-                                        ent->last = list;
-                                    list = list->next;
-                                }
-                            }
-                        } else {
-                            xmlFreeNodeList(list);
-                            list = NULL;
-                        }
-                    } else if ((ret != XML_ERR_OK) &&
-                               (ret != XML_WAR_UNDECLARED_ENTITY)) {
-                        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
-                                 "Entity '%s' failed to parse\n", ent->name);
-                    } else if (list != NULL) {
-                        xmlFreeNodeList(list);
-                        list = NULL;
-                    }
-                }
-                ent->checked = 1;
+            if (ctxt->userData == ctxt)
+                user_data = NULL;
+            else
+                user_data = ctxt->userData;
+
+            if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
+                ctxt->depth++;
+                ret = xmlParseBalancedChunkMemoryInternal(ctxt,
+                                   ent->content, user_data, NULL);
+                ctxt->depth--;
+            } else if (ent->etype ==
+                       XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
+                ctxt->depth++;
+                ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
+                           ctxt->sax, user_data, ctxt->depth,
+                           ent->URI, ent->ExternalID, NULL);
+                ctxt->depth--;
+            } else {
+                ret = XML_ERR_ENTITY_PE_INTERNAL;
+                xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
+                             "invalid entity type found\n", NULL);
             }
-
-            if (ent->children == NULL) {
-                /*
-                 * Probably running in SAX mode and the callbacks don't
-                 * build the entity content. So unless we already went
-                 * though parsing for first checking go though the entity
-                 * content to generate callbacks associated to the entity
-                 */
-                if (was_checked == 1) {
-                    void *user_data;
-                    /*
-                     * This is a bit hackish but this seems the best
-                     * way to make sure both SAX and DOM entity support
-                     * behaves okay.
-                     */
-                    if (ctxt->userData == ctxt)
-                        user_data = NULL;
-                    else
-                        user_data = ctxt->userData;
-
-                    if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
-                        ctxt->depth++;
-                        ret = xmlParseBalancedChunkMemoryInternal(ctxt,
-                                           ent->content, user_data, NULL);
-                        ctxt->depth--;
-                    } else if (ent->etype ==
-                               XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
-                        ctxt->depth++;
-                        ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
-                                   ctxt->sax, user_data, ctxt->depth,
-                                   ent->URI, ent->ExternalID, NULL);
-                        ctxt->depth--;
-                    } else {
-                        ret = XML_ERR_ENTITY_PE_INTERNAL;
-                        xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
-                                     "invalid entity type found\n", NULL);
-                    }
-                    if (ret == XML_ERR_ENTITY_LOOP) {
-                        xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
-                        return;
-                    }
-                }
-                if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
-                    (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
-                    /*
-                     * Entity reference callback comes second, it's somewhat
-                     * superfluous but a compatibility to historical behaviour
-                     */
-                    ctxt->sax->reference(ctxt->userData, ent->name);
-                }
+            if (ret == XML_ERR_ENTITY_LOOP) {
+                xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
                 return;
             }
-            if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
-                (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
+        }
+        if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
+            (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
+            /*
+             * Entity reference callback comes second, it's somewhat
+             * superfluous but a compatibility to historical behaviour
+             */
+            ctxt->sax->reference(ctxt->userData, ent->name);
+        }
+        return;
+    }
+
+    /*
+     * If we didn't get any children for the entity being built
+     */
+    if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
+        (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
+        /*
+         * Create a node.
+         */
+        ctxt->sax->reference(ctxt->userData, ent->name);
+        return;
+    }
+
+    if ((ctxt->replaceEntities) || (ent->children == NULL))  {
+        /*
+         * There is a problem on the handling of _private for entities
+         * (bug 155816): Should we copy the content of the field from
+         * the entity (possibly overwriting some value set by the user
+         * when a copy is created), should we leave it alone, or should
+         * we try to take care of different situations?  The problem
+         * is exacerbated by the usage of this field by the xmlReader.
+         * To fix this bug, we look at _private on the created node
+         * and, if it's NULL, we copy in whatever was in the entity.
+         * If it's not NULL we leave it alone.  This is somewhat of a
+         * hack - maybe we should have further tests to determine
+         * what to do.
+         */
+        if ((ctxt->node != NULL) && (ent->children != NULL)) {
+            /*
+             * Seems we are generating the DOM content, do
+             * a simple tree copy for all references except the first
+             * In the first occurrence list contains the replacement.
+             * progressive == 2 means we are operating on the Reader
+             * and since nodes are discarded we must copy all the time.
+             */
+            if (((list == NULL) && (ent->owner == 0)) ||
+                (ctxt->parseMode == XML_PARSE_READER)) {
+                xmlNodePtr nw = NULL, cur, firstChild = NULL;
+
                 /*
-                 * Create a node.
+                 * when operating on a reader, the entities definitions
+                 * are always owning the entities subtree.
+                if (ctxt->parseMode == XML_PARSE_READER)
+                    ent->owner = 1;
                  */
-                ctxt->sax->reference(ctxt->userData, ent->name);
-                return;
+
+                cur = ent->children;
+                while (cur != NULL) {
+                    nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
+                    if (nw != NULL) {
+                        if (nw->_private == NULL)
+                            nw->_private = cur->_private;
+                        if (firstChild == NULL){
+                            firstChild = nw;
+                        }
+                        nw = xmlAddChild(ctxt->node, nw);
+                    }
+                    if (cur == ent->last) {
+                        /*
+                         * needed to detect some strange empty
+                         * node cases in the reader tests
+                         */
+                        if ((ctxt->parseMode == XML_PARSE_READER) &&
+                            (nw != NULL) &&
+                            (nw->type == XML_ELEMENT_NODE) &&
+                            (nw->children == NULL))
+                            nw->extra = 1;
+
+                        break;
+                    }
+                    cur = cur->next;
+                }
+#ifdef LIBXML_LEGACY_ENABLED
+                if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
+                  xmlAddEntityReference(ent, firstChild, nw);
+#endif /* LIBXML_LEGACY_ENABLED */
+            } else if (list == NULL) {
+                xmlNodePtr nw = NULL, cur, next, last,
+                           firstChild = NULL;
+                /*
+                 * Copy the entity child list and make it the new
+                 * entity child list. The goal is to make sure any
+                 * ID or REF referenced will be the one from the
+                 * document content and not the entity copy.
+                 */
+                cur = ent->children;
+                ent->children = NULL;
+                last = ent->last;
+                ent->last = NULL;
+                while (cur != NULL) {
+                    next = cur->next;
+                    cur->next = NULL;
+                    cur->parent = NULL;
+                    nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
+                    if (nw != NULL) {
+                        if (nw->_private == NULL)
+                            nw->_private = cur->_private;
+                        if (firstChild == NULL){
+                            firstChild = cur;
+                        }
+                        xmlAddChild((xmlNodePtr) ent, nw);
+                        xmlAddChild(ctxt->node, cur);
+                    }
+                    if (cur == last)
+                        break;
+                    cur = next;
+                }
+                if (ent->owner == 0)
+                    ent->owner = 1;
+#ifdef LIBXML_LEGACY_ENABLED
+                if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
+                  xmlAddEntityReference(ent, firstChild, nw);
+#endif /* LIBXML_LEGACY_ENABLED */
+            } else {
+                const xmlChar *nbktext;
+
+                /*
+                 * the name change is to avoid coalescing of the
+                 * node with a possible previous text one which
+                 * would make ent->children a dangling pointer
+                 */
+                nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
+                                        -1);
+                if (ent->children->type == XML_TEXT_NODE)
+                    ent->children->name = nbktext;
+                if ((ent->last != ent->children) &&
+                    (ent->last->type == XML_TEXT_NODE))
+                    ent->last->name = nbktext;
+                xmlAddChildList(ctxt->node, ent->children);
             }
-            if ((ctxt->replaceEntities) || (ent->children == NULL))  {
-                /*
-                 * There is a problem on the handling of _private for entities
-                 * (bug 155816): Should we copy the content of the field from
-                 * the entity (possibly overwriting some value set by the user
-                 * when a copy is created), should we leave it alone, or should
-                 * we try to take care of different situations?  The problem
-                 * is exacerbated by the usage of this field by the xmlReader.
-                 * To fix this bug, we look at _private on the created node
-                 * and, if it's NULL, we copy in whatever was in the entity.
-                 * If it's not NULL we leave it alone.  This is somewhat of a
-                 * hack - maybe we should have further tests to determine
-                 * what to do.
-                 */
-                if ((ctxt->node != NULL) && (ent->children != NULL)) {
-                    /*
-                     * Seems we are generating the DOM content, do
-                     * a simple tree copy for all references except the first
-                     * In the first occurrence list contains the replacement.
-                     * progressive == 2 means we are operating on the Reader
-                     * and since nodes are discarded we must copy all the time.
-                     */
-                    if (((list == NULL) && (ent->owner == 0)) ||
-                        (ctxt->parseMode == XML_PARSE_READER)) {
-                        xmlNodePtr nw = NULL, cur, firstChild = NULL;
-
-                        /*
-                         * when operating on a reader, the entities definitions
-                         * are always owning the entities subtree.
-                        if (ctxt->parseMode == XML_PARSE_READER)
-                            ent->owner = 1;
-                         */
-
-                        cur = ent->children;
-                        while (cur != NULL) {
-                            nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
-                            if (nw != NULL) {
-                                if (nw->_private == NULL)
-                                    nw->_private = cur->_private;
-                                if (firstChild == NULL){
-                                    firstChild = nw;
-                                }
-                                nw = xmlAddChild(ctxt->node, nw);
-                            }
-                            if (cur == ent->last) {
-                                /*
-                                 * needed to detect some strange empty
-                                 * node cases in the reader tests
-                                 */
-                                if ((ctxt->parseMode == XML_PARSE_READER) &&
-                                    (nw != NULL) &&
-                                    (nw->type == XML_ELEMENT_NODE) &&
-                                    (nw->children == NULL))
-                                    nw->extra = 1;
-
-                                break;
-                            }
-                            cur = cur->next;
-                        }
-#ifdef LIBXML_LEGACY_ENABLED
-                        if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)                         
-                          xmlAddEntityReference(ent, firstChild, nw);
-#endif /* LIBXML_LEGACY_ENABLED */
-                    } else if (list == NULL) {
-                        xmlNodePtr nw = NULL, cur, next, last,
-                                   firstChild = NULL;
-                        /*
-                         * Copy the entity child list and make it the new
-                         * entity child list. The goal is to make sure any
-                         * ID or REF referenced will be the one from the
-                         * document content and not the entity copy.
-                         */
-                        cur = ent->children;
-                        ent->children = NULL;
-                        last = ent->last;
-                        ent->last = NULL;
-                        while (cur != NULL) {
-                            next = cur->next;
-                            cur->next = NULL;
-                            cur->parent = NULL;
-                            nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
-                            if (nw != NULL) {
-                                if (nw->_private == NULL)
-                                    nw->_private = cur->_private;
-                                if (firstChild == NULL){
-                                    firstChild = cur;
-                                }
-                                xmlAddChild((xmlNodePtr) ent, nw);
-                                xmlAddChild(ctxt->node, cur);
-                            }
-                            if (cur == last)
-                                break;
-                            cur = next;
-                        }
-                        ent->owner = 1;
-#ifdef LIBXML_LEGACY_ENABLED
-                        if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)                         
-                          xmlAddEntityReference(ent, firstChild, nw);
-#endif /* LIBXML_LEGACY_ENABLED */
-                    } else {
-                        const xmlChar *nbktext;
-
-                        /*
-                         * the name change is to avoid coalescing of the
-                         * node with a possible previous text one which
-                         * would make ent->children a dangling pointer
-                         */
-                        nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
-                                                -1);
-                        if (ent->children->type == XML_TEXT_NODE)
-                            ent->children->name = nbktext;
-                        if ((ent->last != ent->children) &&
-                            (ent->last->type == XML_TEXT_NODE))
-                            ent->last->name = nbktext;
-                        xmlAddChildList(ctxt->node, ent->children);
-                    }
-
-                    /*
-                     * This is to avoid a nasty side effect, see
-                     * characters() in SAX.c
-                     */
-                    ctxt->nodemem = 0;
-                    ctxt->nodelen = 0;
-                    return;
-                }
-            }
-        } else {
-            val = ent->content;
-            if (val == NULL) return;
+
             /*
-             * inline the entity.
+             * This is to avoid a nasty side effect, see
+             * characters() in SAX.c
              */
-            if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
-                (!ctxt->disableSAX))
-                ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
+            ctxt->nodemem = 0;
+            ctxt->nodelen = 0;
+            return;
         }
     }
 }
 
 /**
  * xmlParseEntityRef:
  * @ctxt:  an XML parser context
  *
  * parse ENTITY references declarations
  *
@@ skipping 18 matching lines @@
  * An entity reference must not contain the name of an unparsed entity
  *
  * Returns the xmlEntityPtr if found, or NULL otherwise.
  */
 xmlEntityPtr
 xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
     const xmlChar *name;
     xmlEntityPtr ent = NULL;
 
     GROW;
-    
-    if (RAW == '&') {
-        NEXT;
-        name = xmlParseName(ctxt);
-        if (name == NULL) {
-            xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
-                           "xmlParseEntityRef: no name\n");
+
+    if (RAW != '&')
+        return(NULL);
+    NEXT;
+    name = xmlParseName(ctxt);
+    if (name == NULL) {
+        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+                       "xmlParseEntityRef: no name\n");
+        return(NULL);
+    }
+    if (RAW != ';') {
+        xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
+        return(NULL);
+    }
+    NEXT;
+
+    /*
+     * Predefined entites override any extra definition
+     */
+    if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
+        ent = xmlGetPredefinedEntity(name);
+        if (ent != NULL)
+            return(ent);
+    }
+
+    /*
+     * Increate the number of entity references parsed
+     */
+    ctxt->nbentities++;
+
+    /*
+     * Ask first SAX for entity resolution, otherwise try the
+     * entities which may have stored in the parser context.
+     */
+    if (ctxt->sax != NULL) {
+        if (ctxt->sax->getEntity != NULL)
+            ent = ctxt->sax->getEntity(ctxt->userData, name);
+        if ((ctxt->wellFormed == 1 ) && (ent == NULL) && 
+            (ctxt->options & XML_PARSE_OLDSAX))
+            ent = xmlGetPredefinedEntity(name);
+        if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
+            (ctxt->userData==ctxt)) {
+            ent = xmlSAX2GetEntity(ctxt, name);
+        }
+    }
+    /*
+     * [ WFC: Entity Declared ]
+     * In a document without any DTD, a document with only an
+     * internal DTD subset which contains no parameter entity
+     * references, or a document with "standalone='yes'", the
+     * Name given in the entity reference must match that in an
+     * entity declaration, except that well-formed documents
+     * need not declare any of the following entities: amp, lt,
+     * gt, apos, quot.
+     * The declaration of a parameter entity must precede any
+     * reference to it.
+     * Similarly, the declaration of a general entity must
+     * precede any reference to it which appears in a default
+     * value in an attribute-list declaration. Note that if
+     * entities are declared in the external subset or in
+     * external parameter entities, a non-validating processor
+     * is not obligated to read and process their declarations;
+     * for such documents, the rule that an entity must be
+     * declared is a well-formedness constraint only if
+     * standalone='yes'.
+     */
+    if (ent == NULL) {
+        if ((ctxt->standalone == 1) ||
+            ((ctxt->hasExternalSubset == 0) &&
+             (ctxt->hasPErefs == 0))) {
+            xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
+                     "Entity '%s' not defined\n", name);
         } else {
-            if (RAW == ';') {
-                NEXT;
-                /*
-                 * Ask first SAX for entity resolution, otherwise try the
-                 * predefined set.
-                 */
-                if (ctxt->sax != NULL) {
-                    if (ctxt->sax->getEntity != NULL)
-                        ent = ctxt->sax->getEntity(ctxt->userData, name);
-                    if ((ctxt->wellFormed == 1 ) && (ent == NULL))
-                        ent = xmlGetPredefinedEntity(name);
-                    if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
-                        (ctxt->userData==ctxt)) {
-                        ent = xmlSAX2GetEntity(ctxt, name);
-                    }
-                }
-                /*
-                 * [ WFC: Entity Declared ]
-                 * In a document without any DTD, a document with only an
-                 * internal DTD subset which contains no parameter entity
-                 * references, or a document with "standalone='yes'", the
-                 * Name given in the entity reference must match that in an
-                 * entity declaration, except that well-formed documents
-                 * need not declare any of the following entities: amp, lt,
-                 * gt, apos, quot.
-                 * The declaration of a parameter entity must precede any
-                 * reference to it.
-                 * Similarly, the declaration of a general entity must
-                 * precede any reference to it which appears in a default
-                 * value in an attribute-list declaration. Note that if
-                 * entities are declared in the external subset or in
-                 * external parameter entities, a non-validating processor
-                 * is not obligated to read and process their declarations;
-                 * for such documents, the rule that an entity must be
-                 * declared is a well-formedness constraint only if
-                 * standalone='yes'. 
-                 */
-                if (ent == NULL) {
-                    if ((ctxt->standalone == 1) ||
-                        ((ctxt->hasExternalSubset == 0) &&
-                         (ctxt->hasPErefs == 0))) {
-                        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
-                                 "Entity '%s' not defined\n", name);
-                    } else {
-                        xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
-                                 "Entity '%s' not defined\n", name);
-                        if ((ctxt->inSubset == 0) &&
-                            (ctxt->sax != NULL) &&
-                            (ctxt->sax->reference != NULL)) {
-                            ctxt->sax->reference(ctxt->userData, name);
-                        }
-                    }
-                    ctxt->valid = 0;
-                }
-
-                /*
-                 * [ WFC: Parsed Entity ]
-                 * An entity reference must not contain the name of an
-                 * unparsed entity
-                 */
-                else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
-                    xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
-                             "Entity reference to unparsed entity %s\n", name);
-                }
-
-                /*
-                 * [ WFC: No External Entity References ]
-                 * Attribute values cannot contain direct or indirect
-                 * entity references to external entities.
-                 */
-                else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
-                         (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
-                    xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
-                         "Attribute references external entity '%s'\n", name);
-                }
-                /*
-                 * [ WFC: No < in Attribute Values ]
-                 * The replacement text of any entity referred to directly or
-                 * indirectly in an attribute value (other than "&lt;") must
-                 * not contain a <. 
-                 */
-                else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
-                         (ent != NULL) &&
-                         (!xmlStrEqual(ent->name, BAD_CAST "lt")) &&
-                         (ent->content != NULL) &&
-                         (xmlStrchr(ent->content, '<'))) {
-                    xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
-         "'<' in entity '%s' is not allowed in attributes values\n", name);
-                }
-
-                /*
-                 * Internal check, no parameter entities here ...
-                 */
-                else {
-                    switch (ent->etype) {
-                        case XML_INTERNAL_PARAMETER_ENTITY:
-                        case XML_EXTERNAL_PARAMETER_ENTITY:
-                        xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
-                         "Attempt to reference the parameter entity '%s'\n",
-                                          name);
-                        break;
-                        default:
-                        break;
-                    }
-                }
-
-                /*
-                 * [ WFC: No Recursion ]
-                 * A parsed entity must not contain a recursive reference
-                 * to itself, either directly or indirectly. 
-                 * Done somewhere else
-                 */
-
-            } else {
-                xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
+            xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
+                     "Entity '%s' not defined\n", name);
+            if ((ctxt->inSubset == 0) &&
+                (ctxt->sax != NULL) &&
+                (ctxt->sax->reference != NULL)) {
+                ctxt->sax->reference(ctxt->userData, name);
             }
         }
+        ctxt->valid = 0;
     }
+
+    /*
+     * [ WFC: Parsed Entity ]
+     * An entity reference must not contain the name of an
+     * unparsed entity
+     */
+    else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
+        xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
+                 "Entity reference to unparsed entity %s\n", name);
+    }
+
+    /*
+     * [ WFC: No External Entity References ]
+     * Attribute values cannot contain direct or indirect
+     * entity references to external entities.
+     */
+    else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
+             (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
+        xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
+             "Attribute references external entity '%s'\n", name);
+    }
+    /*
+     * [ WFC: No < in Attribute Values ]
+     * The replacement text of any entity referred to directly or
+     * indirectly in an attribute value (other than "&lt;") must
+     * not contain a <. 
+     */
+    else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
+             (ent != NULL) && (ent->content != NULL) &&
+             (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
+             (xmlStrchr(ent->content, '<'))) {
+        xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
+    "'<' in entity '%s' is not allowed in attributes values\n", name);
+    }
+
+    /*
+     * Internal check, no parameter entities here ...
+     */
+    else {
+        switch (ent->etype) {
+            case XML_INTERNAL_PARAMETER_ENTITY:
+            case XML_EXTERNAL_PARAMETER_ENTITY:
+            xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
+             "Attempt to reference the parameter entity '%s'\n",
+                              name);
+            break;
+            default:
+            break;
+        }
+    }
+
+    /*
+     * [ WFC: No Recursion ]
+     * A parsed entity must not contain a recursive reference
+     * to itself, either directly or indirectly. 
+     * Done somewhere else
+     */
     return(ent);
 }
 
 /**
  * xmlParseStringEntityRef:
  * @ctxt:  an XML parser context
  * @str:  a pointer to an index in the string
  *
  * parse ENTITY references declarations, but this version parses it from
  * a string value.
@@ skipping 14 matching lines @@
  * processor is not obligated to read and process their declarations;
  * for such documents, the rule that an entity must be declared is a
  * well-formedness constraint only if standalone='yes'.
  *
  * [ WFC: Parsed Entity ]
  * An entity reference must not contain the name of an unparsed entity
  *
  * Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer
  * is updated to the current location in the string.
  */
-xmlEntityPtr
+static xmlEntityPtr
 xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
     xmlChar *name;
     const xmlChar *ptr;
     xmlChar cur;
     xmlEntityPtr ent = NULL;
 
     if ((str == NULL) || (*str == NULL))
         return(NULL);
     ptr = *str;
     cur = *ptr;
-    if (cur == '&') {
-        ptr++;
-        cur = *ptr;
-        name = xmlParseStringName(ctxt, &ptr);
-        if (name == NULL) {
-            xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
-                           "xmlParseStringEntityRef: no name\n");
-        } else {
-            if (*ptr == ';') {
-                ptr++;
-                /*
-                 * Ask first SAX for entity resolution, otherwise try the
-                 * predefined set.
-                 */
-                if (ctxt->sax != NULL) {
-                    if (ctxt->sax->getEntity != NULL)
-                        ent = ctxt->sax->getEntity(ctxt->userData, name);
-                    if (ent == NULL)
-                        ent = xmlGetPredefinedEntity(name);
-                    if ((ent == NULL) && (ctxt->userData==ctxt)) {
-                        ent = xmlSAX2GetEntity(ctxt, name);
-                    }
-                }
-                /*
-                 * [ WFC: Entity Declared ]
-                 * In a document without any DTD, a document with only an
-                 * internal DTD subset which contains no parameter entity
-                 * references, or a document with "standalone='yes'", the
-                 * Name given in the entity reference must match that in an
-                 * entity declaration, except that well-formed documents
-                 * need not declare any of the following entities: amp, lt,
-                 * gt, apos, quot.
-                 * The declaration of a parameter entity must precede any
-                 * reference to it.
-                 * Similarly, the declaration of a general entity must
-                 * precede any reference to it which appears in a default
-                 * value in an attribute-list declaration. Note that if
-                 * entities are declared in the external subset or in
-                 * external parameter entities, a non-validating processor
-                 * is not obligated to read and process their declarations;
-                 * for such documents, the rule that an entity must be
-                 * declared is a well-formedness constraint only if
-                 * standalone='yes'. 
-                 */
-                if (ent == NULL) {
-                    if ((ctxt->standalone == 1) ||
-                        ((ctxt->hasExternalSubset == 0) &&
-                         (ctxt->hasPErefs == 0))) {
-                        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
-                                 "Entity '%s' not defined\n", name);
-                    } else {
-                        xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
-                                      "Entity '%s' not defined\n",
-                                      name);
-                    }
-                    /* TODO ? check regressions ctxt->valid = 0; */
-                }
+    if (cur != '&')
+        return(NULL);
 
-                /*
-                 * [ WFC: Parsed Entity ]
-                 * An entity reference must not contain the name of an
-                 * unparsed entity
-                 */
-                else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
-                    xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
-                             "Entity reference to unparsed entity %s\n", name);
-                }
+    ptr++;
+    name = xmlParseStringName(ctxt, &ptr);
+    if (name == NULL) {
+        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+                       "xmlParseStringEntityRef: no name\n");
+        *str = ptr;
+        return(NULL);
+    }
+    if (*ptr != ';') {
+        xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
+        xmlFree(name);
+        *str = ptr;
+        return(NULL);
+    }
+    ptr++;
 
-                /*
-                 * [ WFC: No External Entity References ]
-                 * Attribute values cannot contain direct or indirect
-                 * entity references to external entities.
-                 */
-                else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
-                         (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
-                    xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
-                     "Attribute references external entity '%s'\n", name);
-                }
-                /*
-                 * [ WFC: No < in Attribute Values ]
-                 * The replacement text of any entity referred to directly or
-                 * indirectly in an attribute value (other than "&lt;") must
-                 * not contain a <. 
-                 */
-                else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
-                         (ent != NULL) &&
-                         (!xmlStrEqual(ent->name, BAD_CAST "lt")) &&
-                         (ent->content != NULL) &&
-                         (xmlStrchr(ent->content, '<'))) {
-                    xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
-                 "'<' in entity '%s' is not allowed in attributes values\n",
-                                      name);
-                }
 
-                /*
-                 * Internal check, no parameter entities here ...
-                 */
-                else {
-                    switch (ent->etype) {
-                        case XML_INTERNAL_PARAMETER_ENTITY:
-                        case XML_EXTERNAL_PARAMETER_ENTITY:
-                            xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
-                         "Attempt to reference the parameter entity '%s'\n",
-                                              name);
-                        break;
-                        default:
-                        break;
-                    }
-                }
+    /*
+     * Predefined entites override any extra definition
+     */
+    if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
+        ent = xmlGetPredefinedEntity(name);
+        if (ent != NULL) {
+            xmlFree(name);
+            *str = ptr;
+            return(ent);
+        }
+    }
 
-                /*
-                 * [ WFC: No Recursion ]
-                 * A parsed entity must not contain a recursive reference
-                 * to itself, either directly or indirectly. 
-                 * Done somewhere else
-                 */
+    /*
+     * Increate the number of entity references parsed
+     */
+    ctxt->nbentities++;
 
-            } else {
-                xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
-            }
-            xmlFree(name);
+    /*
+     * Ask first SAX for entity resolution, otherwise try the
+     * entities which may have stored in the parser context.
+     */
+    if (ctxt->sax != NULL) {
+        if (ctxt->sax->getEntity != NULL)
+            ent = ctxt->sax->getEntity(ctxt->userData, name);
+        if ((ent == NULL) && (ctxt->options & XML_PARSE_OLDSAX))
+            ent = xmlGetPredefinedEntity(name);
+        if ((ent == NULL) && (ctxt->userData==ctxt)) {
+            ent = xmlSAX2GetEntity(ctxt, name);
         }
     }
+
+    /*
+     * [ WFC: Entity Declared ]
+     * In a document without any DTD, a document with only an
+     * internal DTD subset which contains no parameter entity
+     * references, or a document with "standalone='yes'", the
+     * Name given in the entity reference must match that in an
+     * entity declaration, except that well-formed documents
+     * need not declare any of the following entities: amp, lt,
+     * gt, apos, quot.
+     * The declaration of a parameter entity must precede any
+     * reference to it.
+     * Similarly, the declaration of a general entity must
+     * precede any reference to it which appears in a default
+     * value in an attribute-list declaration. Note that if
+     * entities are declared in the external subset or in
+     * external parameter entities, a non-validating processor
+     * is not obligated to read and process their declarations;
+     * for such documents, the rule that an entity must be
+     * declared is a well-formedness constraint only if
+     * standalone='yes'. 
+     */
+    if (ent == NULL) {
+        if ((ctxt->standalone == 1) ||
+            ((ctxt->hasExternalSubset == 0) &&
+             (ctxt->hasPErefs == 0))) {
+            xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
+                     "Entity '%s' not defined\n", name);
+        } else {
+            xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
+                          "Entity '%s' not defined\n",
+                          name);
+        }
+        /* TODO ? check regressions ctxt->valid = 0; */
+    }
+
+    /*
+     * [ WFC: Parsed Entity ]
+     * An entity reference must not contain the name of an
+     * unparsed entity
+     */
+    else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
+        xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
+                 "Entity reference to unparsed entity %s\n", name);
+    }
+
+    /*
+     * [ WFC: No External Entity References ]
+     * Attribute values cannot contain direct or indirect
+     * entity references to external entities.
+     */
+    else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
+             (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
+        xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
+         "Attribute references external entity '%s'\n", name);
+    }
+    /*
+     * [ WFC: No < in Attribute Values ]
+     * The replacement text of any entity referred to directly or
+     * indirectly in an attribute value (other than "&lt;") must
+     * not contain a <.
+     */
+    else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
+             (ent != NULL) && (ent->content != NULL) &&
+             (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
+             (xmlStrchr(ent->content, '<'))) {
+        xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
+     "'<' in entity '%s' is not allowed in attributes values\n",
+                          name);
+    }
+
+    /*
+     * Internal check, no parameter entities here ...
+     */
+    else {
+        switch (ent->etype) {
+            case XML_INTERNAL_PARAMETER_ENTITY:
+            case XML_EXTERNAL_PARAMETER_ENTITY:
+                xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
+             "Attempt to reference the parameter entity '%s'\n",
+                                  name);
+            break;
+            default:
+            break;
+        }
+    }
+
+    /*
+     * [ WFC: No Recursion ]
+     * A parsed entity must not contain a recursive reference
+     * to itself, either directly or indirectly.
+     * Done somewhere else
+     */
+
+    xmlFree(name);
     *str = ptr;
     return(ent);
 }
 
 /**
  * xmlParsePEReference:
  * @ctxt:  an XML parser context
  *
  * parse PEReference declarations
  * The entity content is handled directly by pushing it's content as
@@ skipping 20 matching lines @@
  * Parameter-entity references may only appear in the DTD.
  * NOTE: misleading but this is handled.
  */
 void
 xmlParsePEReference(xmlParserCtxtPtr ctxt)
 {
     const xmlChar *name;
     xmlEntityPtr entity = NULL;
     xmlParserInputPtr input;
 
-    if (RAW == '%') {
-        NEXT;
-        name = xmlParseName(ctxt);
-        if (name == NULL) {
-            xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
-                           "xmlParsePEReference: no name\n");
-        } else {
-            if (RAW == ';') {
-                NEXT;
-                if ((ctxt->sax != NULL) &&
-                    (ctxt->sax->getParameterEntity != NULL))
-                    entity = ctxt->sax->getParameterEntity(ctxt->userData,
-                                                           name);
-                if (entity == NULL) {
-                    /*
-                     * [ WFC: Entity Declared ]
-                     * In a document without any DTD, a document with only an
-                     * internal DTD subset which contains no parameter entity
-                     * references, or a document with "standalone='yes'", ...
-                     * ... The declaration of a parameter entity must precede
-                     * any reference to it...
-                     */
-                    if ((ctxt->standalone == 1) ||
-                        ((ctxt->hasExternalSubset == 0) &&
-                         (ctxt->hasPErefs == 0))) {
-                        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
-                                          "PEReference: %%%s; not found\n",
-                                          name);
-                    } else {
-                        /*
-                         * [ VC: Entity Declared ]
-                         * In a document with an external subset or external
-                         * parameter entities with "standalone='no'", ...
-                         * ... The declaration of a parameter entity must
-                         * precede any reference to it...
-                         */
-                        xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
-                                      "PEReference: %%%s; not found\n",
-                                      name, NULL);
-                        ctxt->valid = 0;
-                    }
-                } else {
-                    /*
-                     * Internal checking in case the entity quest barfed
-                     */
-                    if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
-                        (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
-                        xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
-                              "Internal: %%%s; is not a parameter entity\n",
-                                      name, NULL);
-                    } else if (ctxt->input->free != deallocblankswrapper) {
-                        input =
-                            xmlNewBlanksWrapperInputStream(ctxt, entity);
-                        xmlPushInput(ctxt, input);
-                    } else {
-                        /*
-                         * TODO !!!
-                         * handle the extra spaces added before and after
-                         * c.f. http://www.w3.org/TR/REC-xml#as-PE
-                         */
-                        input = xmlNewEntityInputStream(ctxt, entity);
-                        xmlPushInput(ctxt, input);
-                        if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
-                            (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
-                            (IS_BLANK_CH(NXT(5)))) {
-                            xmlParseTextDecl(ctxt);
-                            if (ctxt->errNo ==
-                                XML_ERR_UNSUPPORTED_ENCODING) {
-                                /*
-                                 * The XML REC instructs us to stop parsing
-                                 * right here
-                                 */
-                                ctxt->instate = XML_PARSER_EOF;
-                                return;
-                            }
-                        }
-                    }
-                }
-                ctxt->hasPErefs = 1;
-            } else {
-                xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
-            }
-        }
+    if (RAW != '%')
+        return;
+    NEXT;
+    name = xmlParseName(ctxt);
+    if (name == NULL) {
+        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+                       "xmlParsePEReference: no name\n");
+        return;
     }
+    if (RAW != ';') {
+        xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
+        return;
+    }
+
+    NEXT;
+
+    /*
+     * Increate the number of entity references parsed
+     */
+    ctxt->nbentities++;
+
+    /*
+     * Request the entity from SAX
+     */
+    if ((ctxt->sax != NULL) &&
+        (ctxt->sax->getParameterEntity != NULL))
+        entity = ctxt->sax->getParameterEntity(ctxt->userData,
+                                               name);
+    if (entity == NULL) {
+        /*
+         * [ WFC: Entity Declared ]
+         * In a document without any DTD, a document with only an
+         * internal DTD subset which contains no parameter entity
+         * references, or a document with "standalone='yes'", ...
+         * ... The declaration of a parameter entity must precede
+         * any reference to it...
+         */
+        if ((ctxt->standalone == 1) ||
+            ((ctxt->hasExternalSubset == 0) &&
+             (ctxt->hasPErefs == 0))) {
+            xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
+                              "PEReference: %%%s; not found\n",
+                              name);
+        } else {
+            /*
+             * [ VC: Entity Declared ]
+             * In a document with an external subset or external
+             * parameter entities with "standalone='no'", ...
+             * ... The declaration of a parameter entity must
+             * precede any reference to it...
+             */
+            xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
+                          "PEReference: %%%s; not found\n",
+                          name, NULL);
+            ctxt->valid = 0;
+        }
+    } else {
+        /*
+         * Internal checking in case the entity quest barfed
+         */
+        if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
+            (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
+            xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
+                  "Internal: %%%s; is not a parameter entity\n",
+                          name, NULL);
+        } else if (ctxt->input->free != deallocblankswrapper) {
+            input = xmlNewBlanksWrapperInputStream(ctxt, entity);
+            if (xmlPushInput(ctxt, input) < 0)
+                return;
+        } else {
+            /*
+             * TODO !!!
+             * handle the extra spaces added before and after
+             * c.f. http://www.w3.org/TR/REC-xml#as-PE
+             */
+            input = xmlNewEntityInputStream(ctxt, entity);
+            if (xmlPushInput(ctxt, input) < 0)
+                return;
+            if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
+                (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
+                (IS_BLANK_CH(NXT(5)))) {
+                xmlParseTextDecl(ctxt);
+                if (ctxt->errNo ==
+                    XML_ERR_UNSUPPORTED_ENCODING) {
+                    /*
+                     * The XML REC instructs us to stop parsing
+                     * right here
+                     */
+                    ctxt->instate = XML_PARSER_EOF;
+                    return;
+                }
+            }
+        }
+    }
+    ctxt->hasPErefs = 1;
 }
 
 /**
  * xmlLoadEntityContent:
  * @ctxt:  an XML parser context
  * @entity: an unloaded system entity
  *
  * Load the original content of the given system entity from the
  * ExternalID/SystemID given. This is to be used for Included in Literal
  * http://www.w3.org/TR/REC-xml/#inliteral processing of entities references
@@ skipping 32 matching lines @@
         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
                     "xmlLoadEntityContent input error");
         xmlBufferFree(buf);
         return(-1);
     }
 
     /*
      * Push the entity as the current input, read char by char
      * saving to the buffer until the end of the entity or an error
      */
-    xmlPushInput(ctxt, input);
+    if (xmlPushInput(ctxt, input) < 0) {
+        xmlBufferFree(buf);
+        return(-1);
+    }
+
     GROW;
     c = CUR_CHAR(l);
     while ((ctxt->input == input) && (ctxt->input->cur < ctxt->input->end) &&
            (IS_CHAR(c))) {
         xmlBufferAdd(buf, ctxt->input->cur, l);
         if (count++ > 100) {
             count = 0;
             GROW;
         }
         NEXTL(l);
@@ skipping 40 matching lines @@
  * with "standalone='no'", ...  ... The declaration of a parameter entity
  * must precede any reference to it...
  *
  * [ WFC: In DTD ]
  * Parameter-entity references may only appear in the DTD.
  * NOTE: misleading but this is handled.
  *
  * Returns the string of the entity content.
  *         str is updated to the current value of the index
  */
-xmlEntityPtr
+static xmlEntityPtr
 xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
     const xmlChar *ptr;
     xmlChar cur;
     xmlChar *name;
     xmlEntityPtr entity = NULL;
 
     if ((str == NULL) || (*str == NULL)) return(NULL);
     ptr = *str;
     cur = *ptr;
-    if (cur == '%') {
-        ptr++;
-        cur = *ptr;
-        name = xmlParseStringName(ctxt, &ptr);
-        if (name == NULL) {
-            xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
-                           "xmlParseStringPEReference: no name\n");
+    if (cur != '%')
+        return(NULL);
+    ptr++;
+    name = xmlParseStringName(ctxt, &ptr);
+    if (name == NULL) {
+        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
+                       "xmlParseStringPEReference: no name\n");
+        *str = ptr;
+        return(NULL);
+    }
+    cur = *ptr;
+    if (cur != ';') {
+        xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
+        xmlFree(name);
+        *str = ptr;
+        return(NULL);
+    }
+    ptr++;
+
+    /*
+     * Increate the number of entity references parsed
+     */
+    ctxt->nbentities++;
+
+    /*
+     * Request the entity from SAX
+     */
+    if ((ctxt->sax != NULL) &&
+        (ctxt->sax->getParameterEntity != NULL))
+        entity = ctxt->sax->getParameterEntity(ctxt->userData,
+                                               name);
+    if (entity == NULL) {
+        /*
+         * [ WFC: Entity Declared ]
+         * In a document without any DTD, a document with only an
+         * internal DTD subset which contains no parameter entity
+         * references, or a document with "standalone='yes'", ...
+         * ... The declaration of a parameter entity must precede
+         * any reference to it...
+         */
+        if ((ctxt->standalone == 1) ||
+            ((ctxt->hasExternalSubset == 0) && (ctxt->hasPErefs == 0))) {
+            xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
+                 "PEReference: %%%s; not found\n", name);
         } else {
-            cur = *ptr;
-            if (cur == ';') {
-                ptr++;
-                cur = *ptr;
-                if ((ctxt->sax != NULL) &&
-                    (ctxt->sax->getParameterEntity != NULL))
-                    entity = ctxt->sax->getParameterEntity(ctxt->userData,
-                                                           name);
-                if (entity == NULL) {
-                    /*
-                     * [ WFC: Entity Declared ]
-                     * In a document without any DTD, a document with only an
-                     * internal DTD subset which contains no parameter entity
-                     * references, or a document with "standalone='yes'", ...
-                     * ... The declaration of a parameter entity must precede
-                     * any reference to it...
-                     */
-                    if ((ctxt->standalone == 1) ||
-                        ((ctxt->hasExternalSubset == 0) &&
-                         (ctxt->hasPErefs == 0))) {
-                        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
-                             "PEReference: %%%s; not found\n", name);
-                    } else {
-                        /*
-                         * [ VC: Entity Declared ]
-                         * In a document with an external subset or external
-                         * parameter entities with "standalone='no'", ...
-                         * ... The declaration of a parameter entity must
-                         * precede any reference to it...
-                         */
-                        xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
-                                      "PEReference: %%%s; not found\n",
-                                      name, NULL);
-                        ctxt->valid = 0;
-                    }
-                } else {
-                    /*
-                     * Internal checking in case the entity quest barfed
-                     */
-                    if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
-                        (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
-                        xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
-                                      "%%%s; is not a parameter entity\n",
-                                      name, NULL);
-                    }
-                }
-                ctxt->hasPErefs = 1;
-            } else {
-                xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
-            }
-            xmlFree(name);
+            /*
+             * [ VC: Entity Declared ]
+             * In a document with an external subset or external
+             * parameter entities with "standalone='no'", ...
+             * ... The declaration of a parameter entity must
+             * precede any reference to it...
+             */
+            xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
+                          "PEReference: %%%s; not found\n",
+                          name, NULL);
+            ctxt->valid = 0;
+        }
+    } else {
+        /*
+         * Internal checking in case the entity quest barfed
+         */
+        if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
+            (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
+            xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
+                          "%%%s; is not a parameter entity\n",
+                          name, NULL);
         }
     }
+    ctxt->hasPErefs = 1;
+    xmlFree(name);
     *str = ptr;
     return(entity);
 }
 
 /**
  * xmlParseDocTypeDecl:
  * @ctxt:  an XML parser context
  *
  * parse a DOCTYPE declaration
  *
@@ skipping 456 matching lines @@
     xmlParseEndTag1(ctxt, 0);
 }
 #endif /* LIBXML_SAX1_ENABLED */
 
 /************************************************************************
  *                                                                      *
  *                    SAX 2 specific operations                         *
  *                                                                      *
  ************************************************************************/
 
-static const xmlChar *
-xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
-    int len = 0, l;
-    int c;
-    int count = 0;
-
-    /*
-     * Handler for more complex cases
-     */
-    GROW;
-    c = CUR_CHAR(l);
-    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
-        (!IS_LETTER(c) && (c != '_'))) {
-        return(NULL);
-    }
-
-    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
-           ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
-            (c == '.') || (c == '-') || (c == '_') ||
-            (IS_COMBINING(c)) ||
-            (IS_EXTENDER(c)))) {
-        if (count++ > 100) {
-            count = 0;
-            GROW;
-        }
-        len += l;
-        NEXTL(l);
-        c = CUR_CHAR(l);
-    }
-    return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
-}
-
 /*
  * xmlGetNamespace:
  * @ctxt:  an XML parser context
  * @prefix:  the prefix to lookup
  *
  * Lookup the namespace name for the @prefix (which ca be NULL)
  * The prefix must come from the @ctxt->dict dictionnary
  *
  * Returns the namespace name or NULL if not bound
  */
 static const xmlChar *
 xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
     int i;
 
     if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
     for (i = ctxt->nsNr - 2;i >= 0;i-=2)
         if (ctxt->nsTab[i] == prefix) {
             if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
                 return(NULL);
             return(ctxt->nsTab[i + 1]);
         }
-    if (ctxt->nsParent) return xmlGetNamespace(ctxt->nsParent, prefix);
     return(NULL);
 }
 
 /**
- * xmlParseNCName:
- * @ctxt:  an XML parser context
- * @len:  lenght of the string parsed
- *
- * parse an XML name.
- *
- * [4NS] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
- *                      CombiningChar | Extender
- *
- * [5NS] NCName ::= (Letter | '_') (NCNameChar)*
- *
- * Returns the Name parsed or NULL
- */
-
-static const xmlChar *
-xmlParseNCName(xmlParserCtxtPtr ctxt) {
-    const xmlChar *in;
-    const xmlChar *ret;
-    int count = 0;
-
-    /*
-     * Accelerator for simple ASCII names
-     */
-    in = ctxt->input->cur;
-    if (((*in >= 0x61) && (*in <= 0x7A)) ||
-        ((*in >= 0x41) && (*in <= 0x5A)) ||
-        (*in == '_')) {
-        in++;
-        while (((*in >= 0x61) && (*in <= 0x7A)) ||
-               ((*in >= 0x41) && (*in <= 0x5A)) ||
-               ((*in >= 0x30) && (*in <= 0x39)) ||
-               (*in == '_') || (*in == '-') ||
-               (*in == '.'))
-            in++;
-        if ((*in > 0) && (*in < 0x80)) {
-            count = in - ctxt->input->cur;
-            ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
-            ctxt->input->cur = in;
-            ctxt->nbChars += count;
-            ctxt->input->col += count;
-            if (ret == NULL) {
-                xmlErrMemory(ctxt, NULL);
-            }
-            return(ret);
-        }
-    }
-    return(xmlParseNCNameComplex(ctxt));
-}
-
-/**
  * xmlParseQName:
  * @ctxt:  an XML parser context
  * @prefix:  pointer to store the prefix part
  *
  * parse an XML Namespace QName
  *
  * [6]  QName  ::= (Prefix ':')? LocalPart
  * [7]  Prefix  ::= NCName
  * [8]  LocalPart  ::= NCName
  *
@@ skipping 21 matching lines @@
     }
     if (CUR == ':') {
         NEXT;
         p = l;
         l = xmlParseNCName(ctxt);
         if (l == NULL) {
             xmlChar *tmp;
 
             xmlNsErr(ctxt, XML_NS_ERR_QNAME,
                      "Failed to parse QName '%s:'\n", p, NULL, NULL);
-            tmp = xmlBuildQName(BAD_CAST "", p, NULL, 0);
+            l = xmlParseNmtoken(ctxt);
+            if (l == NULL)
+                tmp = xmlBuildQName(BAD_CAST "", p, NULL, 0);
+            else {
+                tmp = xmlBuildQName(l, p, NULL, 0);
+                xmlFree((char *)l);
+            }
             p = xmlDictLookup(ctxt->dict, tmp, -1);
             if (tmp != NULL) xmlFree(tmp);
             *prefix = NULL;
             return(p);
         }
         if (CUR == ':') {
             xmlChar *tmp;
 
             xmlNsErr(ctxt, XML_NS_ERR_QNAME,
                      "Failed to parse QName '%s:%s:'\n", p, l, NULL);
@@ skipping 27 matching lines @@
  * parse an XML name and compares for match
  * (specialized for endtag parsing)
  *
  * Returns NULL for an illegal name, (xmlChar*) 1 for success
  * and the name for mismatch
  */
 
 static const xmlChar *
 xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
                         xmlChar const *prefix) {
-    const xmlChar *cmp = name;
+    const xmlChar *cmp;
     const xmlChar *in;
     const xmlChar *ret;
     const xmlChar *prefix2;
 
     if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
 
     GROW;
     in = ctxt->input->cur;
-    
+
     cmp = prefix;
     while (*in != 0 && *in == *cmp) {
         ++in;
         ++cmp;
     }
     if ((*cmp == 0) && (*in == ':')) {
         in++;
         cmp = name;
         while (*in != 0 && *in == *cmp) {
             ++in;
@@ skipping 230 matching lines @@
             /*
              * Sometimes a second normalisation pass for spaces is needed
              * but that only happens if charrefs or entities refernces
              * have been used in the attribute value, i.e. the attribute
              * value have been extracted in an allocated string already.
              */
             if (*alloc) {
                 const xmlChar *val2;
 
                 val2 = xmlAttrNormalizeSpace2(ctxt, val, len);
-                if (val2 != NULL) {
+                if ((val2 != NULL) && (val2 != val)) {
                     xmlFree(val);
                     val = (xmlChar *) val2;
                 }
             }
         }
         ctxt->instate = XML_PARSER_CONTENT;
     } else {
         xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
                           "Specification mandate value for attribute %s\n",
                           name);
@@ skipping 142 matching lines @@
         }
         if ((attname != NULL) && (attvalue != NULL)) {
             if (len < 0) len = xmlStrlen(attvalue);
             if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
                 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
                 xmlURIPtr uri;
 
                 if (*URL != 0) {
                     uri = xmlParseURI((const char *) URL);
                     if (uri == NULL) {
-                        xmlWarningMsg(ctxt, XML_WAR_NS_URI,
-                                      "xmlns: %s not a valid URI\n",
-                                      URL, NULL);
+                        xmlNsErr(ctxt, XML_WAR_NS_URI,
+                                 "xmlns: '%s' is not a valid URI\n",
+                                           URL, NULL, NULL);
                     } else {
                         if (uri->scheme == NULL) {
-                            xmlWarningMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
-                                   "xmlns: URI %s is not absolute\n",
-                                          URL, NULL);
+                            xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
+                                      "xmlns: URI %s is not absolute\n",
+                                      URL, NULL, NULL);
                         }
                         xmlFreeURI(uri);
                     }
+                    if (URL == ctxt->str_xml_ns) {
+                        if (attname != ctxt->str_xml) {
+                            xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
+                         "xml namespace URI cannot be the default namespace\n",
+                                     NULL, NULL, NULL);
+                        }
+                        goto skip_default_ns;
+                    }
+                    if ((len == 29) &&
+                        (xmlStrEqual(URL,
+                                 BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
+                        xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
+                             "reuse of the xmlns namespace name is forbidden\n",
+                                 NULL, NULL, NULL);
+                        goto skip_default_ns;
+                    }
                 }
                 /*
                  * check that it's not a defined namespace
                  */
                 for (j = 1;j <= nbNs;j++)
                     if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
                         break;
                 if (j <= nbNs)
                     xmlErrAttributeDup(ctxt, NULL, attname);
                 else
                     if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
+skip_default_ns:
                 if (alloc != 0) xmlFree(attvalue);
                 SKIP_BLANKS;
                 continue;
             }
             if (aprefix == ctxt->str_xmlns) {
                 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
                 xmlURIPtr uri;
 
                 if (attname == ctxt->str_xml) {
                     if (URL != ctxt->str_xml_ns) {
                         xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
                                  "xml namespace prefix mapped to wrong URI\n",
                                  NULL, NULL, NULL);
                     }
                     /*
                      * Do not keep a namespace definition node
                      */
-                    if (alloc != 0) xmlFree(attvalue);
-                    SKIP_BLANKS;
-                    continue;
+                    goto skip_ns;
                 }
-                uri = xmlParseURI((const char *) URL);
-                if (uri == NULL) {
-                    xmlWarningMsg(ctxt, XML_WAR_NS_URI,
-                         "xmlns:%s: '%s' is not a valid URI\n",
-                                       attname, URL);
+                if (URL == ctxt->str_xml_ns) {
+                    if (attname != ctxt->str_xml) {
+                        xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
+                                 "xml namespace URI mapped to wrong prefix\n",
+                                 NULL, NULL, NULL);
+                    }
+                    goto skip_ns;
+                }
+                if (attname == ctxt->str_xmlns) {
+                    xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
+                             "redefinition of the xmlns prefix is forbidden\n",
+                             NULL, NULL, NULL);
+                    goto skip_ns;
+                }
+                if ((len == 29) &&
+                    (xmlStrEqual(URL,
+                                 BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
+                    xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
+                             "reuse of the xmlns namespace name is forbidden\n",
+                             NULL, NULL, NULL);
+                    goto skip_ns;
+                }
+                if ((URL == NULL) || (URL[0] == 0)) {
+                    xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
+                             "xmlns:%s: Empty XML namespace is not allowed\n",
+                                  attname, NULL, NULL);
+                    goto skip_ns;
                 } else {
-                    if ((ctxt->pedantic) && (uri->scheme == NULL)) {
-                        xmlWarningMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
+                    uri = xmlParseURI((const char *) URL);
+                    if (uri == NULL) {
+                        xmlNsErr(ctxt, XML_WAR_NS_URI,
+                             "xmlns:%s: '%s' is not a valid URI\n",
+                                           attname, URL, NULL);
+                    } else {
+                        if ((ctxt->pedantic) && (uri->scheme == NULL)) {
+                            xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
                                       "xmlns:%s: URI %s is not absolute\n",
-                                      attname, URL);
+                                      attname, URL, NULL);
+                        }
+                        xmlFreeURI(uri);
                     }
-                    xmlFreeURI(uri);
                 }
 
                 /*
                  * check that it's not a defined namespace
                  */
                 for (j = 1;j <= nbNs;j++)
                     if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
                         break;
                 if (j <= nbNs)
                     xmlErrAttributeDup(ctxt, aprefix, attname);
                 else
                     if (nsPush(ctxt, attname, URL) > 0) nbNs++;
+skip_ns:
                 if (alloc != 0) xmlFree(attvalue);
                 SKIP_BLANKS;
                 if (ctxt->input->base != base) goto base_changed;
                 continue;
             }
 
             /*
              * Add the pair to atts
              */
             if ((atts == NULL) || (nbatts + 5 > maxatts)) {
@@ skipping 14 matching lines @@
             atts[nbatts++] = attvalue;
             /*
              * tag if some deallocation is needed
              */
             if (alloc != 0) attval = 1;
         } else {
             if ((attvalue != NULL) && (attvalue[len] == 0))
                 xmlFree(attvalue);
         }
 
-failed:     
+failed:
 
         GROW
         if (ctxt->input->base != base) goto base_changed;
         if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
             break;
         if (!IS_BLANK_CH(RAW)) {
             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                            "attributes construct error\n");
             break;
         }
@@ skipping 10 matching lines @@
 
     /*
      * The attributes defaulting
      */
     if (ctxt->attsDefault != NULL) {
         xmlDefAttrsPtr defaults;
 
         defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
         if (defaults != NULL) {
             for (i = 0;i < defaults->nbAttrs;i++) {
-                attname = defaults->values[4 * i];
-                aprefix = defaults->values[4 * i + 1];
+                attname = defaults->values[5 * i];
+                aprefix = defaults->values[5 * i + 1];
 
                 /*
                  * special work for namespaces defaulted defs
                  */
                 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
                     /*
                      * check that it's not a defined namespace
                      */
                     for (j = 1;j <= nbNs;j++)
                         if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
                             break;
                     if (j <= nbNs) continue;
 
                     nsname = xmlGetNamespace(ctxt, NULL);
-                    if (nsname != defaults->values[4 * i + 2]) {
+                    if (nsname != defaults->values[5 * i + 2]) {
                         if (nsPush(ctxt, NULL,
-                                   defaults->values[4 * i + 2]) > 0)
+                                   defaults->values[5 * i + 2]) > 0)
                             nbNs++;
                     }
                 } else if (aprefix == ctxt->str_xmlns) {
                     /*
                      * check that it's not a defined namespace
                      */
                     for (j = 1;j <= nbNs;j++)
                         if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
                             break;
                     if (j <= nbNs) continue;
 
                     nsname = xmlGetNamespace(ctxt, attname);
                     if (nsname != defaults->values[2]) {
                         if (nsPush(ctxt, attname,
-                                   defaults->values[4 * i + 2]) > 0)
+                                   defaults->values[5 * i + 2]) > 0)
                             nbNs++;
                     }
                 } else {
                     /*
                      * check that it's not a defined attribute
                      */
                     for (j = 0;j < nbatts;j+=5) {
                         if ((attname == atts[j]) && (aprefix == atts[j+1]))
                             break;
                     }
                     if (j < nbatts) continue;
 
                     if ((atts == NULL) || (nbatts + 5 > maxatts)) {
                         if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
                             return(NULL);
                         }
                         maxatts = ctxt->maxatts;
                         atts = ctxt->atts;
                     }
                     atts[nbatts++] = attname;
                     atts[nbatts++] = aprefix;
                     if (aprefix == NULL)
                         atts[nbatts++] = NULL;
                     else
                         atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
-                    atts[nbatts++] = defaults->values[4 * i + 2];
-                    atts[nbatts++] = defaults->values[4 * i + 3];
+                    atts[nbatts++] = defaults->values[5 * i + 2];
+                    atts[nbatts++] = defaults->values[5 * i + 3];
+                    if ((ctxt->standalone == 1) &&
+                        (defaults->values[5 * i + 4] != NULL)) {
+                        xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED, 
+          "standalone: attribute %s on %s defaulted from external subset\n",
+                                         attname, localname);
+                    }
                     nbdef++;
                 }
             }
         }
     }
 
     /*
      * The attributes checkings
      */
     for (i = 0; i < nbatts;i += 5) {
@@ skipping 136 matching lines @@
         NEXT1;
 
     /*
      * [ WFC: Element Type Match ]
      * The Name in an element's end-tag must match the element type in the
      * start-tag. 
      *
      */
     if (name != (xmlChar*)1) {
         if (name == NULL) name = BAD_CAST "unparseable";
+        if ((line == 0) && (ctxt->node != NULL))
+            line = ctxt->node->line;
         xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
                      "Opening and ending tag mismatch: %s line %d and %s\n",
                                 ctxt->name, line, name);
     }
 
     /*
      * SAX: End of Tag
      */
 done:
     if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
@@ skipping 199 matching lines @@
  *
  * [ WFC: Element Type Match ]
  * The Name in an element's end-tag must match the element type in the
  * start-tag. 
  *
  */
 
 void
 xmlParseElement(xmlParserCtxtPtr ctxt) {
     const xmlChar *name;
-    const xmlChar *prefix;
-    const xmlChar *URI;
+    const xmlChar *prefix = NULL;
+    const xmlChar *URI = NULL;
     xmlParserNodeInfo node_info;
     int line, tlen;
     xmlNodePtr ret;
     int nsNr = ctxt->nsNr;
 
-    if ((unsigned int) ctxt->nameNr > xmlParserMaxDepth) {
-        xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
-              "Excessive depth in document: change xmlParserMaxDepth = %d\n",
-                          xmlParserMaxDepth);
+    if (((unsigned int) ctxt->nameNr > xmlParserMaxDepth) &&
+        ((ctxt->options & XML_PARSE_HUGE) == 0)) {
+        xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
+                 "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
+                          xmlParserMaxDepth);
         ctxt->instate = XML_PARSER_EOF;
         return;
     }
 
     /* Capture start position */
     if (ctxt->record_info) {
         node_info.begin_pos = ctxt->input->consumed +
                           (CUR_PTR - ctxt->input->base);
         node_info.begin_line = ctxt->input->line;
     }
@@ skipping 133 matching lines @@
        xmlParserAddNodeInfo(ctxt, &node_info);
     }
 }
 
 /**
  * xmlParseVersionNum:
  * @ctxt:  an XML parser context
  *
  * parse the XML version value.
  *
- * [26] VersionNum ::= ([a-zA-Z0-9_.:] | '-')+
+ * [26] VersionNum ::= '1.' [0-9]+
+ *
+ * In practice allow [0-9].[0-9]+ at that level
  *
  * Returns the string giving the XML version number, or NULL
  */
 xmlChar *
 xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
     xmlChar *buf = NULL;
     int len = 0;
     int size = 10;
     xmlChar cur;
 
     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
     if (buf == NULL) {
         xmlErrMemory(ctxt, NULL);
         return(NULL);
     }
     cur = CUR;
-    while (((cur >= 'a') && (cur <= 'z')) ||
-           ((cur >= 'A') && (cur <= 'Z')) ||
-           ((cur >= '0') && (cur <= '9')) ||
-           (cur == '_') || (cur == '.') ||
-           (cur == ':') || (cur == '-')) {
+    if (!((cur >= '0') && (cur <= '9'))) {
+        xmlFree(buf);
+        return(NULL);
+    }
+    buf[len++] = cur;
+    NEXT;
+    cur=CUR;
+    if (cur != '.') {
+        xmlFree(buf);
+        return(NULL);
+    }
+    buf[len++] = cur;
+    NEXT;
+    cur=CUR;
+    while ((cur >= '0') && (cur <= '9')) {
         if (len + 1 >= size) {
             xmlChar *tmp;
 
             size *= 2;
             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
             if (tmp == NULL) {
                 xmlFree(buf);
                 xmlErrMemory(ctxt, NULL);
                 return(NULL);
             }
@@ skipping 72 matching lines @@
     xmlChar cur;
 
     cur = CUR;
     if (((cur >= 'a') && (cur <= 'z')) ||
         ((cur >= 'A') && (cur <= 'Z'))) {
         buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
         if (buf == NULL) {
             xmlErrMemory(ctxt, NULL);
             return(NULL);
         }
-        
+
         buf[len++] = cur;
         NEXT;
         cur = CUR;
         while (((cur >= 'a') && (cur <= 'z')) ||
                ((cur >= 'A') && (cur <= 'Z')) ||
                ((cur >= '0') && (cur <= '9')) ||
                (cur == '.') || (cur == '_') ||
                (cur == '-')) {
             if (len + 1 >= size) {
                 xmlChar *tmp;
@@ skipping 67 matching lines @@
         } else {
             xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
         }
         /*
          * UTF-16 encoding stwich has already taken place at this stage,
          * more over the little-endian/big-endian selection is already done
          */
         if ((encoding != NULL) &&
             ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-16")) ||
              (!xmlStrcasecmp(encoding, BAD_CAST "UTF16")))) {
+            /*
+             * If no encoding was passed to the parser, that we are
+             * using UTF-16 and no decoder is present i.e. the 
+             * document is apparently UTF-8 compatible, then raise an
+             * encoding mismatch fatal error
+             */
+            if ((ctxt->encoding == NULL) &&
+                (ctxt->input->buf != NULL) &&
+                (ctxt->input->buf->encoder == NULL)) {
+                xmlFatalErrMsg(ctxt, XML_ERR_INVALID_ENCODING,
+                  "Document labelled UTF-16 but has UTF-8 content\n");
+            }
             if (ctxt->encoding != NULL)
                 xmlFree((xmlChar *) ctxt->encoding);
             ctxt->encoding = encoding;
         }
         /*
          * UTF-8 encoding is handled natively
          */
         else if ((encoding != NULL) &&
             ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-8")) ||
              (!xmlStrcasecmp(encoding, BAD_CAST "UTF8")))) {
@@ skipping 138 matching lines @@
 
     /*
      * We must have the VersionInfo here.
      */
     version = xmlParseVersionInfo(ctxt);
     if (version == NULL) {
         xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
     } else {
         if (!xmlStrEqual(version, (const xmlChar *) XML_DEFAULT_VERSION)) {
             /*
-             * TODO: Blueberry should be detected here
+             * Changed here for XML-1.0 5th edition
              */
-            xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
-                          "Unsupported version '%s'\n",
-                          version, NULL);
+            if (ctxt->options & XML_PARSE_OLD10) {
+                xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
+                                  "Unsupported version '%s'\n",
+                                  version);
+            } else {
+                if ((version[0] == '1') && ((version[1] == '.'))) {
+                    xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
+                                  "Unsupported version '%s'\n",
+                                  version, NULL);
+                } else {
+                    xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
+                                      "Unsupported version '%s'\n",
+                                      version);
+                }
+            }
         }
         if (ctxt->version != NULL)
             xmlFree((void *) ctxt->version);
         ctxt->version = version;
     }
 
     /*
      * We may have the encoding declaration
      */
     if (!IS_BLANK_CH(RAW)) {
@@ skipping 14 matching lines @@
     /*
      * We may have the standalone status.
      */
     if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
         if ((RAW == '?') && (NXT(1) == '>')) {
             SKIP(2);
             return;
         }
         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
     }
+
+    /*
+     * We can grow the input buffer freely at that point
+     */
+    GROW;
+
     SKIP_BLANKS;
     ctxt->input->standalone = xmlParseSDDecl(ctxt);
 
     SKIP_BLANKS;
     if ((RAW == '?') && (NXT(1) == '>')) {
         SKIP(2);
     } else if (RAW == '>') {
         /* Deprecated old WD ... */
         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
         NEXT;
@@ skipping 82 matching lines @@
         }
     }
 
 
     if (CUR == 0) {
         xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
     }
 
     /*
      * Check for the XMLDecl in the Prolog.
+     * do not GROW here to avoid the detected encoder to decode more
+     * than just the first line, unless the amount of data is really
+     * too small to hold "<?xml version="1.0" encoding="foo"
      */
-    GROW;
+    if ((ctxt->input->end - ctxt->input->cur) < 35) {
+       GROW;
+    }
     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
 
         /*
          * Note that we will switch encoding on the fly.
          */
         xmlParseXMLDecl(ctxt);
         if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
             /*
              * The XML REC instructs us to stop parsing right here
              */
@@ skipping 75 matching lines @@
 
     /*
      * Remove locally kept entity definitions if the tree was not built
      */
     if ((ctxt->myDoc != NULL) &&
         (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
         xmlFreeDoc(ctxt->myDoc);
         ctxt->myDoc = NULL;
     }
 
+    if ((ctxt->wellFormed) && (ctxt->myDoc != NULL)) {
+        ctxt->myDoc->properties |= XML_DOC_WELLFORMED;
+        if (ctxt->valid)
+            ctxt->myDoc->properties |= XML_DOC_DTDVALID;
+        if (ctxt->nsWellFormed)
+            ctxt->myDoc->properties |= XML_DOC_NSVALID;
+        if (ctxt->options & XML_PARSE_OLD10)
+            ctxt->myDoc->properties |= XML_DOC_OLD10;
+    }
     if (! ctxt->wellFormed) {
         ctxt->valid = 0;
         return(-1);
     }
     return(0);
 }
 
 /**
  * xmlParseExtParsedEnt:
  * @ctxt:  an XML parser context
@@ skipping 542 matching lines @@
                         ctxt->sax->startDocument(ctxt->userData);
                     ctxt->instate = XML_PARSER_MISC;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "PP: entering MISC\n");
 #endif
                 }
                 break;
             case XML_PARSER_START_TAG: {
                 const xmlChar *name;
-                const xmlChar *prefix;
-                const xmlChar *URI;
+                const xmlChar *prefix = NULL;
+                const xmlChar *URI = NULL;
                 int nsNr = ctxt->nsNr;
 
                 if ((avail < 2) && (ctxt->inputNr == 1))
                     goto done;
                 cur = ctxt->input->cur[0];
                 if (cur != '<') {
                     xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
                     ctxt->instate = XML_PARSER_EOF;
                     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
                         ctxt->sax->endDocument(ctxt->userData);
@@ skipping 693 matching lines @@
  * @terminate:  last chunk indicator
  *
  * Parse a Chunk of memory
  *
  * Returns zero if no error, the xmlParserErrors otherwise.
  */
 int
 xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
               int terminate) {
     int end_in_lf = 0;
+    int remain = 0;
 
     if (ctxt == NULL)
         return(XML_ERR_INTERNAL_ERROR);
     if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
         return(ctxt->errNo);
     if (ctxt->instate == XML_PARSER_START)
         xmlDetectSAX2(ctxt);
     if ((size > 0) && (chunk != NULL) && (!terminate) &&
         (chunk[size - 1] == '\r')) {
         end_in_lf = 1;
         size--;
     }
+
+xmldecl_done:
+
     if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
         (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF))  {
         int base = ctxt->input->base - ctxt->input->buf->buffer->content;
         int cur = ctxt->input->cur - ctxt->input->base;
         int res;
-        
+
+        /* Chromium note: commenting out the following block of code is a gory
+         * hack, meant to partially undo
+         *  http://git.gnome.org/browse/libxml2/commit/?id=a6c76a
+         *
+         * WebKit and libxml disagree about who is responsible for the
+         * document encoding.
+         *
+         * This bug:
+         *   https://bugs.webkit.org/show_bug.cgi?id=30508
+         * has links to test cases, libxml bug reports, and mailing list threads
+         * arguing about it; for now, though, we can just undo the change that
+         * caused libxml to regress.
+         */
+#if 0
+        /*
+         * Specific handling if we autodetected an encoding, we should not
+         * push more than the first line ... which depend on the encoding
+         * And only push the rest once the final encoding was detected
+         */
+        if ((ctxt->instate == XML_PARSER_START) && (ctxt->input != NULL) &&
+            (ctxt->input->buf != NULL) && (ctxt->input->buf->encoder != NULL)) {
+            unsigned int len = 45;
+
+            if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
+                               BAD_CAST "UTF-16")) ||
+                (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
+                               BAD_CAST "UTF16")))
+                len = 90;
+            else if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
+                                    BAD_CAST "UCS-4")) ||
+                     (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
+                                    BAD_CAST "UCS4")))
+                len = 180;
+
+            if (ctxt->input->buf->rawconsumed < len)
+                len -= ctxt->input->buf->rawconsumed;
+
+            /*
+             * Change size for reading the initial declaration only
+             * if size is greater than len. Otherwise, memmove in xmlBufferAdd
+             * will blindly copy extra bytes from memory.
+             */
+            if (size > len) {
+                remain = size - len;
+                size = len;
+            } else {
+                remain = 0;
+            }
+        }
+#endif
         res =xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
         if (res < 0) {
             ctxt->errNo = XML_PARSER_EOF;
             ctxt->disableSAX = 1;
             return (XML_PARSER_EOF);
         }
         ctxt->input->base = ctxt->input->buf->buffer->content + base;
         ctxt->input->cur = ctxt->input->base + cur;
         ctxt->input->end =
             &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
 #ifdef DEBUG_PUSH
         xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
 #endif
 
     } else if (ctxt->instate != XML_PARSER_EOF) {
         if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
             xmlParserInputBufferPtr in = ctxt->input->buf;
             if ((in->encoder != NULL) && (in->buffer != NULL) &&
                     (in->raw != NULL)) {
                 int nbchars;
-                    
+
                 nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
                 if (nbchars < 0) {
                     /* TODO 2.6.0 */
                     xmlGenericError(xmlGenericErrorContext,
                                     "xmlParseChunk: encoder error\n");
                     return(XML_ERR_INVALID_ENCODING);
                 }
             }
         }
     }
-    xmlParseTryOrFinish(ctxt, terminate);
+    if (remain != 0)
+        xmlParseTryOrFinish(ctxt, 0);
+    else
+        xmlParseTryOrFinish(ctxt, terminate);
+    if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
+        return(ctxt->errNo);
+
+    if (remain != 0) {
+        chunk += size;
+        size = remain;
+        remain = 0;
+        goto xmldecl_done;
+    }
     if ((end_in_lf == 1) && (ctxt->input != NULL) &&
         (ctxt->input->buf != NULL)) {
         xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
     }
-    if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
-        return(ctxt->errNo);
     if (terminate) {
         /*
          * Check for termination
          */
         int avail = 0;
 
         if (ctxt->input != NULL) {
             if (ctxt->input->buf == NULL)
                 avail = ctxt->input->length -
                         (ctxt->input->cur - ctxt->input->base);
@@ skipping 291 matching lines @@
     if (pinput == NULL) {
         if (sax != NULL) ctxt->sax = NULL;
         xmlFreeParserInputBuffer(input);
         xmlFreeParserCtxt(ctxt);
         return(NULL);
     }
 
     /*
      * plug some encoding conversion routines here.
      */
-    xmlPushInput(ctxt, pinput);
+    if (xmlPushInput(ctxt, pinput) < 0) {
+        if (sax != NULL) ctxt->sax = NULL;
+        xmlFreeParserCtxt(ctxt);
+        return(NULL);
+    }
     if (enc != XML_CHAR_ENCODING_NONE) {
         xmlSwitchEncoding(ctxt, enc);
     }
 
     pinput->filename = NULL;
     pinput->line = 1;
     pinput->col = 1;
     pinput->base = ctxt->input->cur;
     pinput->cur = ctxt->input->cur;
     pinput->free = NULL;
 
     /*
      * let's parse that entity knowing it's an external subset.
      */
     ctxt->inSubset = 2;
     ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
+    if (ctxt->myDoc == NULL) {
+        xmlErrMemory(ctxt, "New Doc failed");
+        return(NULL);
+    }
+    ctxt->myDoc->properties = XML_DOC_INTERNAL;
     ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
                                        BAD_CAST "none", BAD_CAST "none");
 
     if ((enc == XML_CHAR_ENCODING_NONE) &&
         ((ctxt->input->end - ctxt->input->cur) >= 4)) {
         /* 
          * Get the 4 first bytes and decode the charset
          * if enc != XML_CHAR_ENCODING_NONE
          * plug some encoding conversion routines.
          */
@@ skipping 92 matching lines @@
         if (sax != NULL) ctxt->sax = NULL;
         xmlFreeParserCtxt(ctxt);
         if (systemIdCanonic != NULL)
             xmlFree(systemIdCanonic);
         return(NULL);
     }
 
     /*
      * plug some encoding conversion routines here.
      */
-    xmlPushInput(ctxt, input);
+    if (xmlPushInput(ctxt, input) < 0) {
+        if (sax != NULL) ctxt->sax = NULL;
+        xmlFreeParserCtxt(ctxt);
+        if (systemIdCanonic != NULL)
+            xmlFree(systemIdCanonic);
+        return(NULL);
+    }
     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
         enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
         xmlSwitchEncoding(ctxt, enc);
     }
 
     if (input->filename == NULL)
         input->filename = (char *) systemIdCanonic;
     else
         xmlFree(systemIdCanonic);
     input->line = 1;
     input->col = 1;
     input->base = ctxt->input->cur;
     input->cur = ctxt->input->cur;
     input->free = NULL;
 
     /*
      * let's parse that entity knowing it's an external subset.
      */
     ctxt->inSubset = 2;
     ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
+    if (ctxt->myDoc == NULL) {
+        xmlErrMemory(ctxt, "New Doc failed");
+        if (sax != NULL) ctxt->sax = NULL;
+        xmlFreeParserCtxt(ctxt);
+        return(NULL);
+    }
+    ctxt->myDoc->properties = XML_DOC_INTERNAL;
     ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
                                        ExternalID, SystemID);
     xmlParseExternalSubset(ctxt, ExternalID, SystemID);
 
     if (ctxt->myDoc != NULL) {
         if (ctxt->wellFormed) {
             ret = ctxt->myDoc->extSubset;
             ctxt->myDoc->extSubset = NULL;
             if (ret != NULL) {
                 xmlNodePtr tmp;
 
                 ret->doc = NULL;
                 tmp = ret->children;
                 while (tmp != NULL) {
                     tmp->doc = NULL;
                     tmp = tmp->next;
                 }
             }
         } else {
             ret = NULL;
         }
         xmlFreeDoc(ctxt->myDoc);
         ctxt->myDoc = NULL;
     }
     if (sax != NULL) ctxt->sax = NULL;
     xmlFreeParserCtxt(ctxt);
-    
+
     return(ret);
 }
 
 
 /**
  * xmlParseDTD:
  * @ExternalID:  a NAME* containing the External ID of the DTD
  * @SystemID:  a NAME* containing the URL to the DTD
  *
  * Load and parse an external subset.
- * 
+ *
  * Returns the resulting xmlDtdPtr or NULL in case of error.
  */
 
 xmlDtdPtr
 xmlParseDTD(const xmlChar *ExternalID, const xmlChar *SystemID) {
     return(xmlSAXParseDTD(NULL, ExternalID, SystemID));
 }
 #endif /* LIBXML_VALID_ENABLED */
 
 /************************************************************************
@@ skipping 22 matching lines @@
 int
 xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, const xmlChar *URL,
                        const xmlChar *ID, xmlNodePtr *lst) {
     xmlParserCtxtPtr ctxt;
     xmlDocPtr newDoc;
     xmlNodePtr newRoot;
     xmlSAXHandlerPtr oldsax = NULL;
     int ret = 0;
     xmlChar start[4];
     xmlCharEncoding enc;
-    xmlParserInputPtr inputStream;
-    char *directory = NULL;
 
     if (ctx == NULL) return(-1);
 
-    if (ctx->depth > 40) {
+    if (((ctx->depth > 40) && ((ctx->options & XML_PARSE_HUGE) == 0)) ||
+        (ctx->depth > 1024)) {
         return(XML_ERR_ENTITY_LOOP);
     }
 
     if (lst != NULL)
         *lst = NULL;
     if ((URL == NULL) && (ID == NULL))
         return(-1);
     if (ctx->myDoc == NULL) /* @@ relax but check for dereferences */
         return(-1);
 
-    ctxt = xmlNewParserCtxt();
+    ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, ctx);
     if (ctxt == NULL) {
         return(-1);
     }
-    
-    ctxt->userData = ctxt;
-    ctxt->_private = ctx->_private;
-    
-    inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt);
-    if (inputStream == NULL) {
-        xmlFreeParserCtxt(ctxt);
-        return(-1);
-    }
 
-    inputPush(ctxt, inputStream);
-
-    if ((ctxt->directory == NULL) && (directory == NULL))
-        directory = xmlParserGetDirectory((char *)URL);
-    if ((ctxt->directory == NULL) && (directory != NULL))
-        ctxt->directory = directory;
-    
     oldsax = ctxt->sax;
     ctxt->sax = ctx->sax;
     xmlDetectSAX2(ctxt);
     newDoc = xmlNewDoc(BAD_CAST "1.0");
     if (newDoc == NULL) {
         xmlFreeParserCtxt(ctxt);
         return(-1);
     }
+    newDoc->properties = XML_DOC_INTERNAL;
     if (ctx->myDoc->dict) {
         newDoc->dict = ctx->myDoc->dict;
         xmlDictReference(newDoc->dict);
     }
     if (ctx->myDoc != NULL) {
         newDoc->intSubset = ctx->myDoc->intSubset;
         newDoc->extSubset = ctx->myDoc->extSubset;
     }
     if (ctx->myDoc->URL != NULL) {
         newDoc->URL = xmlStrdup(ctx->myDoc->URL);
     }
     newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
     if (newRoot == NULL) {
         ctxt->sax = oldsax;
         xmlFreeParserCtxt(ctxt);
         newDoc->intSubset = NULL;
         newDoc->extSubset = NULL;
         xmlFreeDoc(newDoc);
         return(-1);
     }
     xmlAddChild((xmlNodePtr) newDoc, newRoot);
     nodePush(ctxt, newDoc->children);
     if (ctx->myDoc == NULL) {
         ctxt->myDoc = newDoc;
     } else {
         ctxt->myDoc = ctx->myDoc;
         newDoc->children->doc = ctx->myDoc;
     }
 
-    /* 
+    /*
      * Get the 4 first bytes and decode the charset
      * if enc != XML_CHAR_ENCODING_NONE
      * plug some encoding conversion routines.
      */
     GROW
     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
         start[0] = RAW;
         start[1] = NXT(1);
         start[2] = NXT(2);
         start[3] = NXT(3);
         enc = xmlDetectCharEncoding(start, 4);
         if (enc != XML_CHAR_ENCODING_NONE) {
             xmlSwitchEncoding(ctxt, enc);
         }
     }
 
     /*
      * Parse a possible text declaration first
      */
     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
         xmlParseTextDecl(ctxt);
+        /*
+         * An XML-1.0 document can't reference an entity not XML-1.0
+         */
+        if ((xmlStrEqual(ctx->version, BAD_CAST "1.0")) &&
+            (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) {
+            xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH, 
+                           "Version mismatch between document and entity\n");
+        }
     }
 
     /*
      * Doing validity checking on chunk doesn't make sense
      */
     ctxt->instate = XML_PARSER_CONTENT;
     ctxt->validate = ctx->validate;
     ctxt->valid = ctx->valid;
     ctxt->loadsubset = ctx->loadsubset;
     ctxt->depth = ctx->depth + 1;
@@ skipping 13 matching lines @@
     ctxt->dict = ctx->dict;
     ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
     ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
     ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
     ctxt->dictNames = ctx->dictNames;
     ctxt->attsDefault = ctx->attsDefault;
     ctxt->attsSpecial = ctx->attsSpecial;
     ctxt->linenumbers = ctx->linenumbers;
 
     xmlParseContent(ctxt);
-   
+
     ctx->validate = ctxt->validate;
     ctx->valid = ctxt->valid;
     if ((RAW == '<') && (NXT(1) == '/')) {
         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
     } else if (RAW != 0) {
         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
     }
     if (ctxt->node != newDoc->children) {
         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
     }
@@ skipping 22 matching lines @@
         ret = 0;
     }
     ctxt->sax = oldsax;
     ctxt->dict = NULL;
     ctxt->attsDefault = NULL;
     ctxt->attsSpecial = NULL;
     xmlFreeParserCtxt(ctxt);
     newDoc->intSubset = NULL;
     newDoc->extSubset = NULL;
     xmlFreeDoc(newDoc);
-    
+
     return(ret);
 }
 
 /**
  * xmlParseExternalEntityPrivate:
  * @doc:  the document the chunk pertains to
  * @oldctxt:  the previous parser context if available
  * @sax:  the SAX handler bloc (possibly NULL)
  * @user_data:  The user data returned on SAX callbacks (possibly NULL)
  * @depth:  Used for loop detection, use 0
@@ skipping 13 matching lines @@
                       void *user_data, int depth, const xmlChar *URL,
                       const xmlChar *ID, xmlNodePtr *list) {
     xmlParserCtxtPtr ctxt;
     xmlDocPtr newDoc;
     xmlNodePtr newRoot;
     xmlSAXHandlerPtr oldsax = NULL;
     xmlParserErrors ret = XML_ERR_OK;
     xmlChar start[4];
     xmlCharEncoding enc;
 
-    if (depth > 40) {
+    if (((depth > 40) &&
+        ((oldctxt == NULL) || (oldctxt->options & XML_PARSE_HUGE) == 0)) ||
+        (depth > 1024)) {
         return(XML_ERR_ENTITY_LOOP);
     }
 
-
-
     if (list != NULL)
         *list = NULL;
     if ((URL == NULL) && (ID == NULL))
         return(XML_ERR_INTERNAL_ERROR);
     if (doc == NULL)
         return(XML_ERR_INTERNAL_ERROR);
 
 
-    ctxt = xmlCreateEntityParserCtxt(URL, ID, NULL);
+    ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, oldctxt);
     if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
     ctxt->userData = ctxt;
     if (oldctxt != NULL) {
         ctxt->_private = oldctxt->_private;
         ctxt->loadsubset = oldctxt->loadsubset;
         ctxt->validate = oldctxt->validate;
         ctxt->external = oldctxt->external;
         ctxt->record_info = oldctxt->record_info;
         ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
         ctxt->node_seq.length = oldctxt->node_seq.length;
@@ skipping 16 matching lines @@
     }
     xmlDetectSAX2(ctxt);
     newDoc = xmlNewDoc(BAD_CAST "1.0");
     if (newDoc == NULL) {
         ctxt->node_seq.maximum = 0;
         ctxt->node_seq.length = 0;
         ctxt->node_seq.buffer = NULL;
         xmlFreeParserCtxt(ctxt);
         return(XML_ERR_INTERNAL_ERROR);
     }
+    newDoc->properties = XML_DOC_INTERNAL;
     newDoc->intSubset = doc->intSubset;
     newDoc->extSubset = doc->extSubset;
     newDoc->dict = doc->dict;
     xmlDictReference(newDoc->dict);
 
     if (doc->URL != NULL) {
         newDoc->URL = xmlStrdup(doc->URL);
     }
     newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
     if (newRoot == NULL) {
         if (sax != NULL)
             ctxt->sax = oldsax;
         ctxt->node_seq.maximum = 0;
         ctxt->node_seq.length = 0;
         ctxt->node_seq.buffer = NULL;
         xmlFreeParserCtxt(ctxt);
         newDoc->intSubset = NULL;
         newDoc->extSubset = NULL;
         xmlFreeDoc(newDoc);
         return(XML_ERR_INTERNAL_ERROR);
     }
     xmlAddChild((xmlNodePtr) newDoc, newRoot);
     nodePush(ctxt, newDoc->children);
     ctxt->myDoc = doc;
     newRoot->doc = doc;
 
-    /* 
+    /*
      * Get the 4 first bytes and decode the charset
      * if enc != XML_CHAR_ENCODING_NONE
      * plug some encoding conversion routines.
      */
     GROW;
     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
         start[0] = RAW;
         start[1] = NXT(1);
         start[2] = NXT(2);
         start[3] = NXT(3);
         enc = xmlDetectCharEncoding(start, 4);
         if (enc != XML_CHAR_ENCODING_NONE) {
             xmlSwitchEncoding(ctxt, enc);
         }
     }
 
     /*
      * Parse a possible text declaration first
      */
     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
         xmlParseTextDecl(ctxt);
     }
 
     ctxt->instate = XML_PARSER_CONTENT;
     ctxt->depth = depth;
 
     xmlParseContent(ctxt);
-   
+
     if ((RAW == '<') && (NXT(1) == '/')) {
         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
     } else if (RAW != 0) {
         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
     }
     if (ctxt->node != newDoc->children) {
         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
     }
 
     if (!ctxt->wellFormed) {
@@ skipping 12 matching lines @@
             cur = newDoc->children->children;
             *list = cur;
             while (cur != NULL) {
                 cur->parent = NULL;
                 cur = cur->next;
             }
             newDoc->children->children = NULL;
         }
         ret = XML_ERR_OK;
     }
+
+    /*
+     * Record in the parent context the number of entities replacement
+     * done when parsing that reference.
+     */
+    if (oldctxt != NULL)
+        oldctxt->nbentities += ctxt->nbentities;
+
+    /*
+     * Also record the size of the entity parsed
+     */
+    if (ctxt->input != NULL) {
+        oldctxt->sizeentities += ctxt->input->consumed;
+        oldctxt->sizeentities += (ctxt->input->cur - ctxt->input->base);
+    }
+    /*
+     * And record the last error if any
+     */
+    if (ctxt->lastError.code != XML_ERR_OK)
+        xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
+
     if (sax != NULL) 
         ctxt->sax = oldsax;
     oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
     oldctxt->node_seq.length = ctxt->node_seq.length;
     oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
     ctxt->node_seq.maximum = 0;
     ctxt->node_seq.length = 0;
     ctxt->node_seq.buffer = NULL;
     xmlFreeParserCtxt(ctxt);
     newDoc->intSubset = NULL;
     newDoc->extSubset = NULL;
     xmlFreeDoc(newDoc);
-    
+
     return(ret);
 }
 
 #ifdef LIBXML_SAX1_ENABLED
 /**
  * xmlParseExternalEntity:
  * @doc:  the document the chunk pertains to
  * @sax:  the SAX handler bloc (possibly NULL)
  * @user_data:  The user data returned on SAX callbacks (possibly NULL)
  * @depth:  Used for loop detection, use 0
@@ skipping 56 matching lines @@
  *
  * Parse a well-balanced chunk of an XML document
  * called by the parser
  * The allowed sequence for the Well Balanced Chunk is the one defined by
  * the content production in the XML grammar:
  *
  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
  *
  * Returns XML_ERR_OK if the chunk is well balanced, and the parser
  * error code otherwise
- *    
+ *
  * In case recover is set to 1, the nodelist will not be empty even if
- * the parsed chunk is not well balanced. 
+ * the parsed chunk is not well balanced.
  */
 static xmlParserErrors
 xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
         const xmlChar *string, void *user_data, xmlNodePtr *lst) {
     xmlParserCtxtPtr ctxt;
     xmlDocPtr newDoc = NULL;
     xmlNodePtr newRoot;
     xmlSAXHandlerPtr oldsax = NULL;
     xmlNodePtr content = NULL;
     xmlNodePtr last = NULL;
     int size;
     xmlParserErrors ret = XML_ERR_OK;
+#ifdef SAX2
+    int i;
+#endif
 
-    if (oldctxt->depth > 40) {
+    if (((oldctxt->depth > 40) && ((oldctxt->options & XML_PARSE_HUGE) == 0)) ||
+        (oldctxt->depth >  1024)) {
         return(XML_ERR_ENTITY_LOOP);
     }
 
 
     if (lst != NULL)
         *lst = NULL;
     if (string == NULL)
         return(XML_ERR_INTERNAL_ERROR);
 
     size = xmlStrlen(string);
 
     ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
     if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
     if (user_data != NULL)
         ctxt->userData = user_data;
     else
         ctxt->userData = ctxt;
     if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
     ctxt->dict = oldctxt->dict;
     ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
     ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
     ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
 
-    ctxt->nsParent = oldctxt;
+#ifdef SAX2
+    /* propagate namespaces down the entity */
+    for (i = 0;i < oldctxt->nsNr;i += 2) {
+        nsPush(ctxt, oldctxt->nsTab[i], oldctxt->nsTab[i+1]);
+    }
+#endif
 
     oldsax = ctxt->sax;
     ctxt->sax = oldctxt->sax;
     xmlDetectSAX2(ctxt);
     ctxt->replaceEntities = oldctxt->replaceEntities;
     ctxt->options = oldctxt->options;
-    
+
     ctxt->_private = oldctxt->_private;
     if (oldctxt->myDoc == NULL) {
         newDoc = xmlNewDoc(BAD_CAST "1.0");
         if (newDoc == NULL) {
             ctxt->sax = oldsax;
             ctxt->dict = NULL;
             xmlFreeParserCtxt(ctxt);
             return(XML_ERR_INTERNAL_ERROR);
         }
+        newDoc->properties = XML_DOC_INTERNAL;
         newDoc->dict = ctxt->dict;
         xmlDictReference(newDoc->dict);
         ctxt->myDoc = newDoc;
     } else {
         ctxt->myDoc = oldctxt->myDoc;
         content = ctxt->myDoc->children;
         last = ctxt->myDoc->last;
     }
     newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
     if (newRoot == NULL) {
@@ skipping 35 matching lines @@
     }
 
     if (!ctxt->wellFormed) {
         if (ctxt->errNo == 0)
             ret = XML_ERR_INTERNAL_ERROR;
         else
             ret = (xmlParserErrors)ctxt->errNo;
     } else {
       ret = XML_ERR_OK;
     }
-    
+
     if ((lst != NULL) && (ret == XML_ERR_OK)) {
         xmlNodePtr cur;
 
         /*
          * Return the newly created nodeset after unlinking it from
          * they pseudo parent.
          */
         cur = ctxt->myDoc->children->children;
         *lst = cur;
         while (cur != NULL) {
 #ifdef LIBXML_VALID_ENABLED
             if ((oldctxt->validate) && (oldctxt->wellFormed) &&
                 (oldctxt->myDoc) && (oldctxt->myDoc->intSubset) &&
                 (cur->type == XML_ELEMENT_NODE)) {
                 oldctxt->valid &= xmlValidateElement(&oldctxt->vctxt,
                         oldctxt->myDoc, cur);
             }
 #endif /* LIBXML_VALID_ENABLED */
             cur->parent = NULL;
             cur = cur->next;
         }
         ctxt->myDoc->children->children = NULL;
     }
     if (ctxt->myDoc != NULL) {
         xmlFreeNode(ctxt->myDoc->children);
         ctxt->myDoc->children = content;
         ctxt->myDoc->last = last;
     }
-        
+
+    /*
+     * Record in the parent context the number of entities replacement
+     * done when parsing that reference.
+     */
+    if (oldctxt != NULL)
+        oldctxt->nbentities += ctxt->nbentities;
+
+    /*
+     * Also record the last error if any
+     */
+    if (ctxt->lastError.code != XML_ERR_OK)
+        xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
+
     ctxt->sax = oldsax;
     ctxt->dict = NULL;
     ctxt->attsDefault = NULL;
     ctxt->attsSpecial = NULL;
     xmlFreeParserCtxt(ctxt);
     if (newDoc != NULL) {
         xmlFreeDoc(newDoc);
     }
-    
+
     return(ret);
 }
 
 /**
  * xmlParseInNodeContext:
  * @node:  the context node
  * @data:  the input string
  * @datalen:  the input string length in bytes
  * @options:  a combination of xmlParserOption
  * @lst:  the return value for the set of parsed nodes
@@ skipping 53 matching lines @@
     if (doc == NULL)
         return(XML_ERR_INTERNAL_ERROR);
 
     /*
      * allocate a context and set-up everything not related to the
      * node position in the tree
      */
     if (doc->type == XML_DOCUMENT_NODE)
         ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
 #ifdef LIBXML_HTML_ENABLED
-    else if (doc->type == XML_HTML_DOCUMENT_NODE)
+    else if (doc->type == XML_HTML_DOCUMENT_NODE) {
         ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
+        /*
+         * When parsing in context, it makes no sense to add implied
+         * elements like html/body/etc...
+         */
+        options |= HTML_PARSE_NOIMPLIED;
+    }
 #endif
     else
         return(XML_ERR_INTERNAL_ERROR);
 
     if (ctxt == NULL)
         return(XML_ERR_NO_MEMORY);
-    fake = xmlNewComment(NULL);
-    if (fake == NULL) {
-        xmlFreeParserCtxt(ctxt);
-        return(XML_ERR_NO_MEMORY);
-    }
-    xmlAddChild(node, fake);
 
-    /* 
+    /*
      * Use input doc's dict if present, else assure XML_PARSE_NODICT is set.
      * We need a dictionary for xmlDetectSAX2, so if there's no doc dict
      * we must wait until the last moment to free the original one.
      */
     if (doc->dict != NULL) {
         if (ctxt->dict != NULL)
             xmlDictFree(ctxt->dict);
         ctxt->dict = doc->dict;
     } else
         options |= XML_PARSE_NODICT;
 
-    xmlCtxtUseOptions(ctxt, options);
+    if (doc->encoding != NULL) {
+        xmlCharEncodingHandlerPtr hdlr;
+
+        if (ctxt->encoding != NULL)
+            xmlFree((xmlChar *) ctxt->encoding);
+        ctxt->encoding = xmlStrdup((const xmlChar *) doc->encoding);
+
+        hdlr = xmlFindCharEncodingHandler(doc->encoding);
+        if (hdlr != NULL) {
+            xmlSwitchToEncoding(ctxt, hdlr);
+        } else {
+            return(XML_ERR_UNSUPPORTED_ENCODING);
+        }
+    }
+
+    xmlCtxtUseOptionsInternal(ctxt, options, NULL);
     xmlDetectSAX2(ctxt);
     ctxt->myDoc = doc;
 
+    fake = xmlNewComment(NULL);
+    if (fake == NULL) {
+        xmlFreeParserCtxt(ctxt);
+        return(XML_ERR_NO_MEMORY);
+    }
+    xmlAddChild(node, fake);
+
     if (node->type == XML_ELEMENT_NODE) {
         nodePush(ctxt, node);
         /*
          * initialize the SAX2 namespaces stack
          */
         cur = node;
         while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) {
             xmlNsPtr ns = cur->nsDef;
             const xmlChar *iprefix, *ihref;
 
             while (ns != NULL) {
                 if (ctxt->dict) {
                     iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
                     ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
                 } else {
                     iprefix = ns->prefix;
                     ihref = ns->href;
                 }
 
                 if (xmlGetNamespace(ctxt, iprefix) == NULL) {
                     nsPush(ctxt, iprefix, ihref);
                     nsnr++;
                 }
                 ns = ns->next;
             }
             cur = cur->parent;
         }
         ctxt->instate = XML_PARSER_CONTENT;
-    } 
+    }
 
     if ((ctxt->validate) || (ctxt->replaceEntities != 0)) {
         /*
          * ID/IDREF registration will be done in xmlValidateElement below
          */
         ctxt->loadsubset |= XML_SKIP_IDS;
     }
 
 #ifdef LIBXML_HTML_ENABLED
     if (doc->type == XML_HTML_DOCUMENT_NODE)
@@ skipping 14 matching lines @@
     }
 
     if (!ctxt->wellFormed) {
         if (ctxt->errNo == 0)
             ret = XML_ERR_INTERNAL_ERROR;
         else
             ret = (xmlParserErrors)ctxt->errNo;
     } else {
         ret = XML_ERR_OK;
     }
-    
+
     /*
      * Return the newly created nodeset after unlinking it from
      * the pseudo sibling.
      */
-    
+
     cur = fake->next;
     fake->next = NULL;
     node->last = fake;
 
     if (cur != NULL) {
         cur->prev = NULL;
     }
 
     *lst = cur;
 
     while (cur != NULL) {
         cur->parent = NULL;
         cur = cur->next;
     }
 
     xmlUnlinkNode(fake);
     xmlFreeNode(fake);
 
 
     if (ret != XML_ERR_OK) {
         xmlFreeNodeList(*lst);
         *lst = NULL;
     }
 
     if (doc->dict != NULL)
         ctxt->dict = NULL;
     xmlFreeParserCtxt(ctxt);
-    
+
     return(ret);
 #else /* !SAX2 */
     return(XML_ERR_INTERNAL_ERROR);
 #endif
 }
 
 #ifdef LIBXML_SAX1_ENABLED
 /**
  * xmlParseBalancedChunkMemoryRecover:
  * @doc:  the document the chunk pertains to
@@ skipping 49 matching lines @@
         oldsax = ctxt->sax;
         ctxt->sax = sax;
         if (user_data != NULL)
             ctxt->userData = user_data;
     }
     newDoc = xmlNewDoc(BAD_CAST "1.0");
     if (newDoc == NULL) {
         xmlFreeParserCtxt(ctxt);
         return(-1);
     }
+    newDoc->properties = XML_DOC_INTERNAL;
     if ((doc != NULL) && (doc->dict != NULL)) {
         xmlDictFree(ctxt->dict);
         ctxt->dict = doc->dict;
         xmlDictReference(ctxt->dict);
         ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
         ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
         ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
         ctxt->dictNames = 1;
     } else {
-        xmlCtxtUseOptions(ctxt, XML_PARSE_NODICT);
+        xmlCtxtUseOptionsInternal(ctxt, XML_PARSE_NODICT, NULL);
     }
     if (doc != NULL) {
         newDoc->intSubset = doc->intSubset;
         newDoc->extSubset = doc->extSubset;
     }
     newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
     if (newRoot == NULL) {
         if (sax != NULL)
             ctxt->sax = oldsax;
         xmlFreeParserCtxt(ctxt);
@@ skipping 42 matching lines @@
     }
 
     if (!ctxt->wellFormed) {
         if (ctxt->errNo == 0)
             ret = 1;
         else
             ret = ctxt->errNo;
     } else {
       ret = 0;
     }
-    
+
     if ((lst != NULL) && ((ret == 0) || (recover == 1))) {
         xmlNodePtr cur;
 
         /*
          * Return the newly created nodeset after unlinking it from
          * they pseudo parent.
          */
         cur = newDoc->children->children;
         *lst = cur;
         while (cur != NULL) {
             xmlSetTreeDoc(cur, doc);
             cur->parent = NULL;
             cur = cur->next;
         }
         newDoc->children->children = NULL;
     }
-        
-    if (sax != NULL) 
+
+    if (sax != NULL)
         ctxt->sax = oldsax;
     xmlFreeParserCtxt(ctxt);
     newDoc->intSubset = NULL;
     newDoc->extSubset = NULL;
     newDoc->oldNs = NULL;
     xmlFreeDoc(newDoc);
-    
+
     return(ret);
 }
 
 /**
  * xmlSAXParseEntity:
  * @sax:  the SAX handler block
  * @filename:  the filename
  *
  * parse an XML external entity out of context and build a tree.
  * It use the given SAX function block to handle the parsing callback.
@@ skipping 27 matching lines @@
     if (ctxt->wellFormed)
         ret = ctxt->myDoc;
     else {
         ret = NULL;
         xmlFreeDoc(ctxt->myDoc);
         ctxt->myDoc = NULL;
     }
     if (sax != NULL)
         ctxt->sax = NULL;
     xmlFreeParserCtxt(ctxt);
-    
+
     return(ret);
 }
 
 /**
  * xmlParseEntity:
  * @filename:  the filename
  *
  * parse an XML external entity out of context and build a tree.
  *
  * [78] extParsedEnt ::= TextDecl? content
  *
  * This correspond to a "Well Balanced" chunk
  *
  * Returns the resulting document tree
  */
 
 xmlDocPtr
 xmlParseEntity(const char *filename) {
     return(xmlSAXParseEntity(NULL, filename));
 }
 #endif /* LIBXML_SAX1_ENABLED */
 
 /**
- * xmlCreateEntityParserCtxt:
+ * xmlCreateEntityParserCtxtInternal:
  * @URL:  the entity URL
  * @ID:  the entity PUBLIC ID
  * @base:  a possible base for the target URI
+ * @pctx:  parser context used to set options on new context
  *
  * Create a parser context for an external entity
  * Automatic support for ZLIB/Compress compressed document is provided
  * by default if found at compile-time.
  *
  * Returns the new parser context or NULL
  */
-xmlParserCtxtPtr
-xmlCreateEntityParserCtxt(const xmlChar *URL, const xmlChar *ID,
-                          const xmlChar *base) {
+static xmlParserCtxtPtr
+xmlCreateEntityParserCtxtInternal(const xmlChar *URL, const xmlChar *ID,
+                          const xmlChar *base, xmlParserCtxtPtr pctx) {
     xmlParserCtxtPtr ctxt;
     xmlParserInputPtr inputStream;
     char *directory = NULL;
     xmlChar *uri;
-    
+
     ctxt = xmlNewParserCtxt();
     if (ctxt == NULL) {
         return(NULL);
     }
 
+    if (pctx != NULL) {
+        ctxt->options = pctx->options;
+        ctxt->_private = pctx->_private;
+    }
+
     uri = xmlBuildURI(URL, base);
 
     if (uri == NULL) {
         inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt);
         if (inputStream == NULL) {
             xmlFreeParserCtxt(ctxt);
             return(NULL);
         }
 
         inputPush(ctxt, inputStream);
@@ skipping 14 matching lines @@
 
         if ((ctxt->directory == NULL) && (directory == NULL))
             directory = xmlParserGetDirectory((char *)uri);
         if ((ctxt->directory == NULL) && (directory != NULL))
             ctxt->directory = directory;
         xmlFree(uri);
     }
     return(ctxt);
 }
 
+/**
+ * xmlCreateEntityParserCtxt:
+ * @URL:  the entity URL
+ * @ID:  the entity PUBLIC ID
+ * @base:  a possible base for the target URI
+ *
+ * Create a parser context for an external entity
+ * Automatic support for ZLIB/Compress compressed document is provided
+ * by default if found at compile-time.
+ *
+ * Returns the new parser context or NULL
+ */
+xmlParserCtxtPtr
+xmlCreateEntityParserCtxt(const xmlChar *URL, const xmlChar *ID,
+                          const xmlChar *base) {
+    return xmlCreateEntityParserCtxtInternal(URL, ID, base, NULL);
+
+}
+
 /************************************************************************
  *                                                                      *
- *              Front ends when parsing from a file                     *
+ *              Front ends when parsing from a file                     *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlCreateURLParserCtxt:
  * @filename:  the filename or URL
  * @options:  a combination of xmlParserOption
  *
  * Create a parser context for a file or URL content. 
  * Automatic support for ZLIB/Compress compressed document is provided
  * by default if found at compile-time and for file accesses
  *
  * Returns the new parser context or NULL
  */
 xmlParserCtxtPtr
 xmlCreateURLParserCtxt(const char *filename, int options)
 {
     xmlParserCtxtPtr ctxt;
     xmlParserInputPtr inputStream;
     char *directory = NULL;
 
     ctxt = xmlNewParserCtxt();
     if (ctxt == NULL) {
         xmlErrMemory(NULL, "cannot allocate parser context");
         return(NULL);
     }
 
     if (options)
-        xmlCtxtUseOptions(ctxt, options);
+        xmlCtxtUseOptionsInternal(ctxt, options, NULL);
     ctxt->linenumbers = 1;
-    
+
     inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
     if (inputStream == NULL) {
         xmlFreeParserCtxt(ctxt);
         return(NULL);
     }
 
     inputPush(ctxt, inputStream);
     if ((ctxt->directory == NULL) && (directory == NULL))
         directory = xmlParserGetDirectory(filename);
     if ((ctxt->directory == NULL) && (directory != NULL))
@@ skipping 114 matching lines @@
  * @cur:  a pointer to an array of xmlChar
  *
  * parse an XML in-memory document and build a tree.
  * In the case the document is not Well Formed, a attempt to build a
  * tree is tried anyway
  *
  * Returns the resulting document tree or NULL in case of failure
  */
 
 xmlDocPtr
-xmlRecoverDoc(xmlChar *cur) {
+xmlRecoverDoc(const xmlChar *cur) {
     return(xmlSAXParseDoc(NULL, cur, 1));
 }
 
 /**
  * xmlParseFile:
  * @filename:  the filename
  *
  * parse an XML file and build a tree. Automatic support for ZLIB/Compress
  * compressed document is provided by default if found at compile-time.
  *
@@ skipping 181 matching lines @@
  *
  * Returns the resulting document tree
  */
 
 xmlDocPtr
 xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax, const char *buffer,
                   int size, int recovery, void *data) {
     xmlDocPtr ret;
     xmlParserCtxtPtr ctxt;
 
+    xmlInitParser();
+
     ctxt = xmlCreateMemoryParserCtxt(buffer, size);
     if (ctxt == NULL) return(NULL);
     if (sax != NULL) {
         if (ctxt->sax != NULL)
             xmlFree(ctxt->sax);
         ctxt->sax = sax;
     }
     xmlDetectSAX2(ctxt);
     if (data!=NULL) {
         ctxt->_private=data;
     }
 
     ctxt->recovery = recovery;
 
     xmlParseDocument(ctxt);
 
     if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
     else {
        ret = NULL;
        xmlFreeDoc(ctxt->myDoc);
        ctxt->myDoc = NULL;
     }
     if (sax != NULL) 
         ctxt->sax = NULL;
     xmlFreeParserCtxt(ctxt);
-    
+
     return(ret);
 }
 
 /**
  * xmlSAXParseMemory:
  * @sax:  the SAX handler block
  * @buffer:  an pointer to a char array
  * @size:  the size of the array
  * @recovery:  work in recovery mode, i.e. tries to read not Well Formed
  *             documents
@@ skipping 42 matching lines @@
 
 /**
  * xmlSAXUserParseMemory:
  * @sax:  a SAX handler
  * @user_data:  The user data returned on SAX callbacks
  * @buffer:  an in-memory XML document input
  * @size:  the length of the XML document in bytes
  *
  * A better SAX parsing routine.
  * parse an XML in-memory buffer and call the given SAX handler routines.
- * 
+ *
  * Returns 0 in case of success or a error number otherwise
  */
 int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data,
                           const char *buffer, int size) {
     int ret = 0;
     xmlParserCtxtPtr ctxt;
-    
+
+    xmlInitParser();
+
     ctxt = xmlCreateMemoryParserCtxt(buffer, size);
     if (ctxt == NULL) return -1;
     if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
         xmlFree(ctxt->sax);
     ctxt->sax = sax;
     xmlDetectSAX2(ctxt);
 
     if (user_data != NULL)
         ctxt->userData = user_data;
-    
+
     xmlParseDocument(ctxt);
     
     if (ctxt->wellFormed)
         ret = 0;
     else {
         if (ctxt->errNo != 0)
             ret = ctxt->errNo;
         else
             ret = -1;
     }
@@ skipping 153 matching lines @@
 
 void
 xmlInitParser(void) {
     if (xmlParserInitialized != 0)
         return;
 
 #ifdef LIBXML_THREAD_ENABLED
     __xmlGlobalInitMutexLock();
     if (xmlParserInitialized == 0) {
 #endif
+        xmlInitGlobals();
+        xmlInitThreads();
         if ((xmlGenericError == xmlGenericErrorDefaultFunc) ||
             (xmlGenericError == NULL))
             initGenericErrorDefaultFunc(NULL);
-        xmlInitGlobals();
-        xmlInitThreads();
         xmlInitMemory();
         xmlInitCharEncodingHandlers();
         xmlDefaultSAXHandlerInit();
         xmlRegisterDefaultInputCallbacks();
 #ifdef LIBXML_OUTPUT_ENABLED
         xmlRegisterDefaultOutputCallbacks();
 #endif /* LIBXML_OUTPUT_ENABLED */
 #ifdef LIBXML_HTML_ENABLED
         htmlInitAutoClose();
         htmlDefaultSAXHandlerInit();
@@ skipping 13 matching lines @@
  *
  * This function name is somewhat misleading. It does not clean up
  * parser state, it cleans up memory allocated by the library itself.
  * It is a cleanup function for the XML library. It tries to reclaim all
  * related global memory allocated for the library processing.
  * It doesn't deallocate any document related memory. One should
  * call xmlCleanupParser() only when the process has finished using
  * the library and all XML/HTML documents built with it.
  * See also xmlInitParser() which has the opposite function of preparing
  * the library for operations.
+ *
+ * WARNING: if your application is multithreaded or has plugin support
+ *          calling this may crash the application if another thread or
+ *          a plugin is still using libxml2. It's sometimes very hard to
+ *          guess if libxml2 is in use in the application, some libraries
+ *          or plugins may use it without notice. In case of doubt abstain
+ *          from calling this function or do it just before calling exit()
+ *          to avoid leak reports from valgrind !
  */
 
 void
 xmlCleanupParser(void) {
     if (!xmlParserInitialized)
         return;
 
     xmlCleanupCharEncodingHandlers();
 #ifdef LIBXML_CATALOG_ENABLED
     xmlCatalogCleanup();
@@ skipping 102 matching lines @@
     ctxt->vctxt.warning = xmlParserValidityWarning;
 #endif
     ctxt->record_info = 0;
     ctxt->nbChars = 0;
     ctxt->checkIndex = 0;
     ctxt->inSubset = 0;
     ctxt->errNo = XML_ERR_OK;
     ctxt->depth = 0;
     ctxt->charset = XML_CHAR_ENCODING_UTF8;
     ctxt->catalogs = NULL;
+    ctxt->nbentities = 0;
+    ctxt->sizeentities = 0;
     xmlInitNodeInfoSeq(&ctxt->node_seq);
 
     if (ctxt->attsDefault != NULL) {
         xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
         ctxt->attsDefault = NULL;
     }
     if (ctxt->attsSpecial != NULL) {
         xmlHashFree(ctxt->attsSpecial, NULL);
         ctxt->attsSpecial = NULL;
     }
@@ skipping 91 matching lines @@
             &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->
                                                use];
 #ifdef DEBUG_PUSH
         xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
 #endif
     }
 
     if (encoding != NULL) {
         xmlCharEncodingHandlerPtr hdlr;
 
+        if (ctxt->encoding != NULL)
+            xmlFree((xmlChar *) ctxt->encoding);
+        ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
+
         hdlr = xmlFindCharEncodingHandler(encoding);
         if (hdlr != NULL) {
             xmlSwitchToEncoding(ctxt, hdlr);
         } else {
             xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                               "Unsupported encoding %s\n", BAD_CAST encoding);
         }
     } else if (enc != XML_CHAR_ENCODING_NONE) {
         xmlSwitchEncoding(ctxt, enc);
     }
 
     return(0);
 }
 
+
 /**
- * xmlCtxtUseOptions:
+ * xmlCtxtUseOptionsInternal:
  * @ctxt: an XML parser context
  * @options:  a combination of xmlParserOption
+ * @encoding:  the user provided encoding to use
  *
  * Applies the options to the parser context
  *
  * Returns 0 in case of success, the set of unknown or unimplemented options
  *         in case of error.
  */
-int
-xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
+static int
+xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options, const char *encoding)
 {
     if (ctxt == NULL)
         return(-1);
+    if (encoding != NULL) {
+        if (ctxt->encoding != NULL)
+            xmlFree((xmlChar *) ctxt->encoding);
+        ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
+    }
     if (options & XML_PARSE_RECOVER) {
         ctxt->recovery = 1;
         options -= XML_PARSE_RECOVER;
+        ctxt->options |= XML_PARSE_RECOVER;
     } else
         ctxt->recovery = 0;
     if (options & XML_PARSE_DTDLOAD) {
         ctxt->loadsubset = XML_DETECT_IDS;
         options -= XML_PARSE_DTDLOAD;
+        ctxt->options |= XML_PARSE_DTDLOAD;
     } else
         ctxt->loadsubset = 0;
     if (options & XML_PARSE_DTDATTR) {
         ctxt->loadsubset |= XML_COMPLETE_ATTRS;
         options -= XML_PARSE_DTDATTR;
+        ctxt->options |= XML_PARSE_DTDATTR;
     }
     if (options & XML_PARSE_NOENT) {
         ctxt->replaceEntities = 1;
         /* ctxt->loadsubset |= XML_DETECT_IDS; */
         options -= XML_PARSE_NOENT;
+        ctxt->options |= XML_PARSE_NOENT;
     } else
         ctxt->replaceEntities = 0;
     if (options & XML_PARSE_PEDANTIC) {
         ctxt->pedantic = 1;
         options -= XML_PARSE_PEDANTIC;
+        ctxt->options |= XML_PARSE_PEDANTIC;
     } else
         ctxt->pedantic = 0;
     if (options & XML_PARSE_NOBLANKS) {
         ctxt->keepBlanks = 0;
         ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
         options -= XML_PARSE_NOBLANKS;
+        ctxt->options |= XML_PARSE_NOBLANKS;
     } else
         ctxt->keepBlanks = 1;
     if (options & XML_PARSE_DTDVALID) {
         ctxt->validate = 1;
         if (options & XML_PARSE_NOWARNING)
             ctxt->vctxt.warning = NULL;
         if (options & XML_PARSE_NOERROR)
             ctxt->vctxt.error = NULL;
         options -= XML_PARSE_DTDVALID;
+        ctxt->options |= XML_PARSE_DTDVALID;
     } else
         ctxt->validate = 0;
     if (options & XML_PARSE_NOWARNING) {
         ctxt->sax->warning = NULL;
         options -= XML_PARSE_NOWARNING;
     }
     if (options & XML_PARSE_NOERROR) {
         ctxt->sax->error = NULL;
         ctxt->sax->fatalError = NULL;
         options -= XML_PARSE_NOERROR;
     }
 #ifdef LIBXML_SAX1_ENABLED
     if (options & XML_PARSE_SAX1) {
         ctxt->sax->startElement = xmlSAX2StartElement;
         ctxt->sax->endElement = xmlSAX2EndElement;
         ctxt->sax->startElementNs = NULL;
         ctxt->sax->endElementNs = NULL;
         ctxt->sax->initialized = 1;
         options -= XML_PARSE_SAX1;
+        ctxt->options |= XML_PARSE_SAX1;
     }
 #endif /* LIBXML_SAX1_ENABLED */
     if (options & XML_PARSE_NODICT) {
         ctxt->dictNames = 0;
         options -= XML_PARSE_NODICT;
+        ctxt->options |= XML_PARSE_NODICT;
     } else {
         ctxt->dictNames = 1;
     }
     if (options & XML_PARSE_NOCDATA) {
         ctxt->sax->cdataBlock = NULL;
         options -= XML_PARSE_NOCDATA;
+        ctxt->options |= XML_PARSE_NOCDATA;
     }
     if (options & XML_PARSE_NSCLEAN) {
         ctxt->options |= XML_PARSE_NSCLEAN;
         options -= XML_PARSE_NSCLEAN;
     }
     if (options & XML_PARSE_NONET) {
         ctxt->options |= XML_PARSE_NONET;
         options -= XML_PARSE_NONET;
     }
     if (options & XML_PARSE_COMPACT) {
         ctxt->options |= XML_PARSE_COMPACT;
         options -= XML_PARSE_COMPACT;
     }
+    if (options & XML_PARSE_OLD10) {
+        ctxt->options |= XML_PARSE_OLD10;
+        options -= XML_PARSE_OLD10;
+    }
+    if (options & XML_PARSE_NOBASEFIX) {
+        ctxt->options |= XML_PARSE_NOBASEFIX;
+        options -= XML_PARSE_NOBASEFIX;
+    }
+    if (options & XML_PARSE_HUGE) {
+        ctxt->options |= XML_PARSE_HUGE;
+        options -= XML_PARSE_HUGE;
+    }
+    if (options & XML_PARSE_OLDSAX) {
+        ctxt->options |= XML_PARSE_OLDSAX;
+        options -= XML_PARSE_OLDSAX;
+    }
     ctxt->linenumbers = 1;
     return (options);
 }
 
 /**
+ * xmlCtxtUseOptions:
+ * @ctxt: an XML parser context
+ * @options:  a combination of xmlParserOption
+ *
+ * Applies the options to the parser context
+ *
+ * Returns 0 in case of success, the set of unknown or unimplemented options
+ *         in case of error.
+ */
+int
+xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
+{
+   return(xmlCtxtUseOptionsInternal(ctxt, options, NULL));
+}
+
+/**
  * xmlDoRead:
  * @ctxt:  an XML parser context
  * @URL:  the base URL to use for the document
  * @encoding:  the document encoding, or NULL
  * @options:  a combination of xmlParserOption
  * @reuse:  keep the context for reuse
  *
  * Common front-end for the xmlRead functions
- * 
+ *
  * Returns the resulting document tree or NULL
  */
 static xmlDocPtr
 xmlDoRead(xmlParserCtxtPtr ctxt, const char *URL, const char *encoding,
           int options, int reuse)
 {
     xmlDocPtr ret;
-    
-    xmlCtxtUseOptions(ctxt, options);
+
+    xmlCtxtUseOptionsInternal(ctxt, options, encoding);
     if (encoding != NULL) {
         xmlCharEncodingHandlerPtr hdlr;
 
         hdlr = xmlFindCharEncodingHandler(encoding);
         if (hdlr != NULL)
             xmlSwitchToEncoding(ctxt, hdlr);
     }
     if ((URL != NULL) && (ctxt->input != NULL) &&
         (ctxt->input->filename == NULL))
         ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL);
@@ skipping 360 matching lines @@
     if (stream == NULL) {
         xmlFreeParserInputBuffer(input);
         return (NULL);
     }
     inputPush(ctxt, stream);
     return (xmlDoRead(ctxt, URL, encoding, options, 1));
 }
 
 #define bottom_parser
 #include "elfgcchack.h"