Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/HTMLparser.c

 /*
  * HTMLparser.c : an HTML 4.0 non-verifying parser
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
 
 #define IN_LIBXML
 #include "libxml.h"
@@ skipping 26 matching lines @@
 #include <libxml/xmlerror.h>
 #include <libxml/HTMLparser.h>
 #include <libxml/HTMLtree.h>
 #include <libxml/entities.h>
 #include <libxml/encoding.h>
 #include <libxml/valid.h>
 #include <libxml/xmlIO.h>
 #include <libxml/globals.h>
 #include <libxml/uri.h>
 
+#include "buf.h"
+#include "enc.h"
+
 #define HTML_MAX_NAMELEN 1000
 #define HTML_PARSER_BIG_BUFFER_SIZE 1000
 #define HTML_PARSER_BUFFER_SIZE 100
 
 /* #define DEBUG */
 /* #define DEBUG_PUSH */
 
 static int htmlOmittedDefaultValue = 1;
 
 xmlChar * htmlDecodeEntities(htmlParserCtxtPtr ctxt, int len,
@@ skipping 663 matching lines @@
 static const char* const input_attrs[] = { ATTRS, "type", "name", "value", "checked", "disabled", "readonly", "size", "maxlength", "src", "alt", "usemap", "ismap", "tabindex", "accesskey", "onfocus", "onblur", "onselect", "onchange", "accept", NULL } ;
 static const char* const prompt_attrs[] = { COREATTRS, I18N, "prompt", NULL } ;
 static const char* const label_attrs[] = { ATTRS, "for", "accesskey", "onfocus", "onblur", NULL } ;
 static const char* const legend_attrs[] = { ATTRS, "accesskey", NULL } ;
 static const char* const align_attr[] = { "align", NULL } ;
 static const char* const link_attrs[] = { ATTRS, "charset", "href", "hreflang", "type", "rel", "rev", "media", NULL } ;
 static const char* const map_contents[] = { BLOCK, "area", NULL } ;
 static const char* const name_attr[] = { "name", NULL } ;
 static const char* const action_attr[] = { "action", NULL } ;
 static const char* const blockli_elt[] = { BLOCK, "li", NULL } ;
-static const char* const meta_attrs[] = { I18N, "http-equiv", "name", "scheme", NULL } ;
+static const char* const meta_attrs[] = { I18N, "http-equiv", "name", "scheme", "charset", NULL } ;
 static const char* const content_attr[] = { "content", NULL } ;
 static const char* const type_attr[] = { "type", NULL } ;
 static const char* const noframes_content[] = { "body", FLOW MODIFIER, NULL } ;
 static const char* const object_contents[] = { FLOW, "param", NULL } ;
 static const char* const object_attrs[] = { ATTRS, "declare", "classid", "codebase", "data", "type", "codetype", "archive", "standby", "height", "width", "usemap", "name", "tabindex", NULL } ;
 static const char* const object_depr[] = { "align", "border", "hspace", "vspace", NULL } ;
 static const char* const ol_attrs[] = { "type", "compact", "start", NULL} ;
 static const char* const option_elt[] = { "option", NULL } ;
 static const char* const optgroup_attrs[] = { ATTRS, "disabled", NULL } ;
 static const char* const option_attrs[] = { ATTRS, "disabled", "label", "selected", "value", NULL } ;
@@ skipping 332 matching lines @@
 "dt",           "p", "menu", "dir", "address", "pre", "listing", "xmp",
                 "head", "dd", NULL,
 "dd",           "p", "menu", "dir", "address", "pre", "listing", "xmp",
                 "head", "dt", NULL,
 "ul",           "p", "head", "ol", "menu", "dir", "address", "pre",
                 "listing", "xmp", NULL,
 "ol",           "p", "head", "ul", NULL,
 "menu",         "p", "head", "ul", NULL,
 "p",            "p", "head", "h1", "h2", "h3", "h4", "h5", "h6", FONTSTYLE, NULL,
 "div",          "p", "head", NULL,
-"noscript",     "p", "head", NULL,
+"noscript",     "p", NULL,
 "center",       "font", "b", "i", "p", "head", NULL,
-"a",            "a", NULL,
+"a",            "a", "head", NULL,
 "caption",      "p", NULL,
 "colgroup",     "caption", "colgroup", "col", "p", NULL,
 "col",          "caption", "col", "p", NULL,
 "table",        "p", "head", "h1", "h2", "h3", "h4", "h5", "h6", "pre",
                 "listing", "xmp", "a", NULL,
 "th",           "th", "td", "p", "span", "font", "a", "b", "i", "u", NULL,
 "td",           "th", "td", "p", "span", "font", "a", "b", "i", "u", NULL,
 "tr",           "th", "td", "tr", "caption", "col", "colgroup", "p", NULL,
 "thead",        "caption", "col", "colgroup", NULL,
 "tfoot",        "th", "td", "tr", "caption", "col", "colgroup", "thead",
                 "tbody", "p", NULL,
 "tbody",        "th", "td", "tr", "caption", "col", "colgroup", "thead",
                 "tfoot", "tbody", "p", NULL,
 "optgroup",     "option", NULL,
 "option",       "option", NULL,
 "fieldset",     "legend", "p", "head", "h1", "h2", "h3", "h4", "h5", "h6",
                 "pre", "listing", "xmp", "a", NULL,
+/* most tags in in FONTSTYLE, PHRASE and SPECIAL should close <head> */
+"tt",           "head", NULL,
+"i",            "head", NULL,
+"b",            "head", NULL,
+"u",            "head", NULL,
+"s",            "head", NULL,
+"strike",       "head", NULL,
+"big",          "head", NULL,
+"small",        "head", NULL,
+
+"em",           "head", NULL,
+"strong",       "head", NULL,
+"dfn",          "head", NULL,
+"code",         "head", NULL,
+"samp",         "head", NULL,
+"kbd",          "head", NULL,
+"var",          "head", NULL,
+"cite",         "head", NULL,
+"abbr",         "head", NULL,
+"acronym",      "head", NULL,
+
+/* "a" */
+"img",          "head", NULL,
+/* "applet" */
+/* "embed" */
+/* "object" */
+"font",         "head", NULL,
+/* "basefont" */
+"br",           "head", NULL,
+/* "script" */
+"map",          "head", NULL,
+"q",            "head", NULL,
+"sub",          "head", NULL,
+"sup",          "head", NULL,
+"span",         "head", NULL,
+"bdo",          "head", NULL,
+"iframe",       "head", NULL,
 NULL
 };
 
 /*
  * The list of HTML elements which are supposed not to have
  * CDATA content and where a p element will be implied
  *
  * TODO: extend that list by reading the HTML SGML DTD on
  *       implied paragraph
  */
