Update libxml to 2.7.7.

third_party/libxml/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 41 matching lines @@
 /* #define DEBUG_PUSH */
 
 static int htmlOmittedDefaultValue = 1;
 
 xmlChar * htmlDecodeEntities(htmlParserCtxtPtr ctxt, int len,
                              xmlChar end, xmlChar  end2, xmlChar end3);
 static void htmlParseComment(htmlParserCtxtPtr ctxt);
 
 /************************************************************************
  *                                                                      *
- *              Some factorized error routines                          *
+ *              Some factorized error routines                          *
  *                                                                      *
  ************************************************************************/
 
 /**
  * htmlErrMemory:
  * @ctxt:  an HTML parser context
  * @extra:  extra informations
  *
  * Handle a redefinition of attribute error
  */
@@ skipping 67 matching lines @@
         ctxt->errNo = error;
     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_HTML, error,
                     XML_ERR_ERROR, NULL, 0, NULL, NULL,
                     NULL, val, 0, msg, val);
     if (ctxt != NULL)
         ctxt->wellFormed = 0;
 }
 
 /************************************************************************
  *                                                                      *
- *              Parser stacks related functions and macros              *
+ *      Parser stacks related functions and macros              *
  *                                                                      *
  ************************************************************************/
 
 /**
  * htmlnamePush:
  * @ctxt:  an HTML parser context
  * @value:  the element name
  *
  * Pushes a new element name on top of the name stack
  *
  * Returns 0 in case of error, the index in the stack otherwise
  */
 static int
 htmlnamePush(htmlParserCtxtPtr ctxt, const xmlChar * value)
 {
+    if ((ctxt->html < 3) && (xmlStrEqual(value, BAD_CAST "head")))
+        ctxt->html = 3;
+    if ((ctxt->html < 10) && (xmlStrEqual(value, BAD_CAST "body")))
+        ctxt->html = 10;
     if (ctxt->nameNr >= ctxt->nameMax) {
         ctxt->nameMax *= 2;
         ctxt->nameTab = (const xmlChar * *)
                          xmlRealloc((xmlChar * *)ctxt->nameTab,
                                     ctxt->nameMax *
                                     sizeof(ctxt->nameTab[0]));
         if (ctxt->nameTab == NULL) {
             htmlErrMemory(ctxt, NULL);
             return (0);
         }
@@ skipping 22 matching lines @@
         return (NULL);
     if (ctxt->nameNr > 0)
         ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
     else
         ctxt->name = NULL;
     ret = ctxt->nameTab[ctxt->nameNr];
     ctxt->nameTab[ctxt->nameNr] = NULL;
     return (ret);
 }
 
+/**
+ * htmlNodeInfoPush:
+ * @ctxt:  an HTML parser context
+ * @value:  the node info
+ *
+ * Pushes a new element name on top of the node info stack
+ *
+ * Returns 0 in case of error, the index in the stack otherwise
+ */
+static int
+htmlNodeInfoPush(htmlParserCtxtPtr ctxt, htmlParserNodeInfo *value)
+{
+    if (ctxt->nodeInfoNr >= ctxt->nodeInfoMax) {
+        if (ctxt->nodeInfoMax == 0)
+                ctxt->nodeInfoMax = 5;
+        ctxt->nodeInfoMax *= 2;
+        ctxt->nodeInfoTab = (htmlParserNodeInfo *)
+                         xmlRealloc((htmlParserNodeInfo *)ctxt->nodeInfoTab,
+                                    ctxt->nodeInfoMax *
+                                    sizeof(ctxt->nodeInfoTab[0]));
+        if (ctxt->nodeInfoTab == NULL) {
+            htmlErrMemory(ctxt, NULL);
+            return (0);
+        }
+    }
+    ctxt->nodeInfoTab[ctxt->nodeInfoNr] = *value;
+    ctxt->nodeInfo = &ctxt->nodeInfoTab[ctxt->nodeInfoNr];
+    return (ctxt->nodeInfoNr++);
+}
+
+/**
+ * htmlNodeInfoPop:
+ * @ctxt:  an HTML parser context
+ *
+ * Pops the top element name from the node info stack
+ *
+ * Returns 0 in case of error, the pointer to NodeInfo otherwise
+ */
+static htmlParserNodeInfo *
+htmlNodeInfoPop(htmlParserCtxtPtr ctxt)
+{
+    if (ctxt->nodeInfoNr <= 0)
+        return (NULL);
+    ctxt->nodeInfoNr--;
+    if (ctxt->nodeInfoNr < 0)
+        return (NULL);
+    if (ctxt->nodeInfoNr > 0)
+        ctxt->nodeInfo = &ctxt->nodeInfoTab[ctxt->nodeInfoNr - 1];
+    else
+        ctxt->nodeInfo = NULL;
+    return &ctxt->nodeInfoTab[ctxt->nodeInfoNr];
+}
+
 /*
  * Macros for accessing the content. Those should be used only by the parser,
  * and not exported.
  *
  * Dirty macros, i.e. one need to make assumption on the context to use them
  *
  *   CUR_PTR return the current pointer to the xmlChar to be parsed.
  *   CUR     returns the current xmlChar value, i.e. a 8 bit value if compiled
  *           in ISO-Latin or UTF-8, and the current 16 bit value if compiled
  *           in UNICODE mode. This should be used internally by the parser
@@ skipping 38 matching lines @@
 
 #define SKIP_BLANKS htmlSkipBlankChars(ctxt)
 
 /* Inported from XML */
 
 /* #define CUR (ctxt->token ? ctxt->token : (int) (*ctxt->input->cur)) */
 #define CUR ((int) (*ctxt->input->cur))
 #define NEXT xmlNextChar(ctxt)
 
 #define RAW (ctxt->token ? -1 : (*ctxt->input->cur))
-#define NXT(val) ctxt->input->cur[(val)]
-#define CUR_PTR ctxt->input->cur
 
 
 #define NEXTL(l) do {                                                   \
     if (*(ctxt->input->cur) == '\n') {                                  \
         ctxt->input->line++; ctxt->input->col = 1;                      \
     } else ctxt->input->col++;                                          \
     ctxt->token = 0; ctxt->input->cur += l; ctxt->nbChars++;            \
   } while (0)
-    
+
 /************
     \
     if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);     \
     if (*ctxt->input->cur == '&') xmlParserHandleReference(ctxt);
  ************/
 
 #define CUR_CHAR(l) htmlCurrentChar(ctxt, &l)
 #define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
 
 #define COPY_BUF(l,b,i,v)                                               \
     if (l == 1) b[i++] = (xmlChar) v;                                   \
     else i += xmlCopyChar(l,&b[i],v)
 
 /**
+ * htmlFindEncoding:
+ * @the HTML parser context
+ *
+ * Ty to find and encoding in the current data available in the input
+ * buffer this is needed to try to switch to the proper encoding when
+ * one face a character error.
+ * That's an heuristic, since it's operating outside of parsing it could
+ * try to use a meta which had been commented out, that's the reason it
+ * should only be used in case of error, not as a default.
+ *
+ * Returns an encoding string or NULL if not found, the string need to
+ *   be freed
+ */
+static xmlChar *
+htmlFindEncoding(xmlParserCtxtPtr ctxt) {
+    const xmlChar *start, *cur, *end;
+
+    if ((ctxt == NULL) || (ctxt->input == NULL) ||
+        (ctxt->input->encoding != NULL) || (ctxt->input->buf == NULL) ||
+        (ctxt->input->buf->encoder != NULL))
+        return(NULL);
+    if ((ctxt->input->cur == NULL) || (ctxt->input->end == NULL))
+        return(NULL);
+
+    start = ctxt->input->cur;
+    end = ctxt->input->end;
+    /* we also expect the input buffer to be zero terminated */
+    if (*end != 0)
+        return(NULL);
+
+    cur = xmlStrcasestr(start, BAD_CAST "HTTP-EQUIV");
+    if (cur == NULL)
+        return(NULL);
+    cur = xmlStrcasestr(cur, BAD_CAST  "CONTENT");
+    if (cur == NULL)
+        return(NULL);
+    cur = xmlStrcasestr(cur, BAD_CAST  "CHARSET=");
+    if (cur == NULL)
+        return(NULL);
+    cur += 8;
+    start = cur;
+    while (((*cur >= 'A') && (*cur <= 'Z')) ||
+           ((*cur >= 'a') && (*cur <= 'z')) ||
+           ((*cur >= '0') && (*cur <= '9')) ||
+           (*cur == '-') || (*cur == '_') || (*cur == ':') || (*cur == '/'))
+           cur++;
+    if (cur == start)
+        return(NULL);
+    return(xmlStrndup(start, cur - start));
+}
+
+/**
  * htmlCurrentChar:
  * @ctxt:  the HTML parser context
  * @len:  pointer to the length of the char read
  *
  * The current char value, if using UTF-8 this may actually span multiple
  * bytes in the input buffer. Implement the end of line normalization:
  * 2.11 End-of-Line Handling
  * If the encoding is unspecified, in the case we find an ISO-Latin-1
  * char, then the encoding converter is plugged in automatically.
  *
  * Returns the current char value and its length
  */
 
 static int
 htmlCurrentChar(xmlParserCtxtPtr ctxt, int *len) {
     if (ctxt->instate == XML_PARSER_EOF)
         return(0);
 
     if (ctxt->token != 0) {
         *len = 0;
         return(ctxt->token);
-    }   
+    }
     if (ctxt->charset == XML_CHAR_ENCODING_UTF8) {
         /*
          * We are supposed to handle UTF8, check it's valid
          * From rfc2044: encoding of the Unicode values on UTF-8:
          *
          * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
          * 0000 0000-0000 007F   0xxxxxxx
          * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
-         * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx 
+         * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
          *
          * 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 (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;
                 } else {
                   /* 3-byte code */
                     *len = 3;
                     val = (cur[0] & 0xf) << 12;
                     val |= (cur[1] & 0x3f) << 6;
                     val |= cur[2] & 0x3f;
                 }
             } else {
               /* 2-byte code */
                 *len = 2;
                 val = (cur[0] & 0x1f) << 6;
                 val |= cur[1] & 0x3f;
             }
             if (!IS_CHAR(val)) {
                 htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
                                 "Char 0x%X out of allowed range\n", val);
-            }    
+            }
             return(val);
         } else {
+            if ((*ctxt->input->cur == 0) &&
+                (ctxt->input->cur < ctxt->input->end)) {
+                    htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
+                                "Char 0x%X out of allowed range\n", 0);
+                *len = 1;
+                return(' ');
+            }
             /* 1-byte code */
             *len = 1;
             return((int) *ctxt->input->cur);
         }
     }
     /*
      * Assume it's a fixed length encoding (1) with
      * a compatible encoding for the ASCII set, since
      * XML constructs only use < 128 chars
      */
     *len = 1;
     if ((int) *ctxt->input->cur < 0x80)
         return((int) *ctxt->input->cur);
 
     /*
      * Humm this is bad, do an automatic flow conversion
      */
-    xmlSwitchEncoding(ctxt, XML_CHAR_ENCODING_8859_1);
-    ctxt->charset = XML_CHAR_ENCODING_UTF8;
+    {
+        xmlChar * guess;
+        xmlCharEncodingHandlerPtr handler;
+
+        guess = htmlFindEncoding(ctxt);
+        if (guess == NULL) {
+            xmlSwitchEncoding(ctxt, XML_CHAR_ENCODING_8859_1);
+        } else {
+            if (ctxt->input->encoding != NULL)
+                xmlFree((xmlChar *) ctxt->input->encoding);
+            ctxt->input->encoding = guess;
+            handler = xmlFindCharEncodingHandler((const char *) guess);
+            if (handler != NULL) {
+                xmlSwitchToEncoding(ctxt, handler);
+            } else {
+                htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING,
+                             "Unsupported encoding %s", guess, NULL);
+            }
+        }
+        ctxt->charset = XML_CHAR_ENCODING_UTF8;
+    }
+
     return(xmlCurrentChar(ctxt, len));
 
 encoding_error:
     /*
      * If we detect an UTF8 error that probably mean that the
      * input encoding didn't get properly advertized in the
      * declaration header. Report the error and switch the encoding
      * to ISO-Latin-1 (if you don't like this policy, just declare the
      * encoding !)
      */
     {
         char buffer[150];
 
         if (ctxt->input->end - ctxt->input->cur >= 4) {
             snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
                             ctxt->input->cur[0], ctxt->input->cur[1],
                             ctxt->input->cur[2], ctxt->input->cur[3]);
         } else {
             snprintf(buffer, 149, "Bytes: 0x%02X\n", ctxt->input->cur[0]);
         }
         htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING,
                      "Input is not proper UTF-8, indicate encoding !\n",
                      BAD_CAST buffer, NULL);
     }
 
-    ctxt->charset = XML_CHAR_ENCODING_8859_1; 
+    ctxt->charset = XML_CHAR_ENCODING_8859_1;
     *len = 1;
     return((int) *ctxt->input->cur);
 }
 
 /**
  * htmlSkipBlankChars:
  * @ctxt:  the HTML parser context
  *
  * skip all blanks character found at that point in the input streams.
  *
@@ skipping 19 matching lines @@
         }
         res++;
     }
     return(res);
 }
 
 
 
 /************************************************************************
  *                                                                      *
- *              The list of HTML elements and their properties          *
+ *      The list of HTML elements and their properties          *
  *                                                                      *
  ************************************************************************/
 
 /*
  *  Start Tag: 1 means the start tag can be ommited
  *  End Tag:   1 means the end tag can be ommited
  *             2 means it's forbidden (empty elements)
  *             3 means the tag is stylistic and should be closed easily
  *  Depr:      this element is deprecated
  *  DTD:       1 means that this element is valid only in the Loose DTD
  *             2 means that this element is valid only in the Frameset DTD
  *
  * Name,Start Tag,End Tag,Save End,Empty,Deprecated,DTD,inline,Description
         , subElements , impliedsubelt , Attributes, userdata
  */
 
 /* Definitions and a couple of vars for HTML Elements */
 
 #define FONTSTYLE "tt", "i", "b", "u", "s", "strike", "big", "small"
 #define NB_FONTSTYLE 8
 #define PHRASE "em", "strong", "dfn", "code", "samp", "kbd", "var", "cite", "abbr", "acronym"
 #define NB_PHRASE 10
 #define SPECIAL "a", "img", "applet", "embed", "object", "font", "basefont", "br", "script", "map", "q", "sub", "sup", "span", "bdo", "iframe"
 #define NB_SPECIAL 16
