Update libxml to 2.7.7.

third_party/libxml/parserInternals.c

 /*
  * parserInternals.c : Internal routines (and obsolete ones) needed for the
  *                     XML and HTML parsers.
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
 
 #define IN_LIBXML
@@ skipping 476 matching lines @@
              * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx 
              *
              * Check for the 0x110000 limit too
              */
             cur = ctxt->input->cur;
 
             c = *cur;
             if (c & 0x80) {
                 if (c == 0xC0)
                     goto encoding_error;
-                if (cur[1] == 0)
+                if (cur[1] == 0) {
                     xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+                    cur = ctxt->input->cur;
+                }
                 if ((cur[1] & 0xc0) != 0x80)
                     goto encoding_error;
                 if ((c & 0xe0) == 0xe0) {
                     unsigned int val;
 
-                    if (cur[2] == 0)
+                    if (cur[2] == 0) {
                         xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+                        cur = ctxt->input->cur;
+                    }
                     if ((cur[2] & 0xc0) != 0x80)
                         goto encoding_error;
                     if ((c & 0xf0) == 0xf0) {
-                        if (cur[3] == 0)
+                        if (cur[3] == 0) {
                             xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+                            cur = ctxt->input->cur;
+                        }
                         if (((c & 0xf8) != 0xf0) ||
                             ((cur[3] & 0xc0) != 0x80))
                             goto encoding_error;
                         /* 4-byte code */
                         ctxt->input->cur += 4;
                         val = (cur[0] & 0x7) << 18;
                         val |= (cur[1] & 0x3f) << 12;
                         val |= (cur[2] & 0x3f) << 6;
                         val |= cur[3] & 0x3f;
                     } else {
@@ skipping 112 matching lines @@
          * Check for the 0x110000 limit too
          */
         const unsigned char *cur = ctxt->input->cur;
         unsigned char c;
         unsigned int val;
 
         c = *cur;
         if (c & 0x80) {
             if (((c & 0x40) == 0) || (c == 0xC0))
                 goto encoding_error;
-            if (cur[1] == 0)
+            if (cur[1] == 0) {
                 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+                cur = ctxt->input->cur;
+            }
             if ((cur[1] & 0xc0) != 0x80)
                 goto encoding_error;
             if ((c & 0xe0) == 0xe0) {
-                if (cur[2] == 0)
+                if (cur[2] == 0) {
                     xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+                    cur = ctxt->input->cur;
+                }
                 if ((cur[2] & 0xc0) != 0x80)
                     goto encoding_error;
                 if ((c & 0xf0) == 0xf0) {
-                    if (cur[3] == 0)
+                    if (cur[3] == 0) {
                         xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
+                        cur = ctxt->input->cur;
+                    }
                     if (((c & 0xf8) != 0xf0) ||
                         ((cur[3] & 0xc0) != 0x80))
                         goto encoding_error;
                     /* 4-byte code */
                     *len = 4;
                     val = (cur[0] & 0x7) << 18;
                     val |= (cur[1] & 0x3f) << 12;
                     val |= (cur[2] & 0x3f) << 6;
                     val |= cur[3] & 0x3f;
                     if (val < 0x10000)
@@ skipping 261 matching lines @@
     *out = (xmlChar) val;
     return 1;
 }
 
 /************************************************************************
  *                                                                      *
  *              Commodity functions to switch encodings                 *
  *                                                                      *
  ************************************************************************/
 
+/* defined in encoding.c, not public */
+int
+xmlCharEncFirstLineInt(xmlCharEncodingHandler *handler, xmlBufferPtr out,
+                       xmlBufferPtr in, int len);
+
+static int
+xmlSwitchToEncodingInt(xmlParserCtxtPtr ctxt,
+                       xmlCharEncodingHandlerPtr handler, int len);
+static int
+xmlSwitchInputEncodingInt(xmlParserCtxtPtr ctxt, xmlParserInputPtr input,
+                          xmlCharEncodingHandlerPtr handler, int len);
 /**
  * xmlSwitchEncoding:
  * @ctxt:  the parser context
  * @enc:  the encoding value (number)
  *
  * change the input functions when discovering the character encoding
  * of a given entity.
  *
  * Returns 0 in case of success, -1 otherwise
  */
 int
 xmlSwitchEncoding(xmlParserCtxtPtr ctxt, xmlCharEncoding enc)
 {
     xmlCharEncodingHandlerPtr handler;
+    int len = -1;
 
     if (ctxt == NULL) return(-1);
     switch (enc) {
         case XML_CHAR_ENCODING_ERROR:
             __xmlErrEncoding(ctxt, XML_ERR_UNKNOWN_ENCODING,
                            "encoding unknown\n", NULL, NULL);
             return(-1);
         case XML_CHAR_ENCODING_NONE:
             /* let's assume it's UTF-8 without the XML decl */
             ctxt->charset = XML_CHAR_ENCODING_UTF8;
@@ skipping 23 matching lines @@
          *So the raw UTF16 Byte Order Mark
          *has also been converted into
          *an UTF-8 BOM. Let's skip that BOM.
          */
         if ((ctxt->input != NULL) && (ctxt->input->cur != NULL) &&
             (ctxt->input->cur[0] == 0xEF) &&
             (ctxt->input->cur[1] == 0xBB) &&
             (ctxt->input->cur[2] == 0xBF)) {
             ctxt->input->cur += 3;
         }
-        break ;
-        default:
-            break;
+        len = 90;
+        break;
+    case XML_CHAR_ENCODING_UCS2:
+        len = 90;
+        break;
+    case XML_CHAR_ENCODING_UCS4BE:
+    case XML_CHAR_ENCODING_UCS4LE:
+    case XML_CHAR_ENCODING_UCS4_2143:
+    case XML_CHAR_ENCODING_UCS4_3412:
+        len = 180;
+        break;
+    case XML_CHAR_ENCODING_EBCDIC:
+    case XML_CHAR_ENCODING_8859_1:
+    case XML_CHAR_ENCODING_8859_2:
+    case XML_CHAR_ENCODING_8859_3:
+    case XML_CHAR_ENCODING_8859_4:
+    case XML_CHAR_ENCODING_8859_5:
+    case XML_CHAR_ENCODING_8859_6:
+    case XML_CHAR_ENCODING_8859_7:
+    case XML_CHAR_ENCODING_8859_8:
+    case XML_CHAR_ENCODING_8859_9:
+    case XML_CHAR_ENCODING_ASCII:
+    case XML_CHAR_ENCODING_2022_JP:
+    case XML_CHAR_ENCODING_SHIFT_JIS:
+    case XML_CHAR_ENCODING_EUC_JP:
+        len = 45;
+        break;
     }
     handler = xmlGetCharEncodingHandler(enc);
     if (handler == NULL) {
         /*
          * Default handlers.
          */
         switch (enc) {
             case XML_CHAR_ENCODING_ASCII:
                 /* default encoding, no conversion should be needed */
                 ctxt->charset = XML_CHAR_ENCODING_UTF8;
@@ skipping 70 matching lines @@
                                "encoding not supported %s\n",
                                BAD_CAST "EUC-JP", NULL);
                 break;
             default:
                 break;
         }
     }
     if (handler == NULL)
         return(-1);
     ctxt->charset = XML_CHAR_ENCODING_UTF8;
-    return(xmlSwitchToEncoding(ctxt, handler));
+    return(xmlSwitchToEncodingInt(ctxt, handler, len));
 }
 
 /**
  * xmlSwitchInputEncoding:
  * @ctxt:  the parser context
  * @input:  the input stream
  * @handler:  the encoding handler
+ * @len:  the number of bytes to convert for the first line or -1
  *
  * change the input functions when discovering the character encoding
  * of a given entity.
  *
  * Returns 0 in case of success, -1 otherwise
  */
-int
-xmlSwitchInputEncoding(xmlParserCtxtPtr ctxt, xmlParserInputPtr input,
-                       xmlCharEncodingHandlerPtr handler)
+static int
+xmlSwitchInputEncodingInt(xmlParserCtxtPtr ctxt, xmlParserInputPtr input,
+                          xmlCharEncodingHandlerPtr handler, int len)
 {
     int nbchars;
 
     if (handler == NULL)
         return (-1);
     if (input == NULL)
         return (-1);
     if (input->buf != NULL) {
         if (input->buf->encoder != NULL) {
             /*
@@ skipping 76 matching lines @@
                 nbchars = xmlCharEncInFunc(input->buf->encoder,
                                            input->buf->buffer,
                                            input->buf->raw);
             } else {
                 /*
                  * convert just enough to get
                  * '<?xml version="1.0" encoding="xxx"?>'
                  * parsed with the autodetected encoding
                  * into the parser reading buffer.
                  */
-                nbchars = xmlCharEncFirstLine(input->buf->encoder,
-                                              input->buf->buffer,
-                                              input->buf->raw);
+                nbchars = xmlCharEncFirstLineInt(input->buf->encoder,
+                                                 input->buf->buffer,
+                                                 input->buf->raw,
+                                                 len);
             }
             if (nbchars < 0) {
                 xmlErrInternal(ctxt,
                                "switching encoding: encoder error\n",
                                NULL);
                 return (-1);
             }
             input->buf->rawconsumed += use - input->buf->raw->use;
             input->base = input->cur = input->buf->buffer->content;
             input->end = &input->base[input->buf->buffer->use];
 
         }
         return (0);
     } else if (input->length == 0) {
         /*
          * When parsing a static memory array one must know the
          * size to be able to convert the buffer.
          */
         xmlErrInternal(ctxt, "switching encoding : no input\n", NULL);
         return (-1);
     }
     return (0);
 }
 
 /**
- * xmlSwitchToEncoding:
+ * xmlSwitchInputEncoding:
  * @ctxt:  the parser context
+ * @input:  the input stream
  * @handler:  the encoding handler
  *
  * change the input functions when discovering the character encoding
  * of a given entity.
  *
  * Returns 0 in case of success, -1 otherwise
  */
 int
-xmlSwitchToEncoding(xmlParserCtxtPtr ctxt, xmlCharEncodingHandlerPtr handler) 
-{
+xmlSwitchInputEncoding(xmlParserCtxtPtr ctxt, xmlParserInputPtr input,
+                          xmlCharEncodingHandlerPtr handler) {
+    return(xmlSwitchInputEncodingInt(ctxt, input, handler, -1));
+}
+
+/**
+ * xmlSwitchToEncodingInt:
+ * @ctxt:  the parser context
+ * @handler:  the encoding handler
+ * @len: the lenght to convert or -1
+ *
+ * change the input functions when discovering the character encoding
+ * of a given entity, and convert only @len bytes of the output, this
+ * is needed on auto detect to allows any declared encoding later to
+ * convert the actual content after the xmlDecl
+ *
+ * Returns 0 in case of success, -1 otherwise
+ */
+static int
+xmlSwitchToEncodingInt(xmlParserCtxtPtr ctxt,
+                       xmlCharEncodingHandlerPtr handler, int len) {
     int ret = 0;
 
     if (handler != NULL) {
         if (ctxt->input != NULL) {
-            ret = xmlSwitchInputEncoding(ctxt, ctxt->input, handler);
+            ret = xmlSwitchInputEncodingInt(ctxt, ctxt->input, handler, len);
         } else {
             xmlErrInternal(ctxt, "xmlSwitchToEncoding : no input\n",
                            NULL);
             return(-1);
         }
         /*
          * The parsing is now done in UTF8 natively
          */
         ctxt->charset = XML_CHAR_ENCODING_UTF8;
-    } else 
+    } else
         return(-1);
     return(ret);
 }
 
+/**
+ * xmlSwitchToEncoding:
+ * @ctxt:  the parser context
+ * @handler:  the encoding handler
+ *
+ * change the input functions when discovering the character encoding
+ * of a given entity.
+ *
+ * Returns 0 in case of success, -1 otherwise
+ */
+int
+xmlSwitchToEncoding(xmlParserCtxtPtr ctxt, xmlCharEncodingHandlerPtr handler) 
+{
+    return (xmlSwitchToEncodingInt(ctxt, handler, -1));
+}
+
 /************************************************************************
  *                                                                      *
  *      Commodity functions to handle entities processing               *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlFreeInputStream:
  * @input:  an xmlParserInputPtr
  *
@@ skipping 124 matching lines @@
                       "Predefined entity %s without content !\n",
                                entity->name);
                 break;
         }
         return(NULL);
     }
     input = xmlNewInputStream(ctxt);
     if (input == NULL) {
         return(NULL);
     }
-    input->filename = (char *) entity->URI;
+    if (entity->URI != NULL)
+        input->filename = (char *) xmlStrdup((xmlChar *) entity->URI);
     input->base = entity->content;
     input->cur = entity->content;
     input->length = entity->length;
     input->end = &entity->content[input->length];
     return(input);
 }
 
 /**
  * xmlNewStringInputStream:
  * @ctxt:  an XML parser context
@@ skipping 249 matching lines @@
     }
     ctxt->replaceEntities = xmlSubstituteEntitiesDefaultValue;
     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;
     xmlInitNodeInfoSeq(&ctxt->node_seq);
     return(0);
 }
 
 /**
  * xmlFreeParserCtxt:
  * @ctxt:  an XML parser context
  *
  * Free all the memory used by a parser context. However the parsed
  * document in ctxt->myDoc is not freed.
  */
 
 void
 xmlFreeParserCtxt(xmlParserCtxtPtr ctxt)
 {
     xmlParserInputPtr input;
 
     if (ctxt == NULL) return;
 
     while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
         xmlFreeInputStream(input);
     }
     if (ctxt->spaceTab != NULL) xmlFree(ctxt->spaceTab);
     if (ctxt->nameTab != NULL) xmlFree((xmlChar * *)ctxt->nameTab);
     if (ctxt->nodeTab != NULL) xmlFree(ctxt->nodeTab);
+    if (ctxt->nodeInfoTab != NULL) xmlFree(ctxt->nodeInfoTab);
     if (ctxt->inputTab != NULL) xmlFree(ctxt->inputTab);
     if (ctxt->version != NULL) xmlFree((char *) ctxt->version);
     if (ctxt->encoding != NULL) xmlFree((char *) ctxt->encoding);
     if (ctxt->extSubURI != NULL) xmlFree((char *) ctxt->extSubURI);
     if (ctxt->extSubSystem != NULL) xmlFree((char *) ctxt->extSubSystem);
 #ifdef LIBXML_SAX1_ENABLED
     if ((ctxt->sax != NULL) &&
         (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler))
 #else
     if (ctxt->sax != NULL)
@@ skipping 351 matching lines @@
  * if blanks sections are kept, indentation is not generated.
  *
  * Returns the last value for 0 for no substitution, 1 for substitution.
  */
 
 int
 xmlKeepBlanksDefault(int val) {
     int old = xmlKeepBlanksDefaultValue;
 
     xmlKeepBlanksDefaultValue = val;
-    xmlIndentTreeOutput = !val;
+    if (!val) xmlIndentTreeOutput = 1;
     return(old);
 }
 
 #define bottom_parserInternals
 #include "elfgcchack.h"