@@ skipping 17 matching lines @@
     "onmousemove",
     "onmouseout",
     "onkeypress",
     "onkeydown",
     "onkeyup",
     "onload",
     "onunload",
     "onfocus",
     "onblur",
     "onsubmit",
-    "onrest",
+    "onreset",
     "onchange",
     "onselect"
 };
 
 /*
  * This table is used by the htmlparser to know what to do with
  * broken html pages. By assigning different priorities to different
  * elements the parser can decide how to handle extra endtags.
  * Endtags are only allowed to close elements with lower or equal
  * priority.
@@ skipping 1729 matching lines @@
                 ctxt->sax->characters(ctxt->userData, buf, nbchar);
             }
             nbchar = 0;
         }
         GROW;
         NEXTL(l);
         cur = CUR_CHAR(l);
     }
 
     if ((!(IS_CHAR_CH(cur))) && (!((cur == 0) && (ctxt->progressive)))) {
-        htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
-                        "Invalid char in CDATA 0x%X\n", cur);
-        NEXT;
+        htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
+                    "Invalid char in CDATA 0x%X\n", cur);
+        if (ctxt->input->cur < ctxt->input->end) {
+            NEXT;
+        }
     }
 
     if ((nbchar != 0) && (ctxt->sax != NULL) && (!ctxt->disableSAX)) {
         if (ctxt->sax->cdataBlock!= NULL) {
             /*
              * Insert as CDATA, which is the same as HTML_PRESERVE_NODE
              */
             ctxt->sax->cdataBlock(ctxt->userData, buf, nbchar);
         } else if (ctxt->sax->characters != NULL) {
             ctxt->sax->characters(ctxt->userData, buf, nbchar);
@@ skipping 29 matching lines @@
                         "Invalid char in CDATA 0x%X\n", cur);
         } else {
             COPY_BUF(l,buf,nbchar,cur);
         }
         if (nbchar >= HTML_PARSER_BIG_BUFFER_SIZE) {
             /*
              * Ok the segment is to be consumed as chars.
              */
             if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
                 if (areBlanks(ctxt, buf, nbchar)) {
-                    if (ctxt->sax->ignorableWhitespace != NULL)
-                        ctxt->sax->ignorableWhitespace(ctxt->userData,
-                                                       buf, nbchar);
+                    if (ctxt->keepBlanks) {
+                        if (ctxt->sax->characters != NULL)
+                            ctxt->sax->characters(ctxt->userData, buf, nbchar);
+                    } else {
+                        if (ctxt->sax->ignorableWhitespace != NULL)
+                            ctxt->sax->ignorableWhitespace(ctxt->userData,
+                                                           buf, nbchar);
+                    }
                 } else {
                     htmlCheckParagraph(ctxt);
                     if (ctxt->sax->characters != NULL)
                         ctxt->sax->characters(ctxt->userData, buf, nbchar);
                 }
             }
             nbchar = 0;
         }
         NEXTL(l);
         chunk++;
@@ skipping 10 matching lines @@
         }
     }
     if (nbchar != 0) {
         buf[nbchar] = 0;
 
         /*
          * Ok the segment is to be consumed as chars.
          */
         if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
             if (areBlanks(ctxt, buf, nbchar)) {
-                if (ctxt->sax->ignorableWhitespace != NULL)
-                    ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
+                if (ctxt->keepBlanks) {
+                    if (ctxt->sax->characters != NULL)
+                        ctxt->sax->characters(ctxt->userData, buf, nbchar);
+                } else {
+                    if (ctxt->sax->ignorableWhitespace != NULL)
+                        ctxt->sax->ignorableWhitespace(ctxt->userData,
+                                                       buf, nbchar);
+                }
             } else {
                 htmlCheckParagraph(ctxt);
                 if (ctxt->sax->characters != NULL)
                     ctxt->sax->characters(ctxt->userData, buf, nbchar);
             }
         }
     } else {
         /*
          * Loop detection
          */
@@ skipping 281 matching lines @@
         SKIP(3);
         while (CUR != ';') {
             if ((CUR >= '0') && (CUR <= '9'))
                 val = val * 16 + (CUR - '0');
             else if ((CUR >= 'a') && (CUR <= 'f'))
                 val = val * 16 + (CUR - 'a') + 10;
             else if ((CUR >= 'A') && (CUR <= 'F'))
                 val = val * 16 + (CUR - 'A') + 10;
             else {
                 htmlParseErr(ctxt, XML_ERR_INVALID_HEX_CHARREF,
-                             "htmlParseCharRef: missing semicolumn\n",
+                             "htmlParseCharRef: missing semicolon\n",
                              NULL, NULL);
                 break;
             }
             NEXT;
         }
         if (CUR == ';')
             NEXT;
     } else if  ((CUR == '&') && (NXT(1) == '#')) {
         SKIP(2);
         while (CUR != ';') {
             if ((CUR >= '0') && (CUR <= '9'))
                 val = val * 10 + (CUR - '0');
             else {
                 htmlParseErr(ctxt, XML_ERR_INVALID_DEC_CHARREF,
-                             "htmlParseCharRef: missing semicolumn\n",
+                             "htmlParseCharRef: missing semicolon\n",
                              NULL, NULL);
                 break;
             }
             NEXT;
         }
         if (CUR == ';')
             NEXT;
     } else {
         htmlParseErr(ctxt, XML_ERR_INVALID_CHARREF,
                      "htmlParseCharRef: invalid value\n", NULL, NULL);
@@ skipping 122 matching lines @@
         NEXT;
         SKIP_BLANKS;
         val = htmlParseAttValue(ctxt);
     }
 
     *value = val;
     return(name);
 }
 
 /**
- * htmlCheckEncoding:
+ * htmlCheckEncodingDirect:
  * @ctxt:  an HTML parser context
  * @attvalue: the attribute value
  *
- * Checks an http-equiv attribute from a Meta tag to detect
+ * Checks an attribute value to detect
  * the encoding
  * If a new encoding is detected the parser is switched to decode
  * it and pass UTF8
  */
 static void