-#define INLINE PCDATA FONTSTYLE PHRASE SPECIAL FORMCTRL
+#define INLINE FONTSTYLE, PHRASE, SPECIAL, FORMCTRL
 #define NB_INLINE NB_PCDATA + NB_FONTSTYLE + NB_PHRASE + NB_SPECIAL + NB_FORMCTRL
-#define BLOCK HEADING, LIST "pre", "p", "dl", "div", "center", "noscript", "noframes", "blockquote", "form", "isindex", "hr", "table", "fieldset", "address"
+#define BLOCK HEADING, LIST, "pre", "p", "dl", "div", "center", "noscript", "noframes", "blockquote", "form", "isindex", "hr", "table", "fieldset", "address"
 #define NB_BLOCK NB_HEADING + NB_LIST + 14
 #define FORMCTRL "input", "select", "textarea", "label", "button"
 #define NB_FORMCTRL 5
 #define PCDATA
 #define NB_PCDATA 0
 #define HEADING "h1", "h2", "h3", "h4", "h5", "h6"
 #define NB_HEADING 6
 #define LIST "ul", "ol", "dir", "menu"
 #define NB_LIST 4
 #define MODIFIER
@@ skipping 105 matching lines @@
 static const char* const optgroup_attrs[] = { ATTRS, "disabled", NULL } ;
 static const char* const option_attrs[] = { ATTRS, "disabled", "label", "selected", "value", NULL } ;
 static const char* const param_attrs[] = { "id", "value", "valuetype", "type", NULL } ;
 static const char* const width_attr[] = { "width", NULL } ;
 static const char* const pre_content[] = { PHRASE, "tt", "i", "b", "u", "s", "strike", "a", "br", "script", "map", "q", "span", "bdo", "iframe", NULL } ;
 static const char* const script_attrs[] = { "charset", "src", "defer", "event", "for", NULL } ;
 static const char* const language_attr[] = { "language", NULL } ;
 static const char* const select_content[] = { "optgroup", "option", NULL } ;
 static const char* const select_attrs[] = { ATTRS, "name", "size", "multiple", "disabled", "tabindex", "onfocus", "onblur", "onchange", NULL } ;
 static const char* const style_attrs[] = { I18N, "media", "title", NULL } ;
-static const char* const table_attrs[] = { ATTRS "summary", "width", "border", "frame", "rules", "cellspacing", "cellpadding", "datapagesize", NULL } ;
+static const char* const table_attrs[] = { ATTRS, "summary", "width", "border", "frame", "rules", "cellspacing", "cellpadding", "datapagesize", NULL } ;
 static const char* const table_depr[] = { "align", "bgcolor", NULL } ;
 static const char* const table_contents[] = { "caption", "col", "colgroup", "thead", "tfoot", "tbody", "tr", NULL} ;
 static const char* const tr_elt[] = { "tr", NULL } ;
 static const char* const talign_attrs[] = { ATTRS, CELLHALIGN, CELLVALIGN, NULL} ;
 static const char* const th_td_depr[] = { "nowrap", "bgcolor", "width", "height", NULL } ;
 static const char* const th_td_attr[] = { ATTRS, "abbr", "axis", "headers", "scope", "rowspan", "colspan", CELLHALIGN, CELLVALIGN, NULL } ;
 static const char* const textarea_attrs[] = { ATTRS, "name", "disabled", "readonly", "tabindex", "accesskey", "onfocus", "onblur", "onselect", "onchange", NULL } ;
 static const char* const tr_contents[] = { "th", "td", NULL } ;
 static const char* const bgcolor_attr[] = { "bgcolor", NULL } ;
 static const char* const li_elt[] = { "li", NULL } ;
@@ skipping 311 matching lines @@
 "dl",           "p", "dt", "menu", "dir", "address", "pre", "listing",
                 "xmp", "head", NULL,
 "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", NULL,
+"p",            "p", "head", "h1", "h2", "h3", "h4", "h5", "h6", FONTSTYLE, NULL,
 "div",          "p", "head", NULL,
 "noscript",     "p", "head", NULL,
 "center",       "font", "b", "i", "p", "head", NULL,
 "a",            "a", 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,      
+"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,
@@ skipping 38 matching lines @@
     "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.
- */ 
+ */
 
 typedef struct {
     const char *name;
     int priority;
 } elementPriority;
 
 static const elementPriority htmlEndPriority[] = {
     {"div",   150},
     {"td",    160},
     {"th",    160},
     {"tr",    170},
     {"thead", 180},
     {"tbody", 180},
     {"tfoot", 180},
     {"table", 190},
     {"head",  200},
     {"body",  200},
     {"html",  220},
     {NULL,    100} /* Default priority */
 };
 
 static const char** htmlStartCloseIndex[100];
 static int htmlStartCloseIndexinitialized = 0;
 
 /************************************************************************
  *                                                                      *
- *              functions to handle HTML specific data                  *
+ *      functions to handle HTML specific data                  *
  *                                                                      *
  ************************************************************************/
 
 /**
  * htmlInitAutoClose:
  *
  * Initialize the htmlStartCloseIndex for fast lookup of closing tags names.
  * This is not reentrant. Call xmlInitParser() once before processing in
  * case of use in multithreaded programs.
  */
@@ skipping 29 matching lines @@
                      sizeof(html40ElementTable[0]));i++) {
         if (!xmlStrcasecmp(tag, BAD_CAST html40ElementTable[i].name))
             return((htmlElemDescPtr) &html40ElementTable[i]);
     }
     return(NULL);
 }
 
 /**
  * htmlGetEndPriority:
  * @name: The name of the element to look up the priority for.
- * 
+ *
  * Return value: The "endtag" priority.
  **/
 static int
 htmlGetEndPriority (const xmlChar *name) {
     int i = 0;
 
     while ((htmlEndPriority[i].name != NULL) &&
            (!xmlStrEqual((const xmlChar *)htmlEndPriority[i].name, name)))
         i++;
 
@@ skipping 58 matching lines @@
     priority = htmlGetEndPriority(newtag);
 
     for (i = (ctxt->nameNr - 1); i >= 0; i--) {
 
         if (xmlStrEqual(newtag, ctxt->nameTab[i]))
             break;
         /*
          * A missplaced endtag can only close elements with lower
          * or equal priority, so if we find an element with higher
          * priority before we find an element with
-         * matching name, we just ignore this endtag 
+         * matching name, we just ignore this endtag
          */
         if (htmlGetEndPriority(ctxt->nameTab[i]) > priority)
             return;
     }
     if (i < 0)
         return;
 
     while (!xmlStrEqual(newtag, ctxt->name)) {
         info = htmlTagLookup(ctxt->name);
         if ((info != NULL) && (info->endTag == 3)) {
@@ skipping 30 matching lines @@
 /**
  * htmlAutoClose:
  * @ctxt:  an HTML parser context
  * @newtag:  The new tag name or NULL
  *
  * The HTML DTD allows a tag to implicitly close other tags.
  * The list is kept in htmlStartClose array. This function is
  * called when a new tag has been detected and generates the
  * appropriates closes if possible/needed.
  * If newtag is NULL this mean we are at the end of the resource
- * and we should check 
+ * and we should check
  */
 static void
 htmlAutoClose(htmlParserCtxtPtr ctxt, const xmlChar * newtag)
 {
     while ((newtag != NULL) && (ctxt->name != NULL) &&
            (htmlCheckAutoClose(newtag, ctxt->name))) {
         if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
             ctxt->sax->endElement(ctxt->userData, ctxt->name);
         htmlnamePop(ctxt);
     }
@@ skipping 67 matching lines @@
  * htmlCheckImplied:
  * @ctxt:  an HTML parser context
  * @newtag:  The new tag name
  *
  * The HTML DTD allows a tag to exists only implicitly
  * called when a new tag has been detected and generates the
  * appropriates implicit tags if missing
  */
 static void
 htmlCheckImplied(htmlParserCtxtPtr ctxt, const xmlChar *newtag) {
+    int i;
+
+    if (ctxt->options & HTML_PARSE_NOIMPLIED)
+        return;
     if (!htmlOmittedDefaultValue)
         return;
     if (xmlStrEqual(newtag, BAD_CAST"html"))
         return;
     if (ctxt->nameNr <= 0) {
         htmlnamePush(ctxt, BAD_CAST"html");
         if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
             ctxt->sax->startElement(ctxt->userData, BAD_CAST"html", NULL);
     }
     if ((xmlStrEqual(newtag, BAD_CAST"body")) || (xmlStrEqual(newtag, BAD_CAST"head")))
         return;
-    if ((ctxt->nameNr <= 1) && 
+    if ((ctxt->nameNr <= 1) &&
         ((xmlStrEqual(newtag, BAD_CAST"script")) ||
          (xmlStrEqual(newtag, BAD_CAST"style")) ||
          (xmlStrEqual(newtag, BAD_CAST"meta")) ||
          (xmlStrEqual(newtag, BAD_CAST"link")) ||
          (xmlStrEqual(newtag, BAD_CAST"title")) ||
          (xmlStrEqual(newtag, BAD_CAST"base")))) {
-            /* 
-             * dropped OBJECT ... i you put it first BODY will be
-             * assumed !
-             */
-            htmlnamePush(ctxt, BAD_CAST"head");
-            if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
-                ctxt->sax->startElement(ctxt->userData, BAD_CAST"head", NULL);
+        if (ctxt->html >= 3) {
+            /* we already saw or generated an <head> before */
+            return;
+        }
+        /*
+         * dropped OBJECT ... i you put it first BODY will be
+         * assumed !
+         */
+        htmlnamePush(ctxt, BAD_CAST"head");
+        if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
+            ctxt->sax->startElement(ctxt->userData, BAD_CAST"head", NULL);
     } else if ((!xmlStrEqual(newtag, BAD_CAST"noframes")) &&
                (!xmlStrEqual(newtag, BAD_CAST"frame")) &&
                (!xmlStrEqual(newtag, BAD_CAST"frameset"))) {
-        int i;
+        if (ctxt->html >= 10) {
+            /* we already saw or generated a <body> before */
+            return;
+        }
         for (i = 0;i < ctxt->nameNr;i++) {
             if (xmlStrEqual(ctxt->nameTab[i], BAD_CAST"body")) {
                 return;
             }
             if (xmlStrEqual(ctxt->nameTab[i], BAD_CAST"head")) {
                 return;
             }
         }
-            
+
         htmlnamePush(ctxt, BAD_CAST"body");
         if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL))
             ctxt->sax->startElement(ctxt->userData, BAD_CAST"body", NULL);
     }
 }
 
 /**
  * htmlCheckParagraph
  * @ctxt:  an HTML parser context
  *
@@ skipping 41 matching lines @@
  *
  * Check if an attribute is of content type Script
  *
  * Returns 1 is the attribute is a script 0 otherwise
  */
 int
 htmlIsScriptAttribute(const xmlChar *name) {
     unsigned int i;
 
     if (name == NULL)
-        return(0);
+      return(0);
     /*
      * all script attributes start with 'on'
      */
     if ((name[0] != 'o') || (name[1] != 'n'))
-        return(0);
+      return(0);
     for (i = 0;
          i < sizeof(htmlScriptAttributes)/sizeof(htmlScriptAttributes[0]);
          i++) {
         if (xmlStrEqual(name, (const xmlChar *) htmlScriptAttributes[i]))
             return(1);
     }
     return(0);
 }
 
 /************************************************************************
  *                                                                      *
- *              The list of HTML predefined entities                    *
+ *      The list of HTML predefined entities                    *
  *                                                                      *
  ************************************************************************/
 
 
 static const htmlEntityDesc  html40EntitiesTable[] = {
 /*
  * the 4 absolute ones, plus apostrophe.
  */
 { 34,   "quot", "quotation mark = APL quote, U+0022 ISOnum" },
 { 38,   "amp",  "ampersand, U+0026 ISOnum" },
@@ skipping 393 matching lines @@
         else if (d < 0xF8)  { c= d & 0x07; trailing= 3; }
         else {
             /* no chance for this in Ascii */
             *outlen = out - outstart;
             *inlen = processed - instart;
             return(-2);
         }
 
         if (inend - in < trailing) {
             break;
-        } 
+        }
 
         for ( ; trailing; trailing--) {
             if ((in >= inend) || (((d= *in++) & 0xC0) != 0x80))
                 break;
             c <<= 6;
             c |= d & 0x3F;
         }
 
         /* assertion: c is a single UTF-4 value */
         if (c < 0x80) {
@@ skipping 169 matching lines @@
     return(input);
 }
 
 
 /************************************************************************
  *                                                                      *
  *              Commodity functions, cleanup needed ?                   *
  *                                                                      *
  ************************************************************************/
 /*
- * all tags allowing pc data from the html 4.01 loose dtd 
+ * all tags allowing pc data from the html 4.01 loose dtd
  * NOTE: it might be more apropriate to integrate this information
  * into the html40ElementTable array but I don't want to risk any
  * binary incomptibility
  */
 static const char *allowPCData[] = {
     "a", "abbr", "acronym", "address", "applet", "b", "bdo", "big",
     "blockquote", "body", "button", "caption", "center", "cite", "code",
     "dd", "del", "dfn", "div", "dt", "em", "font", "form", "h1", "h2",
     "h3", "h4", "h5", "h6", "i", "iframe", "ins", "kbd", "label", "legend",
     "li", "noframes", "noscript", "object", "p", "pre", "q", "s", "samp",
@@ skipping 39 matching lines @@
         }
     }
 
     if (ctxt->node == NULL) return(0);
     lastChild = xmlGetLastChild(ctxt->node);
     while ((lastChild) && (lastChild->type == XML_COMMENT_NODE))
         lastChild = lastChild->prev;
     if (lastChild == NULL) {
         if ((ctxt->node->type != XML_ELEMENT_NODE) &&
             (ctxt->node->content != NULL)) return(0);
-        /* keep ws in constructs like ...<b> </b>... 
+        /* keep ws in constructs like ...<b> </b>...
            for all tags "b" allowing PCDATA */
         for ( i = 0; i < sizeof(allowPCData)/sizeof(allowPCData[0]); i++ ) {
             if ( xmlStrEqual(ctxt->name, BAD_CAST allowPCData[i]) ) {
                 return(0);
             }
         }
     } else if (xmlNodeIsText(lastChild)) {
         return(0);
     } else {
-        /* keep ws in constructs like <p><b>xy</b> <i>z</i><p> 
+        /* keep ws in constructs like <p><b>xy</b> <i>z</i><p>
            for all tags "p" allowing PCDATA */
         for ( i = 0; i < sizeof(allowPCData)/sizeof(allowPCData[0]); i++ ) {
             if ( xmlStrEqual(lastChild->name, BAD_CAST allowPCData[i]) ) {
                 return(0);
             }
         }
     }
     return(1);
 }
 
@@ skipping 19 matching lines @@
         htmlErrMemory(NULL, "HTML document creation failed\n");
         return(NULL);
     }
     memset(cur, 0, sizeof(xmlDoc));
 
     cur->type = XML_HTML_DOCUMENT_NODE;
     cur->version = NULL;
     cur->intSubset = NULL;
     cur->doc = cur;
     cur->name = NULL;
