Roll libxml to 8effcb578e0590cc01bbcab0f9dccefc6bdbcdbd

third_party/libxml/src/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 3607 matching lines @@
         ++cmp;
         ctxt->input->col++;
     }
     if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
         /* 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 */
+    /* strings coming from the dictionary direct compare possible */
     if (ret == other) {
         return (const xmlChar*) 1;
     }
     return ret;
 }
 
 /**
  * xmlParseStringName:
  * @ctxt:  an XML parser context
  * @str:  a pointer to the string pointer (IN/OUT)
@@ skipping 5173 matching lines @@
  *                    SAX 2 specific operations                         *
  *                                                                      *
  ************************************************************************/
 
 /*
  * 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
+ * The prefix must come from the @ctxt->dict dictionary
  *
  * 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) {
@@ skipping 2371 matching lines @@
                     *lastgt = NULL;
             }
         }
     } else {
         *lastlt = NULL;
         *lastgt = NULL;
     }
 }
 /**
  * xmlCheckCdataPush:
- * @cur: pointer to the bock of characters
+ * @cur: pointer to the block of characters
  * @len: length of the block in bytes
+ * @complete: 1 if complete CDATA block is passed in, 0 if partial block
  *
  * Check that the block of characters is okay as SCdata content [20]
  *
  * Returns the number of bytes to pass if okay, a negative index where an
  *         UTF-8 error occured otherwise
  */
 static int
-xmlCheckCdataPush(const xmlChar *utf, int len) {
+xmlCheckCdataPush(const xmlChar *utf, int len, int complete) {
     int ix;
     unsigned char c;
     int codepoint;
 
     if ((utf == NULL) || (len <= 0))
         return(0);
 
     for (ix = 0; ix < len;) {      /* string is 0-terminated */
         c = utf[ix];
         if ((c & 0x80) == 0x00) {       /* 1-byte code, starts with 10 */
             if (c >= 0x20)
                 ix++;
             else if ((c == 0xA) || (c == 0xD) || (c == 0x9))
                 ix++;
             else
                 return(-ix);
         } else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */
-            if (ix + 2 > len) return(-ix);
+            if (ix + 2 > len) return(complete ? -ix : ix);
             if ((utf[ix+1] & 0xc0 ) != 0x80)
                 return(-ix);
             codepoint = (utf[ix] & 0x1f) << 6;
             codepoint |= utf[ix+1] & 0x3f;
             if (!xmlIsCharQ(codepoint))
                 return(-ix);
             ix += 2;
         } else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */
-            if (ix + 3 > len) return(-ix);
+            if (ix + 3 > len) return(complete ? -ix : ix);
             if (((utf[ix+1] & 0xc0) != 0x80) ||
                 ((utf[ix+2] & 0xc0) != 0x80))
                     return(-ix);
             codepoint = (utf[ix] & 0xf) << 12;
             codepoint |= (utf[ix+1] & 0x3f) << 6;
             codepoint |= utf[ix+2] & 0x3f;
             if (!xmlIsCharQ(codepoint))
                 return(-ix);
             ix += 3;
         } else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */
-            if (ix + 4 > len) return(-ix);
+            if (ix + 4 > len) return(complete ? -ix : ix);
             if (((utf[ix+1] & 0xc0) != 0x80) ||
                 ((utf[ix+2] & 0xc0) != 0x80) ||
                 ((utf[ix+3] & 0xc0) != 0x80))
                     return(-ix);
             codepoint = (utf[ix] & 0x7) << 18;
             codepoint |= (utf[ix+1] & 0x3f) << 12;
             codepoint |= (utf[ix+2] & 0x3f) << 6;
             codepoint |= utf[ix+3] & 0x3f;
             if (!xmlIsCharQ(codepoint))
                 return(-ix);
@@ skipping 494 matching lines @@
                  * cdataBlock merge back contiguous callbacks.
                  */
                 int base;
 
                 base = xmlParseLookupSequence(ctxt, ']', ']', '>');
                 if (base < 0) {
                     if (avail >= XML_PARSER_BIG_BUFFER_SIZE + 2) {
                         int tmp;
 
                         tmp = xmlCheckCdataPush(ctxt->input->cur,
-                                                XML_PARSER_BIG_BUFFER_SIZE);
+                                                XML_PARSER_BIG_BUFFER_SIZE, 0);
                         if (tmp < 0) {
                             tmp = -tmp;
                             ctxt->input->cur += tmp;
                             goto encoding_error;
                         }
                         if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
                             if (ctxt->sax->cdataBlock != NULL)
                                 ctxt->sax->cdataBlock(ctxt->userData,
                                                       ctxt->input->cur, tmp);
                             else if (ctxt->sax->characters != NULL)
                                 ctxt->sax->characters(ctxt->userData,
                                                       ctxt->input->cur, tmp);
                         }
                         if (ctxt->instate == XML_PARSER_EOF)
                             goto done;
                         SKIPL(tmp);
                         ctxt->checkIndex = 0;
                     }
                     goto done;
                 } else {
                     int tmp;
 
-                    tmp = xmlCheckCdataPush(ctxt->input->cur, base);
+                    tmp = xmlCheckCdataPush(ctxt->input->cur, base, 1);
                     if ((tmp < 0) || (tmp != base)) {
                         tmp = -tmp;
                         ctxt->input->cur += tmp;
                         goto encoding_error;
                     }
                     if ((ctxt->sax != NULL) && (base == 0) &&
                         (ctxt->sax->cdataBlock != NULL) &&
                         (!ctxt->disableSAX)) {
                         /*
                          * Special case to provide identical behaviour
@@ skipping 3174 matching lines @@
 /************************************************************************
  *                                                                      *
  *      New set (2.6.0) of simpler and more flexible APIs               *
  *                                                                      *
  ************************************************************************/
 
 /**
  * DICT_FREE:
  * @str:  a string
  *
- * Free a string if it is not owned by the "dict" dictionnary in the
+ * Free a string if it is not owned by the "dict" dictionary in the
  * current scope
  */
 #define DICT_FREE(str)                                          \
         if ((str) && ((!dict) ||                                \
             (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))  \
             xmlFree((char *)(str));
 
 /**
  * xmlCtxtReset:
  * @ctxt: an XML parser context
@@ skipping 763 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"