-htmlCheckEncoding(htmlParserCtxtPtr ctxt, const xmlChar *attvalue) {
-    const xmlChar *encoding;
+htmlCheckEncodingDirect(htmlParserCtxtPtr ctxt, const xmlChar *encoding) {
 
-    if ((ctxt == NULL) || (attvalue == NULL))
+    if ((ctxt == NULL) || (encoding == NULL) ||
+        (ctxt->options & HTML_PARSE_IGNORE_ENC))
         return;
 
     /* do not change encoding */
     if (ctxt->input->encoding != NULL)
         return;
 
-    encoding = xmlStrcasestr(attvalue, BAD_CAST"charset=");
-    if (encoding != NULL) {
-        encoding += 8;
-    } else {
-        encoding = xmlStrcasestr(attvalue, BAD_CAST"charset =");
-        if (encoding != NULL)
-            encoding += 9;
-    }
     if (encoding != NULL) {
         xmlCharEncoding enc;
         xmlCharEncodingHandlerPtr handler;
 
         while ((*encoding == ' ') || (*encoding == '\t')) encoding++;
 
         if (ctxt->input->encoding != NULL)
             xmlFree((xmlChar *) ctxt->input->encoding);
         ctxt->input->encoding = xmlStrdup(encoding);
 
@@ skipping 17 matching lines @@
             ctxt->charset = XML_CHAR_ENCODING_UTF8;
         } else {
             /*
              * fallback for unknown encodings
              */
             handler = xmlFindCharEncodingHandler((const char *) encoding);
             if (handler != NULL) {
                 xmlSwitchToEncoding(ctxt, handler);
                 ctxt->charset = XML_CHAR_ENCODING_UTF8;
             } else {
-                ctxt->errNo = XML_ERR_UNSUPPORTED_ENCODING;
+                htmlParseErr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
+                             "htmlCheckEncoding: unknown encoding %s\n",
+                             encoding, NULL);
             }
         }
 
         if ((ctxt->input->buf != NULL) &&
             (ctxt->input->buf->encoder != NULL) &&
             (ctxt->input->buf->raw != NULL) &&
             (ctxt->input->buf->buffer != NULL)) {
             int nbchars;
             int processed;
 
             /*
              * convert as much as possible to the parser reading buffer.
              */
             processed = ctxt->input->cur - ctxt->input->base;
-            xmlBufferShrink(ctxt->input->buf->buffer, processed);
-            nbchars = xmlCharEncInFunc(ctxt->input->buf->encoder,
-                                       ctxt->input->buf->buffer,
-                                       ctxt->input->buf->raw);
+            xmlBufShrink(ctxt->input->buf->buffer, processed);
+            nbchars = xmlCharEncInput(ctxt->input->buf, 1);
             if (nbchars < 0) {
                 htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING,
                              "htmlCheckEncoding: encoder error\n",
                              NULL, NULL);
             }
-            ctxt->input->base =
-            ctxt->input->cur = ctxt->input->buf->buffer->content;
-            ctxt->input->end =
-                          &ctxt->input->base[ctxt->input->buf->buffer->use];
+            xmlBufResetInput(ctxt->input->buf->buffer, ctxt->input);
         }
     }
 }
 
 /**
+ * htmlCheckEncoding:
+ * @ctxt:  an HTML parser context
+ * @attvalue: the attribute value
+ *
+ * Checks an http-equiv attribute from a Meta tag to detect
+ * the encoding
+ * If a new encoding is detected the parser is switched to decode
+ * it and pass UTF8
+ */
+static void
+htmlCheckEncoding(htmlParserCtxtPtr ctxt, const xmlChar *attvalue) {
+    const xmlChar *encoding;
+
+    if (!attvalue)
+        return;
+
+    encoding = xmlStrcasestr(attvalue, BAD_CAST"charset");
+    if (encoding != NULL) {
+        encoding += 7;
+    }
+    /*
+     * skip blank
+     */
+    if (encoding && IS_BLANK_CH(*encoding))
+        encoding = xmlStrcasestr(attvalue, BAD_CAST"=");
+    if (encoding && *encoding == '=') {
+        encoding ++;
+        htmlCheckEncodingDirect(ctxt, encoding);
+    }
+}
+
+/**
  * htmlCheckMeta:
  * @ctxt:  an HTML parser context
  * @atts:  the attributes values
  *
  * Checks an attributes from a Meta tag
  */
 static void
 htmlCheckMeta(htmlParserCtxtPtr ctxt, const xmlChar **atts) {
     int i;
     const xmlChar *att, *value;
     int http = 0;
     const xmlChar *content = NULL;
 
     if ((ctxt == NULL) || (atts == NULL))
         return;
 
     i = 0;
     att = atts[i++];
     while (att != NULL) {
         value = atts[i++];
         if ((value != NULL) && (!xmlStrcasecmp(att, BAD_CAST"http-equiv"))
          && (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))
             http = 1;
+        else if ((value != NULL) && (!xmlStrcasecmp(att, BAD_CAST"charset")))
+            htmlCheckEncodingDirect(ctxt, value);
         else if ((value != NULL) && (!xmlStrcasecmp(att, BAD_CAST"content")))
             content = value;
         att = atts[i++];
     }
     if ((http) && (content != NULL))
         htmlCheckEncoding(ctxt, content);
 
 }
 
 /**
@@ skipping 21 matching lines @@
     const xmlChar *name;
     const xmlChar *attname;
     xmlChar *attvalue;
     const xmlChar **atts;
     int nbatts = 0;
     int maxatts;
     int meta = 0;
     int i;
     int discardtag = 0;
 
-    if (ctxt->instate == XML_PARSER_EOF)
-        return(-1);
     if ((ctxt == NULL) || (ctxt->input == NULL)) {
         htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
                      "htmlParseStartTag: context error\n", NULL, NULL);
         return -1;
     }
+    if (ctxt->instate == XML_PARSER_EOF)
+        return(-1);
     if (CUR != '<') return -1;
     NEXT;
 
     atts = ctxt->atts;
     maxatts = ctxt->maxatts;
 
     GROW;
     name = htmlParseHTMLName(ctxt);
     if (name == NULL) {
         htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED,
@@ skipping 261 matching lines @@
         }
     }
 
     /*
      * SAX: End of Tag
      */
     oldname = ctxt->name;
     if ((oldname != NULL) && (xmlStrEqual(oldname, name))) {
         if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
             ctxt->sax->endElement(ctxt->userData, name);
+        htmlNodeInfoPop(ctxt);
         htmlnamePop(ctxt);
         ret = 1;
     } else {
         ret = 0;
     }
 
     return (ret);
 }
 
 