-    cur->children = NULL; 
+    cur->children = NULL;
     cur->extSubset = NULL;
     cur->oldNs = NULL;
     cur->encoding = NULL;
     cur->standalone = 1;
     cur->compression = 0;
     cur->ids = NULL;
     cur->refs = NULL;
     cur->_private = NULL;
     cur->charset = XML_CHAR_ENCODING_UTF8;
+    cur->properties = XML_DOC_HTML | XML_DOC_USERBUILT;
     if ((ExternalID != NULL) ||
         (URI != NULL))
         xmlCreateIntSubset(cur, BAD_CAST "html", ExternalID, URI);
     return(cur);
 }
 
 /**
  * htmlNewDoc:
  * @URI:  URI for the dtd, or NULL
  * @ExternalID:  the external ID of the DTD, or NULL
@@ skipping 37 matching lines @@
  *
  * Returns the Tag Name parsed or NULL
  */
 
 static const xmlChar *
 htmlParseHTMLName(htmlParserCtxtPtr ctxt) {
     int i = 0;
     xmlChar loc[HTML_PARSER_BUFFER_SIZE];
 
     if (!IS_ASCII_LETTER(CUR) && (CUR != '_') &&
-        (CUR != ':')) return(NULL);
+        (CUR != ':') && (CUR != '.')) return(NULL);
 
     while ((i < HTML_PARSER_BUFFER_SIZE) &&
            ((IS_ASCII_LETTER(CUR)) || (IS_ASCII_DIGIT(CUR)) ||
-           (CUR == ':') || (CUR == '-') || (CUR == '_'))) {
+           (CUR == ':') || (CUR == '-') || (CUR == '_') ||
+           (CUR == '.'))) {
         if ((CUR >= 'A') && (CUR <= 'Z')) loc[i] = CUR + 0x20;
         else loc[i] = CUR;
         i++;
-        
+
         NEXT;
     }
-    
+
     return(xmlDictLookup(ctxt->dict, loc, i));
 }
 
 
 /**
  * htmlParseHTMLName_nonInvasive:
  * @ctxt:  an HTML parser context
  *
  * parse an HTML tag or attribute name, note that we convert it to lowercase
  * since HTML names are not case-sensitive, this doesn't consume the data
  * from the stream, it's a look-ahead
  *
  * Returns the Tag Name parsed or NULL
  */
 
 static const xmlChar *
 htmlParseHTMLName_nonInvasive(htmlParserCtxtPtr ctxt) {
     int i = 0;
     xmlChar loc[HTML_PARSER_BUFFER_SIZE];
 
     if (!IS_ASCII_LETTER(NXT(1)) && (NXT(1) != '_') &&
         (NXT(1) != ':')) return(NULL);
- 
+
     while ((i < HTML_PARSER_BUFFER_SIZE) &&
            ((IS_ASCII_LETTER(NXT(1+i))) || (IS_ASCII_DIGIT(NXT(1+i))) ||
            (NXT(1+i) == ':') || (NXT(1+i) == '-') || (NXT(1+i) == '_'))) {
         if ((NXT(1+i) >= 'A') && (NXT(1+i) <= 'Z')) loc[i] = NXT(1+i) + 0x20;
         else loc[i] = NXT(1+i);
         i++;
     }
-    
+
     return(xmlDictLookup(ctxt->dict, loc, i));
 }
 
 
 /**
  * htmlParseName:
  * @ctxt:  an HTML parser context
  *
  * parse an HTML name, this routine is case sensitive.
  *
@@ skipping 47 matching lines @@
     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 == ':') || 
+            (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));
 }
 
 
 /**
  * htmlParseHTMLAttribute:
  * @ctxt:  an HTML parser context
  * @stop:  a char stop value
- * 
+ *
  * parse an HTML attribute value till the stop (quote), if
  * stop is 0 then it stops at the first space
  *
  * Returns the attribute parsed or NULL
  */
 
 static xmlChar *
 htmlParseHTMLAttribute(htmlParserCtxtPtr ctxt, const xmlChar stop) {
     xmlChar *buffer = NULL;
     int buffer_size = 0;
@@ skipping 24 matching lines @@
                 unsigned int c;
                 int bits;
 
                 c = htmlParseCharRef(ctxt);
                 if      (c <    0x80)
                         { *out++  = c;                bits= -6; }
                 else if (c <   0x800)
                         { *out++  =((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
                 else if (c < 0x10000)
                         { *out++  =((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
-                else                 
+                else
                         { *out++  =((c >> 18) & 0x07) | 0xF0;  bits= 12; }
-         
+
                 for ( ; bits >= 0; bits-= 6) {
                     *out++  = ((c >> bits) & 0x3F) | 0x80;
                 }
-                
+
                 if (out - buffer > buffer_size - 100) {
                         int indx = out - buffer;
 
                         growBuffer(buffer);
                         out = &buffer[indx];
                 }
             } else {
                 ent = htmlParseEntityRef(ctxt, &name);
                 if (name == NULL) {
                     *out++ = '&';
@@ skipping 25 matching lines @@
                         growBuffer(buffer);
                         out = &buffer[indx];
                     }
                     c = ent->value;
                     if      (c <    0x80)
                         { *out++  = c;                bits= -6; }
                     else if (c <   0x800)
                         { *out++  =((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
                     else if (c < 0x10000)
                         { *out++  =((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
-                    else                 
+                    else
                         { *out++  =((c >> 18) & 0x07) | 0xF0;  bits= 12; }
-             
+
                     for ( ; bits >= 0; bits-= 6) {
                         *out++  = ((c >> bits) & 0x3F) | 0x80;
                     }
                 }
             }
         } else {
             unsigned int c;
             int bits, l;
 
             if (out - buffer > buffer_size - 100) {
                 int indx = out - buffer;
 
                 growBuffer(buffer);
                 out = &buffer[indx];
             }
             c = CUR_CHAR(l);
             if      (c <    0x80)
                     { *out++  = c;                bits= -6; }
             else if (c <   0x800)
                     { *out++  =((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
             else if (c < 0x10000)
                     { *out++  =((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
-            else                 
+            else
                     { *out++  =((c >> 18) & 0x07) | 0xF0;  bits= 12; }
-     
+
             for ( ; bits >= 0; bits-= 6) {
                 *out++  = ((c >> bits) & 0x3F) | 0x80;
             }
             NEXT;
         }
     }
-    *out++ = 0;
+    *out = 0;
     return(buffer);
 }
 
 /**
  * htmlParseEntityRef:
  * @ctxt:  an HTML parser context
  * @str:  location to store the entity name
  *
  * parse an HTML ENTITY references
  *
@@ skipping 40 matching lines @@
     return(ent);
 }
 
 /**
  * htmlParseAttValue:
  * @ctxt:  an HTML parser context
  *
  * parse a value for an attribute
  * Note: the parser won't do substitution of entities here, this
  * will be handled later in xmlStringGetNodeList, unless it was
- * asked for ctxt->replaceEntities != 0 
+ * asked for ctxt->replaceEntities != 0
  *
  * Returns the AttValue parsed or NULL.
  */
 
 static xmlChar *
 htmlParseAttValue(htmlParserCtxtPtr ctxt) {
     xmlChar *ret = NULL;
 
     if (CUR == '"') {
         NEXT;
@@ skipping 20 matching lines @@
             htmlParseErr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
                          "AttValue: no value found\n", NULL, NULL);
         }
     }
     return(ret);
 }
 
 /**
  * htmlParseSystemLiteral:
  * @ctxt:  an HTML parser context
- * 
+ *
  * parse an HTML Literal
  *
  * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
  *
  * Returns the SystemLiteral parsed or NULL
  */
 
 static xmlChar *
 htmlParseSystemLiteral(htmlParserCtxtPtr ctxt) {
     const xmlChar *q;
@@ skipping 20 matching lines @@
             htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED,
                          "Unfinished SystemLiteral\n", NULL, NULL);
         } else {
             ret = xmlStrndup(q, CUR_PTR - q);
             NEXT;
         }
     } else {
         htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_STARTED,
                      " or ' expected\n", NULL, NULL);
     }
-    
+
     return(ret);
 }
 
 /**
  * htmlParsePubidLiteral:
  * @ctxt:  an HTML parser context
  *
  * parse an HTML public literal
  *
  * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
@@ skipping 28 matching lines @@
             htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED,
                          "Unfinished PubidLiteral\n", NULL, NULL);
         } else {
             ret = xmlStrndup(q, CUR_PTR - q);
             NEXT;
         }
     } else {
         htmlParseErr(ctxt, XML_ERR_LITERAL_NOT_STARTED,
                      "PubidLiteral \" or ' expected\n", NULL, NULL);
     }
-    
+
     return(ret);
 }
 
 /**
  * htmlParseScript:
  * @ctxt:  an HTML parser context
  *
  * parse the content of an HTML SCRIPT or STYLE element
  * http://www.w3.org/TR/html4/sgml/dtd.html#Script
  * http://www.w3.org/TR/html4/sgml/dtd.html#StyleSheet
@@ skipping 26 matching lines @@
              * Authors should therefore escape "</" within the content.
              * Escape mechanisms are specific to each scripting or
              * style sheet language.
              *
              * In recovery mode, only break if end tag match the
              * current tag, effectively ignoring all tags inside the
              * script/style block and treating the entire block as
              * CDATA.
              */
             if (ctxt->recovery) {
-                if (xmlStrncasecmp(ctxt->name, ctxt->input->cur+2, 
-                                   xmlStrlen(ctxt->name)) == 0) 
+                if (xmlStrncasecmp(ctxt->name, ctxt->input->cur+2,
+                                   xmlStrlen(ctxt->name)) == 0)
                 {
                     break; /* while */
                 } else {
                     htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
                                  "Element %s embeds close tag\n",
                                  ctxt->name, NULL);
                 }
             } else {
                 if (((NXT(2) >= 'A') && (NXT(2) <= 'Z')) ||
-                    ((NXT(2) >= 'a') && (NXT(2) <= 'z'))) 
+                    ((NXT(2) >= 'a') && (NXT(2) <= 'z')))
                 {
                     break; /* while */
                 }
             }
         }
         COPY_BUF(l,buf,nbchar,cur);
         if (nbchar >= HTML_PARSER_BIG_BUFFER_SIZE) {
             if (ctxt->sax->cdataBlock!= NULL) {
                 /*
                  * Insert as CDATA, which is the same as HTML_PRESERVE_NODE
@@ skipping 36 matching lines @@
  * if we are within a CDATA section ']]>' marks an end of section.
  *
  * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
  */
 
 static void
 htmlParseCharData(htmlParserCtxtPtr ctxt) {
     xmlChar buf[HTML_PARSER_BIG_BUFFER_SIZE + 5];
     int nbchar = 0;
     int cur, l;
+    int chunk = 0;
 
     SHRINK;
     cur = CUR_CHAR(l);
     while (((cur != '<') || (ctxt->token == '<')) &&
-           ((cur != '&') || (ctxt->token == '&')) && 
+           ((cur != '&') || (ctxt->token == '&')) &&
            (cur != 0)) {
         if (!(IS_CHAR(cur))) {
             htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,
                         "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);
                 } else {
                     htmlCheckParagraph(ctxt);
                     if (ctxt->sax->characters != NULL)
                         ctxt->sax->characters(ctxt->userData, buf, nbchar);
                 }
             }
             nbchar = 0;
         }
         NEXTL(l);
+        chunk++;
+        if (chunk > HTML_PARSER_BUFFER_SIZE) {
+            chunk = 0;
+            SHRINK;
+            GROW;
+        }
         cur = CUR_CHAR(l);
         if (cur == 0) {
             SHRINK;
             GROW;
             cur = CUR_CHAR(l);
         }
     }
     if (nbchar != 0) {
         buf[nbchar] = 0;
 
@@ skipping 174 matching lines @@
                 /*
                  * SAX: PI detected.
                  */
                 if ((ctxt->sax) && (!ctxt->disableSAX) &&
                     (ctxt->sax->processingInstruction != NULL))
                     ctxt->sax->processingInstruction(ctxt->userData,
                                                      target, buf);
             }
             xmlFree(buf);
         } else {
-            htmlParseErr(ctxt, XML_ERR_PI_NOT_STARTED, 
+            htmlParseErr(ctxt, XML_ERR_PI_NOT_STARTED,
                          "PI is not started correctly", NULL, NULL);
         }
         ctxt->instate = state;
     }
 }
 
 /**
  * htmlParseComment:
  * @ctxt:  an HTML parser context
  *
@@ skipping 95 matching lines @@
     if ((ctxt == NULL) || (ctxt->input == NULL)) {
         htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
                      "htmlParseCharRef: context error\n",
                      NULL, NULL);
         return(0);
     }
     if ((CUR == '&') && (NXT(1) == '#') &&
         ((NXT(2) == 'x') || NXT(2) == 'X')) {
         SKIP(3);
         while (CUR != ';') {
-            if ((CUR >= '0') && (CUR <= '9')) 
+            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",
                              NULL, NULL);
                 break;
             }
             NEXT;
         }
         if (CUR == ';')
             NEXT;
     } else if  ((CUR == '&') && (NXT(1) == '#')) {
         SKIP(2);
         while (CUR != ';') {
-            if ((CUR >= '0') && (CUR <= '9')) 
+            if ((CUR >= '0') && (CUR <= '9'))
                 val = val * 10 + (CUR - '0');
             else {
                 htmlParseErr(ctxt, XML_ERR_INVALID_DEC_CHARREF,
                              "htmlParseCharRef: missing semicolumn\n",
                              NULL, NULL);
                 break;
             }
             NEXT;
         }
         if (CUR == ';')
@@ skipping 15 matching lines @@
     return(0);
 }
 
 
 /**
  * htmlParseDocTypeDecl:
  * @ctxt:  an HTML parser context
  *
  * parse a DOCTYPE declaration
  *
- * [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? 
+ * [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S?
  *                      ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
  */
 
 static void
 htmlParseDocTypeDecl(htmlParserCtxtPtr ctxt) {
     const xmlChar *name;
     xmlChar *ExternalID = NULL;
     xmlChar *URI = NULL;
 
     /*
@@ skipping 83 matching lines @@
     }
 
     /*
      * read the value
      */
     SKIP_BLANKS;
     if (CUR == '=') {
         NEXT;
         SKIP_BLANKS;
         val = htmlParseAttValue(ctxt);
-    } else if (htmlIsBooleanAttr(name)) {
-        /*
-         * assume a minimized attribute
-         */
-        val = xmlStrdup(name);
     }
 
     *value = val;
     return(name);
 }
 
 /**
  * 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 ((ctxt == NULL) || (attvalue == NULL))
         return;
 
-    /* do not change encoding */        
+    /* 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);
 
         enc = xmlParseCharEncoding((const char *) encoding);
         /*
          * registered set of known encodings
          */
         if (enc != XML_CHAR_ENCODING_ERROR) {
-            if (((enc == XML_CHAR_ENCODING_UTF16LE) || 
+            if (((enc == XML_CHAR_ENCODING_UTF16LE) ||
                  (enc == XML_CHAR_ENCODING_UTF16BE) ||
                  (enc == XML_CHAR_ENCODING_UCS4LE) ||
                  (enc == XML_CHAR_ENCODING_UCS4BE)) &&
                 (ctxt->input->buf != NULL) &&
                 (ctxt->input->buf->encoder == NULL)) {
                 htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING,
                              "htmlCheckEncoding: wrong encoding meta\n",
                              NULL, NULL);
             } else {
                 xmlSwitchEncoding(ctxt, enc);
@@ skipping 27 matching lines @@
             nbchars = xmlCharEncInFunc(ctxt->input->buf->encoder,
                                        ctxt->input->buf->buffer,
                                        ctxt->input->buf->raw);
             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];
         }
     }
 }
 
 /**
  * htmlCheckMeta:
  * @ctxt:  an HTML parser context
  * @atts:  the attributes values
  *
  * Checks an attributes from a Meta tag
@@ skipping 20 matching lines @@
         att = atts[i++];
     }
     if ((http) && (content != NULL))
         htmlCheckEncoding(ctxt, content);
 
 }
 
 /**
  * htmlParseStartTag:
  * @ctxt:  an HTML parser context
- * 
+ *
  * parse a start of tag either for rule element or
  * EmptyElement. In both case we don't parse the tag closing chars.
  *
  * [40] STag ::= '<' Name (S Attribute)* S? '>'
  *
  * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
  *
  * With namespace:
  *
  * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
  *
  * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
  *
  * Returns 0 in case of success, -1 in case of error and 1 if discarded
  */
 
 static int
 htmlParseStartTag(htmlParserCtxtPtr ctxt) {
     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 (CUR != '<') return -1;
     NEXT;
 
     atts = ctxt->atts;
     maxatts = ctxt->maxatts;
 
     GROW;
     name = htmlParseHTMLName(ctxt);
     if (name == NULL) {
         htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED,
                      "htmlParseStartTag: invalid element name\n",
                      NULL, NULL);
         /* Dump the bogus tag like browsers do */
-        while ((IS_CHAR_CH(CUR)) && (CUR != '>'))
+        while ((IS_CHAR_CH(CUR)) && (CUR != '>') &&
+               (ctxt->instate != XML_PARSER_EOF))
             NEXT;
         return -1;
     }
     if (xmlStrEqual(name, BAD_CAST"meta"))
         meta = 1;
 
     /*
      * Check for auto-closure of HTML elements.
      */
     htmlAutoClose(ctxt, name);
 
     /*
      * Check for implied HTML elements.
      */
     htmlCheckImplied(ctxt, name);
 
     /*
      * Avoid html at any level > 0, head at any level != 1
      * or any attempt to recurse body
      */
     if ((ctxt->nameNr > 0) && (xmlStrEqual(name, BAD_CAST"html"))) {
         htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
                      "htmlParseStartTag: misplaced <html> tag\n",
                      name, NULL);
         discardtag = 1;
+        ctxt->depth++;
     }
-    if ((ctxt->nameNr != 1) && 
+    if ((ctxt->nameNr != 1) &&
         (xmlStrEqual(name, BAD_CAST"head"))) {
         htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
                      "htmlParseStartTag: misplaced <head> tag\n",
                      name, NULL);
         discardtag = 1;
+        ctxt->depth++;
     }
     if (xmlStrEqual(name, BAD_CAST"body")) {
         int indx;
         for (indx = 0;indx < ctxt->nameNr;indx++) {
             if (xmlStrEqual(ctxt->nameTab[indx], BAD_CAST"body")) {
                 htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
                              "htmlParseStartTag: misplaced <body> tag\n",
                              name, NULL);
                 discardtag = 1;
+                ctxt->depth++;
             }
         }
     }
 
     /*
      * Now parse the attributes, it ends up with the ending
      *
      * (S Attribute)* S?
      */
     SKIP_BLANKS;
     while ((IS_CHAR_CH(CUR)) &&
-           (CUR != '>') && 
+           (CUR != '>') &&
            ((CUR != '/') || (NXT(1) != '>'))) {
         long cons = ctxt->nbChars;
 
         GROW;
         attname = htmlParseAttribute(ctxt, &attvalue);
         if (attname != NULL) {
 
             /*
              * Well formedness requires at most one declaration of an attribute
              */
@@ skipping 118 matching lines @@
     if ((CUR != '<') || (NXT(1) != '/')) {
         htmlParseErr(ctxt, XML_ERR_LTSLASH_REQUIRED,
                      "htmlParseEndTag: '</' not found\n", NULL, NULL);
         return (0);
     }
     SKIP(2);
 
     name = htmlParseHTMLName(ctxt);
     if (name == NULL)
         return (0);
-
     /*
      * We should definitely be at the ending "S? '>'" part
      */
     SKIP_BLANKS;
     if ((!IS_CHAR_CH(CUR)) || (CUR != '>')) {
         htmlParseErr(ctxt, XML_ERR_GT_REQUIRED,
                      "End tag : expected '>'\n", NULL, NULL);
         if (ctxt->recovery) {
             /*
              * We're not at the ending > !!
              * Error, unless in recover mode where we search forwards
              * until we find a >
              */
             while (CUR != '\0' && CUR != '>') NEXT;
             NEXT;
         }
     } else
         NEXT;
 
     /*
+     * if we ignored misplaced tags in htmlParseStartTag don't pop them
+     * out now.
+     */
+    if ((ctxt->depth > 0) &&
+        (xmlStrEqual(name, BAD_CAST "html") ||
+         xmlStrEqual(name, BAD_CAST "body") ||
+         xmlStrEqual(name, BAD_CAST "head"))) {
+        ctxt->depth--;
+        return (0);
+    }
+
+    /*
      * If the name read is not one of the element in the parsing stack
      * then return, it's just an error.
      */
     for (i = (ctxt->nameNr - 1); i >= 0; i--) {
         if (xmlStrEqual(name, ctxt->nameTab[i]))
             break;
     }
     if (i < 0) {
         htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
                      "Unexpected end tag : %s\n", name, NULL);
@@ skipping 33 matching lines @@
         ret = 0;
     }
 
     return (ret);
 }
 
 
 /**
  * htmlParseReference:
  * @ctxt:  an HTML parser context
- * 
+ *
  * parse and handle entity references in content,
  * this will end-up in a call to character() since this is either a
  * CharRef, or a predefined entity.
  */
 static void
 htmlParseReference(htmlParserCtxtPtr ctxt) {
     const htmlEntityDesc * ent;
     xmlChar out[6];
     const xmlChar *name;
     if (CUR != '&') return;
 
     if (NXT(1) == '#') {
         unsigned int c;
         int bits, i = 0;
 
         c = htmlParseCharRef(ctxt);
         if (c == 0)
             return;
 
         if      (c <    0x80) { out[i++]= c;                bits= -6; }
         else if (c <   0x800) { out[i++]=((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
         else if (c < 0x10000) { out[i++]=((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
         else                  { out[i++]=((c >> 18) & 0x07) | 0xF0;  bits= 12; }
- 
+
         for ( ; bits >= 0; bits-= 6) {
             out[i++]= ((c >> bits) & 0x3F) | 0x80;
         }
         out[i] = 0;
 
         htmlCheckParagraph(ctxt);
         if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
             ctxt->sax->characters(ctxt->userData, out, i);
     } else {
         ent = htmlParseEntityRef(ctxt, &name);
@@ skipping 14 matching lines @@
             unsigned int c;
             int bits, i = 0;
 
             c = ent->value;
             if      (c <    0x80)
                     { out[i++]= c;                bits= -6; }
             else if (c <   0x800)
                     { out[i++]=((c >>  6) & 0x1F) | 0xC0;  bits=  0; }
             else if (c < 0x10000)
                     { out[i++]=((c >> 12) & 0x0F) | 0xE0;  bits=  6; }
-            else                 
+            else
                     { out[i++]=((c >> 18) & 0x07) | 0xF0;  bits= 12; }
-     
+
             for ( ; bits >= 0; bits-= 6) {
                 out[i++]= ((c >> bits) & 0x3F) | 0x80;
             }
             out[i] = 0;
 
             htmlCheckParagraph(ctxt);
             if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
                 ctxt->sax->characters(ctxt->userData, out, i);
         }
     }
 }
 
 /**
  * htmlParseContent:
  * @ctxt:  an HTML parser context
  *
  * Parse a content: comment, sub-element, reference or text.
+ * Kept for compatibility with old code
  */
 
 static void
 htmlParseContent(htmlParserCtxtPtr ctxt) {
     xmlChar *currentNode;
     int depth;
     const xmlChar *name;
 
     currentNode = xmlStrdup(ctxt->name);
     depth = ctxt->nameNr;
     while (1) {
         long cons = ctxt->nbChars;
 
         GROW;
+
+        if (ctxt->instate == XML_PARSER_EOF)
+            break;
+
         /*
          * Our tag or one of it's parent or children is ending.
          */
         if ((CUR == '<') && (NXT(1) == '/')) {
             if (htmlParseEndTag(ctxt) &&
                 ((currentNode != NULL) || (ctxt->nameNr == 0))) {
                 if (currentNode != NULL)
                     xmlFree(currentNode);
                 return;
             }
             continue; /* while */
         }
 
         else if ((CUR == '<') &&
                  ((IS_ASCII_LETTER(NXT(1))) ||
                   (NXT(1) == '_') || (NXT(1) == ':'))) {
             name = htmlParseHTMLName_nonInvasive(ctxt);
             if (name == NULL) {
                 htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED,
                          "htmlParseStartTag: invalid element name\n",
                          NULL, NULL);
                 /* Dump the bogus tag like browsers do */
-                while ((IS_CHAR_CH(CUR)) && (CUR != '>'))
+        while ((IS_CHAR_CH(CUR)) && (CUR != '>'))
                     NEXT;
 
                 if (currentNode != NULL)
                     xmlFree(currentNode);
                 return;
             }
 
             if (ctxt->name != NULL) {
                 if (htmlCheckAutoClose(name, ctxt->name) == 1) {
                     htmlAutoClose(ctxt, name);
                     continue;
                 }
-            }     
+            }
         }
 
         /*
          * Has this node been popped out during parsing of
          * the next element
          */
         if ((ctxt->nameNr > 0) && (depth >= ctxt->nameNr) &&
             (!xmlStrEqual(currentNode, ctxt->name)))
              {
             if (currentNode != NULL) xmlFree(currentNode);
@@ skipping 38 matching lines @@
 
             /*
              * Third case :  a sub-element.
              */
             else if (CUR == '<') {
                 htmlParseElement(ctxt);
             }
 
             /*
              * Fourth case : a reference. If if has not been resolved,
-             *    parsing returns it's Name, create the node 
+             *    parsing returns it's Name, create the node
              */
             else if (CUR == '&') {
                 htmlParseReference(ctxt);
             }
 
             /*
              * Fifth case : end of the resource
              */
             else if (CUR == 0) {
                 htmlAutoCloseOnEnd(ctxt);
@@ skipping 15 matching lines @@
                 }
                 break;
             }
         }
         GROW;
     }
     if (currentNode != NULL) xmlFree(currentNode);
 }
 
 /**
- * htmlParseContent:
- * @ctxt:  an HTML parser context
- *
- * Parse a content: comment, sub-element, reference or text.
- */
-
-void
-__htmlParseContent(void *ctxt) {
-    if (ctxt != NULL)
-        htmlParseContent((htmlParserCtxtPtr) ctxt);
-}
-
-/**
  * htmlParseElement:
  * @ctxt:  an HTML parser context
  *
  * parse an HTML element, this is highly recursive
+ * this is kept for compatibility with previous code versions
  *
  * [39] element ::= EmptyElemTag | STag content ETag
  *
  * [41] Attribute ::= Name Eq AttValue
  */
 
 void
 htmlParseElement(htmlParserCtxtPtr ctxt) {
     const xmlChar *name;
     xmlChar *currentNode = NULL;
     const htmlElemDesc * info;
     htmlParserNodeInfo node_info;
     int failed;
     int depth;
     const xmlChar *oldptr;
 
     if ((ctxt == NULL) || (ctxt->input == NULL)) {
         htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
                      "htmlParseElement: context error\n", NULL, NULL);
         return;
     }
+
+    if (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;
     }
 
     failed = htmlParseStartTag(ctxt);
     name = ctxt->name;
     if ((failed == -1) || (name == NULL)) {
@@ skipping 24 matching lines @@
 
     if (CUR == '>') {
         NEXT;
     } else {
         htmlParseErr(ctxt, XML_ERR_GT_REQUIRED,
                      "Couldn't find end of Start Tag %s\n", name, NULL);
 
         /*
          * end of parsing of this node.
          */
-        if (xmlStrEqual(name, ctxt->name)) { 
+        if (xmlStrEqual(name, ctxt->name)) {
             nodePop(ctxt);
             htmlnamePop(ctxt);
-        }    
+        }
 
         /*
          * Capture end position and add node
          */
         if (ctxt->record_info) {
            node_info.end_pos = ctxt->input->consumed +
                               (CUR_PTR - ctxt->input->base);
            node_info.end_line = ctxt->input->line;
            node_info.node = ctxt->node;
            xmlParserAddNodeInfo(ctxt, &node_info);
@@ skipping 13 matching lines @@
 
     /*
      * Parse the content of the element:
      */
     currentNode = xmlStrdup(ctxt->name);
     depth = ctxt->nameNr;
     while (IS_CHAR_CH(CUR)) {
         oldptr = ctxt->input->cur;
         htmlParseContent(ctxt);
         if (oldptr==ctxt->input->cur) break;
-        if (ctxt->nameNr < depth) break; 
-    }   
+        if (ctxt->nameNr < depth) break;
+    }
 
     /*
      * Capture end position and add node
      */
     if ( currentNode != NULL && ctxt->record_info ) {
        node_info.end_pos = ctxt->input->consumed +
                           (CUR_PTR - ctxt->input->base);
        node_info.end_line = ctxt->input->line;
        node_info.node = ctxt->node;
        xmlParserAddNodeInfo(ctxt, &node_info);
     }
     if (!IS_CHAR_CH(CUR)) {
         htmlAutoCloseOnEnd(ctxt);
     }
 
     if (currentNode != NULL)
         xmlFree(currentNode);
 }
 
+static void
+htmlParserFinishElementParsing(htmlParserCtxtPtr ctxt) {
+    /*
+     * Capture end position and add node
+     */
+    if ( ctxt->node != NULL && ctxt->record_info ) {
+       ctxt->nodeInfo->end_pos = ctxt->input->consumed +
+                                (CUR_PTR - ctxt->input->base);
+       ctxt->nodeInfo->end_line = ctxt->input->line;
+       ctxt->nodeInfo->node = ctxt->node;
+       xmlParserAddNodeInfo(ctxt, ctxt->nodeInfo);
+       htmlNodeInfoPop(ctxt);
+    }
+    if (!IS_CHAR_CH(CUR)) {
+       htmlAutoCloseOnEnd(ctxt);
+    }
+}
+
+/**
+ * htmlParseElementInternal:
+ * @ctxt:  an HTML parser context
+ *
+ * parse an HTML element, new version, non recursive
+ *
+ * [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;
+    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;
+
+    /* 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;
+        return;
+    }
+
+    /*
+     * Lookup the info for that element.
+     */
+    info = htmlTagLookup(name);
+    if (info == NULL) {
+        htmlParseErr(ctxt, XML_HTML_UNKNOWN_TAG,
+                     "Tag %s invalid\n", name, NULL);
+    }
+
+    /*
+     * Check for an Empty Element labeled the XML/SGML way
+     */
+    if ((CUR == '/') && (NXT(1) == '>')) {
+        SKIP(2);
+        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
+            ctxt->sax->endElement(ctxt->userData, name);
+        htmlnamePop(ctxt);
+        return;
+    }
+
+    if (CUR == '>') {
+        NEXT;
+    } else {
+        htmlParseErr(ctxt, XML_ERR_GT_REQUIRED,
+                     "Couldn't find end of Start Tag %s\n", 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);
+        htmlParserFinishElementParsing(ctxt);
+        return;
+    }
+
+    /*
+     * 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);
+        return;
+    }
+
+    if (ctxt->record_info)
+        htmlNodeInfoPush(ctxt, &node_info);
+}
+
+/**
+ * htmlParseContentInternal:
+ * @ctxt:  an HTML parser context
+ *
+ * Parse a content: comment, sub-element, reference or text.
+ * New version for non recursive htmlParseElementInternal
+ */
+
+static void
+htmlParseContentInternal(htmlParserCtxtPtr ctxt) {
+    xmlChar *currentNode;
+    int depth;
+    const xmlChar *name;
+
+    currentNode = xmlStrdup(ctxt->name);
+    depth = ctxt->nameNr;
+    while (1) {
+        long cons = ctxt->nbChars;
+
+        GROW;
+
+        if (ctxt->instate == XML_PARSER_EOF)
+            break;
+
+        /*
+         * Our tag or one of it's parent or children is ending.
+         */
+        if ((CUR == '<') && (NXT(1) == '/')) {
+            if (htmlParseEndTag(ctxt) &&
+                ((currentNode != NULL) || (ctxt->nameNr == 0))) {
+                if (currentNode != NULL)
+                    xmlFree(currentNode);
+
+                currentNode = xmlStrdup(ctxt->name);
+                depth = ctxt->nameNr;
+            }
+            continue; /* while */
+        }
+
+        else if ((CUR == '<') &&
+                 ((IS_ASCII_LETTER(NXT(1))) ||
+                  (NXT(1) == '_') || (NXT(1) == ':'))) {
+            name = htmlParseHTMLName_nonInvasive(ctxt);
+            if (name == NULL) {
+                htmlParseErr(ctxt, XML_ERR_NAME_REQUIRED,
+                         "htmlParseStartTag: invalid element name\n",
+                         NULL, NULL);
+                /* Dump the bogus tag like browsers do */
+                while ((IS_CHAR_CH(CUR)) && (CUR != '>'))
+                    NEXT;
+
+                htmlParserFinishElementParsing(ctxt);
+                if (currentNode != NULL)
+                    xmlFree(currentNode);
+
+                currentNode = xmlStrdup(ctxt->name);
+                depth = ctxt->nameNr;
+                continue;
+            }
+
+            if (ctxt->name != NULL) {
+                if (htmlCheckAutoClose(name, ctxt->name) == 1) {
+                    htmlAutoClose(ctxt, name);
+                    continue;
+                }
+            }
+        }
+
+        /*
+         * Has this node been popped out during parsing of
+         * the next element
+         */
+        if ((ctxt->nameNr > 0) && (depth >= ctxt->nameNr) &&
+            (!xmlStrEqual(currentNode, ctxt->name)))
+             {
+            htmlParserFinishElementParsing(ctxt);
+            if (currentNode != NULL) xmlFree(currentNode);
+
+            currentNode = xmlStrdup(ctxt->name);
+            depth = ctxt->nameNr;
+            continue;
+        }
+
+        if ((CUR != 0) && ((xmlStrEqual(currentNode, BAD_CAST"script")) ||
+            (xmlStrEqual(currentNode, BAD_CAST"style")))) {
+            /*
+             * Handle SCRIPT/STYLE separately
+             */
+            htmlParseScript(ctxt);
+        } else {
+            /*
+             * Sometimes DOCTYPE arrives in the middle of the document
+             */
+            if ((CUR == '<') && (NXT(1) == '!') &&
+                (UPP(2) == 'D') && (UPP(3) == 'O') &&
+                (UPP(4) == 'C') && (UPP(5) == 'T') &&
+                (UPP(6) == 'Y') && (UPP(7) == 'P') &&
+                (UPP(8) == 'E')) {
+                htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
+                             "Misplaced DOCTYPE declaration\n",
+                             BAD_CAST "DOCTYPE" , NULL);
+                htmlParseDocTypeDecl(ctxt);
+            }
+
+            /*
+             * First case :  a comment
+             */
+            if ((CUR == '<') && (NXT(1) == '!') &&
+                (NXT(2) == '-') && (NXT(3) == '-')) {
+                htmlParseComment(ctxt);
+            }
+
+            /*
+             * Second case : a Processing Instruction.
+             */
+            else if ((CUR == '<') && (NXT(1) == '?')) {
+                htmlParsePI(ctxt);
+            }
+
+            /*
+             * Third case :  a sub-element.
+             */
+            else if (CUR == '<') {
+                htmlParseElementInternal(ctxt);
+                if (currentNode != NULL) xmlFree(currentNode);
+
+                currentNode = xmlStrdup(ctxt->name);
+                depth = ctxt->nameNr;
+            }
+
+            /*
+             * Fourth case : a reference. If if has not been resolved,
+             *    parsing returns it's Name, create the node
+             */
+            else if (CUR == '&') {
+                htmlParseReference(ctxt);
+            }
+
+            /*
+             * Fifth case : end of the resource
+             */
+            else if (CUR == 0) {
+                htmlAutoCloseOnEnd(ctxt);
+                break;
+            }
+
+            /*
+             * Last case, text. Note that References are handled directly.
+             */
+            else {
+                htmlParseCharData(ctxt);
+            }
+
+            if (cons == ctxt->nbChars) {
+                if (ctxt->node != NULL) {
+                    htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
+                                 "detected an error in element content\n",
+                                 NULL, NULL);
+                }
+                break;
+            }
+        }
+        GROW;
+    }
+    if (currentNode != NULL) xmlFree(currentNode);
+}
+
+/**
+ * htmlParseContent:
+ * @ctxt:  an HTML parser context
+ *
+ * Parse a content: comment, sub-element, reference or text.
+ * This is the entry point when called from parser.c
+ */
+
+void
+__htmlParseContent(void *ctxt) {
+    if (ctxt != NULL)
+        htmlParseContentInternal((htmlParserCtxtPtr) ctxt);
+}
+
 /**
  * htmlParseDocument:
  * @ctxt:  an HTML parser context
- * 
+ *
  * parse an HTML document (and build a tree if using the standard SAX
  * interface).
  *
  * Returns 0, -1 in case of error. the parser context is augmented
  *                as a result of the parsing.
  */
 
 int
 htmlParseDocument(htmlParserCtxtPtr ctxt) {
+    xmlChar start[4];
+    xmlCharEncoding enc;
     xmlDtdPtr dtd;
 
     xmlInitParser();
 
     htmlDefaultSAXHandlerInit();
 
     if ((ctxt == NULL) || (ctxt->input == NULL)) {
         htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
                      "htmlParseDocument: context error\n", NULL, NULL);
         return(XML_ERR_INTERNAL_ERROR);
     }
     ctxt->html = 1;
+    ctxt->linenumbers = 1;
     GROW;
     /*
      * SAX: beginning of the document processing.
      */
     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
         ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
 
+    if ((ctxt->encoding == (const xmlChar *)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.
+         */
+        start[0] = RAW;
+        start[1] = NXT(1);
+        start[2] = NXT(2);
+        start[3] = NXT(3);
+        enc = xmlDetectCharEncoding(&start[0], 4);
+        if (enc != XML_CHAR_ENCODING_NONE) {
+            xmlSwitchEncoding(ctxt, enc);
+        }
+    }
+
     /*
      * Wipe out everything which is before the first '<'
      */
     SKIP_BLANKS;
     if (CUR == 0) {
-        htmlParseErr(ctxt, XML_ERR_DOCUMENT_EMPTY, 
+        htmlParseErr(ctxt, XML_ERR_DOCUMENT_EMPTY,
                      "Document is empty\n", NULL, NULL);
     }
 
     if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
         ctxt->sax->startDocument(ctxt->userData);
 
 
     /*
      * Parse possible comments and PIs before any content
      */
     while (((CUR == '<') && (NXT(1) == '!') &&
             (NXT(2) == '-') && (NXT(3) == '-')) ||
            ((CUR == '<') && (NXT(1) == '?'))) {
-        htmlParseComment(ctxt);    
-        htmlParsePI(ctxt);         
+        htmlParseComment(ctxt);
+        htmlParsePI(ctxt);
         SKIP_BLANKS;
-    }      
+    }
 
 
     /*
      * Then possibly doc type declaration(s) and more Misc
      * (doctypedecl Misc*)?
      */
     if ((CUR == '<') && (NXT(1) == '!') &&
         (UPP(2) == 'D') && (UPP(3) == 'O') &&
         (UPP(4) == 'C') && (UPP(5) == 'T') &&
         (UPP(6) == 'Y') && (UPP(7) == 'P') &&
         (UPP(8) == 'E')) {
         htmlParseDocTypeDecl(ctxt);
     }
     SKIP_BLANKS;
 
     /*
      * Parse possible comments and PIs before any content
      */
     while (((CUR == '<') && (NXT(1) == '!') &&
             (NXT(2) == '-') && (NXT(3) == '-')) ||
            ((CUR == '<') && (NXT(1) == '?'))) {
-        htmlParseComment(ctxt);    
-        htmlParsePI(ctxt);         
+        htmlParseComment(ctxt);
+        htmlParsePI(ctxt);
         SKIP_BLANKS;
-    }      
+    }
 
     /*
      * Time to start parsing the tree itself
      */
-    htmlParseContent(ctxt);
+    htmlParseContentInternal(ctxt);
 
     /*
      * autoclose
      */
     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) {
         dtd = xmlGetIntSubset(ctxt->myDoc);
         if (dtd == NULL)
-            ctxt->myDoc->intSubset = 
-                xmlCreateIntSubset(ctxt->myDoc, BAD_CAST "html", 
+            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 25 matching lines @@
     }
     sax = (htmlSAXHandler *) xmlMalloc(sizeof(htmlSAXHandler));
     if (sax == NULL) {
         htmlErrMemory(NULL, "htmlInitParserCtxt: out of memory\n");
         return(-1);
     }
     else
         memset(sax, 0, sizeof(htmlSAXHandler));
 
     /* Allocate the Input stack */
-    ctxt->inputTab = (htmlParserInputPtr *) 
+    ctxt->inputTab = (htmlParserInputPtr *)
                       xmlMalloc(5 * sizeof(htmlParserInputPtr));
     if (ctxt->inputTab == NULL) {
         htmlErrMemory(NULL, "htmlInitParserCtxt: out of memory\n");
         ctxt->inputNr = 0;
         ctxt->inputMax = 0;
         ctxt->input = NULL;
         return(-1);
     }
     ctxt->inputNr = 0;
     ctxt->inputMax = 5;
@@ skipping 17 matching lines @@
     }
     ctxt->nodeNr = 0;
     ctxt->nodeMax = 10;
     ctxt->node = NULL;
 
     /* Allocate the Name stack */
     ctxt->nameTab = (const xmlChar **) xmlMalloc(10 * sizeof(xmlChar *));
     if (ctxt->nameTab == NULL) {
         htmlErrMemory(NULL, "htmlInitParserCtxt: out of memory\n");
         ctxt->nameNr = 0;
-        ctxt->nameMax = 10;
+        ctxt->nameMax = 0;
         ctxt->name = NULL;
         ctxt->nodeNr = 0;
         ctxt->nodeMax = 0;
         ctxt->node = NULL;
         ctxt->inputNr = 0;
         ctxt->inputMax = 0;
         ctxt->input = NULL;
         return(-1);
     }
     ctxt->nameNr = 0;
     ctxt->nameMax = 10;
     ctxt->name = NULL;
 
+    ctxt->nodeInfoTab = NULL;
+    ctxt->nodeInfoNr  = 0;
+    ctxt->nodeInfoMax = 0;
+
     if (sax == NULL) ctxt->sax = (xmlSAXHandlerPtr) &htmlDefaultSAXHandler;
     else {
         ctxt->sax = sax;
         memcpy(sax, &htmlDefaultSAXHandler, sizeof(xmlSAXHandlerV1));
     }
     ctxt->userData = ctxt;
     ctxt->myDoc = NULL;
     ctxt->wellFormed = 1;
     ctxt->replaceEntities = 0;
     ctxt->linenumbers = xmlLineNumbersDefaultValue;
@@ skipping 126 matching lines @@
         ctxt->input->encoding = xmlStrdup((const xmlChar *) encoding);
 
         enc = xmlParseCharEncoding(encoding);
         /*
          * registered set of known encodings
          */
         if (enc != XML_CHAR_ENCODING_ERROR) {
             xmlSwitchEncoding(ctxt, enc);
             if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
                 htmlParseErr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
-                             "Unsupported encoding %s\n", 
+                             "Unsupported encoding %s\n",
                              (const xmlChar *) encoding, NULL);
             }
         } else {
             /*
              * fallback for unknown encodings
              */
             handler = xmlFindCharEncodingHandler((const char *) encoding);
             if (handler != NULL) {
                 xmlSwitchToEncoding(ctxt, handler);
             } else {
                 htmlParseErr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                              "Unsupported encoding %s\n",
                              (const xmlChar *) encoding, NULL);
             }
         }
     }
     return(ctxt);
 }
 
 #ifdef LIBXML_PUSH_ENABLED
 /************************************************************************
  *                                                                      *
- *              Progressive parsing interfaces                          *
+ *      Progressive parsing interfaces                          *
  *                                                                      *
  ************************************************************************/
 
 /**
  * htmlParseLookupSequence:
  * @ctxt:  an HTML parser context
  * @first:  the first char to lookup
  * @next:  the next char to lookup or zero
  * @third:  the next char to lookup or zero
  * @comment: flag to force checking inside comments
  *
  * Try to find if a sequence (first, next, third) or  just (first next) or
  * (first) 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.
  * This is basically similar to xmlParseLookupSequence()
  *
  * Returns the index to the current parsing point if the full sequence
  *      is available, -1 otherwise.
  */
 static int
 htmlParseLookupSequence(htmlParserCtxtPtr ctxt, xmlChar first,
-                        xmlChar next, xmlChar third, int iscomment) {
+                        xmlChar next, xmlChar third, int iscomment,
+                        int ignoreattrval)
+{
     int base, len;
     htmlParserInputPtr in;
     const xmlChar *buf;
     int incomment = 0;
+    int invalue = 0;
+    char valdellim = 0x0;
 
     in = ctxt->input;
-    if (in == NULL) return(-1);
+    if (in == NULL)
+        return (-1);
+
     base = in->cur - in->base;
-    if (base < 0) return(-1);
+    if (base < 0)
+        return (-1);
+
     if (ctxt->checkIndex > base)
         base = ctxt->checkIndex;
+
     if (in->buf == NULL) {
-        buf = in->base;
-        len = in->length;
+        buf = in->base;
+        len = in->length;
     } else {
-        buf = in->buf->buffer->content;
-        len = in->buf->buffer->use;
+        buf = in->buf->buffer->content;
+        len = in->buf->buffer->use;
     }
+
     /* 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] == '!') &&
-                (buf[base + 2] == '-') && (buf[base + 3] == '-')) {
-                incomment = 1;
-                /* do not increment past <! - some people use <!--> */
-                base += 2;
-            }
-        }
-        if (incomment) {
-            if (base + 3 > len)
-                return(-1);
-            if ((buf[base] == '-') && (buf[base + 1] == '-') &&
-                (buf[base + 2] == '>')) {
-                incomment = 0;
-                base += 2;
-            }
-            continue;
-        }
+    if (third)
+        len -= 2;
+    else if (next)
+        len--;
+    for (; base < len; base++) {
+        if ((!incomment) && (base + 4 < len) && (!iscomment)) {
+            if ((buf[base] == '<') && (buf[base + 1] == '!') &&
+                (buf[base + 2] == '-') && (buf[base + 3] == '-')) {
+                incomment = 1;
+                /* do not increment past <! - some people use <!--> */
+                base += 2;
+            }
+        }
+        if (ignoreattrval) {
+            if (buf[base] == '"' || buf[base] == '\'') {
+                if (invalue) {
+                    if (buf[base] == valdellim) {
+                        invalue = 0;
+                        continue;
+                    }
+                } else {
+                    valdellim = buf[base];
+                    invalue = 1;
+                    continue;
+                }
+            } else if (invalue) {
+                continue;
+            }
+        }
+        if (incomment) {
+            if (base + 3 > len)
+                return (-1);
+            if ((buf[base] == '-') && (buf[base + 1] == '-') &&
+                (buf[base + 2] == '>')) {
+                incomment = 0;
+                base += 2;
+            }
+            continue;
+        }
         if (buf[base] == first) {
-            if (third != 0) {
-                if ((buf[base + 1] != next) ||
-                    (buf[base + 2] != third)) continue;
-            } else if (next != 0) {
-                if (buf[base + 1] != next) continue;
-            }
-            ctxt->checkIndex = 0;
+            if (third != 0) {
+                if ((buf[base + 1] != next) || (buf[base + 2] != third))
+                    continue;
+            } else if (next != 0) {
+                if (buf[base + 1] != next)
+                    continue;
+            }
+            ctxt->checkIndex = 0;
 #ifdef DEBUG_PUSH
-            if (next == 0)
-                xmlGenericError(xmlGenericErrorContext,
-                        "HPP: lookup '%c' found at %d\n",
-                        first, base);
-            else if (third == 0)
-                xmlGenericError(xmlGenericErrorContext,
-                        "HPP: lookup '%c%c' found at %d\n",
-                        first, next, base);
-            else 
-                xmlGenericError(xmlGenericErrorContext,
-                        "HPP: lookup '%c%c%c' found at %d\n",
-                        first, next, third, base);
+            if (next == 0)
+                xmlGenericError(xmlGenericErrorContext,
+                                "HPP: lookup '%c' found at %d\n",
+                                first, base);
+            else if (third == 0)
+                xmlGenericError(xmlGenericErrorContext,
+                                "HPP: lookup '%c%c' found at %d\n",
+                                first, next, base);
+            else
+                xmlGenericError(xmlGenericErrorContext,
+                                "HPP: lookup '%c%c%c' found at %d\n",
+                                first, next, third, base);
 #endif
-            return(base - (in->cur - in->base));
-        }
+            return (base - (in->cur - in->base));
+        }
     }