@@ skipping 386 matching lines @@
  *
  * [39] element ::= EmptyElemTag | STag content ETag
  *
  * [41] Attribute ::= Name Eq AttValue
  */
 
 static void
 htmlParseElementInternal(htmlParserCtxtPtr ctxt) {
     const xmlChar *name;
     const htmlElemDesc * info;
-    htmlParserNodeInfo node_info;
+    htmlParserNodeInfo node_info = { 0, };
     int failed;
 
     if ((ctxt == NULL) || (ctxt->input == NULL)) {
         htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
                      "htmlParseElementInternal: context error\n", NULL, NULL);
         return;
     }
 
     if (ctxt->instate == XML_PARSER_EOF)
         return;
@@ skipping 360 matching lines @@
     if (CUR == 0)
         htmlAutoCloseOnEnd(ctxt);
 
 
     /*
      * SAX: end of the document processing.
      */
     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
         ctxt->sax->endDocument(ctxt->userData);
 
-    if (ctxt->myDoc != NULL) {
+    if ((!(ctxt->options & HTML_PARSE_NODEFDTD)) && (ctxt->myDoc != NULL)) {
         dtd = xmlGetIntSubset(ctxt->myDoc);
         if (dtd == NULL)
             ctxt->myDoc->intSubset =
                 xmlCreateIntSubset(ctxt->myDoc, BAD_CAST "html",
                     BAD_CAST "-//W3C//DTD HTML 4.0 Transitional//EN",
                     BAD_CAST "http://www.w3.org/TR/REC-html40/loose.dtd");
     }
     if (! ctxt->wellFormed) return(-1);
     return(0);
 }
@@ skipping 184 matching lines @@
     if (buf == NULL) return(NULL);
 
     input = xmlNewInputStream(ctxt);
     if (input == NULL) {
         xmlFreeParserCtxt(ctxt);
         return(NULL);
     }
 
     input->filename = NULL;
     input->buf = buf;