-    ctxt->checkIndex = base;
+    if ((!incomment) && (!invalue))
+        ctxt->checkIndex = base;
 #ifdef DEBUG_PUSH
     if (next == 0)
-        xmlGenericError(xmlGenericErrorContext,
-                "HPP: lookup '%c' failed\n", first);
+        xmlGenericError(xmlGenericErrorContext,
+                        "HPP: lookup '%c' failed\n", first);
     else if (third == 0)
-        xmlGenericError(xmlGenericErrorContext,
-                "HPP: lookup '%c%c' failed\n", first, next);
-    else        
-        xmlGenericError(xmlGenericErrorContext,
-                "HPP: lookup '%c%c%c' failed\n", first, next, third);
+        xmlGenericError(xmlGenericErrorContext,
+                        "HPP: lookup '%c%c' failed\n", first, next);
+    else
+        xmlGenericError(xmlGenericErrorContext,
+                        "HPP: lookup '%c%c%c' failed\n", first, next,
+                        third);
 #endif
-    return(-1);
+    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 
+ * 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 
+ *      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;
+    }
+
+    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;
+            }
+        }
+        if (incomment) {
+            if (base + 3 > len)
+                return (-1);
+            if ((buf[base] == '-') && (buf[base + 1] == '-') &&
+                (buf[base + 2] == '>')) {
+                incomment = 0;
+                base += 2;
+            }
+            continue;
+        }
+        for (i = 0; i < stopLen; ++i) {
+            if (buf[base] == stop[i]) {
+                ctxt->checkIndex = 0;
+                return (base - (in->cur - in->base));
+            }
+        }
+    }
+    ctxt->checkIndex = base;
+    return (-1);
+}
+
+/**
  * htmlParseTryOrFinish:
  * @ctxt:  an HTML parser context
  * @terminate:  last chunk indicator
  *
  * Try to progress on parsing
  *
  * Returns zero if no parsing was possible
  */
 static int
 htmlParseTryOrFinish(htmlParserCtxtPtr ctxt, int terminate) {
@@ skipping 58 matching lines @@
     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);
         if ((avail == 0) && (terminate)) {
             htmlAutoCloseOnEnd(ctxt);
-            if ((ctxt->nameNr == 0) && (ctxt->instate != XML_PARSER_EOF)) { 
+            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 (avail < 1)
             goto done;
@@ skipping 29 matching lines @@
                     ctxt->sax->startDocument(ctxt->userData);
 
                 cur = in->cur[0];
                 next = in->cur[1];
                 if ((cur == '<') && (next == '!') &&
                     (UPP(2) == 'D') && (UPP(3) == 'O') &&
                     (UPP(4) == 'C') && (UPP(5) == 'T') &&
                     (UPP(6) == 'Y') && (UPP(7) == 'P') &&
                     (UPP(8) == 'E')) {
                     if ((!terminate) &&
-                        (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0))
+                        (htmlParseLookupSequence(ctxt, '>', 0, 0, 0, 1) < 0))
                         goto done;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: Parsing internal subset\n");
 #endif
                     htmlParseDocTypeDecl(ctxt);
                     ctxt->instate = XML_PARSER_PROLOG;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: entering PROLOG\n");
@@ skipping 12 matching lines @@
                     avail = in->length - (in->cur - in->base);
                 else
                     avail = in->buf->buffer->use - (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) < 0))
+                        (htmlParseLookupSequence(ctxt, '-', '-', '>', 1, 1) < 0))
                         goto done;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: Parsing Comment\n");
 #endif
                     htmlParseComment(ctxt);
                     ctxt->instate = XML_PARSER_MISC;
                 } else if ((cur == '<') && (next == '?')) {
                     if ((!terminate) &&
-                        (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0))
+                        (htmlParseLookupSequence(ctxt, '>', 0, 0, 0, 1) < 0))
                         goto done;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: Parsing PI\n");
 #endif
                     htmlParsePI(ctxt);
                     ctxt->instate = XML_PARSER_MISC;
                 } else if ((cur == '<') && (next == '!') &&
                     (UPP(2) == 'D') && (UPP(3) == 'O') &&
                     (UPP(4) == 'C') && (UPP(5) == 'T') &&
                     (UPP(6) == 'Y') && (UPP(7) == 'P') &&
                     (UPP(8) == 'E')) {
                     if ((!terminate) &&
-                        (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0))
+                        (htmlParseLookupSequence(ctxt, '>', 0, 0, 0, 1) < 0))
                         goto done;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: Parsing internal subset\n");
 #endif
                     htmlParseDocTypeDecl(ctxt);
                     ctxt->instate = XML_PARSER_PROLOG;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: entering PROLOG\n");
 #endif
                 } else if ((cur == '<') && (next == '!') &&
                            (avail < 9)) {
                     goto done;
                 } else {
                     ctxt->instate = XML_PARSER_START_TAG;
 #ifdef DEBUG_PUSH
                     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);