-    input->base = input->buf->buffer->content;
-    input->cur = input->buf->buffer->content;
-    input->end = &input->buf->buffer->content[input->buf->buffer->use];
+    xmlBufResetInput(buf->buffer, input);
 
     inputPush(ctxt, input);
     return(ctxt);
 }
 
 /**
  * htmlCreateDocParserCtxt:
  * @cur:  a pointer to an array of xmlChar
  * @encoding:  a free form C string describing the HTML document encoding, or NULL
  *
@@ skipping 96 matching lines @@
     if (base < 0)
         return (-1);
 
     if (ctxt->checkIndex > base)
         base = ctxt->checkIndex;
 
     if (in->buf == NULL) {
         buf = in->base;
         len = in->length;
     } else {
-        buf = in->buf->buffer->content;
-        len = in->buf->buffer->use;
+        buf = xmlBufContent(in->buf->buffer);
+        len = xmlBufUse(in->buf->buffer);
     }
 
     /* take into account the sequence length */
     if (third)
         len -= 2;
     else if (next)
         len--;
     for (; base < len; base++) {
         if ((!incomment) && (base + 4 < len) && (!iscomment)) {
             if ((buf[base] == '<') && (buf[base + 1] == '!') &&
@@ skipping 71 matching lines @@
 #endif
     return (-1);
 }
 
 /**
  * htmlParseLookupChars:
  * @ctxt: an HTML parser context
  * @stop: Array of chars, which stop the lookup.
  * @stopLen: Length of stop-Array
  *
- * Try to find if any char of the stop-Array is available in the input 
+ * Try to find if any char of the stop-Array is available in the input
  * stream.
  * This function has a side effect of (possibly) incrementing ctxt->checkIndex
  * to avoid rescanning sequences of bytes, it DOES change the state of the
  * parser, do not use liberally.
  *
- * Returns the index to the current parsing point if a stopChar 
+ * Returns the index to the current parsing point if a stopChar
  *      is available, -1 otherwise.
  */
 static int
 htmlParseLookupChars(htmlParserCtxtPtr ctxt, const xmlChar * stop,
                      int stopLen)
 {
     int base, len;
     htmlParserInputPtr in;
     const xmlChar *buf;
     int incomment = 0;
     int i;
 
     in = ctxt->input;
     if (in == NULL)
         return (-1);
 
     base = in->cur - in->base;
     if (base < 0)
         return (-1);
 
     if (ctxt->checkIndex > base)
         base = ctxt->checkIndex;
 
     if (in->buf == NULL) {
         buf = in->base;
         len = in->length;
     } else {
-        buf = in->buf->buffer->content;
-        len = in->buf->buffer->use;
+        buf = xmlBufContent(in->buf->buffer);
+        len = xmlBufUse(in->buf->buffer);
     }
 
     for (; base < len; base++) {
         if (!incomment && (base + 4 < len)) {
             if ((buf[base] == '<') && (buf[base + 1] == '!') &&
                 (buf[base + 2] == '-') && (buf[base + 3] == '-')) {
                 incomment = 1;
                 /* do not increment past <! - some people use <!--> */
                 base += 2;
             }
@@ skipping 28 matching lines @@
  *
  * Returns zero if no parsing was possible
  */
 static int
 htmlParseTryOrFinish(htmlParserCtxtPtr ctxt, int terminate) {
     int ret = 0;
     htmlParserInputPtr in;
     int avail = 0;
     xmlChar cur, next;
 
+    htmlParserNodeInfo node_info;
+
 #ifdef DEBUG_PUSH
     switch (ctxt->instate) {
         case XML_PARSER_EOF:
             xmlGenericError(xmlGenericErrorContext,
                     "HPP: try EOF\n"); break;
         case XML_PARSER_START:
             xmlGenericError(xmlGenericErrorContext,
                     "HPP: try START\n"); break;
         case XML_PARSER_MISC:
             xmlGenericError(xmlGenericErrorContext,
@@ skipping 40 matching lines @@
     }
 #endif
 
     while (1) {
 
         in = ctxt->input;
         if (in == NULL) break;
         if (in->buf == NULL)
             avail = in->length - (in->cur - in->base);
         else
-            avail = in->buf->buffer->use - (in->cur - in->base);
+            avail = xmlBufUse(in->buf->buffer) - (in->cur - in->base);
         if ((avail == 0) && (terminate)) {
             htmlAutoCloseOnEnd(ctxt);
             if ((ctxt->nameNr == 0) && (ctxt->instate != XML_PARSER_EOF)) {
                 /*
                  * SAX: end of the document processing.
                  */
                 ctxt->instate = XML_PARSER_EOF;
                 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
                     ctxt->sax->endDocument(ctxt->userData);
             }
@@ skipping 15 matching lines @@
             case XML_PARSER_START:
                 /*
                  * Very first chars read from the document flow.
                  */
                 cur = in->cur[0];
                 if (IS_BLANK_CH(cur)) {
                     SKIP_BLANKS;
                     if (in->buf == NULL)
                         avail = in->length - (in->cur - in->base);
                     else
-                        avail = in->buf->buffer->use - (in->cur - in->base);
+                        avail = xmlBufUse(in->buf->buffer) - (in->cur - in->base);
                 }
                 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
                     ctxt->sax->setDocumentLocator(ctxt->userData,
                                                   &xmlDefaultSAXLocator);
                 if ((ctxt->sax) && (ctxt->sax->startDocument) &&
                     (!ctxt->disableSAX))
                     ctxt->sax->startDocument(ctxt->userData);
 
                 cur = in->cur[0];
                 next = in->cur[1];
@@ skipping 21 matching lines @@
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: entering MISC\n");
 #endif
                 }
                 break;
             case XML_PARSER_MISC:
                 SKIP_BLANKS;
                 if (in->buf == NULL)
                     avail = in->length - (in->cur - in->base);
                 else
-                    avail = in->buf->buffer->use - (in->cur - in->base);
-                if (avail < 2)
+                    avail = xmlBufUse(in->buf->buffer) - (in->cur - in->base);
+                /*
+                 * no chars in buffer
+                 */
+                if (avail < 1)
                     goto done;
+                /*
+                 * not enouth chars in buffer
+                 */
+                if (avail < 2) {
+                    if (!terminate)
+                        goto done;
+                    else
+                        next = ' ';
+                } else {
+                    next = in->cur[1];
+                }
                 cur = in->cur[0];
-                next = in->cur[1];
                 if ((cur == '<') && (next == '!') &&
                     (in->cur[2] == '-') && (in->cur[3] == '-')) {
                     if ((!terminate) &&
                         (htmlParseLookupSequence(ctxt, '-', '-', '>', 1, 1) < 0))
                         goto done;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: Parsing Comment\n");
 #endif
                     htmlParseComment(ctxt);
@@ skipping 35 matching lines @@
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: entering START_TAG\n");
 #endif
                 }
                 break;
             case XML_PARSER_PROLOG:
                 SKIP_BLANKS;
                 if (in->buf == NULL)
                     avail = in->length - (in->cur - in->base);
                 else
-                    avail = in->buf->buffer->use - (in->cur - in->base);
+                    avail = xmlBufUse(in->buf->buffer) - (in->cur - in->base);
                 if (avail < 2)
                     goto done;
                 cur = in->cur[0];
                 next = in->cur[1];
                 if ((cur == '<') && (next == '!') &&
                     (in->cur[2] == '-') && (in->cur[3] == '-')) {
                     if ((!terminate) &&
                         (htmlParseLookupSequence(ctxt, '-', '-', '>', 1, 1) < 0))
                         goto done;
 #ifdef DEBUG_PUSH
@@ skipping 20 matching lines @@
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: entering START_TAG\n");
 #endif
                 }
                 break;
             case XML_PARSER_EPILOG:
                 if (in->buf == NULL)
                     avail = in->length - (in->cur - in->base);
                 else
-                    avail = in->buf->buffer->use - (in->cur - in->base);
+                    avail = xmlBufUse(in->buf->buffer) - (in->cur - in->base);
                 if (avail < 1)
                     goto done;
                 cur = in->cur[0];
                 if (IS_BLANK_CH(cur)) {
                     htmlParseCharData(ctxt);
                     goto done;
                 }
                 if (avail < 2)
                     goto done;
                 next = in->cur[1];
@@ skipping 32 matching lines @@
                     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
                         ctxt->sax->endDocument(ctxt->userData);
                     goto done;
                 }
                 break;
             case XML_PARSER_START_TAG: {
                 const xmlChar *name;
                 int failed;
                 const htmlElemDesc * info;
 
-                if (avail < 2)
+                /*
+                 * no chars in buffer
+                 */
+                if (avail < 1)
                     goto done;
+                /*
+                 * not enouth chars in buffer
+                 */
+                if (avail < 2) {
+                    if (!terminate)
+                        goto done;
+                    else
+                        next = ' ';
+                } else {
+                    next = in->cur[1];
+                }
                 cur = in->cur[0];
                 if (cur != '<') {
                     ctxt->instate = XML_PARSER_CONTENT;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: entering CONTENT\n");
 #endif
                     break;
                 }
-                if (in->cur[1] == '/') {
+                if (next == '/') {
                     ctxt->instate = XML_PARSER_END_TAG;
                     ctxt->checkIndex = 0;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: entering END_TAG\n");
 #endif
                     break;
                 }
                 if ((!terminate) &&
                     (htmlParseLookupSequence(ctxt, '>', 0, 0, 0, 1) < 0))
                     goto done;
 
+                /* 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;
+                }
+
+
                 failed = htmlParseStartTag(ctxt);
                 name = ctxt->name;
                 if ((failed == -1) ||
                     (name == NULL)) {
                     if (CUR == '>')
                         NEXT;
                     break;
                 }
 
                 /*
@@ skipping 29 matching lines @@
                                  name, NULL);
 
                     /*
                      * end of parsing of this node.
                      */
                     if (xmlStrEqual(name, ctxt->name)) {
                         nodePop(ctxt);
                         htmlnamePop(ctxt);
                     }
 
+                    if (ctxt->record_info)
+                        htmlNodeInfoPush(ctxt, &node_info);
+
                     ctxt->instate = XML_PARSER_CONTENT;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: entering CONTENT\n");
 #endif
                     break;
                 }
 
                 /*
                  * Check for an Empty Element from DTD definition
                  */
                 if ((info != NULL) && (info->empty)) {
                     if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
                         ctxt->sax->endElement(ctxt->userData, name);
                     htmlnamePop(ctxt);
                 }
+
+                if (ctxt->record_info)
+                    htmlNodeInfoPush(ctxt, &node_info);
+
                 ctxt->instate = XML_PARSER_CONTENT;
 #ifdef DEBUG_PUSH
                 xmlGenericError(xmlGenericErrorContext,
                         "HPP: entering CONTENT\n");
 #endif
                 break;
             }
             case XML_PARSER_CONTENT: {
                 long cons;
                 /*
                  * Handle preparsed entities and charRef
                  */
                 if (ctxt->token != 0) {
                     xmlChar chr[2] = { 0 , 0 } ;
 
                     chr[0] = (xmlChar) ctxt->token;
                     htmlCheckParagraph(ctxt);
                     if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
                         ctxt->sax->characters(ctxt->userData, chr, 1);
                     ctxt->token = 0;
                     ctxt->checkIndex = 0;
                 }
                 if ((avail == 1) && (terminate)) {
                     cur = in->cur[0];
                     if ((cur != '<') && (cur != '&')) {
                         if (ctxt->sax != NULL) {
                             if (IS_BLANK_CH(cur)) {
-                                if (ctxt->sax->ignorableWhitespace != NULL)
-                                    ctxt->sax->ignorableWhitespace(
-                                            ctxt->userData, &cur, 1);
+                                if (ctxt->keepBlanks) {
+                                    if (ctxt->sax->characters != NULL)
+                                        ctxt->sax->characters(
+                                                ctxt->userData, &cur, 1);
+                                } else {
+                                    if (ctxt->sax->ignorableWhitespace != NULL)
+                                        ctxt->sax->ignorableWhitespace(
+                                                ctxt->userData, &cur, 1);
+                                }
                             } else {
                                 htmlCheckParagraph(ctxt);
                                 if (ctxt->sax->characters != NULL)
                                     ctxt->sax->characters(
                                             ctxt->userData, &cur, 1);
                             }
                         }
                         ctxt->token = 0;
                         ctxt->checkIndex = 0;
                         in->cur++;
                         break;
                     }
                 }
                 if (avail < 2)
                     goto done;
                 cur = in->cur[0];
                 next = in->cur[1];
                 cons = ctxt->nbChars;
                 if ((xmlStrEqual(ctxt->name, BAD_CAST"script")) ||
                     (xmlStrEqual(ctxt->name, BAD_CAST"style"))) {
                     /*
                      * Handle SCRIPT/STYLE separately
                      */
                     if (!terminate) {
                         int idx;
                         xmlChar val;
 
-                        idx = htmlParseLookupSequence(ctxt, '<', '/', 0, 0, 1);
+                        idx = htmlParseLookupSequence(ctxt, '<', '/', 0, 0, 0);
                         if (idx < 0)
                             goto done;
                         val = in->cur[idx + 2];
                         if (val == 0) /* bad cut of input */
                             goto done;
                     }
                     htmlParseScript(ctxt);
                     if ((cur == '<') && (next == '/')) {
                         ctxt->instate = XML_PARSER_END_TAG;
                         ctxt->checkIndex = 0;
@@ skipping 236 matching lines @@
         htmlAutoCloseOnEnd(ctxt);
         if ((ctxt->nameNr == 0) && (ctxt->instate != XML_PARSER_EOF)) {
             /*
              * SAX: end of the document processing.
              */
             ctxt->instate = XML_PARSER_EOF;
             if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
                 ctxt->sax->endDocument(ctxt->userData);
         }
     }
-    if ((ctxt->myDoc != NULL) &&
+    if ((!(ctxt->options & HTML_PARSE_NODEFDTD)) && (ctxt->myDoc != NULL) &&
         ((terminate) || (ctxt->instate == XML_PARSER_EOF) ||
          (ctxt->instate == XML_PARSER_EPILOG))) {
         xmlDtdPtr dtd;
         dtd = xmlGetIntSubset(ctxt->myDoc);
         if (dtd == NULL)
             ctxt->myDoc->intSubset =
                 xmlCreateIntSubset(ctxt->myDoc, BAD_CAST "html",
                     BAD_CAST "-//W3C//DTD HTML 4.0 Transitional//EN",
                     BAD_CAST "http://www.w3.org/TR/REC-html40/loose.dtd");
     }
@@ skipping 17 matching lines @@
 int
 htmlParseChunk(htmlParserCtxtPtr ctxt, const char *chunk, int size,
               int terminate) {
     if ((ctxt == NULL) || (ctxt->input == NULL)) {
         htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
                      "htmlParseChunk: context error\n", NULL, NULL);
         return(XML_ERR_INTERNAL_ERROR);
     }
     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;
+        size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
+        size_t cur = ctxt->input->cur - ctxt->input->base;
         int res;
 
         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];
+        xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
 #ifdef DEBUG_PUSH
         xmlGenericError(xmlGenericErrorContext, "HPP: pushed %d\n", size);
 #endif
 
 #if 0
         if ((terminate) || (ctxt->input->buf->buffer->use > 80))
             htmlParseTryOrFinish(ctxt, terminate);
 #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;
+                size_t base = xmlBufGetInputBase(in->buffer, ctxt->input);
+                size_t current = ctxt->input->cur - ctxt->input->base;
 
-                nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
+                nbchars = xmlCharEncInput(in, terminate);
                 if (nbchars < 0) {
                     htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING,
                                  "encoder error\n", NULL, NULL);
                     return(XML_ERR_INVALID_ENCODING);
                 }
+                xmlBufSetInputBaseCur(in->buffer, ctxt->input, base, current);
             }
         }
     }
     htmlParseTryOrFinish(ctxt, terminate);
     if (terminate) {
         if ((ctxt->instate != XML_PARSER_EOF) &&
             (ctxt->instate != XML_PARSER_EPILOG) &&
             (ctxt->instate != XML_PARSER_MISC)) {
             ctxt->errNo = XML_ERR_DOCUMENT_END;
             ctxt->wellFormed = 0;
@@ skipping 73 matching lines @@
         xmlFree(buf);
         return(NULL);
     }
 
     if (filename == NULL)
         inputStream->filename = NULL;
     else
         inputStream->filename = (char *)
             xmlCanonicPath((const xmlChar *) filename);
     inputStream->buf = buf;
-    inputStream->base = inputStream->buf->buffer->content;
-    inputStream->cur = inputStream->buf->buffer->content;
-    inputStream->end =
-        &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
+    xmlBufResetInput(buf->buffer, inputStream);
 
     inputPush(ctxt, inputStream);
 
     if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
         (ctxt->input->buf != NULL))  {
-        int base = ctxt->input->base - ctxt->input->buf->buffer->content;
-        int cur = ctxt->input->cur - ctxt->input->base;
+        size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
+        size_t cur = ctxt->input->cur - ctxt->input->base;
 
         xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
 
-        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];
+        xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
 #ifdef DEBUG_PUSH
         xmlGenericError(xmlGenericErrorContext, "HPP: pushed %d\n", size);
 #endif
     }
     ctxt->progressive = 1;
 
     return(ctxt);
 }
 #endif /* LIBXML_PUSH_ENABLED */
 
@@ skipping 99 matching lines @@
     xmlFree(canonicFilename);
     if (inputStream == NULL) {
         xmlFreeParserCtxt(ctxt);
         return(NULL);
     }
 
     inputPush(ctxt, inputStream);
 
     /* set encoding */
     if (encoding) {
-        content = xmlMallocAtomic (xmlStrlen(content_line) + strlen(encoding) + 1);
-        if (content) {
-            strcpy ((char *)content, (char *)content_line);
-            strcat ((char *)content, (char *)encoding);
-            htmlCheckEncoding (ctxt, content);
-            xmlFree (content);
+        size_t l = strlen(encoding);
+
+        if (l < 1000) {
+            content = xmlMallocAtomic (xmlStrlen(content_line) + l + 1);
+            if (content) {
+                strcpy ((char *)content, (char *)content_line);
+                strcat ((char *)content, (char *)encoding);
+                htmlCheckEncoding (ctxt, content);
+                xmlFree (content);
+            }
         }
     }
 
     return(ctxt);
 }
 
 /**
  * htmlSAXParseFile:
  * @filename:  the filename
  * @encoding:  a free form C string describing the HTML document encoding, or NULL
@@ skipping 256 matching lines @@
     ctxt->standalone = -1;
     ctxt->hasExternalSubset = 0;
     ctxt->hasPErefs = 0;
     ctxt->html = 1;
     ctxt->external = 0;
     ctxt->instate = XML_PARSER_START;
     ctxt->token = 0;
 
     ctxt->wellFormed = 1;
     ctxt->nsWellFormed = 1;
+    ctxt->disableSAX = 0;
     ctxt->valid = 1;
     ctxt->vctxt.userData = ctxt;
     ctxt->vctxt.error = xmlParserValidityError;
     ctxt->vctxt.warning = xmlParserValidityWarning;
     ctxt->record_info = 0;
     ctxt->nbChars = 0;
     ctxt->checkIndex = 0;
     ctxt->inSubset = 0;
     ctxt->errNo = XML_ERR_OK;
     ctxt->depth = 0;
@@ skipping 59 matching lines @@
     } else
         ctxt->recovery = 0;
     if (options & HTML_PARSE_COMPACT) {
         ctxt->options |= HTML_PARSE_COMPACT;
         options -= HTML_PARSE_COMPACT;
     }
     if (options & XML_PARSE_HUGE) {
         ctxt->options |= XML_PARSE_HUGE;
         options -= XML_PARSE_HUGE;
     }
+    if (options & HTML_PARSE_NODEFDTD) {
+        ctxt->options |= HTML_PARSE_NODEFDTD;
+        options -= HTML_PARSE_NODEFDTD;
+    }
+    if (options & HTML_PARSE_IGNORE_ENC) {
+        ctxt->options |= HTML_PARSE_IGNORE_ENC;
+        options -= HTML_PARSE_IGNORE_ENC;
+    }
+    if (options & HTML_PARSE_NOIMPLIED) {
+        ctxt->options |= HTML_PARSE_NOIMPLIED;
+        options -= HTML_PARSE_NOIMPLIED;
+    }
     ctxt->dictNames = 0;
     return (options);
 }
 
 /**
  * htmlDoRead:
  * @ctxt:  an HTML parser context
  * @URL:  the base URL to use for the document
  * @encoding:  the document encoding, or NULL
  * @options:  a combination of htmlParserOption(s)
@@ skipping 126 matching lines @@
  */
 htmlDocPtr
 htmlReadFd(int fd, const char *URL, const char *encoding, int options)
 {
     htmlParserCtxtPtr ctxt;
     xmlParserInputBufferPtr input;
     xmlParserInputPtr stream;
 
     if (fd < 0)
         return (NULL);
+    xmlInitParser();
 
     xmlInitParser();
     input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
     if (input == NULL)
         return (NULL);
     ctxt = xmlNewParserCtxt();
     if (ctxt == NULL) {
         xmlFreeParserInputBuffer(input);
         return (NULL);
     }
@@ skipping 27 matching lines @@
     htmlParserCtxtPtr ctxt;
     xmlParserInputBufferPtr input;
     xmlParserInputPtr stream;
 
     if (ioread == NULL)
         return (NULL);
     xmlInitParser();
 
     input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
                                          XML_CHAR_ENCODING_NONE);
-    if (input == NULL)
+    if (input == NULL) {
+        if (ioclose != NULL)
+            ioclose(ioctx);
         return (NULL);
+    }
     ctxt = htmlNewParserCtxt();
     if (ctxt == NULL) {
         xmlFreeParserInputBuffer(input);
         return (NULL);
     }
     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
     if (stream == NULL) {
         xmlFreeParserInputBuffer(input);
         xmlFreeParserCtxt(ctxt);
         return (NULL);
@@ skipping 18 matching lines @@
 htmlDocPtr
 htmlCtxtReadDoc(htmlParserCtxtPtr ctxt, const xmlChar * cur,
                const char *URL, const char *encoding, int options)
 {
     xmlParserInputPtr stream;
 
     if (cur == NULL)
         return (NULL);
     if (ctxt == NULL)
         return (NULL);
+    xmlInitParser();
 
     htmlCtxtReset(ctxt);
 
     stream = xmlNewStringInputStream(ctxt, cur);
     if (stream == NULL) {
         return (NULL);
     }
     inputPush(ctxt, stream);
     return (htmlDoRead(ctxt, URL, encoding, options, 1));
 }
@@ skipping 13 matching lines @@
 htmlDocPtr
 htmlCtxtReadFile(htmlParserCtxtPtr ctxt, const char *filename,
                 const char *encoding, int options)
 {
     xmlParserInputPtr stream;
 
     if (filename == NULL)
         return (NULL);
     if (ctxt == NULL)
         return (NULL);
+    xmlInitParser();
 
     htmlCtxtReset(ctxt);
 
     stream = xmlLoadExternalEntity(filename, NULL, ctxt);
     if (stream == NULL) {
         return (NULL);
     }
     inputPush(ctxt, stream);
     return (htmlDoRead(ctxt, NULL, encoding, options, 1));
 }
@@ skipping 16 matching lines @@
 htmlCtxtReadMemory(htmlParserCtxtPtr ctxt, const char *buffer, int size,
                   const char *URL, const char *encoding, int options)
 {
     xmlParserInputBufferPtr input;
     xmlParserInputPtr stream;
 
     if (ctxt == NULL)
         return (NULL);
     if (buffer == NULL)
         return (NULL);
+    xmlInitParser();
 
     htmlCtxtReset(ctxt);
 
     input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
     if (input == NULL) {
         return(NULL);
     }
 
     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
     if (stream == NULL) {
@@ skipping 22 matching lines @@
 htmlCtxtReadFd(htmlParserCtxtPtr ctxt, int fd,
               const char *URL, const char *encoding, int options)
 {
     xmlParserInputBufferPtr input;
     xmlParserInputPtr stream;
 
     if (fd < 0)
         return (NULL);
     if (ctxt == NULL)
         return (NULL);
+    xmlInitParser();
 
     htmlCtxtReset(ctxt);
 
 
     input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
     if (input == NULL)
         return (NULL);
     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
     if (stream == NULL) {
         xmlFreeParserInputBuffer(input);
@@ skipping 24 matching lines @@
               const char *URL,
               const char *encoding, int options)
 {
     xmlParserInputBufferPtr input;
     xmlParserInputPtr stream;
 
     if (ioread == NULL)
         return (NULL);
     if (ctxt == NULL)
         return (NULL);
+    xmlInitParser();
 
     htmlCtxtReset(ctxt);
 
     input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
                                          XML_CHAR_ENCODING_NONE);
-    if (input == NULL)
+    if (input == NULL) {
+        if (ioclose != NULL)
+            ioclose(ioctx);
         return (NULL);
+    }
     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
     if (stream == NULL) {
         xmlFreeParserInputBuffer(input);
         return (NULL);
     }
     inputPush(ctxt, stream);
     return (htmlDoRead(ctxt, URL, encoding, options, 1));
 }
 
 #define bottom_HTMLparser
 #include "elfgcchack.h"
 #endif /* LIBXML_HTML_ENABLED */