-                if (avail < 2) 
+                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) < 0))
+                        (htmlParseLookupSequence(ctxt, '-', '-', '>', 1, 1) < 0))
                         goto done;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: Parsing Comment\n");
 #endif
                     htmlParseComment(ctxt);
                     ctxt->instate = XML_PARSER_PROLOG;
                 } else if ((cur == '<') && (next == '?')) {
                     if ((!terminate) &&
-                        (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0))
+                        (htmlParseLookupSequence(ctxt, '>', 0, 0, 0, 1) < 0))
                         goto done;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: Parsing PI\n");
 #endif
                     htmlParsePI(ctxt);
                     ctxt->instate = XML_PARSER_PROLOG;
                 } else if ((cur == '<') && (next == '!') &&
                            (avail < 4)) {
                     goto done;
@@ skipping 16 matching lines @@
                 if (IS_BLANK_CH(cur)) {
                     htmlParseCharData(ctxt);
                     goto done;
                 }
                 if (avail < 2)
                     goto done;
                 next = in->cur[1];
                 if ((cur == '<') && (next == '!') &&
                     (in->cur[2] == '-') && (in->cur[3] == '-')) {
                     if ((!terminate) &&
-                        (htmlParseLookupSequence(ctxt, '-', '-', '>', 1) < 0))
+                        (htmlParseLookupSequence(ctxt, '-', '-', '>', 1, 1) < 0))
                         goto done;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: Parsing Comment\n");
 #endif
                     htmlParseComment(ctxt);
                     ctxt->instate = XML_PARSER_EPILOG;
                 } else if ((cur == '<') && (next == '?')) {
                     if ((!terminate) &&
-                        (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0))
+                        (htmlParseLookupSequence(ctxt, '>', 0, 0, 0, 1) < 0))
                         goto done;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: Parsing PI\n");
 #endif
                     htmlParsePI(ctxt);
                     ctxt->instate = XML_PARSER_EPILOG;
                 } else if ((cur == '<') && (next == '!') &&
                            (avail < 4)) {
                     goto done;
@@ skipping 29 matching lines @@
                 if (in->cur[1] == '/') {
                     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) < 0))
+                    (htmlParseLookupSequence(ctxt, '>', 0, 0, 0, 1) < 0))
                     goto done;
 
                 failed = htmlParseStartTag(ctxt);
                 name = ctxt->name;
                 if ((failed == -1) ||
                     (name == NULL)) {
                     if (CUR == '>')
                         NEXT;
                     break;
                 }
@@ skipping 26 matching lines @@
                 if (CUR == '>') {
                     NEXT;
                 } else {
                     htmlParseErr(ctxt, XML_ERR_GT_REQUIRED,
                                  "Couldn't find end of Start Tag %s\n",
                                  name, NULL);
 
                     /*
                      * end of parsing of this node.
                      */
-                    if (xmlStrEqual(name, ctxt->name)) { 
+                    if (xmlStrEqual(name, ctxt->name)) {
                         nodePop(ctxt);
                         htmlnamePop(ctxt);
-                    }    
+                    }
 
                     ctxt->instate = XML_PARSER_CONTENT;
 #ifdef DEBUG_PUSH
                     xmlGenericError(xmlGenericErrorContext,
                             "HPP: entering CONTENT\n");
 #endif
                     break;
                 }
 
                 /*
@@ skipping 54 matching lines @@
                 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);
+                        idx = htmlParseLookupSequence(ctxt, '<', '/', 0, 0, 1);
                         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;
 #ifdef DEBUG_PUSH
                         xmlGenericError(xmlGenericErrorContext,
                                 "HPP: entering END_TAG\n");
 #endif
                         break;
                     }
                 } else {
                     /*
                      * Sometimes DOCTYPE arrives in the middle of the document
                      */
                     if ((cur == '<') && (next == '!') &&
                         (UPP(2) == 'D') && (UPP(3) == 'O') &&
                         (UPP(4) == 'C') && (UPP(5) == 'T') &&
                         (UPP(6) == 'Y') && (UPP(7) == 'P') &&
                         (UPP(8) == 'E')) {
                         if ((!terminate) &&
-                            (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0))
+                            (htmlParseLookupSequence(ctxt, '>', 0, 0, 0, 1) < 0))
                             goto done;
                         htmlParseErr(ctxt, XML_HTML_STRUCURE_ERROR,
                                      "Misplaced DOCTYPE declaration\n",
                                      BAD_CAST "DOCTYPE" , NULL);
                         htmlParseDocTypeDecl(ctxt);
                     } else if ((cur == '<') && (next == '!') &&
                         (in->cur[2] == '-') && (in->cur[3] == '-')) {
                         if ((!terminate) &&
                             (htmlParseLookupSequence(
-                                        ctxt, '-', '-', '>', 1) < 0))
+                                ctxt, '-', '-', '>', 1, 1) < 0))
                             goto done;
 #ifdef DEBUG_PUSH
                         xmlGenericError(xmlGenericErrorContext,
                                 "HPP: Parsing Comment\n");
 #endif
                         htmlParseComment(ctxt);
                         ctxt->instate = XML_PARSER_CONTENT;
                     } else if ((cur == '<') && (next == '?')) {
                         if ((!terminate) &&
-                            (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0))
+                            (htmlParseLookupSequence(ctxt, '>', 0, 0, 0, 1) < 0))
                             goto done;
 #ifdef DEBUG_PUSH
                         xmlGenericError(xmlGenericErrorContext,
                                 "HPP: Parsing PI\n");
 #endif
                         htmlParsePI(ctxt);
                         ctxt->instate = XML_PARSER_CONTENT;
                     } else if ((cur == '<') && (next == '!') && (avail < 4)) {
                         goto done;
                     } else if ((cur == '<') && (next == '/')) {
                         ctxt->instate = XML_PARSER_END_TAG;
                         ctxt->checkIndex = 0;
 #ifdef DEBUG_PUSH
                         xmlGenericError(xmlGenericErrorContext,
                                 "HPP: entering END_TAG\n");
 #endif
                         break;
                     } else if (cur == '<') {
                         ctxt->instate = XML_PARSER_START_TAG;
                         ctxt->checkIndex = 0;
 #ifdef DEBUG_PUSH
                         xmlGenericError(xmlGenericErrorContext,
                                 "HPP: entering START_TAG\n");
 #endif
                         break;
                     } else if (cur == '&') {
                         if ((!terminate) &&
-                            (htmlParseLookupSequence(ctxt, ';', 0, 0, 0) < 0))
+                            (htmlParseLookupChars(ctxt,
+                                                  BAD_CAST "; >/", 4) < 0))
                             goto done;
 #ifdef DEBUG_PUSH
                         xmlGenericError(xmlGenericErrorContext,
                                 "HPP: Parsing Reference\n");
 #endif
                         /* TODO: check generation of subtrees if noent !!! */
                         htmlParseReference(ctxt);
                     } else {
                         /*
                          * check that the text sequence is complete
                          * before handing out the data to the parser
                          * to avoid problems with erroneous end of
                          * data detection.
                          */
                         if ((!terminate) &&
-                            (htmlParseLookupSequence(ctxt, '<', 0, 0, 0) < 0))
+                            (htmlParseLookupChars(ctxt, BAD_CAST "<&", 2) < 0))
                             goto done;
                         ctxt->checkIndex = 0;
 #ifdef DEBUG_PUSH
                         xmlGenericError(xmlGenericErrorContext,
                                 "HPP: Parsing char data\n");
 #endif
                         htmlParseCharData(ctxt);
                     }
                 }
                 if (cons == ctxt->nbChars) {
                     if (ctxt->node != NULL) {
                         htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
                                      "detected an error in element content\n",
                                      NULL, NULL);
                     }
                     NEXT;
                     break;
                 }
 
                 break;
             }
             case XML_PARSER_END_TAG:
                 if (avail < 2)
                     goto done;
                 if ((!terminate) &&
-                    (htmlParseLookupSequence(ctxt, '>', 0, 0, 0) < 0))
+                    (htmlParseLookupSequence(ctxt, '>', 0, 0, 0, 1) < 0))
                     goto done;
                 htmlParseEndTag(ctxt);
                 if (ctxt->nameNr == 0) {
                     ctxt->instate = XML_PARSER_EPILOG;
                 } else {
                     ctxt->instate = XML_PARSER_CONTENT;
                 }
                 ctxt->checkIndex = 0;
 #ifdef DEBUG_PUSH
                 xmlGenericError(xmlGenericErrorContext,
@@ skipping 106 matching lines @@
                 ctxt->instate = XML_PARSER_CONTENT;
                 ctxt->checkIndex = 0;
 #ifdef DEBUG_PUSH
                 xmlGenericError(xmlGenericErrorContext,
                         "HPP: entering CONTENT\n");
 #endif
                 break;
 
         }
     }
-done:    
+done:
     if ((avail == 0) && (terminate)) {
         htmlAutoCloseOnEnd(ctxt);
-        if ((ctxt->nameNr == 0) && (ctxt->instate != XML_PARSER_EOF)) { 
+        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) &&
         ((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", 
+            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");
     }
 #ifdef DEBUG_PUSH
     xmlGenericError(xmlGenericErrorContext, "HPP: done %d\n", ret);
 #endif
     return(ret);
 }
 
 /**
@@ skipping 13 matching lines @@
     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;
         int res;
-        
-        res = xmlParserInputBufferPush(ctxt->input->buf, size, chunk);        
+
+        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, "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;
-                    
+
                 nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
                 if (nbchars < 0) {
                     htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING,
                                  "encoder error\n", NULL, NULL);
                     return(XML_ERR_INVALID_ENCODING);
                 }
             }
         }
     }
     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;
-        } 
+        }
         if (ctxt->instate != XML_PARSER_EOF) {
             if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
                 ctxt->sax->endDocument(ctxt->userData);
         }
         ctxt->instate = XML_PARSER_EOF;
     }
-    return((xmlParserErrors) ctxt->errNo);            
+    return((xmlParserErrors) ctxt->errNo);
 }
 
 /************************************************************************
  *                                                                      *
  *                      User entry points                               *
  *                                                                      *
  ************************************************************************/
 
 /**
  * htmlCreatePushParserCtxt:
  * @sax:  a SAX handler
  * @user_data:  The user data returned on SAX callbacks
  * @chunk:  a pointer to an array of chars
  * @size:  number of chars in the array
  * @filename:  an optional file name or URI
  * @enc:  an optional encoding
  *
  * Create a parser context for using the HTML parser in push mode
  * The value of @filename is used for fetching external entities
  * and error/warning reports.
  *
  * Returns the new parser context or NULL
  */
 htmlParserCtxtPtr
-htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax, void *user_data, 
+htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax, void *user_data,
                          const char *chunk, int size, const char *filename,
                          xmlCharEncoding enc) {
     htmlParserCtxtPtr ctxt;
     htmlParserInputPtr inputStream;
     xmlParserInputBufferPtr buf;
 
     xmlInitParser();
 
     buf = xmlAllocParserInputBuffer(enc);
     if (buf == NULL) return(NULL);
@@ skipping 10 matching lines @@
             xmlFree(ctxt->sax);
         ctxt->sax = (htmlSAXHandlerPtr) xmlMalloc(sizeof(htmlSAXHandler));
         if (ctxt->sax == NULL) {
             xmlFree(buf);
             xmlFree(ctxt);
             return(NULL);
         }
         memcpy(ctxt->sax, sax, sizeof(htmlSAXHandler));
         if (user_data != NULL)
             ctxt->userData = user_data;
-    }   
+    }
     if (filename == NULL) {
         ctxt->directory = NULL;
     } else {
         ctxt->directory = xmlParserGetDirectory(filename);
     }
 
     inputStream = htmlNewInputStream(ctxt);
     if (inputStream == NULL) {
         xmlFreeParserCtxt(ctxt);
         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->end =
         &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
 
     inputPush(ctxt, inputStream);
 
     if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
-        (ctxt->input->buf != NULL))  {        
+        (ctxt->input->buf != NULL))  {
         int base = ctxt->input->base - ctxt->input->buf->buffer->content;
         int cur = ctxt->input->cur - ctxt->input->base;
 
-        xmlParserInputBufferPush(ctxt->input->buf, size, chunk);              
+        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];
 #ifdef DEBUG_PUSH
         xmlGenericError(xmlGenericErrorContext, "HPP: pushed %d\n", size);
 #endif
     }
     ctxt->progressive = 1;
 
     return(ctxt);
 }
 #endif /* LIBXML_PUSH_ENABLED */
 
 /**
  * htmlSAXParseDoc:
  * @cur:  a pointer to an array of xmlChar
  * @encoding:  a free form C string describing the HTML document encoding, or NULL
  * @sax:  the SAX handler block
- * @userData: if using SAX, this pointer will be provided on callbacks. 
+ * @userData: if using SAX, this pointer will be provided on callbacks.
  *
  * Parse an HTML in-memory document. If sax is not NULL, use the SAX callbacks
  * to handle parse events. If sax is NULL, fallback to the default DOM
  * behavior and return a tree.
- * 
+ *
  * Returns the resulting document tree unless SAX is NULL or the document is
  *     not well formed.
  */
 
 htmlDocPtr
 htmlSAXParseDoc(xmlChar *cur, const char *encoding, htmlSAXHandlerPtr sax, void *userData) {
     htmlDocPtr ret;
     htmlParserCtxtPtr ctxt;
 
     xmlInitParser();
 
     if (cur == NULL) return(NULL);
 
 
     ctxt = htmlCreateDocParserCtxt(cur, encoding);
     if (ctxt == NULL) return(NULL);
-    if (sax != NULL) { 
+    if (sax != NULL) {
         if (ctxt->sax != NULL) xmlFree (ctxt->sax);
         ctxt->sax = sax;
         ctxt->userData = userData;
     }
 
     htmlParseDocument(ctxt);
     ret = ctxt->myDoc;
     if (sax != NULL) {
         ctxt->sax = NULL;
         ctxt->userData = NULL;
     }
     htmlFreeParserCtxt(ctxt);
-    
+
     return(ret);
 }
 
 /**
  * htmlParseDoc:
  * @cur:  a pointer to an array of xmlChar
  * @encoding:  a free form C string describing the HTML document encoding, or NULL
  *
  * parse an HTML in-memory document and build a tree.
- * 
+ *
  * Returns the resulting document tree
  */
 
 htmlDocPtr
 htmlParseDoc(xmlChar *cur, const char *encoding) {
     return(htmlSAXParseDoc(cur, encoding, NULL, NULL));
 }
 
 
 /**
  * htmlCreateFileParserCtxt:
  * @filename:  the filename
  * @encoding:  a free form C string describing the HTML document encoding, or NULL
  *
- * Create a parser context for a file content. 
+ * Create a parser context for a file content.
  * Automatic support for ZLIB/Compress compressed document is provided
  * by default if found at compile-time.
  *
  * Returns the new parser context or NULL
  */
 htmlParserCtxtPtr
 htmlCreateFileParserCtxt(const char *filename, const char *encoding)
 {
     htmlParserCtxtPtr ctxt;
     htmlParserInputPtr inputStream;
@@ skipping 11 matching lines @@
     canonicFilename = (char *) xmlCanonicPath((const xmlChar *) filename);
     if (canonicFilename == NULL) {
 #ifdef LIBXML_SAX1_ENABLED
         if (xmlDefaultSAXHandler.error != NULL) {
             xmlDefaultSAXHandler.error(NULL, "out of memory\n");
         }
 #endif
         xmlFreeParserCtxt(ctxt);
         return(NULL);
     }
-    
+
     inputStream = xmlLoadExternalEntity(canonicFilename, NULL, ctxt);
     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) {  
+        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
  * @sax:  the SAX handler block
- * @userData: if using SAX, this pointer will be provided on callbacks. 
+ * @userData: if using SAX, this pointer will be provided on callbacks.
  *
  * parse an HTML file and build a tree. Automatic support for ZLIB/Compress
  * compressed document is provided by default if found at compile-time.
  * It use the given SAX function block to handle the parsing callback.
  * If sax is NULL, fallback to the default DOM tree building routines.
  *
  * Returns the resulting document tree unless SAX is NULL or the document is
  *     not well formed.
  */
 
 htmlDocPtr
-htmlSAXParseFile(const char *filename, const char *encoding, htmlSAXHandlerPtr sax, 
+htmlSAXParseFile(const char *filename, const char *encoding, htmlSAXHandlerPtr sax,
                  void *userData) {
     htmlDocPtr ret;
     htmlParserCtxtPtr ctxt;
     htmlSAXHandlerPtr oldsax = NULL;
 
     xmlInitParser();
 
     ctxt = htmlCreateFileParserCtxt(filename, encoding);
     if (ctxt == NULL) return(NULL);
     if (sax != NULL) {
         oldsax = ctxt->sax;
         ctxt->sax = sax;
         ctxt->userData = userData;
     }
 
     htmlParseDocument(ctxt);
 
     ret = ctxt->myDoc;
     if (sax != NULL) {
         ctxt->sax = oldsax;
         ctxt->userData = NULL;
     }
     htmlFreeParserCtxt(ctxt);
-    
+
     return(ret);
 }
 
 /**
  * htmlParseFile:
  * @filename:  the filename
  * @encoding:  a free form C string describing the HTML document encoding, or NULL
  *
  * parse an HTML file and build a tree. Automatic support for ZLIB/Compress
  * compressed document is provided by default if found at compile-time.
  *
  * Returns the resulting document tree
  */
 
 htmlDocPtr
 htmlParseFile(const char *filename, const char *encoding) {
     return(htmlSAXParseFile(filename, encoding, NULL, NULL));
 }
 
 /**
  * htmlHandleOmittedElem:
- * @val:  int 0 or 1 
+ * @val:  int 0 or 1
  *
  * Set and return the previous value for handling HTML omitted tags.
  *
  * Returns the last value for 0 for no handling, 1 for auto insertion.
  */
 
 int
 htmlHandleOmittedElem(int val) {
     int old = htmlOmittedDefaultValue;
 
@@ skipping 119 matching lines @@
  *                                                                      *
  ************************************************************************/
 /**
  * DICT_FREE:
  * @str:  a string
  *
  * Free a string if it is not owned by the "dict" dictionnary in the
  * current scope
  */
 #define DICT_FREE(str)                                          \
-        if ((str) && ((!dict) ||                                \
+        if ((str) && ((!dict) ||                                \
             (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))  \
             xmlFree((char *)(str));
 
 /**
  * htmlCtxtReset:
  * @ctxt: an HTML parser context
  *
  * Reset a parser context
  */
 void
 htmlCtxtReset(htmlParserCtxtPtr ctxt)
 {
     xmlParserInputPtr input;
     xmlDictPtr dict;
-    
+
     if (ctxt == NULL)
         return;
 
     xmlInitParser();
     dict = ctxt->dict;
 
     while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
         xmlFreeInputStream(input);
     }
     ctxt->inputNr = 0;
@@ skipping 106 matching lines @@
         ctxt->keepBlanks = 1;
     if (options & HTML_PARSE_RECOVER) {
         ctxt->recovery = 1;
         options -= HTML_PARSE_RECOVER;
     } 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;
+    }
     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)
  * @reuse:  keep the context for reuse
  *
  * Common front-end for the htmlRead functions
- * 
+ *
  * Returns the resulting document tree or NULL
  */
 static htmlDocPtr
 htmlDoRead(htmlParserCtxtPtr ctxt, const char *URL, const char *encoding,
           int options, int reuse)
 {
     htmlDocPtr ret;
-    
+
     htmlCtxtUseOptions(ctxt, options);
     ctxt->html = 1;
     if (encoding != NULL) {
         xmlCharEncodingHandlerPtr hdlr;
 
         hdlr = xmlFindCharEncodingHandler(encoding);
-        if (hdlr != NULL)
+        if (hdlr != NULL) {
             xmlSwitchToEncoding(ctxt, hdlr);
+            if (ctxt->input->encoding != NULL)
+              xmlFree((xmlChar *) ctxt->input->encoding);
+            ctxt->input->encoding = xmlStrdup((xmlChar *)encoding);
+        }
     }
     if ((URL != NULL) && (ctxt->input != NULL) &&
         (ctxt->input->filename == NULL))
         ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL);
     htmlParseDocument(ctxt);
     ret = ctxt->myDoc;
     ctxt->myDoc = NULL;
     if (!reuse) {
         if ((ctxt->dictNames) &&
             (ret != NULL) &&
             (ret->dict == ctxt->dict))
             ctxt->dict = NULL;
         xmlFreeParserCtxt(ctxt);
     }
     return (ret);
 }
 
 /**
  * htmlReadDoc:
  * @cur:  a pointer to a zero terminated string
  * @URL:  the base URL to use for the document
  * @encoding:  the document encoding, or NULL
  * @options:  a combination of htmlParserOption(s)
  *
  * parse an XML in-memory document and build a tree.
- * 
+ *
  * Returns the resulting document tree
  */
 htmlDocPtr
 htmlReadDoc(const xmlChar * cur, const char *URL, const char *encoding, int options)
 {
     htmlParserCtxtPtr ctxt;
 
     if (cur == NULL)
         return (NULL);
 
     xmlInitParser();
     ctxt = htmlCreateDocParserCtxt(cur, NULL);
     if (ctxt == NULL)
         return (NULL);
     return (htmlDoRead(ctxt, URL, encoding, options, 0));
 }
 
 /**
  * htmlReadFile:
  * @filename:  a file or URL
  * @encoding:  the document encoding, or NULL
  * @options:  a combination of htmlParserOption(s)
  *
  * parse an XML file from the filesystem or the network.
- * 
+ *
  * Returns the resulting document tree
  */
 htmlDocPtr
 htmlReadFile(const char *filename, const char *encoding, int options)
 {
     htmlParserCtxtPtr ctxt;
 
     xmlInitParser();
     ctxt = htmlCreateFileParserCtxt(filename, encoding);
     if (ctxt == NULL)
         return (NULL);
     return (htmlDoRead(ctxt, NULL, NULL, options, 0));
 }
 
 /**
  * htmlReadMemory:
  * @buffer:  a pointer to a char array
  * @size:  the size of the array
  * @URL:  the base URL to use for the document
  * @encoding:  the document encoding, or NULL
  * @options:  a combination of htmlParserOption(s)
  *
  * parse an XML in-memory document and build a tree.
- * 
+ *
  * Returns the resulting document tree
  */
 htmlDocPtr
 htmlReadMemory(const char *buffer, int size, const char *URL, const char *encoding, int options)
 {
     htmlParserCtxtPtr ctxt;
 
     xmlInitParser();
     ctxt = xmlCreateMemoryParserCtxt(buffer, size);
     if (ctxt == NULL)
         return (NULL);
     htmlDefaultSAXHandlerInit();
     if (ctxt->sax != NULL)
         memcpy(ctxt->sax, &htmlDefaultSAXHandler, sizeof(xmlSAXHandlerV1));
     return (htmlDoRead(ctxt, URL, encoding, options, 0));
 }
 
 /**
  * htmlReadFd:
  * @fd:  an open file descriptor
  * @URL:  the base URL to use for the document
  * @encoding:  the document encoding, or NULL
  * @options:  a combination of htmlParserOption(s)
  *
  * parse an XML from a file descriptor and build a tree.
- * 
+ *
  * Returns the resulting document tree
  */
 htmlDocPtr
 htmlReadFd(int fd, const char *URL, const char *encoding, int options)
 {
     htmlParserCtxtPtr ctxt;
     xmlParserInputBufferPtr input;
     xmlParserInputPtr stream;
 
     if (fd < 0)
@@ skipping 21 matching lines @@
 /**
  * htmlReadIO:
  * @ioread:  an I/O read function
  * @ioclose:  an I/O close function
  * @ioctx:  an I/O handler
  * @URL:  the base URL to use for the document
  * @encoding:  the document encoding, or NULL
  * @options:  a combination of htmlParserOption(s)
  *
  * parse an HTML document from I/O functions and source and build a tree.
- * 
+ *
  * Returns the resulting document tree
  */
 htmlDocPtr
 htmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
           void *ioctx, const char *URL, const char *encoding, int options)
 {
     htmlParserCtxtPtr ctxt;
     xmlParserInputBufferPtr input;
     xmlParserInputPtr stream;
 
@@ skipping 23 matching lines @@
 /**
  * htmlCtxtReadDoc:
  * @ctxt:  an HTML parser context
  * @cur:  a pointer to a zero terminated string
  * @URL:  the base URL to use for the document
  * @encoding:  the document encoding, or NULL
  * @options:  a combination of htmlParserOption(s)
  *
  * parse an XML in-memory document and build a tree.
  * This reuses the existing @ctxt parser context
- * 
+ *
  * Returns the resulting document tree
  */
 htmlDocPtr
 htmlCtxtReadDoc(htmlParserCtxtPtr ctxt, const xmlChar * cur,
                const char *URL, const char *encoding, int options)
 {
     xmlParserInputPtr stream;
 
     if (cur == NULL)
         return (NULL);
@@ skipping 12 matching lines @@
 
 /**
  * htmlCtxtReadFile:
  * @ctxt:  an HTML parser context
  * @filename:  a file or URL
  * @encoding:  the document encoding, or NULL
  * @options:  a combination of htmlParserOption(s)
  *
  * parse an XML file from the filesystem or the network.
  * This reuses the existing @ctxt parser context
- * 
+ *
  * Returns the resulting document tree
  */
 htmlDocPtr
 htmlCtxtReadFile(htmlParserCtxtPtr ctxt, const char *filename,
                 const char *encoding, int options)
 {
     xmlParserInputPtr stream;
 
     if (filename == NULL)
         return (NULL);
@@ skipping 14 matching lines @@
  * htmlCtxtReadMemory:
  * @ctxt:  an HTML parser context
  * @buffer:  a pointer to a char array
  * @size:  the size of the array
  * @URL:  the base URL to use for the document
  * @encoding:  the document encoding, or NULL
  * @options:  a combination of htmlParserOption(s)
  *
  * parse an XML in-memory document and build a tree.
  * This reuses the existing @ctxt parser context
- * 
+ *
  * Returns the resulting document tree
  */
 htmlDocPtr
 htmlCtxtReadMemory(htmlParserCtxtPtr ctxt, const char *buffer, int size,
                   const char *URL, const char *encoding, int options)
 {
     xmlParserInputBufferPtr input;
     xmlParserInputPtr stream;
 
     if (ctxt == NULL)
@@ skipping 21 matching lines @@
 /**
  * htmlCtxtReadFd:
  * @ctxt:  an HTML parser context
  * @fd:  an open file descriptor
  * @URL:  the base URL to use for the document
  * @encoding:  the document encoding, or NULL
  * @options:  a combination of htmlParserOption(s)
  *
  * parse an XML from a file descriptor and build a tree.
  * This reuses the existing @ctxt parser context
- * 
+ *
  * Returns the resulting document tree
  */
 htmlDocPtr
 htmlCtxtReadFd(htmlParserCtxtPtr ctxt, int fd,
               const char *URL, const char *encoding, int options)
 {
     xmlParserInputBufferPtr input;
     xmlParserInputPtr stream;
 
     if (fd < 0)
@@ skipping 21 matching lines @@
  * @ctxt:  an HTML parser context
  * @ioread:  an I/O read function
  * @ioclose:  an I/O close function
  * @ioctx:  an I/O handler
  * @URL:  the base URL to use for the document
  * @encoding:  the document encoding, or NULL
  * @options:  a combination of htmlParserOption(s)
  *
  * parse an HTML document from I/O functions and source and build a tree.
  * This reuses the existing @ctxt parser context
- * 
+ *
  * Returns the resulting document tree
  */
 htmlDocPtr
 htmlCtxtReadIO(htmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
               xmlInputCloseCallback ioclose, void *ioctx,
               const char *URL,
               const char *encoding, int options)
 {
     xmlParserInputBufferPtr input;
     xmlParserInputPtr stream;
@@ skipping 14 matching lines @@
         xmlFreeParserInputBuffer(input);
         return (NULL);
     }
     inputPush(ctxt, stream);
     return (htmlDoRead(ctxt, URL, encoding, options, 1));
 }
 
 #define bottom_HTMLparser
 #include "elfgcchack.h"
 #endif /* LIBXML_HTML_ENABLED */