/*
 * HTMLparser.c : an HTML parser
 *
 * References:
 *   HTML Living Standard
 *     https://html.spec.whatwg.org/multipage/parsing.html
 *
 * Tokenization now conforms to HTML5. Tree construction still follows
 * a custom, non-standard implementation. See:
 *
 *     https://gitlab.gnome.org/GNOME/libxml2/-/issues/211
 *
 * See Copyright for the status of this software.
 *
 * Author: Daniel Veillard
 */

#define IN_LIBXML
#include "libxml.h"
#ifdef LIBXML_HTML_ENABLED

#include <string.h>
#include <ctype.h>
#include <stdlib.h>

#include <libxml/HTMLparser.h>
#include <libxml/xmlmemory.h>
#include <libxml/tree.h>
#include <libxml/parser.h>
#include <libxml/parserInternals.h>
#include <libxml/xmlerror.h>
#include <libxml/HTMLtree.h>
#include <libxml/entities.h>
#include <libxml/encoding.h>
#include <libxml/xmlIO.h>
#include <libxml/uri.h>

#include "private/buf.h"
#include "private/dict.h"
#include "private/enc.h"
#include "private/error.h"
#include "private/html.h"
#include "private/io.h"
#include "private/memory.h"
#include "private/parser.h"
#include "private/tree.h"

#define HTML_MAX_NAMELEN 1000
#define HTML_MAX_ATTRS 100000000 /* 100 million */
#define HTML_PARSER_BIG_BUFFER_SIZE 1000
#define HTML_PARSER_BUFFER_SIZE 100

#define IS_HEX_DIGIT(c) \
    ((IS_ASCII_DIGIT(c)) || \
     ((((c) | 0x20) >= 'a') && (((c) | 0x20) <= 'f')))

#define IS_UPPER(c) \
    (((c) >= 'A') && ((c) <= 'Z'))

#define IS_ALNUM(c) \
    (IS_ASCII_LETTER(c) || IS_ASCII_DIGIT(c))

typedef enum {
    INSERT_INITIAL = 1,
    INSERT_IN_HEAD = 3,
    INSERT_IN_BODY = 10
} htmlInsertMode;

typedef const unsigned htmlAsciiMask[2];

static htmlAsciiMask MASK_DQ = {
    0,
    1u << ('"' - 32),
};
static htmlAsciiMask MASK_SQ = {
    0,
    1u << ('\'' - 32),
};
static htmlAsciiMask MASK_GT = {
    0,
    1u << ('>' - 32),
};
static htmlAsciiMask MASK_DASH = {
    0,
    1u << ('-' - 32),
};
static htmlAsciiMask MASK_WS_GT = {
    1u << 0x09 | 1u << 0x0A | 1u << 0x0C | 1u << 0x0D,
    1u << (' ' - 32) | 1u << ('>' - 32),
};
static htmlAsciiMask MASK_DQ_GT = {
    0,
    1u << ('"' - 32) | 1u << ('>' - 32),
};
static htmlAsciiMask MASK_SQ_GT = {
    0,
    1u << ('\'' - 32) | 1u << ('>' - 32),
};

static int htmlOmittedDefaultValue = 1;

static int
htmlParseElementInternal(htmlParserCtxtPtr ctxt);

/************************************************************************
 *									*
 *		Some factorized error routines				*
 *									*
 ************************************************************************/

/**
 * Handle an out-of-memory error
 *
 * @param ctxt  an HTML parser context
 */
static void
htmlErrMemory(xmlParserCtxtPtr ctxt)
{
    xmlCtxtErrMemory(ctxt);
}

/**
 * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 *
 * @param ctxt  an HTML parser context
 * @param error  the error number
 * @param msg  the error message
 * @param str1  string infor
 * @param str2  string infor
 */
static void LIBXML_ATTR_FORMAT(3,0)
htmlParseErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
             const char *msg, const xmlChar *str1, const xmlChar *str2)
{
    xmlCtxtErr(ctxt, NULL, XML_FROM_HTML, error, XML_ERR_ERROR,
               str1, str2, NULL, 0, msg, str1, str2);
}

/************************************************************************
 *									*
 *	Parser stacks related functions and macros		*
 *									*
 ************************************************************************/

/**
 * Pushes a new element name on top of the name stack
 *
 * @param ctxt  an HTML parser context
 * @param value  the element name
 * @returns -1 in case of error, the index in the stack otherwise
 */
static int
htmlnamePush(htmlParserCtxtPtr ctxt, const xmlChar * value)
{
    if ((ctxt->html < INSERT_IN_HEAD) && (xmlStrEqual(value, BAD_CAST "head")))
        ctxt->html = INSERT_IN_HEAD;
    if ((ctxt->html < INSERT_IN_BODY) && (xmlStrEqual(value, BAD_CAST "body")))
        ctxt->html = INSERT_IN_BODY;
    if (ctxt->nameNr >= ctxt->nameMax) {
        const xmlChar **tmp;
        int newSize;

        newSize = xmlGrowCapacity(ctxt->nameMax, sizeof(tmp[0]),
                                  10, XML_MAX_ITEMS);
        if (newSize < 0) {
            htmlErrMemory(ctxt);
            return (-1);
        }
        tmp = xmlRealloc(ctxt->nameTab, newSize * sizeof(tmp[0]));
        if (tmp == NULL) {
            htmlErrMemory(ctxt);
            return(-1);
        }
        ctxt->nameTab = tmp;
        ctxt->nameMax = newSize;
    }
    ctxt->nameTab[ctxt->nameNr] = value;
    ctxt->name = value;
    return (ctxt->nameNr++);
}
/**
 * Pops the top element name from the name stack
 *
 * @param ctxt  an HTML parser context
 * @returns the name just removed
 */
static const xmlChar *
htmlnamePop(htmlParserCtxtPtr ctxt)
{
    const xmlChar *ret;

    if (ctxt->nameNr <= 0)
        return (NULL);
    ctxt->nameNr--;
    if (ctxt->nameNr < 0)
        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);
}

/**
 * Pushes a new element name on top of the node info stack
 *
 * @param ctxt  an HTML parser context
 * @param value  the node info
 * @returns 0 in case of error, the index in the stack otherwise
 */
static int
htmlNodeInfoPush(htmlParserCtxtPtr ctxt, htmlParserNodeInfo *value)
{
    if (ctxt->nodeInfoNr >= ctxt->nodeInfoMax) {
        xmlParserNodeInfo *tmp;
        int newSize;

        newSize = xmlGrowCapacity(ctxt->nodeInfoMax, sizeof(tmp[0]),
                                  5, XML_MAX_ITEMS);
        if (newSize < 0) {
            htmlErrMemory(ctxt);
            return (0);
        }
        tmp = xmlRealloc(ctxt->nodeInfoTab, newSize * sizeof(tmp[0]));
        if (tmp == NULL) {
            htmlErrMemory(ctxt);
            return (0);
        }
        ctxt->nodeInfoTab = tmp;
        ctxt->nodeInfoMax = newSize;
    }
    ctxt->nodeInfoTab[ctxt->nodeInfoNr] = *value;
    ctxt->nodeInfo = &ctxt->nodeInfoTab[ctxt->nodeInfoNr];
    return (ctxt->nodeInfoNr++);
}

/**
 * Pops the top element name from the node info stack
 *
 * @param ctxt  an HTML parser context
 * @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
 *           only to compare to ASCII values otherwise it would break when
 *           running with UTF-8 encoding.
 *   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
 *           to compare on ASCII based substring.
 *   UPP(n)  returns the n'th next xmlChar converted to uppercase. Same as CUR
 *           it should be used only to compare on ASCII based substring.
 *   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
 *           strings without newlines within the parser.
 *
 * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding
 *
 *   COPY(to) copy one char to *to, increment CUR_PTR and to accordingly
 */

#define UPPER (toupper(*ctxt->input->cur))

#define SKIP(val) ctxt->input->cur += (val),ctxt->input->col+=(val)

#define NXT(val) ctxt->input->cur[(val)]

#define UPP(val) (toupper(ctxt->input->cur[(val)]))

#define CUR_PTR ctxt->input->cur
#define BASE_PTR ctxt->input->base

#define SHRINK \
    if ((!PARSER_PROGRESSIVE(ctxt)) && \
        (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
	(ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
	xmlParserShrink(ctxt);

#define GROW \
    if ((!PARSER_PROGRESSIVE(ctxt)) && \
        (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \
	xmlParserGrow(ctxt);

#define SKIP_BLANKS htmlSkipBlankChars(ctxt)

/* Imported from XML */

#define CUR (*ctxt->input->cur)

/**
 * Prescan to find encoding.
 *
 * Try to find an encoding in the current data available in the input
 * buffer.
 *
 * TODO: Implement HTML5 prescan algorithm.
 *
 * @param ctxt  the HTML parser context
 * @returns  an encoding string or NULL if not found
 */
static xmlChar *
htmlFindEncoding(xmlParserCtxtPtr ctxt) {
    const xmlChar *start, *cur, *end;
    xmlChar *ret;

    if ((ctxt == NULL) || (ctxt->input == NULL) ||
        (ctxt->input->flags & XML_INPUT_HAS_ENCODING))
        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 ((IS_ALNUM(*cur)) ||
           (*cur == '-') || (*cur == '_') || (*cur == ':') || (*cur == '/'))
           cur++;
    if (cur == start)
        return(NULL);
    ret = xmlStrndup(start, cur - start);
    if (ret == NULL)
        htmlErrMemory(ctxt);
    return(ret);
}

static int
htmlMaskMatch(htmlAsciiMask mask, unsigned c) {
    if (c >= 64)
        return(0);
    return((mask[c/32] >> (c & 31)) & 1);
}

static int
htmlValidateUtf8(xmlParserCtxtPtr ctxt, const xmlChar *str, size_t len,
                 int partial) {
    unsigned c = str[0];
    int size;

    if (c < 0xC2) {
        goto invalid;
    } else if (c < 0xE0) {
        if (len < 2)
            goto incomplete;
        if ((str[1] & 0xC0) != 0x80)
            goto invalid;
        size = 2;
    } else if (c < 0xF0) {
        unsigned v;

        if (len < 3)
            goto incomplete;

        v = str[1] << 8 | str[2]; /* hint to generate 16-bit load */
        v |= c << 16;

        if (((v & 0x00C0C0) != 0x008080) ||
            ((v & 0x0F2000) == 0x000000) ||
            ((v & 0x0F2000) == 0x0D2000))
            goto invalid;

        size = 3;
    } else {
        unsigned v;

        if (len < 4)
            goto incomplete;

        v = c << 24 | str[1] << 16 | str[2] << 8 | str[3];

        if (((v & 0x00C0C0C0) != 0x00808080) ||
            (v < 0xF0900000) || (v >= 0xF4900000))
            goto invalid;

        size = 4;
    }

    return(size);

incomplete:
    if (partial)
        return(0);

invalid:
    /* Only report the first error */
    if ((ctxt->input->flags & XML_INPUT_ENCODING_ERROR) == 0) {
        htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING,
                     "Invalid bytes in character encoding\n", NULL, NULL);
        ctxt->input->flags |= XML_INPUT_ENCODING_ERROR;
    }

    return(-1);
}

/**
 * skip all blanks character found at that point in the input streams.
 *
 * @param ctxt  the HTML parser context
 * @returns the number of space chars skipped
 */

static int
htmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
    const xmlChar *cur = ctxt->input->cur;
    size_t avail = ctxt->input->end - cur;
    int res = 0;
    int line = ctxt->input->line;
    int col = ctxt->input->col;

    while (!PARSER_STOPPED(ctxt)) {
        if (avail == 0) {
            ctxt->input->cur = cur;
            GROW;
            cur = ctxt->input->cur;
            avail = ctxt->input->end - cur;

            if (avail == 0)
                break;
        }

        if (*cur == '\n') {
            line++;
            col = 1;
        } else if (IS_WS_HTML(*cur)) {
            col++;
        } else {
            break;
        }

        cur += 1;
        avail -= 1;

	if (res < INT_MAX)
	    res++;
    }

    ctxt->input->cur = cur;
    ctxt->input->line = line;
    ctxt->input->col = col;

    if (res > 8)
        GROW;

    return(res);
}


/************************************************************************
 *									*
 *	The list of HTML elements and their properties		*
 *									*
 ************************************************************************/

/*
 *  Start Tag: 1 means the start tag can be omitted
 *  End Tag:   1 means the end tag can be omitted
 *             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
 */

static const htmlElemDesc
html40ElementTable[] = {
{ "a",		0, 0, 0, 0, 0, 0, 1, "anchor ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "abbr",	0, 0, 0, 0, 0, 0, 1, "abbreviated form",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "acronym",	0, 0, 0, 0, 0, 0, 1, "",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "address",	0, 0, 0, 0, 0, 0, 0, "information on author ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "applet",	0, 0, 0, 0, 1, 1, 2, "java applet ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "area",	0, 2, 2, 1, 0, 0, 0, "client-side image map area ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "b",		0, 3, 0, 0, 0, 0, 1, "bold text style",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "base",	0, 2, 2, 1, 0, 0, 0, "document base uri ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "basefont",	0, 2, 2, 1, 1, 1, 1, "base font size " ,
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "bdo",	0, 0, 0, 0, 0, 0, 1, "i18n bidi over-ride ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "bgsound",	0, 0, 2, 1, 0, 0, 0, "",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "big",	0, 3, 0, 0, 0, 0, 1, "large text style",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "blockquote",	0, 0, 0, 0, 0, 0, 0, "long quotation ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "body",	1, 1, 0, 0, 0, 0, 0, "document body ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "br",		0, 2, 2, 1, 0, 0, 1, "forced line break ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "button",	0, 0, 0, 0, 0, 0, 2, "push button ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "caption",	0, 0, 0, 0, 0, 0, 0, "table caption ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "center",	0, 3, 0, 0, 1, 1, 0, "shorthand for div align=center ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "cite",	0, 0, 0, 0, 0, 0, 1, "citation",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "code",	0, 0, 0, 0, 0, 0, 1, "computer code fragment",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "col",	0, 2, 2, 1, 0, 0, 0, "table column ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "colgroup",	0, 1, 0, 0, 0, 0, 0, "table column group ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "dd",		0, 1, 0, 0, 0, 0, 0, "definition description ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "del",	0, 0, 0, 0, 0, 0, 2, "deleted text ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "dfn",	0, 0, 0, 0, 0, 0, 1, "instance definition",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "dir",	0, 0, 0, 0, 1, 1, 0, "directory list",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "div",	0, 0, 0, 0, 0, 0, 0, "generic language/style container",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "dl",		0, 0, 0, 0, 0, 0, 0, "definition list ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "dt",		0, 1, 0, 0, 0, 0, 0, "definition term ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "em",		0, 3, 0, 0, 0, 0, 1, "emphasis",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "embed",	0, 1, 2, 1, 1, 1, 1, "generic embedded object ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "fieldset",	0, 0, 0, 0, 0, 0, 0, "form control group ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "font",	0, 3, 0, 0, 1, 1, 1, "local change to font ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "form",	0, 0, 0, 0, 0, 0, 0, "interactive form ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "frame",	0, 2, 2, 1, 0, 2, 0, "subwindow " ,
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "frameset",	0, 0, 0, 0, 0, 2, 0, "window subdivision" ,
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "h1",		0, 0, 0, 0, 0, 0, 0, "heading ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "h2",		0, 0, 0, 0, 0, 0, 0, "heading ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "h3",		0, 0, 0, 0, 0, 0, 0, "heading ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "h4",		0, 0, 0, 0, 0, 0, 0, "heading ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "h5",		0, 0, 0, 0, 0, 0, 0, "heading ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "h6",		0, 0, 0, 0, 0, 0, 0, "heading ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "head",	1, 1, 0, 0, 0, 0, 0, "document head ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "hr",		0, 2, 2, 1, 0, 0, 0, "horizontal rule " ,
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "html",	1, 1, 0, 0, 0, 0, 0, "document root element ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "i",		0, 3, 0, 0, 0, 0, 1, "italic text style",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "iframe",	0, 0, 0, 0, 0, 1, 2, "inline subwindow ",
	NULL, NULL, NULL, NULL, NULL,
	DATA_RAWTEXT
},
{ "img",	0, 2, 2, 1, 0, 0, 1, "embedded image ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "input",	0, 2, 2, 1, 0, 0, 1, "form control ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "ins",	0, 0, 0, 0, 0, 0, 2, "inserted text",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "isindex",	0, 2, 2, 1, 1, 1, 0, "single line prompt ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "kbd",	0, 0, 0, 0, 0, 0, 1, "text to be entered by the user",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "keygen",	0, 0, 2, 1, 0, 0, 0, "",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "label",	0, 0, 0, 0, 0, 0, 1, "form field label text ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "legend",	0, 0, 0, 0, 0, 0, 0, "fieldset legend ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "li",		0, 1, 1, 0, 0, 0, 0, "list item ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "link",	0, 2, 2, 1, 0, 0, 0, "a media-independent link ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "map",	0, 0, 0, 0, 0, 0, 2, "client-side image map ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "menu",	0, 0, 0, 0, 1, 1, 0, "menu list ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "meta",	0, 2, 2, 1, 0, 0, 0, "generic metainformation ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "noembed",	0, 0, 0, 0, 0, 0, 0, "",
	NULL, NULL, NULL, NULL, NULL,
	DATA_RAWTEXT
},
{ "noframes",	0, 0, 0, 0, 0, 2, 0, "alternate content container for non frame-based rendering ",
	NULL, NULL, NULL, NULL, NULL,
	DATA_RAWTEXT
},
{ "noscript",	0, 0, 0, 0, 0, 0, 0, "alternate content container for non script-based rendering ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "object",	0, 0, 0, 0, 0, 0, 2, "generic embedded object ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "ol",		0, 0, 0, 0, 0, 0, 0, "ordered list ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "optgroup",	0, 0, 0, 0, 0, 0, 0, "option group ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "option",	0, 1, 0, 0, 0, 0, 0, "selectable choice " ,
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "p",		0, 1, 0, 0, 0, 0, 0, "paragraph ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "param",	0, 2, 2, 1, 0, 0, 0, "named property value ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "plaintext",	0, 0, 0, 0, 0, 0, 0, "",
	NULL, NULL, NULL, NULL, NULL,
	DATA_PLAINTEXT
},
{ "pre",	0, 0, 0, 0, 0, 0, 0, "preformatted text ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "q",		0, 0, 0, 0, 0, 0, 1, "short inline quotation ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "s",		0, 3, 0, 0, 1, 1, 1, "strike-through text style",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "samp",	0, 0, 0, 0, 0, 0, 1, "sample program output, scripts, etc.",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "script",	0, 0, 0, 0, 0, 0, 2, "script statements ",
	NULL, NULL, NULL, NULL, NULL,
	DATA_SCRIPT
},
{ "select",	0, 0, 0, 0, 0, 0, 1, "option selector ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "small",	0, 3, 0, 0, 0, 0, 1, "small text style",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "source",	0, 0, 2, 1, 0, 0, 0, "",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "span",	0, 0, 0, 0, 0, 0, 1, "generic language/style container ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "strike",	0, 3, 0, 0, 1, 1, 1, "strike-through text",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "strong",	0, 3, 0, 0, 0, 0, 1, "strong emphasis",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "style",	0, 0, 0, 0, 0, 0, 0, "style info ",
	NULL, NULL, NULL, NULL, NULL,
	DATA_RAWTEXT
},
{ "sub",	0, 3, 0, 0, 0, 0, 1, "subscript",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "sup",	0, 3, 0, 0, 0, 0, 1, "superscript ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "table",	0, 0, 0, 0, 0, 0, 0, "",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "tbody",	1, 0, 0, 0, 0, 0, 0, "table body ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "td",		0, 0, 0, 0, 0, 0, 0, "table data cell",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "textarea",	0, 0, 0, 0, 0, 0, 1, "multi-line text field ",
	NULL, NULL, NULL, NULL, NULL,
	DATA_RCDATA
},
{ "tfoot",	0, 1, 0, 0, 0, 0, 0, "table footer ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "th",		0, 1, 0, 0, 0, 0, 0, "table header cell",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "thead",	0, 1, 0, 0, 0, 0, 0, "table header ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "title",	0, 0, 0, 0, 0, 0, 0, "document title ",
	NULL, NULL, NULL, NULL, NULL,
	DATA_RCDATA
},
{ "tr",		0, 0, 0, 0, 0, 0, 0, "table row ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "track",	0, 0, 2, 1, 0, 0, 0, "",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "tt",		0, 3, 0, 0, 0, 0, 1, "teletype or monospaced text style",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "u",		0, 3, 0, 0, 1, 1, 1, "underlined text style",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "ul",		0, 0, 0, 0, 0, 0, 0, "unordered list ",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "var",	0, 0, 0, 0, 0, 0, 1, "instance of a variable or program argument",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "wbr",	0, 0, 2, 1, 0, 0, 0, "",
	NULL, NULL, NULL, NULL, NULL,
	0
},
{ "xmp",	0, 0, 0, 0, 0, 0, 1, "",
	NULL, NULL, NULL, NULL, NULL,
	DATA_RAWTEXT
}
};

typedef struct {
    const char *oldTag;
    const char *newTag;
} htmlStartCloseEntry;

/*
 * start tags that imply the end of current element
 */
static const htmlStartCloseEntry htmlStartClose[] = {
    { "a", "a" },
    { "a", "fieldset" },
    { "a", "table" },
    { "a", "td" },
    { "a", "th" },
    { "address", "dd" },
    { "address", "dl" },
    { "address", "dt" },
    { "address", "form" },
    { "address", "li" },
    { "address", "ul" },
    { "b", "center" },
    { "b", "p" },
    { "b", "td" },
    { "b", "th" },
    { "big", "p" },
    { "caption", "col" },
    { "caption", "colgroup" },
    { "caption", "tbody" },
    { "caption", "tfoot" },
    { "caption", "thead" },
    { "caption", "tr" },
    { "col", "col" },
    { "col", "colgroup" },
    { "col", "tbody" },
    { "col", "tfoot" },
    { "col", "thead" },
    { "col", "tr" },
    { "colgroup", "colgroup" },
    { "colgroup", "tbody" },
    { "colgroup", "tfoot" },
    { "colgroup", "thead" },
    { "colgroup", "tr" },
    { "dd", "dt" },
    { "dir", "dd" },
    { "dir", "dl" },
    { "dir", "dt" },
    { "dir", "form" },
    { "dir", "ul" },
    { "dl", "form" },
    { "dl", "li" },
    { "dt", "dd" },
    { "dt", "dl" },
    { "font", "center" },
    { "font", "td" },
    { "font", "th" },
    { "form", "form" },
    { "h1", "fieldset" },
    { "h1", "form" },
    { "h1", "li" },
    { "h1", "p" },
    { "h1", "table" },
    { "h2", "fieldset" },
    { "h2", "form" },
    { "h2", "li" },
    { "h2", "p" },
    { "h2", "table" },
    { "h3", "fieldset" },
    { "h3", "form" },
    { "h3", "li" },
    { "h3", "p" },
    { "h3", "table" },
    { "h4", "fieldset" },
    { "h4", "form" },
    { "h4", "li" },
    { "h4", "p" },
    { "h4", "table" },
    { "h5", "fieldset" },
    { "h5", "form" },
    { "h5", "li" },
    { "h5", "p" },
    { "h5", "table" },
    { "h6", "fieldset" },
    { "h6", "form" },
    { "h6", "li" },
    { "h6", "p" },
    { "h6", "table" },
    { "head", "a" },
    { "head", "abbr" },
    { "head", "acronym" },
    { "head", "address" },
    { "head", "b" },
    { "head", "bdo" },
    { "head", "big" },
    { "head", "blockquote" },
    { "head", "body" },
    { "head", "br" },
    { "head", "center" },
    { "head", "cite" },
    { "head", "code" },
    { "head", "dd" },
    { "head", "dfn" },
    { "head", "dir" },
    { "head", "div" },
    { "head", "dl" },
    { "head", "dt" },
    { "head", "em" },
    { "head", "fieldset" },
    { "head", "font" },
    { "head", "form" },
    { "head", "frameset" },
    { "head", "h1" },
    { "head", "h2" },
    { "head", "h3" },
    { "head", "h4" },
    { "head", "h5" },
    { "head", "h6" },
    { "head", "hr" },
    { "head", "i" },
    { "head", "iframe" },
    { "head", "img" },
    { "head", "kbd" },
    { "head", "li" },
    { "head", "listing" },
    { "head", "map" },
    { "head", "menu" },
    { "head", "ol" },
    { "head", "p" },
    { "head", "pre" },
    { "head", "q" },
    { "head", "s" },
    { "head", "samp" },
    { "head", "small" },
    { "head", "span" },
    { "head", "strike" },
    { "head", "strong" },
    { "head", "sub" },
    { "head", "sup" },
    { "head", "table" },
    { "head", "tt" },
    { "head", "u" },
    { "head", "ul" },
    { "head", "var" },
    { "head", "xmp" },
    { "hr", "form" },
    { "i", "center" },
    { "i", "p" },
    { "i", "td" },
    { "i", "th" },
    { "legend", "fieldset" },
    { "li", "li" },
    { "link", "body" },
    { "link", "frameset" },
    { "listing", "dd" },
    { "listing", "dl" },
    { "listing", "dt" },
    { "listing", "fieldset" },
    { "listing", "form" },
    { "listing", "li" },
    { "listing", "table" },
    { "listing", "ul" },
    { "menu", "dd" },
    { "menu", "dl" },
    { "menu", "dt" },
    { "menu", "form" },
    { "menu", "ul" },
    { "ol", "form" },
    { "option", "optgroup" },
    { "option", "option" },
    { "p", "address" },
    { "p", "blockquote" },
    { "p", "body" },
    { "p", "caption" },
    { "p", "center" },
    { "p", "col" },
    { "p", "colgroup" },
    { "p", "dd" },
    { "p", "dir" },
    { "p", "div" },
    { "p", "dl" },
    { "p", "dt" },
    { "p", "fieldset" },
    { "p", "form" },
    { "p", "frameset" },
    { "p", "h1" },
    { "p", "h2" },
    { "p", "h3" },
    { "p", "h4" },
    { "p", "h5" },
    { "p", "h6" },
    { "p", "head" },
    { "p", "hr" },
    { "p", "li" },
    { "p", "listing" },
    { "p", "menu" },
    { "p", "ol" },
    { "p", "p" },
    { "p", "pre" },
    { "p", "table" },
    { "p", "tbody" },
    { "p", "td" },
    { "p", "tfoot" },
    { "p", "th" },
    { "p", "title" },
    { "p", "tr" },
    { "p", "ul" },
    { "p", "xmp" },
    { "pre", "dd" },
    { "pre", "dl" },
    { "pre", "dt" },
    { "pre", "fieldset" },
    { "pre", "form" },
    { "pre", "li" },
    { "pre", "table" },
    { "pre", "ul" },
    { "s", "p" },
    { "script", "noscript" },
    { "small", "p" },
    { "span", "td" },
    { "span", "th" },
    { "strike", "p" },
    { "style", "body" },
    { "style", "frameset" },
    { "tbody", "tbody" },
    { "tbody", "tfoot" },
    { "td", "tbody" },
    { "td", "td" },
    { "td", "tfoot" },
    { "td", "th" },
    { "td", "tr" },
    { "tfoot", "tbody" },
    { "th", "tbody" },
    { "th", "td" },
    { "th", "tfoot" },
    { "th", "th" },
    { "th", "tr" },
    { "thead", "tbody" },
    { "thead", "tfoot" },
    { "title", "body" },
    { "title", "frameset" },
    { "tr", "tbody" },
    { "tr", "tfoot" },
    { "tr", "tr" },
    { "tt", "p" },
    { "u", "p" },
    { "u", "td" },
    { "u", "th" },
    { "ul", "address" },
    { "ul", "form" },
    { "ul", "menu" },
    { "ul", "pre" },
    { "xmp", "dd" },
    { "xmp", "dl" },
    { "xmp", "dt" },
    { "xmp", "fieldset" },
    { "xmp", "form" },
    { "xmp", "li" },
    { "xmp", "table" },
    { "xmp", "ul" }
};

/*
 * The list of HTML attributes which are of content %Script;
 * NOTE: when adding ones, check #htmlIsScriptAttribute since
 *       it assumes the name starts with 'on'
 */
static const char *const htmlScriptAttributes[] = {
    "onclick",
    "ondblclick",
    "onmousedown",
    "onmouseup",
    "onmouseover",
    "onmousemove",
    "onmouseout",
    "onkeypress",
    "onkeydown",
    "onkeyup",
    "onload",
    "onunload",
    "onfocus",
    "onblur",
    "onsubmit",
    "onreset",
    "onchange",
    "onselect"
};

/*
 * This table is used by the htmlparser to know what to do with
 * broken html pages. By assigning different priorities to different
 * elements the parser can decide how to handle extra endtags.
 * Endtags are only allowed to close elements with lower or equal
 * priority.
 */

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 */
};

/************************************************************************
 *									*
 *	functions to handle HTML specific data			*
 *									*
 ************************************************************************/

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);
    }
}

/**
 * @deprecated This is a no-op.
 */
void
htmlInitAutoClose(void) {
}

static int
htmlCompareTags(const void *key, const void *member) {
    const xmlChar *tag = (const xmlChar *) key;
    const htmlElemDesc *desc = (const htmlElemDesc *) member;

    return(xmlStrcasecmp(tag, BAD_CAST desc->name));
}

/**
 * Lookup the HTML tag in the ElementTable
 *
 * @deprecated Only supports HTML 4.
 *
 * @param tag  The tag name in lowercase
 * @returns the related htmlElemDesc or NULL if not found.
 */
const htmlElemDesc *
htmlTagLookup(const xmlChar *tag) {
    if (tag == NULL)
        return(NULL);

    return((const htmlElemDesc *) bsearch(tag, html40ElementTable,
                sizeof(html40ElementTable) / sizeof(htmlElemDesc),
                sizeof(htmlElemDesc), htmlCompareTags));
}

/**
 * @param name  The name of the element to look up the priority for.
 * @returns 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++;

    return(htmlEndPriority[i].priority);
}


static int
htmlCompareStartClose(const void *vkey, const void *member) {
    const htmlStartCloseEntry *key = (const htmlStartCloseEntry *) vkey;
    const htmlStartCloseEntry *entry = (const htmlStartCloseEntry *) member;
    int ret;

    ret = strcmp(key->oldTag, entry->oldTag);
    if (ret == 0)
        ret = strcmp(key->newTag, entry->newTag);

    return(ret);
}

/**
 * Checks whether the new tag is one of the registered valid tags for
 * closing old.
 *
 * @param newtag  The new tag name
 * @param oldtag  The old tag name
 * @returns 0 if no, 1 if yes.
 */
static int
htmlCheckAutoClose(const xmlChar * newtag, const xmlChar * oldtag)
{
    htmlStartCloseEntry key;
    void *res;

    key.oldTag = (const char *) oldtag;
    key.newTag = (const char *) newtag;
    res = bsearch(&key, htmlStartClose,
            sizeof(htmlStartClose) / sizeof(htmlStartCloseEntry),
            sizeof(htmlStartCloseEntry), htmlCompareStartClose);
    return(res != NULL);
}

/**
 * The HTML DTD allows an ending tag to implicitly close other tags.
 *
 * @param ctxt  an HTML parser context
 * @param newtag  The new tag name
 */
static void
htmlAutoCloseOnClose(htmlParserCtxtPtr ctxt, const xmlChar * newtag)
{
    const htmlElemDesc *info;
    int i, priority;

    if (ctxt->options & HTML_PARSE_HTML5)
        return;

    priority = htmlGetEndPriority(newtag);

    for (i = (ctxt->nameNr - 1); i >= 0; i--) {

        if (xmlStrEqual(newtag, ctxt->nameTab[i]))
            break;
        /*
         * A misplaced 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
         */
        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)) {
            htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
	                 "Opening and ending tag mismatch: %s and %s\n",
			 newtag, ctxt->name);
        }
	htmlParserFinishElementParsing(ctxt);
        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
            ctxt->sax->endElement(ctxt->userData, ctxt->name);
	htmlnamePop(ctxt);
    }
}

/**
 * Close all remaining tags at the end of the stream
 *
 * @param ctxt  an HTML parser context
 */
static void
htmlAutoCloseOnEnd(htmlParserCtxtPtr ctxt)
{
    int i;

    if (ctxt->options & HTML_PARSE_HTML5)
        return;

    if (ctxt->nameNr == 0)
        return;
    for (i = (ctxt->nameNr - 1); i >= 0; i--) {
	htmlParserFinishElementParsing(ctxt);
        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
            ctxt->sax->endElement(ctxt->userData, ctxt->name);
	htmlnamePop(ctxt);
    }
}

/**
 * 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
 *
 * @param ctxt  an HTML parser context
 * @param newtag  The new tag name or NULL
 */
static void
htmlAutoClose(htmlParserCtxtPtr ctxt, const xmlChar * newtag)
{
    if (ctxt->options & HTML_PARSE_HTML5)
        return;

    if (newtag == NULL)
        return;

    while ((ctxt->name != NULL) &&
           (htmlCheckAutoClose(newtag, ctxt->name))) {
	htmlParserFinishElementParsing(ctxt);
        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
            ctxt->sax->endElement(ctxt->userData, ctxt->name);
	htmlnamePop(ctxt);
    }
}

/**
 * The HTML DTD allows a tag to implicitly close other tags.
 * The list is kept in htmlStartClose array. This function checks
 * if the element or one of it's children would autoclose the
 * given tag.
 *
 * @deprecated Internal function, don't use.
 *
 * @param doc  the HTML document
 * @param name  The tag name
 * @param elem  the HTML element
 * @returns 1 if autoclose, 0 otherwise
 */
int
htmlAutoCloseTag(xmlDoc *doc, const xmlChar *name, xmlNode *elem) {
    htmlNodePtr child;

    if (elem == NULL) return(1);
    if (xmlStrEqual(name, elem->name)) return(0);
    if (htmlCheckAutoClose(elem->name, name)) return(1);
    child = elem->children;
    while (child != NULL) {
        if (htmlAutoCloseTag(doc, name, child)) return(1);
	child = child->next;
    }
    return(0);
}

/**
 * The HTML DTD allows a tag to implicitly close other tags.
 * The list is kept in htmlStartClose array. This function checks
 * if a tag is autoclosed by one of it's child
 *
 * @deprecated Internal function, don't use.
 *
 * @param doc  the HTML document
 * @param elem  the HTML element
 * @returns 1 if autoclosed, 0 otherwise
 */
int
htmlIsAutoClosed(xmlDoc *doc, xmlNode *elem) {
    htmlNodePtr child;

    if (elem == NULL) return(1);
    child = elem->children;
    while (child != NULL) {
	if (htmlAutoCloseTag(doc, elem->name, child)) return(1);
	child = child->next;
    }
    return(0);
}

/**
 * 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
 *
 * @param ctxt  an HTML parser context
 * @param newtag  The new tag name
 */
static void
htmlCheckImplied(htmlParserCtxtPtr ctxt, const xmlChar *newtag) {
    int i;

    if (ctxt->options & (HTML_PARSE_NOIMPLIED | HTML_PARSE_HTML5))
        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) &&
        ((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")))) {
        if (ctxt->html >= INSERT_IN_HEAD) {
            /* 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"))) {
        if (ctxt->html >= INSERT_IN_BODY) {
            /* 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);
    }
}

/**
 * Prepare for non-whitespace character data.
 *
 * @param ctxt  an HTML parser context
 */

static void
htmlStartCharData(htmlParserCtxtPtr ctxt) {
    if (ctxt->options & (HTML_PARSE_NOIMPLIED | HTML_PARSE_HTML5))
        return;
    if (!htmlOmittedDefaultValue)
	return;

    if (xmlStrEqual(ctxt->name, BAD_CAST "head"))
        htmlAutoClose(ctxt, BAD_CAST "p");
    htmlCheckImplied(ctxt, BAD_CAST "p");
}

/**
 * Check if an attribute is of content type Script
 *
 * @deprecated Only supports HTML 4.
 *
 * @param name  an attribute name
 * @returns 1 is the attribute is a script 0 otherwise
 */
int
htmlIsScriptAttribute(const xmlChar *name) {
    unsigned int i;

    if (name == NULL)
      return(0);
    /*
     * all script attributes start with 'on'
     */
    if ((name[0] != 'o') || (name[1] != 'n'))
      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			*
 *									*
 ************************************************************************/


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" },
{ 39,	"apos",	"single quote" },
{ 60,	"lt",	"less-than sign, U+003C ISOnum" },
{ 62,	"gt",	"greater-than sign, U+003E ISOnum" },

/*
 * A bunch still in the 128-255 range
 * Replacing them depend really on the charset used.
 */
{ 160,	"nbsp",	"no-break space = non-breaking space, U+00A0 ISOnum" },
{ 161,	"iexcl","inverted exclamation mark, U+00A1 ISOnum" },
{ 162,	"cent",	"cent sign, U+00A2 ISOnum" },
{ 163,	"pound","pound sign, U+00A3 ISOnum" },
{ 164,	"curren","currency sign, U+00A4 ISOnum" },
{ 165,	"yen",	"yen sign = yuan sign, U+00A5 ISOnum" },
{ 166,	"brvbar","broken bar = broken vertical bar, U+00A6 ISOnum" },
{ 167,	"sect",	"section sign, U+00A7 ISOnum" },
{ 168,	"uml",	"diaeresis = spacing diaeresis, U+00A8 ISOdia" },
{ 169,	"copy",	"copyright sign, U+00A9 ISOnum" },
{ 170,	"ordf",	"feminine ordinal indicator, U+00AA ISOnum" },
{ 171,	"laquo","left-pointing double angle quotation mark = left pointing guillemet, U+00AB ISOnum" },
{ 172,	"not",	"not sign, U+00AC ISOnum" },
{ 173,	"shy",	"soft hyphen = discretionary hyphen, U+00AD ISOnum" },
{ 174,	"reg",	"registered sign = registered trade mark sign, U+00AE ISOnum" },
{ 175,	"macr",	"macron = spacing macron = overline = APL overbar, U+00AF ISOdia" },
{ 176,	"deg",	"degree sign, U+00B0 ISOnum" },
{ 177,	"plusmn","plus-minus sign = plus-or-minus sign, U+00B1 ISOnum" },
{ 178,	"sup2",	"superscript two = superscript digit two = squared, U+00B2 ISOnum" },
{ 179,	"sup3",	"superscript three = superscript digit three = cubed, U+00B3 ISOnum" },
{ 180,	"acute","acute accent = spacing acute, U+00B4 ISOdia" },
{ 181,	"micro","micro sign, U+00B5 ISOnum" },
{ 182,	"para",	"pilcrow sign = paragraph sign, U+00B6 ISOnum" },
{ 183,	"middot","middle dot = Georgian comma Greek middle dot, U+00B7 ISOnum" },
{ 184,	"cedil","cedilla = spacing cedilla, U+00B8 ISOdia" },
{ 185,	"sup1",	"superscript one = superscript digit one, U+00B9 ISOnum" },
{ 186,	"ordm",	"masculine ordinal indicator, U+00BA ISOnum" },
{ 187,	"raquo","right-pointing double angle quotation mark right pointing guillemet, U+00BB ISOnum" },
{ 188,	"frac14","vulgar fraction one quarter = fraction one quarter, U+00BC ISOnum" },
{ 189,	"frac12","vulgar fraction one half = fraction one half, U+00BD ISOnum" },
{ 190,	"frac34","vulgar fraction three quarters = fraction three quarters, U+00BE ISOnum" },
{ 191,	"iquest","inverted question mark = turned question mark, U+00BF ISOnum" },
{ 192,	"Agrave","latin capital letter A with grave = latin capital letter A grave, U+00C0 ISOlat1" },
{ 193,	"Aacute","latin capital letter A with acute, U+00C1 ISOlat1" },
{ 194,	"Acirc","latin capital letter A with circumflex, U+00C2 ISOlat1" },
{ 195,	"Atilde","latin capital letter A with tilde, U+00C3 ISOlat1" },
{ 196,	"Auml",	"latin capital letter A with diaeresis, U+00C4 ISOlat1" },
{ 197,	"Aring","latin capital letter A with ring above = latin capital letter A ring, U+00C5 ISOlat1" },
{ 198,	"AElig","latin capital letter AE = latin capital ligature AE, U+00C6 ISOlat1" },
{ 199,	"Ccedil","latin capital letter C with cedilla, U+00C7 ISOlat1" },
{ 200,	"Egrave","latin capital letter E with grave, U+00C8 ISOlat1" },
{ 201,	"Eacute","latin capital letter E with acute, U+00C9 ISOlat1" },
{ 202,	"Ecirc","latin capital letter E with circumflex, U+00CA ISOlat1" },
{ 203,	"Euml",	"latin capital letter E with diaeresis, U+00CB ISOlat1" },
{ 204,	"Igrave","latin capital letter I with grave, U+00CC ISOlat1" },
{ 205,	"Iacute","latin capital letter I with acute, U+00CD ISOlat1" },
{ 206,	"Icirc","latin capital letter I with circumflex, U+00CE ISOlat1" },
{ 207,	"Iuml",	"latin capital letter I with diaeresis, U+00CF ISOlat1" },
{ 208,	"ETH",	"latin capital letter ETH, U+00D0 ISOlat1" },
{ 209,	"Ntilde","latin capital letter N with tilde, U+00D1 ISOlat1" },
{ 210,	"Ograve","latin capital letter O with grave, U+00D2 ISOlat1" },
{ 211,	"Oacute","latin capital letter O with acute, U+00D3 ISOlat1" },
{ 212,	"Ocirc","latin capital letter O with circumflex, U+00D4 ISOlat1" },
{ 213,	"Otilde","latin capital letter O with tilde, U+00D5 ISOlat1" },
{ 214,	"Ouml",	"latin capital letter O with diaeresis, U+00D6 ISOlat1" },
{ 215,	"times","multiplication sign, U+00D7 ISOnum" },
{ 216,	"Oslash","latin capital letter O with stroke latin capital letter O slash, U+00D8 ISOlat1" },
{ 217,	"Ugrave","latin capital letter U with grave, U+00D9 ISOlat1" },
{ 218,	"Uacute","latin capital letter U with acute, U+00DA ISOlat1" },
{ 219,	"Ucirc","latin capital letter U with circumflex, U+00DB ISOlat1" },
{ 220,	"Uuml",	"latin capital letter U with diaeresis, U+00DC ISOlat1" },
{ 221,	"Yacute","latin capital letter Y with acute, U+00DD ISOlat1" },
{ 222,	"THORN","latin capital letter THORN, U+00DE ISOlat1" },
{ 223,	"szlig","latin small letter sharp s = ess-zed, U+00DF ISOlat1" },
{ 224,	"agrave","latin small letter a with grave = latin small letter a grave, U+00E0 ISOlat1" },
{ 225,	"aacute","latin small letter a with acute, U+00E1 ISOlat1" },
{ 226,	"acirc","latin small letter a with circumflex, U+00E2 ISOlat1" },
{ 227,	"atilde","latin small letter a with tilde, U+00E3 ISOlat1" },
{ 228,	"auml",	"latin small letter a with diaeresis, U+00E4 ISOlat1" },
{ 229,	"aring","latin small letter a with ring above = latin small letter a ring, U+00E5 ISOlat1" },
{ 230,	"aelig","latin small letter ae = latin small ligature ae, U+00E6 ISOlat1" },
{ 231,	"ccedil","latin small letter c with cedilla, U+00E7 ISOlat1" },
{ 232,	"egrave","latin small letter e with grave, U+00E8 ISOlat1" },
{ 233,	"eacute","latin small letter e with acute, U+00E9 ISOlat1" },
{ 234,	"ecirc","latin small letter e with circumflex, U+00EA ISOlat1" },
{ 235,	"euml",	"latin small letter e with diaeresis, U+00EB ISOlat1" },
{ 236,	"igrave","latin small letter i with grave, U+00EC ISOlat1" },
{ 237,	"iacute","latin small letter i with acute, U+00ED ISOlat1" },
{ 238,	"icirc","latin small letter i with circumflex, U+00EE ISOlat1" },
{ 239,	"iuml",	"latin small letter i with diaeresis, U+00EF ISOlat1" },
{ 240,	"eth",	"latin small letter eth, U+00F0 ISOlat1" },
{ 241,	"ntilde","latin small letter n with tilde, U+00F1 ISOlat1" },
{ 242,	"ograve","latin small letter o with grave, U+00F2 ISOlat1" },
{ 243,	"oacute","latin small letter o with acute, U+00F3 ISOlat1" },
{ 244,	"ocirc","latin small letter o with circumflex, U+00F4 ISOlat1" },
{ 245,	"otilde","latin small letter o with tilde, U+00F5 ISOlat1" },
{ 246,	"ouml",	"latin small letter o with diaeresis, U+00F6 ISOlat1" },
{ 247,	"divide","division sign, U+00F7 ISOnum" },
{ 248,	"oslash","latin small letter o with stroke, = latin small letter o slash, U+00F8 ISOlat1" },
{ 249,	"ugrave","latin small letter u with grave, U+00F9 ISOlat1" },
{ 250,	"uacute","latin small letter u with acute, U+00FA ISOlat1" },
{ 251,	"ucirc","latin small letter u with circumflex, U+00FB ISOlat1" },
{ 252,	"uuml",	"latin small letter u with diaeresis, U+00FC ISOlat1" },
{ 253,	"yacute","latin small letter y with acute, U+00FD ISOlat1" },
{ 254,	"thorn","latin small letter thorn with, U+00FE ISOlat1" },
{ 255,	"yuml",	"latin small letter y with diaeresis, U+00FF ISOlat1" },

{ 338,	"OElig","latin capital ligature OE, U+0152 ISOlat2" },
{ 339,	"oelig","latin small ligature oe, U+0153 ISOlat2" },
{ 352,	"Scaron","latin capital letter S with caron, U+0160 ISOlat2" },
{ 353,	"scaron","latin small letter s with caron, U+0161 ISOlat2" },
{ 376,	"Yuml",	"latin capital letter Y with diaeresis, U+0178 ISOlat2" },

/*
 * Anything below should really be kept as entities references
 */
{ 402,	"fnof",	"latin small f with hook = function = florin, U+0192 ISOtech" },

{ 710,	"circ",	"modifier letter circumflex accent, U+02C6 ISOpub" },
{ 732,	"tilde","small tilde, U+02DC ISOdia" },

{ 913,	"Alpha","greek capital letter alpha, U+0391" },
{ 914,	"Beta",	"greek capital letter beta, U+0392" },
{ 915,	"Gamma","greek capital letter gamma, U+0393 ISOgrk3" },
{ 916,	"Delta","greek capital letter delta, U+0394 ISOgrk3" },
{ 917,	"Epsilon","greek capital letter epsilon, U+0395" },
{ 918,	"Zeta",	"greek capital letter zeta, U+0396" },
{ 919,	"Eta",	"greek capital letter eta, U+0397" },
{ 920,	"Theta","greek capital letter theta, U+0398 ISOgrk3" },
{ 921,	"Iota",	"greek capital letter iota, U+0399" },
{ 922,	"Kappa","greek capital letter kappa, U+039A" },
{ 923,	"Lambda", "greek capital letter lambda, U+039B ISOgrk3" },
{ 924,	"Mu",	"greek capital letter mu, U+039C" },
{ 925,	"Nu",	"greek capital letter nu, U+039D" },
{ 926,	"Xi",	"greek capital letter xi, U+039E ISOgrk3" },
{ 927,	"Omicron","greek capital letter omicron, U+039F" },
{ 928,	"Pi",	"greek capital letter pi, U+03A0 ISOgrk3" },
{ 929,	"Rho",	"greek capital letter rho, U+03A1" },
{ 931,	"Sigma","greek capital letter sigma, U+03A3 ISOgrk3" },
{ 932,	"Tau",	"greek capital letter tau, U+03A4" },
{ 933,	"Upsilon","greek capital letter upsilon, U+03A5 ISOgrk3" },
{ 934,	"Phi",	"greek capital letter phi, U+03A6 ISOgrk3" },
{ 935,	"Chi",	"greek capital letter chi, U+03A7" },
{ 936,	"Psi",	"greek capital letter psi, U+03A8 ISOgrk3" },
{ 937,	"Omega","greek capital letter omega, U+03A9 ISOgrk3" },

{ 945,	"alpha","greek small letter alpha, U+03B1 ISOgrk3" },
{ 946,	"beta",	"greek small letter beta, U+03B2 ISOgrk3" },
{ 947,	"gamma","greek small letter gamma, U+03B3 ISOgrk3" },
{ 948,	"delta","greek small letter delta, U+03B4 ISOgrk3" },
{ 949,	"epsilon","greek small letter epsilon, U+03B5 ISOgrk3" },
{ 950,	"zeta",	"greek small letter zeta, U+03B6 ISOgrk3" },
{ 951,	"eta",	"greek small letter eta, U+03B7 ISOgrk3" },
{ 952,	"theta","greek small letter theta, U+03B8 ISOgrk3" },
{ 953,	"iota",	"greek small letter iota, U+03B9 ISOgrk3" },
{ 954,	"kappa","greek small letter kappa, U+03BA ISOgrk3" },
{ 955,	"lambda","greek small letter lambda, U+03BB ISOgrk3" },
{ 956,	"mu",	"greek small letter mu, U+03BC ISOgrk3" },
{ 957,	"nu",	"greek small letter nu, U+03BD ISOgrk3" },
{ 958,	"xi",	"greek small letter xi, U+03BE ISOgrk3" },
{ 959,	"omicron","greek small letter omicron, U+03BF NEW" },
{ 960,	"pi",	"greek small letter pi, U+03C0 ISOgrk3" },
{ 961,	"rho",	"greek small letter rho, U+03C1 ISOgrk3" },
{ 962,	"sigmaf","greek small letter final sigma, U+03C2 ISOgrk3" },
{ 963,	"sigma","greek small letter sigma, U+03C3 ISOgrk3" },
{ 964,	"tau",	"greek small letter tau, U+03C4 ISOgrk3" },
{ 965,	"upsilon","greek small letter upsilon, U+03C5 ISOgrk3" },
{ 966,	"phi",	"greek small letter phi, U+03C6 ISOgrk3" },
{ 967,	"chi",	"greek small letter chi, U+03C7 ISOgrk3" },
{ 968,	"psi",	"greek small letter psi, U+03C8 ISOgrk3" },
{ 969,	"omega","greek small letter omega, U+03C9 ISOgrk3" },
{ 977,	"thetasym","greek small letter theta symbol, U+03D1 NEW" },
{ 978,	"upsih","greek upsilon with hook symbol, U+03D2 NEW" },
{ 982,	"piv",	"greek pi symbol, U+03D6 ISOgrk3" },

{ 8194,	"ensp",	"en space, U+2002 ISOpub" },
{ 8195,	"emsp",	"em space, U+2003 ISOpub" },
{ 8201,	"thinsp","thin space, U+2009 ISOpub" },
{ 8204,	"zwnj",	"zero width non-joiner, U+200C NEW RFC 2070" },
{ 8205,	"zwj",	"zero width joiner, U+200D NEW RFC 2070" },
{ 8206,	"lrm",	"left-to-right mark, U+200E NEW RFC 2070" },
{ 8207,	"rlm",	"right-to-left mark, U+200F NEW RFC 2070" },
{ 8211,	"ndash","en dash, U+2013 ISOpub" },
{ 8212,	"mdash","em dash, U+2014 ISOpub" },
{ 8216,	"lsquo","left single quotation mark, U+2018 ISOnum" },
{ 8217,	"rsquo","right single quotation mark, U+2019 ISOnum" },
{ 8218,	"sbquo","single low-9 quotation mark, U+201A NEW" },
{ 8220,	"ldquo","left double quotation mark, U+201C ISOnum" },
{ 8221,	"rdquo","right double quotation mark, U+201D ISOnum" },
{ 8222,	"bdquo","double low-9 quotation mark, U+201E NEW" },
{ 8224,	"dagger","dagger, U+2020 ISOpub" },
{ 8225,	"Dagger","double dagger, U+2021 ISOpub" },

{ 8226,	"bull",	"bullet = black small circle, U+2022 ISOpub" },
{ 8230,	"hellip","horizontal ellipsis = three dot leader, U+2026 ISOpub" },

{ 8240,	"permil","per mille sign, U+2030 ISOtech" },

{ 8242,	"prime","prime = minutes = feet, U+2032 ISOtech" },
{ 8243,	"Prime","double prime = seconds = inches, U+2033 ISOtech" },

{ 8249,	"lsaquo","single left-pointing angle quotation mark, U+2039 ISO proposed" },
{ 8250,	"rsaquo","single right-pointing angle quotation mark, U+203A ISO proposed" },

{ 8254,	"oline","overline = spacing overscore, U+203E NEW" },
{ 8260,	"frasl","fraction slash, U+2044 NEW" },

{ 8364,	"euro",	"euro sign, U+20AC NEW" },

{ 8465,	"image","blackletter capital I = imaginary part, U+2111 ISOamso" },
{ 8472,	"weierp","script capital P = power set = Weierstrass p, U+2118 ISOamso" },
{ 8476,	"real",	"blackletter capital R = real part symbol, U+211C ISOamso" },
{ 8482,	"trade","trade mark sign, U+2122 ISOnum" },
{ 8501,	"alefsym","alef symbol = first transfinite cardinal, U+2135 NEW" },
{ 8592,	"larr",	"leftwards arrow, U+2190 ISOnum" },
{ 8593,	"uarr",	"upwards arrow, U+2191 ISOnum" },
{ 8594,	"rarr",	"rightwards arrow, U+2192 ISOnum" },
{ 8595,	"darr",	"downwards arrow, U+2193 ISOnum" },
{ 8596,	"harr",	"left right arrow, U+2194 ISOamsa" },
{ 8629,	"crarr","downwards arrow with corner leftwards = carriage return, U+21B5 NEW" },
{ 8656,	"lArr",	"leftwards double arrow, U+21D0 ISOtech" },
{ 8657,	"uArr",	"upwards double arrow, U+21D1 ISOamsa" },
{ 8658,	"rArr",	"rightwards double arrow, U+21D2 ISOtech" },
{ 8659,	"dArr",	"downwards double arrow, U+21D3 ISOamsa" },
{ 8660,	"hArr",	"left right double arrow, U+21D4 ISOamsa" },

{ 8704,	"forall","for all, U+2200 ISOtech" },
{ 8706,	"part",	"partial differential, U+2202 ISOtech" },
{ 8707,	"exist","there exists, U+2203 ISOtech" },
{ 8709,	"empty","empty set = null set = diameter, U+2205 ISOamso" },
{ 8711,	"nabla","nabla = backward difference, U+2207 ISOtech" },
{ 8712,	"isin",	"element of, U+2208 ISOtech" },
{ 8713,	"notin","not an element of, U+2209 ISOtech" },
{ 8715,	"ni",	"contains as member, U+220B ISOtech" },
{ 8719,	"prod",	"n-ary product = product sign, U+220F ISOamsb" },
{ 8721,	"sum",	"n-ary summation, U+2211 ISOamsb" },
{ 8722,	"minus","minus sign, U+2212 ISOtech" },
{ 8727,	"lowast","asterisk operator, U+2217 ISOtech" },
{ 8730,	"radic","square root = radical sign, U+221A ISOtech" },
{ 8733,	"prop",	"proportional to, U+221D ISOtech" },
{ 8734,	"infin","infinity, U+221E ISOtech" },
{ 8736,	"ang",	"angle, U+2220 ISOamso" },
{ 8743,	"and",	"logical and = wedge, U+2227 ISOtech" },
{ 8744,	"or",	"logical or = vee, U+2228 ISOtech" },
{ 8745,	"cap",	"intersection = cap, U+2229 ISOtech" },
{ 8746,	"cup",	"union = cup, U+222A ISOtech" },
{ 8747,	"int",	"integral, U+222B ISOtech" },
{ 8756,	"there4","therefore, U+2234 ISOtech" },
{ 8764,	"sim",	"tilde operator = varies with = similar to, U+223C ISOtech" },
{ 8773,	"cong",	"approximately equal to, U+2245 ISOtech" },
{ 8776,	"asymp","almost equal to = asymptotic to, U+2248 ISOamsr" },
{ 8800,	"ne",	"not equal to, U+2260 ISOtech" },
{ 8801,	"equiv","identical to, U+2261 ISOtech" },
{ 8804,	"le",	"less-than or equal to, U+2264 ISOtech" },
{ 8805,	"ge",	"greater-than or equal to, U+2265 ISOtech" },
{ 8834,	"sub",	"subset of, U+2282 ISOtech" },
{ 8835,	"sup",	"superset of, U+2283 ISOtech" },
{ 8836,	"nsub",	"not a subset of, U+2284 ISOamsn" },
{ 8838,	"sube",	"subset of or equal to, U+2286 ISOtech" },
{ 8839,	"supe",	"superset of or equal to, U+2287 ISOtech" },
{ 8853,	"oplus","circled plus = direct sum, U+2295 ISOamsb" },
{ 8855,	"otimes","circled times = vector product, U+2297 ISOamsb" },
{ 8869,	"perp",	"up tack = orthogonal to = perpendicular, U+22A5 ISOtech" },
{ 8901,	"sdot",	"dot operator, U+22C5 ISOamsb" },
{ 8968,	"lceil","left ceiling = apl upstile, U+2308 ISOamsc" },
{ 8969,	"rceil","right ceiling, U+2309 ISOamsc" },
{ 8970,	"lfloor","left floor = apl downstile, U+230A ISOamsc" },
{ 8971,	"rfloor","right floor, U+230B ISOamsc" },
{ 9001,	"lang",	"left-pointing angle bracket = bra, U+2329 ISOtech" },
{ 9002,	"rang",	"right-pointing angle bracket = ket, U+232A ISOtech" },
{ 9674,	"loz",	"lozenge, U+25CA ISOpub" },

{ 9824,	"spades","black spade suit, U+2660 ISOpub" },
{ 9827,	"clubs","black club suit = shamrock, U+2663 ISOpub" },
{ 9829,	"hearts","black heart suit = valentine, U+2665 ISOpub" },
{ 9830,	"diams","black diamond suit, U+2666 ISOpub" },

};

/************************************************************************
 *									*
 *		Commodity functions to handle entities			*
 *									*
 ************************************************************************/

/**
 * Lookup the given entity in EntitiesTable
 *
 * @deprecated Only supports HTML 4.
 *
 * TODO: the linear scan is really ugly, an hash table is really needed.
 *
 * @param name  the entity name
 * @returns the associated htmlEntityDesc if found, NULL otherwise.
 */
const htmlEntityDesc *
htmlEntityLookup(const xmlChar *name) {
    unsigned int i;

    for (i = 0;i < (sizeof(html40EntitiesTable)/
                    sizeof(html40EntitiesTable[0]));i++) {
        if (xmlStrEqual(name, BAD_CAST html40EntitiesTable[i].name)) {
            return((htmlEntityDescPtr) &html40EntitiesTable[i]);
	}
    }
    return(NULL);
}

static int
htmlCompareEntityDesc(const void *vkey, const void *vdesc) {
    const unsigned *key = vkey;
    const htmlEntityDesc *desc = vdesc;

    return((int) *key - (int) desc->value);
}

/**
 * Lookup the given entity in EntitiesTable
 *
 * @deprecated Only supports HTML 4.
 *
 * TODO: the linear scan is really ugly, an hash table is really needed.
 *
 * @param value  the entity's unicode value
 * @returns the associated htmlEntityDesc if found, NULL otherwise.
 */
const htmlEntityDesc *
htmlEntityValueLookup(unsigned int value) {
    const htmlEntityDesc *desc;
    size_t nmemb;

    nmemb = sizeof(html40EntitiesTable) / sizeof(html40EntitiesTable[0]);
    desc = bsearch(&value, html40EntitiesTable, nmemb, sizeof(htmlEntityDesc),
                   htmlCompareEntityDesc);

    return(desc);
}

/**
 * Take a block of UTF-8 chars in and try to convert it to an ASCII
 * plus HTML entities block of chars out.
 *
 * @deprecated Internal function, don't use.
 *
 * @param out  a pointer to an array of bytes to store the result
 * @param outlen  the length of `out`
 * @param in  a pointer to an array of UTF-8 chars
 * @param inlen  the length of `in`
 * @returns 0 if success, -2 if the transcoding fails, or -1 otherwise
 * The value of `inlen` after return is the number of octets consumed
 *     as the return value is positive, else unpredictable.
 * The value of `outlen` after return is the number of octets consumed.
 */
int
htmlUTF8ToHtml(unsigned char* out, int *outlen,
               const unsigned char* in, int *inlen) {
    const unsigned char* instart = in;
    const unsigned char* inend;
    unsigned char* outstart = out;
    unsigned char* outend;
    int ret = XML_ENC_ERR_SPACE;

    if ((out == NULL) || (outlen == NULL) || (inlen == NULL))
        return(XML_ENC_ERR_INTERNAL);

    if (in == NULL) {
        /*
	 * initialization nothing to do
	 */
	*outlen = 0;
	*inlen = 0;
	return(XML_ENC_ERR_SUCCESS);
    }

    inend = in + *inlen;
    outend = out + *outlen;
    while (in < inend) {
        const htmlEntityDesc *ent;
        const char *cp;
        char nbuf[16];
        unsigned c, d;
        int seqlen, len, i;

	d = *in;

	if (d < 0x80) {
            if (out >= outend)
                goto done;
            *out++ = d;
            in += 1;
            continue;
        }

        if (d < 0xE0)      { c = d & 0x1F; seqlen = 2; }
        else if (d < 0xF0) { c = d & 0x0F; seqlen = 3; }
        else               { c = d & 0x07; seqlen = 4; }

	if (inend - in < seqlen)
	    break;

	for (i = 1; i < seqlen; i++) {
	    d = in[i];
	    c <<= 6;
	    c |= d & 0x3F;
	}

        /*
         * Try to lookup a predefined HTML entity for it
         */
        ent = htmlEntityValueLookup(c);

        if (ent == NULL) {
          snprintf(nbuf, sizeof(nbuf), "#%u", c);
          cp = nbuf;
        } else {
          cp = ent->name;
        }

        len = strlen(cp);
        if (outend - out < len + 2)
            goto done;

        *out++ = '&';
        memcpy(out, cp, len);
        out += len;
        *out++ = ';';

        in += seqlen;
    }

    ret = out - outstart;

done:
    *outlen = out - outstart;
    *inlen = in - instart;
    return(ret);
}

/**
 * Take a block of UTF-8 chars in and try to convert it to an ASCII
 * plus HTML entities block of chars out.
 *
 * @deprecated Only supports HTML 4.
 *
 * @param out  a pointer to an array of bytes to store the result
 * @param outlen  the length of `out`
 * @param in  a pointer to an array of UTF-8 chars
 * @param inlen  the length of `in`
 * @param quoteChar  the quote character to escape (' or ") or zero.
 * @returns 0 if success, -2 if the transcoding fails, or -1 otherwise
 * The value of `inlen` after return is the number of octets consumed
 *     as the return value is positive, else unpredictable.
 * The value of `outlen` after return is the number of octets consumed.
 */
int
htmlEncodeEntities(unsigned char* out, int *outlen,
		   const unsigned char* in, int *inlen, int quoteChar) {
    const unsigned char* processed = in;
    const unsigned char* outend;
    const unsigned char* outstart = out;
    const unsigned char* instart = in;
    const unsigned char* inend;
    unsigned int c, d;
    int trailing;

    if ((out == NULL) || (outlen == NULL) || (inlen == NULL) || (in == NULL))
        return(-1);
    outend = out + (*outlen);
    inend = in + (*inlen);
    while (in < inend) {
	d = *in++;
	if      (d < 0x80)  { c= d; trailing= 0; }
	else if (d < 0xC0) {
	    /* trailing byte in leading position */
	    *outlen = out - outstart;
	    *inlen = processed - instart;
	    return(-2);
        } else if (d < 0xE0)  { c= d & 0x1F; trailing= 1; }
        else if (d < 0xF0)  { c= d & 0x0F; trailing= 2; }
        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;

	while (trailing--) {
	    if (((d= *in++) & 0xC0) != 0x80) {
		*outlen = out - outstart;
		*inlen = processed - instart;
		return(-2);
	    }
	    c <<= 6;
	    c |= d & 0x3F;
	}

	/* assertion: c is a single UTF-4 value */
	if ((c < 0x80) && (c != (unsigned int) quoteChar) &&
	    (c != '&') && (c != '<') && (c != '>')) {
	    if (out >= outend)
		break;
	    *out++ = c;
	} else {
	    const htmlEntityDesc * ent;
	    const char *cp;
	    char nbuf[16];
	    int len;

	    /*
	     * Try to lookup a predefined HTML entity for it
	     */
	    ent = htmlEntityValueLookup(c);
	    if (ent == NULL) {
		snprintf(nbuf, sizeof(nbuf), "#%u", c);
		cp = nbuf;
	    }
	    else
		cp = ent->name;
	    len = strlen(cp);
	    if (outend - out < len + 2)
		break;
	    *out++ = '&';
	    memcpy(out, cp, len);
	    out += len;
	    *out++ = ';';
	}
	processed = in;
    }
    *outlen = out - outstart;
    *inlen = processed - instart;
    return(0);
}

/************************************************************************
 *									*
 *		Commodity functions, cleanup needed ?			*
 *									*
 ************************************************************************/
/*
 * all tags allowing pc data from the html 4.01 loose dtd
 * NOTE: it might be more appropriate to integrate this information
 * into the html40ElementTable array but I don't want to risk any
 * binary incompatibility
 */
static const char *const 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",
    "small", "span", "strike", "strong", "td", "th", "tt", "u", "var"
};

/**
 * Is this a sequence of blank chars that one can ignore ?
 *
 * @param ctxt  an HTML parser context
 * @param str  a xmlChar *
 * @param len  the size of `str`
 * @returns 1 if ignorable 0 if whitespace, -1 otherwise.
 */

static int areBlanks(htmlParserCtxtPtr ctxt, const xmlChar *str, int len) {
    unsigned int i;
    int j;
    xmlNodePtr lastChild;
    xmlDtdPtr dtd;

    for (j = 0;j < len;j++)
        if (!(IS_WS_HTML(str[j]))) return(-1);

    if (CUR == 0) return(1);
    if (CUR != '<') return(0);
    if (ctxt->name == NULL)
	return(1);
    if (xmlStrEqual(ctxt->name, BAD_CAST"html"))
	return(1);
    if (xmlStrEqual(ctxt->name, BAD_CAST"head"))
	return(1);

    /* Only strip CDATA children of the body tag for strict HTML DTDs */
    if (xmlStrEqual(ctxt->name, BAD_CAST "body") && ctxt->myDoc != NULL) {
        dtd = xmlGetIntSubset(ctxt->myDoc);
        if (dtd != NULL && dtd->ExternalID != NULL) {
            if (!xmlStrcasecmp(dtd->ExternalID, BAD_CAST "-//W3C//DTD HTML 4.01//EN") ||
                    !xmlStrcasecmp(dtd->ExternalID, BAD_CAST "-//W3C//DTD HTML 4//EN"))
                return(1);
        }
    }

    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>...
	   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>
	   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);
}

/**
 * Creates a new HTML document without a DTD node if `URI` and `publicId`
 * are NULL
 *
 * @param URI  system ID (URI) of the DTD (optional)
 * @param publicId  public ID of the DTD (optional)
 * @returns a new document, do not initialize the DTD if not provided
 */
xmlDoc *
htmlNewDocNoDtD(const xmlChar *URI, const xmlChar *publicId) {
    xmlDocPtr cur;

    /*
     * Allocate a new document and fill the fields.
     */
    cur = (xmlDocPtr) xmlMalloc(sizeof(xmlDoc));
    if (cur == NULL)
	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->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 ((publicId != NULL) ||
	(URI != NULL)) {
        xmlDtdPtr intSubset;

	intSubset = xmlCreateIntSubset(cur, BAD_CAST "html", publicId, URI);
        if (intSubset == NULL) {
            xmlFree(cur);
            return(NULL);
        }
    }
    if ((xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
	xmlRegisterNodeDefaultValue((xmlNodePtr)cur);
    return(cur);
}

/**
 * Creates a new HTML document
 *
 * @param URI  system ID (URI) of the DTD (optional)
 * @param publicId  public ID of the DTD (optional)
 * @returns a new document
 */
xmlDoc *
htmlNewDoc(const xmlChar *URI, const xmlChar *publicId) {
    if ((URI == NULL) && (publicId == NULL))
	return(htmlNewDocNoDtD(
		    BAD_CAST "http://www.w3.org/TR/REC-html40/loose.dtd",
		    BAD_CAST "-//W3C//DTD HTML 4.0 Transitional//EN"));

    return(htmlNewDocNoDtD(URI, publicId));
}


/************************************************************************
 *									*
 *			The parser itself				*
 *	Relates to http://www.w3.org/TR/html40				*
 *									*
 ************************************************************************/

/************************************************************************
 *									*
 *			The parser itself				*
 *									*
 ************************************************************************/

/**
 * parse an HTML tag or attribute name, note that we convert it to lowercase
 * since HTML names are not case-sensitive.
 *
 * @param ctxt  an HTML parser context
 * @param attr  whether this is an attribute name
 * @returns the Tag Name parsed or NULL
 */

static xmlHashedString
htmlParseHTMLName(htmlParserCtxtPtr ctxt, int attr) {
    xmlHashedString ret;
    xmlChar buf[HTML_PARSER_BUFFER_SIZE];
    const xmlChar *in;
    size_t avail;
    int eof = PARSER_PROGRESSIVE(ctxt);
    int nbchar = 0;
    int stop = attr ? '=' : ' ';

    in = ctxt->input->cur;
    avail = ctxt->input->end - in;

    while (1) {
        int c, size;

        if ((!eof) && (avail < 32)) {
            size_t oldAvail = avail;

            ctxt->input->cur = in;

            SHRINK;
            xmlParserGrow(ctxt);

            in = ctxt->input->cur;
            avail = ctxt->input->end - in;

            if (oldAvail == avail)
                eof = 1;
        }

        if (avail == 0)
            break;

        c = *in;
        size = 1;

        if ((nbchar != 0) &&
            ((c == '/') || (c == '>') || (c == stop) ||
             (IS_WS_HTML(c))))
            break;

        if (c == 0) {
            if (nbchar + 3 <= HTML_PARSER_BUFFER_SIZE) {
                buf[nbchar++] = 0xEF;
                buf[nbchar++] = 0xBF;
                buf[nbchar++] = 0xBD;
            }
        } else if (c < 0x80) {
            if (nbchar < HTML_PARSER_BUFFER_SIZE) {
                if (IS_UPPER(c))
                    c += 0x20;
                buf[nbchar++] = c;
            }
        } else {
            size = htmlValidateUtf8(ctxt, in, avail, /* partial */ 0);

            if (size > 0) {
                if (nbchar + size <= HTML_PARSER_BUFFER_SIZE) {
                    memcpy(buf + nbchar, in, size);
                    nbchar += size;
                }
            } else {
                size = 1;

                if (nbchar + 3 <= HTML_PARSER_BUFFER_SIZE) {
                    buf[nbchar++] = 0xEF;
                    buf[nbchar++] = 0xBF;
                    buf[nbchar++] = 0xBD;
                }
            }
        }

        in += size;
        avail -= size;
    }

    ctxt->input->cur = in;

    SHRINK;

    ret = xmlDictLookupHashed(ctxt->dict, buf, nbchar);
    if (ret.name == NULL)
        htmlErrMemory(ctxt);

    return(ret);
}

static const short htmlC1Remap[32] = {
    0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
    0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,
    0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
    0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178
};

static const xmlChar *
htmlCodePointToUtf8(int c, xmlChar *out, int *osize) {
    int i = 0;
    int bits, hi;

    if ((c >= 0x80) && (c < 0xA0)) {
        c = htmlC1Remap[c - 0x80];
    } else if ((c <= 0) ||
               ((c >= 0xD800) && (c < 0xE000)) ||
               (c > 0x10FFFF)) {
        c = 0xFFFD;
    }

    if      (c <    0x80) { bits =  0; hi = 0x00; }
    else if (c <   0x800) { bits =  6; hi = 0xC0; }
    else if (c < 0x10000) { bits = 12; hi = 0xE0; }
    else                  { bits = 18; hi = 0xF0; }

    out[i++] = (c >> bits) | hi;

    while (bits > 0) {
        bits -= 6;
        out[i++] = ((c >> bits) & 0x3F) | 0x80;
    }

    *osize = i;
    return(out);
}

#include "codegen/html5ent.inc"

#define ENT_F_SEMICOLON 0x80u
#define ENT_F_SUBTABLE  0x40u
#define ENT_F_ALL       0xC0u

static const xmlChar *
htmlFindEntityPrefix(const xmlChar *string, size_t slen, int isAttr,
                     int *nlen, int *rlen) {
    const xmlChar *match = NULL;
    unsigned left, right;
    int first = string[0];
    size_t matchLen = 0;
    size_t soff = 1;

    if (slen < 2)
        return(NULL);
    if (!IS_ASCII_LETTER(first))
        return(NULL);

    /*
     * Look up range by first character
     */
    first &= 63;
    left = htmlEntAlpha[first*3] | htmlEntAlpha[first*3+1] << 8;
    right = left + htmlEntAlpha[first*3+2];

    /*
     * Binary search
     */
    while (left < right) {
        const xmlChar *bytes;
        unsigned mid;
        size_t len;
        int cmp;

        mid = left + (right - left) / 2;
        bytes = htmlEntStrings + htmlEntValues[mid];
        len = bytes[0] & ~ENT_F_ALL;

        cmp = string[soff] - bytes[1];

        if (cmp == 0) {
            if (slen < len) {
                cmp = strncmp((const char *) string + soff + 1,
                              (const char *) bytes + 2,
                              slen - 1);
                /* Prefix can never match */
                if (cmp == 0)
                    break;
            } else {
                cmp = strncmp((const char *) string + soff + 1,
                              (const char *) bytes + 2,
                              len - 1);
            }
        }

        if (cmp < 0) {
            right = mid;
        } else if (cmp > 0) {
            left = mid + 1;
        } else {
            int term = soff + len < slen ? string[soff + len] : 0;
            int isAlnum, isTerm;

            isAlnum = IS_ALNUM(term);
            isTerm = ((term == ';') ||
                      ((bytes[0] & ENT_F_SEMICOLON) &&
                       ((!isAttr) ||
                        ((!isAlnum) && (term != '=')))));

            if (isTerm) {
                match = bytes + len + 1;
                matchLen = soff + len;
                if (term == ';')
                    matchLen += 1;
            }

            if (bytes[0] & ENT_F_SUBTABLE) {
                if (isTerm)
                    match += 2;

                if ((isAlnum) && (soff + len < slen)) {
                    left = mid + bytes[len + 1];
                    right = left + bytes[len + 2];
                    soff += len;
                    continue;
                }
            }

            break;
        }
    }

    if (match == NULL)
        return(NULL);

    *nlen = matchLen;
    *rlen = match[0];
    return(match + 1);
}

/**
 * Parse data until terminator is reached.
 *
 * @param ctxt  an HTML parser context
 * @param mask  mask of terminating characters
 * @param comment  true if parsing a comment
 * @param refs  true if references are allowed
 * @param maxLength  maximum output length
 * @returns the parsed string or NULL in case of errors.
 */

static xmlChar *
htmlParseData(htmlParserCtxtPtr ctxt, htmlAsciiMask mask,
              int comment, int refs, int maxLength) {
    xmlParserInputPtr input = ctxt->input;
    xmlChar *ret = NULL;
    xmlChar *buffer;
    xmlChar utf8Char[4];
    size_t buffer_size;
    size_t used;
    int eof = PARSER_PROGRESSIVE(ctxt);
    int line, col;
    int termSkip = -1;

    used = 0;
    buffer_size = ctxt->spaceMax;
    buffer = (xmlChar *) ctxt->spaceTab;
    if (buffer == NULL) {
        buffer_size = 500;
        buffer = xmlMalloc(buffer_size + 1);
        if (buffer == NULL) {
            htmlErrMemory(ctxt);
            return(NULL);
        }
    }

    line = input->line;
    col = input->col;

    while (!PARSER_STOPPED(ctxt)) {
        const xmlChar *chunk, *in, *repl;
        size_t avail, chunkSize, extraSize;
        int replSize;
        int skip = 0;
        int ncr = 0;
        int ncrSize = 0;
        int cp = 0;

        chunk = input->cur;
        avail = input->end - chunk;
        in = chunk;

        repl = BAD_CAST "";
        replSize = 0;

        while (!PARSER_STOPPED(ctxt)) {
            size_t j;
            int cur, size;

            if ((!eof) && (avail <= 64)) {
                size_t oldAvail = avail;
                size_t off = in - chunk;

                input->cur = in;

                xmlParserGrow(ctxt);

                in = input->cur;
                chunk = in - off;
                input->cur = chunk;
                avail = input->end - in;

                if (oldAvail == avail)
                    eof = 1;
            }

            if (avail == 0) {
                termSkip = 0;
                break;
            }

            cur = *in;
            size = 1;
            col += 1;

            if (htmlMaskMatch(mask, cur)) {
                if (comment) {
                    if (avail < 2) {
                        termSkip = 1;
                    } else if (in[1] == '-') {
                        if  (avail < 3) {
                            termSkip = 2;
                        } else if (in[2] == '>') {
                            termSkip = 3;
                        } else if (in[2] == '!') {
                            if (avail < 4)
                                termSkip = 3;
                            else if (in[3] == '>')
                                termSkip = 4;
                        }
                    }

                    if (termSkip >= 0)
                        break;
                } else {
                    termSkip = 0;
                    break;
                }
            }

            if (ncr) {
                int lc = cur | 0x20;
                int digit;

                if ((cur >= '0') && (cur <= '9')) {
                    digit = cur - '0';
                } else if ((ncr == 16) && (lc >= 'a') && (lc <= 'f')) {
                    digit = (lc - 'a') + 10;
                } else {
                    if (cur == ';') {
                        in += 1;
                        size += 1;
                        ncrSize += 1;
                    }
                    goto next_chunk;
                }

                cp = cp * ncr + digit;
                if (cp >= 0x110000)
                    cp = 0x110000;

                ncrSize += 1;

                goto next_char;
            }

            switch (cur) {
            case '&':
                if (!refs)
                    break;

                j = 1;

                if ((j < avail) && (in[j] == '#')) {
                    j += 1;
                    if (j < avail) {
                        if ((in[j] | 0x20) == 'x') {
                            j += 1;
                            if ((j < avail) && (IS_HEX_DIGIT(in[j]))) {
                                ncr = 16;
                                size = 3;
                                ncrSize = 3;
                                cp = 0;
                            }
                        } else if (IS_ASCII_DIGIT(in[j])) {
                            ncr = 10;
                            size = 2;
                            ncrSize = 2;
                            cp = 0;
                        }
                    }
                } else {
                    repl = htmlFindEntityPrefix(in + j,
                                                avail - j,
                                                /* isAttr */ 1,
                                                &skip, &replSize);
                    if (repl != NULL) {
                        skip += 1;
                        goto next_chunk;
                    }

                    skip = 0;
                }

                break;

            case '\0':
                skip = 1;
                repl = BAD_CAST "\xEF\xBF\xBD";
                replSize = 3;
                goto next_chunk;

            case '\n':
                line += 1;
                col = 1;
                break;

            case '\r':
                skip = 1;
                if (in[1] != 0x0A) {
                    repl = BAD_CAST "\x0A";
                    replSize = 1;
                }
                goto next_chunk;

            default:
                if (cur < 0x80)
                    break;

                if ((input->flags & XML_INPUT_HAS_ENCODING) == 0) {
                    xmlChar * guess;

                    if (in > chunk)
                        goto next_chunk;

#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
                    guess = NULL;
#else
                    guess = htmlFindEncoding(ctxt);
#endif
                    if (guess == NULL) {
                        xmlSwitchEncoding(ctxt,
                                XML_CHAR_ENCODING_WINDOWS_1252);
                    } else {
                        xmlSwitchEncodingName(ctxt, (const char *) guess);
                        xmlFree(guess);
                    }
                    input->flags |= XML_INPUT_HAS_ENCODING;

                    eof = PARSER_PROGRESSIVE(ctxt);
                    goto restart;
                }

                size = htmlValidateUtf8(ctxt, in, avail, /* partial */ 0);

                if (size <= 0) {
                    skip = 1;
                    repl = BAD_CAST "\xEF\xBF\xBD";
                    replSize = 3;
                    goto next_chunk;
                }

                break;
            }

next_char:
            in += size;
            avail -= size;
        }

next_chunk:
        if (ncrSize > 0) {
            skip = ncrSize;
            in -= ncrSize;

            repl = htmlCodePointToUtf8(cp, utf8Char, &replSize);
        }

        chunkSize = in - chunk;
        extraSize = chunkSize + replSize;

        if (extraSize > maxLength - used) {
            htmlParseErr(ctxt, XML_ERR_RESOURCE_LIMIT,
                         "value too long\n", NULL, NULL);
            goto error;
        }

        if (extraSize > buffer_size - used) {
            size_t newSize = (used + extraSize) * 2;
            xmlChar *tmp = xmlRealloc(buffer, newSize + 1);

            if (tmp == NULL) {
                htmlErrMemory(ctxt);
                goto error;
            }
            buffer = tmp;
            buffer_size = newSize;
        }

        if (chunkSize > 0) {
            input->cur += chunkSize;
            memcpy(buffer + used, chunk, chunkSize);
            used += chunkSize;
        }

        input->cur += skip;
        if (replSize > 0) {
            memcpy(buffer + used, repl, replSize);
            used += replSize;
        }

        SHRINK;

        if (termSkip >= 0)
            break;

restart:
        ;
    }

    if (termSkip > 0) {
        input->cur += termSkip;
        col += termSkip;
    }

    input->line = line;
    input->col = col;

    ret = xmlMalloc(used + 1);
    if (ret == NULL) {
        htmlErrMemory(ctxt);
    } else {
        memcpy(ret, buffer, used);
        ret[used] = 0;
    }

error:
    ctxt->spaceTab = (void *) buffer;
    ctxt->spaceMax = buffer_size;

    return(ret);
}

/**
 * @deprecated Internal function, don't use.
 *
 * @param ctxt  an HTML parser context
 * @param str  location to store the entity name
 * @returns NULL.
 */
const htmlEntityDesc *
htmlParseEntityRef(htmlParserCtxt *ctxt ATTRIBUTE_UNUSED,
                   const xmlChar **str ATTRIBUTE_UNUSED) {
    return(NULL);
}

/**
 * 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
 *
 * @param ctxt  an HTML parser context
 * @returns the AttValue parsed or NULL.
 */

static xmlChar *
htmlParseAttValue(htmlParserCtxtPtr ctxt) {
    xmlChar *ret = NULL;
    int maxLength = (ctxt->options & HTML_PARSE_HUGE) ?
                    XML_MAX_HUGE_LENGTH :
                    XML_MAX_TEXT_LENGTH;

    if (CUR == '"') {
        SKIP(1);
	ret = htmlParseData(ctxt, MASK_DQ, 0, 1, maxLength);
        if (CUR == '"')
            SKIP(1);
    } else if (CUR == '\'') {
        SKIP(1);
	ret = htmlParseData(ctxt, MASK_SQ, 0, 1, maxLength);
        if (CUR == '\'')
            SKIP(1);
    } else {
	ret = htmlParseData(ctxt, MASK_WS_GT, 0, 1, maxLength);
    }
    return(ret);
}

static void
htmlCharDataSAXCallback(htmlParserCtxtPtr ctxt, const xmlChar *buf,
                        int size, int mode) {
    if ((ctxt->sax == NULL) || (ctxt->disableSAX))
        return;

    if ((mode == 0) || (mode == DATA_RCDATA) ||
        (ctxt->sax->cdataBlock == NULL)) {
        if ((ctxt->name == NULL) ||
            (xmlStrEqual(ctxt->name, BAD_CAST "html")) ||
            (xmlStrEqual(ctxt->name, BAD_CAST "head"))) {
            int i;

            /*
             * Add leading whitespace to html or head elements before
             * calling htmlStartCharData.
             */
            for (i = 0; i < size; i++)
                if (!IS_WS_HTML(buf[i]))
                    break;

            if (i > 0) {
                if (!ctxt->keepBlanks) {
                    if (ctxt->sax->ignorableWhitespace != NULL)
                        ctxt->sax->ignorableWhitespace(ctxt->userData, buf, i);
                } else {
                    if (ctxt->sax->characters != NULL)
                        ctxt->sax->characters(ctxt->userData, buf, i);
                }

                buf += i;
                size -= i;
            }

            if (size <= 0)
                return;

            htmlStartCharData(ctxt);

            if (PARSER_STOPPED(ctxt))
                return;
        }

        if ((mode == 0) &&
            (!ctxt->keepBlanks) &&
            (areBlanks(ctxt, buf, size) > 0)) {
            if (ctxt->sax->ignorableWhitespace != NULL)
                ctxt->sax->ignorableWhitespace(ctxt->userData, buf, size);
        } else {
            if (ctxt->sax->characters != NULL)
                ctxt->sax->characters(ctxt->userData, buf, size);
        }
    } else {
        /*
         * Insert as CDATA, which is the same as HTML_PRESERVE_NODE
         */
        ctxt->sax->cdataBlock(ctxt->userData, buf, size);
    }
}

/**
 * Parse character data and references.
 *
 * @param ctxt  an HTML parser context
 * @param partial  true if the input buffer is incomplete
 * @returns 1 if all data was parsed, 0 otherwise.
 */

static int
htmlParseCharData(htmlParserCtxtPtr ctxt, int partial) {
    xmlParserInputPtr input = ctxt->input;
    xmlChar utf8Char[4];
    int complete = 0;
    int done = 0;
    int mode;
    int eof = PARSER_PROGRESSIVE(ctxt);
    int line, col;

    mode = ctxt->endCheckState;

    line = input->line;
    col = input->col;

    while (!PARSER_STOPPED(ctxt)) {
        const xmlChar *chunk, *in, *repl;
        size_t avail;
        int replSize;
        int skip = 0;
        int ncr = 0;
        int ncrSize = 0;
        int cp = 0;

        chunk = input->cur;
        avail = input->end - chunk;
        in = chunk;

        repl = BAD_CAST "";
        replSize = 0;

        while (!PARSER_STOPPED(ctxt)) {
            size_t j;
            int cur, size;

            if (avail <= 64) {
                if (!eof) {
                    size_t oldAvail = avail;
                    size_t off = in - chunk;

                    input->cur = in;

                    xmlParserGrow(ctxt);

                    in = input->cur;
                    chunk = in - off;
                    input->cur = chunk;
                    avail = input->end - in;

                    if (oldAvail == avail)
                        eof = 1;
                }

                if (avail == 0) {
                    if ((partial) && (ncr)) {
                        in -= ncrSize;
                        ncrSize = 0;
                    }

                    done = 1;
                    break;
                }
            }

            /* Accelerator */
            if (!ncr) {
                while (avail > 0) {
                    static const unsigned mask[8] = {
                        0x00002401, 0x10002040,
                        0x00000000, 0x00000000,
                        0xFFFFFFFF, 0xFFFFFFFF,
                        0xFFFFFFFF, 0xFFFFFFFF
                    };
                    cur = *in;
                    if ((1u << (cur & 0x1F)) & mask[cur >> 5])
                        break;
                    col += 1;
                    in += 1;
                    avail -= 1;
                }

                if ((!eof) && (avail <= 64))
                    continue;
                if (avail == 0)
                    continue;
            }

            cur = *in;
            size = 1;
            col += 1;

            if (ncr) {
                int lc = cur | 0x20;
                int digit;

                if ((cur >= '0') && (cur <= '9')) {
                    digit = cur - '0';
                } else if ((ncr == 16) && (lc >= 'a') && (lc <= 'f')) {
                    digit = (lc - 'a') + 10;
                } else {
                    if (cur == ';') {
                        in += 1;
                        size += 1;
                        ncrSize += 1;
                    }
                    goto next_chunk;
                }

                cp = cp * ncr + digit;
                if (cp >= 0x110000)
                    cp = 0x110000;

                ncrSize += 1;

                goto next_char;
            }

            switch (cur) {
            case '<':
                if (mode == 0) {
                    done = 1;
                    complete = 1;
                    goto next_chunk;
                }
                if (mode == DATA_PLAINTEXT)
                    break;

                j = 1;
                if (j < avail) {
                    if ((mode == DATA_SCRIPT) && (in[j] == '!')) {
                        /* Check for comment start */

                        j += 1;
                        if ((j < avail) && (in[j] == '-')) {
                            j += 1;
                            if ((j < avail) && (in[j] == '-'))
                                mode = DATA_SCRIPT_ESC1;
                        }
                    } else {
                        int i = 0;
                        int solidus = 0;

                        /* Check for tag */

                        if (in[j] == '/') {
                            j += 1;
                            solidus = 1;
                        }

                        if ((solidus) || (mode == DATA_SCRIPT_ESC1)) {
                            while ((j < avail) &&
                                   (ctxt->name[i] != 0) &&
                                   (ctxt->name[i] == (in[j] | 0x20))) {
                                i += 1;
                                j += 1;
                            }

                            if ((ctxt->name[i] == 0) && (j < avail)) {
                                int c = in[j];

                                if ((c == '>') || (c == '/') ||
                                    (IS_WS_HTML(c))) {
                                    if ((mode == DATA_SCRIPT_ESC1) &&
                                        (!solidus)) {
                                        mode = DATA_SCRIPT_ESC2;
                                    } else if (mode == DATA_SCRIPT_ESC2) {
                                        mode = DATA_SCRIPT_ESC1;
                                    } else {
                                        complete = 1;
                                        done = 1;
                                        goto next_chunk;
                                    }
                                }
                            }
                        }
                    }
                }

                if ((partial) && (j >= avail)) {
                    done = 1;
                    goto next_chunk;
                }

                break;

            case '-':
                if ((mode != DATA_SCRIPT_ESC1) && (mode != DATA_SCRIPT_ESC2))
                    break;

                /* Check for comment end */

                j = 1;
                if ((j < avail) && (in[j] == '-')) {
                    j += 1;
                    if ((j < avail) && (in[j] == '>'))
                        mode = DATA_SCRIPT;
                }

                if ((partial) && (j >= avail)) {
                    done = 1;
                    goto next_chunk;
                }

                break;

            case '&':
                if ((mode != 0) && (mode != DATA_RCDATA))
                    break;

                j = 1;

                if ((j < avail) && (in[j] == '#')) {
                    j += 1;
                    if (j < avail) {
                        if ((in[j] | 0x20) == 'x') {
                            j += 1;
                            if ((j < avail) && (IS_HEX_DIGIT(in[j]))) {
                                ncr = 16;
                                size = 3;
                                ncrSize = 3;
                                cp = 0;
                            }
                        } else if (IS_ASCII_DIGIT(in[j])) {
                            ncr = 10;
                            size = 2;
                            ncrSize = 2;
                            cp = 0;
                        }
                    }
                } else {
                    if (partial) {
                        int terminated = 0;
                        size_t i;

                        /*
                         * &CounterClockwiseContourIntegral; has 33 bytes.
                         */
                        for (i = 1; i < avail; i++) {
                            if ((i >= 32) ||
                                (!IS_ASCII_LETTER(in[i]) &&
                                 ((i < 2) || !IS_ASCII_DIGIT(in[i])))) {
                                terminated = 1;
                                break;
                            }
                        }

                        if (!terminated) {
                            done = 1;
                            goto next_chunk;
                        }
                    }

                    repl = htmlFindEntityPrefix(in + j,
                                                avail - j,
                                                /* isAttr */ 0,
                                                &skip, &replSize);
                    if (repl != NULL) {
                        skip += 1;
                        goto next_chunk;
                    }

                    skip = 0;
                }

                if ((partial) && (j >= avail)) {
                    done = 1;
                    goto next_chunk;
                }

                break;

            case '\0':
                skip = 1;

                if (mode == 0) {
                    /*
                     * The HTML5 spec says that the tokenizer should
                     * pass on U+0000 unmodified in normal data mode.
                     * These characters should then be ignored in body
                     * and other text, but should be replaced with
                     * U+FFFD in foreign content.
                     *
                     * At least for now, we always strip U+0000 when
                     * tokenizing.
                     */
                    repl = BAD_CAST "";
                    replSize = 0;
                } else {
                    repl = BAD_CAST "\xEF\xBF\xBD";
                    replSize = 3;
                }

                goto next_chunk;

            case '\n':
                line += 1;
                col = 1;
                break;

            case '\r':
                if (partial && avail < 2) {
                    done = 1;
                    goto next_chunk;
                }

                skip = 1;
                if (in[1] != 0x0A) {
                    repl = BAD_CAST "\x0A";
                    replSize = 1;
                }
                goto next_chunk;

            default:
                if (cur < 0x80)
                    break;

                if ((input->flags & XML_INPUT_HAS_ENCODING) == 0) {
                    xmlChar * guess;

                    if (in > chunk)
                        goto next_chunk;

#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
                    guess = NULL;
#else
                    guess = htmlFindEncoding(ctxt);
#endif
                    if (guess == NULL) {
                        xmlSwitchEncoding(ctxt,
                                XML_CHAR_ENCODING_WINDOWS_1252);
                    } else {
                        xmlSwitchEncodingName(ctxt, (const char *) guess);
                        xmlFree(guess);
                    }
                    input->flags |= XML_INPUT_HAS_ENCODING;

                    eof = PARSER_PROGRESSIVE(ctxt);
                    goto restart;
                }

                size = htmlValidateUtf8(ctxt, in, avail, partial);

                if ((partial) && (size == 0)) {
                    done = 1;
                    goto next_chunk;
                }

                if (size <= 0) {
                    skip = 1;
                    repl = BAD_CAST "\xEF\xBF\xBD";
                    replSize = 3;
                    goto next_chunk;
                }

                break;
            }

next_char:
            in += size;
            avail -= size;
        }

next_chunk:
        if (ncrSize > 0) {
            skip = ncrSize;
            in -= ncrSize;

            repl = htmlCodePointToUtf8(cp, utf8Char, &replSize);
        }

        if (in > chunk) {
            input->cur += in - chunk;
            htmlCharDataSAXCallback(ctxt, chunk, in - chunk, mode);
        }

        input->cur += skip;
        if (replSize > 0)
            htmlCharDataSAXCallback(ctxt, repl, replSize, mode);

        SHRINK;

        if (done)
            break;

restart:
        ;
    }

    input->line = line;
    input->col = col;

    if (complete)
        ctxt->endCheckState = 0;
    else
        ctxt->endCheckState = mode;

    return(complete);
}

/**
 * Parse an HTML comment
 *
 * @param ctxt  an HTML parser context
 * @param bogus  true if this is a bogus comment
 */
static void
htmlParseComment(htmlParserCtxtPtr ctxt, int bogus) {
    const xmlChar *comment = BAD_CAST "";
    xmlChar *buf = NULL;
    int maxLength = (ctxt->options & HTML_PARSE_HUGE) ?
                    XML_MAX_HUGE_LENGTH :
                    XML_MAX_TEXT_LENGTH;

    if (bogus) {
        buf = htmlParseData(ctxt, MASK_GT, 0, 0, maxLength);
        if (CUR == '>')
            SKIP(1);
        comment = buf;
    } else {
        if ((!PARSER_PROGRESSIVE(ctxt)) &&
            (ctxt->input->end - ctxt->input->cur < 2))
            xmlParserGrow(ctxt);

        if (CUR == '>') {
            SKIP(1);
        } else if ((CUR == '-') && (NXT(1) == '>')) {
            SKIP(2);
        } else {
            buf = htmlParseData(ctxt, MASK_DASH, 1, 0, maxLength);
            comment = buf;
        }
    }

    if (comment == NULL)
        return;

    if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
        (!ctxt->disableSAX))
        ctxt->sax->comment(ctxt->userData, comment);

    xmlFree(buf);
}

/**
 * @deprecated Internal function, don't use.
 *
 * @param ctxt  an HTML parser context
 * @returns 0
 */
int
htmlParseCharRef(htmlParserCtxt *ctxt ATTRIBUTE_UNUSED) {
    return(0);
}


/**
 * Parse a DOCTYPE SYTSTEM or PUBLIC literal.
 *
 * @param ctxt  an HTML parser context
 * @returns the literal or NULL in case of error.
 */

static xmlChar *
htmlParseDoctypeLiteral(htmlParserCtxtPtr ctxt) {
    xmlChar *ret;
    int maxLength = (ctxt->options & HTML_PARSE_HUGE) ?
                    XML_MAX_TEXT_LENGTH :
                    XML_MAX_NAME_LENGTH;

    if (CUR == '"') {
        SKIP(1);
        ret = htmlParseData(ctxt, MASK_DQ_GT, 0, 0, maxLength);
        if (CUR == '"')
            SKIP(1);
    } else if (CUR == '\'') {
        SKIP(1);
        ret = htmlParseData(ctxt, MASK_SQ_GT, 0, 0, maxLength);
        if (CUR == '\'')
            SKIP(1);
    } else {
        return(NULL);
    }

    return(ret);
}

static void
htmlSkipBogusDoctype(htmlParserCtxtPtr ctxt) {
    const xmlChar *in;
    size_t avail;
    int eof = PARSER_PROGRESSIVE(ctxt);
    int line, col;

    line = ctxt->input->line;
    col = ctxt->input->col;

    in = ctxt->input->cur;
    avail = ctxt->input->end - in;

    while (!PARSER_STOPPED(ctxt)) {
        int cur;

        if ((!eof) && (avail <= 64)) {
            size_t oldAvail = avail;

            ctxt->input->cur = in;

            xmlParserGrow(ctxt);

            in = ctxt->input->cur;
            avail = ctxt->input->end - in;

            if (oldAvail == avail)
                eof = 1;
        }

        if (avail == 0)
            break;

        col += 1;

        cur = *in;
        if (cur == '>') {
            in += 1;
            break;
        } else if (cur == 0x0A) {
            line += 1;
            col = 1;
        }

        in += 1;
        avail -= 1;

        SHRINK;
    }

    ctxt->input->cur = in;
    ctxt->input->line = line;
    ctxt->input->col = col;
}

/**
 * Parse a DOCTYPE declaration.
 *
 * @param ctxt  an HTML parser context
 */

static void
htmlParseDocTypeDecl(htmlParserCtxtPtr ctxt) {
    xmlChar *name = NULL;
    xmlChar *publicId = NULL;
    xmlChar *URI = NULL;
    int maxLength = (ctxt->options & HTML_PARSE_HUGE) ?
                    XML_MAX_TEXT_LENGTH :
                    XML_MAX_NAME_LENGTH;

    /*
     * We know that '<!DOCTYPE' has been detected.
     */
    SKIP(9);

    SKIP_BLANKS;

    if ((ctxt->input->cur < ctxt->input->end) && (CUR != '>')) {
        name = htmlParseData(ctxt, MASK_WS_GT, 0, 0, maxLength);

        if ((ctxt->options & HTML_PARSE_HTML5) && (name != NULL)) {
            xmlChar *cur;

            for (cur = name; *cur; cur++) {
                if (IS_UPPER(*cur))
                    *cur += 0x20;
            }
        }

        SKIP_BLANKS;
    }

    /*
     * Check for SystemID and publicId
     */
    if ((UPPER == 'P') && (UPP(1) == 'U') &&
	(UPP(2) == 'B') && (UPP(3) == 'L') &&
	(UPP(4) == 'I') && (UPP(5) == 'C')) {
        SKIP(6);
        SKIP_BLANKS;
	publicId = htmlParseDoctypeLiteral(ctxt);
	if (publicId == NULL)
            goto bogus;
        SKIP_BLANKS;
	URI = htmlParseDoctypeLiteral(ctxt);
    } else if ((UPPER == 'S') && (UPP(1) == 'Y') &&
               (UPP(2) == 'S') && (UPP(3) == 'T') &&
	       (UPP(4) == 'E') && (UPP(5) == 'M')) {
        SKIP(6);
        SKIP_BLANKS;
	URI = htmlParseDoctypeLiteral(ctxt);
    }

bogus:
    htmlSkipBogusDoctype(ctxt);

    /*
     * Create or update the document accordingly to the DOCTYPE
     */
    if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
	(!ctxt->disableSAX))
	ctxt->sax->internalSubset(ctxt->userData, name, publicId, URI);

    xmlFree(name);
    xmlFree(URI);
    xmlFree(publicId);
}

/**
 * parse an attribute
 *
 * [41] Attribute ::= Name Eq AttValue
 *
 * [25] Eq ::= S? '=' S?
 *
 * With namespace:
 *
 * [NS 11] Attribute ::= QName Eq AttValue
 *
 * Also the case QName == xmlns:??? is handled independently as a namespace
 * definition.
 *
 * @param ctxt  an HTML parser context
 * @param value  a xmlChar ** used to store the value of the attribute
 * @returns the attribute name, and the value in *value.
 */

static xmlHashedString
htmlParseAttribute(htmlParserCtxtPtr ctxt, xmlChar **value) {
    xmlHashedString hname;
    xmlChar *val = NULL;

    *value = NULL;
    hname = htmlParseHTMLName(ctxt, 1);
    if (hname.name == NULL)
        return(hname);

    /*
     * read the value
     */
    SKIP_BLANKS;
    if (CUR == '=') {
        SKIP(1);
	SKIP_BLANKS;
	val = htmlParseAttValue(ctxt);
    }

    *value = val;
    return(hname);
}

static int
htmlCharEncCheckAsciiCompatible(htmlParserCtxt *ctxt,
                                const xmlChar *encoding) {
    xmlCharEncodingHandler *handler;
    xmlChar in[9] = "<a A=\"/>";
    xmlChar out[9];
    int inlen, outlen;
    int res;

    res = xmlCreateCharEncodingHandler(
            (const char *) encoding,
            XML_ENC_INPUT | XML_ENC_HTML,
            ctxt->convImpl, ctxt->convCtxt,
            &handler);
    if (res != XML_ERR_OK) {
        xmlFatalErr(ctxt, res, (const char *) encoding);
        return(-1);
    }

    /* UTF-8 */
    if (handler == NULL)
        return(0);

    inlen = 8;
    outlen = 8;
    res = xmlEncInputChunk(handler, out, &outlen, in, &inlen, /* flush */ 1);

    xmlCharEncCloseFunc(handler);

    if ((res != XML_ENC_ERR_SUCCESS) ||
        (inlen != 8) || (outlen != 8) ||
        (memcmp(in, out, 8) != 0)) {
        htmlParseErr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                     "Encoding %s isn't ASCII-compatible", encoding, NULL);
        return(-1);
    }

    return(0);
}

/**
 * Handle charset encoding in meta tag.
 *
 * @param ctxt  an HTML parser context
 * @param atts  the attributes values
 */
static void
htmlCheckMeta(htmlParserCtxtPtr ctxt, const xmlChar **atts) {
    int i;
    const xmlChar *att, *value;
    int isContentType = 0;
    const xmlChar *content = NULL;
    xmlChar *encoding = NULL;

    if ((ctxt == NULL) || (atts == NULL))
	return;

    i = 0;
    att = atts[i++];
    while (att != NULL) {
	value = atts[i++];
        if (value != NULL) {
            if ((!xmlStrcasecmp(att, BAD_CAST "http-equiv")) &&
                (!xmlStrcasecmp(value, BAD_CAST "Content-Type"))) {
                isContentType = 1;
            } else if (!xmlStrcasecmp(att, BAD_CAST "charset")) {
                encoding = xmlStrdup(value);
                if (encoding == NULL)
                    htmlErrMemory(ctxt);
                break;
            } else if (!xmlStrcasecmp(att, BAD_CAST "content")) {
                content = value;
            }
        }
	att = atts[i++];
    }

    if ((encoding == NULL) && (isContentType) && (content != NULL)) {
        htmlMetaEncodingOffsets off;

        if (htmlParseContentType(content, &off)) {
            encoding = xmlStrndup(content + off.start, off.end - off.start);
            if (encoding == NULL)
                htmlErrMemory(ctxt);
        }
    }

    if (encoding != NULL) {
        if (htmlCharEncCheckAsciiCompatible(ctxt, encoding) < 0) {
            xmlFree(encoding);
            return;
        }

        xmlSetDeclaredEncoding(ctxt, encoding);
    }
}

/**
 * Inserts a new attribute into the hash table.
 *
 * @param ctxt  parser context
 * @param size  size of the hash table
 * @param name  attribute name
 * @param hashValue  hash value of name
 * @param aindex  attribute index (this is a multiple of 5)
 * @returns INT_MAX if no existing attribute was found, the attribute
 * index if an attribute was found, -1 if a memory allocation failed.
 */
static int
htmlAttrHashInsert(xmlParserCtxtPtr ctxt, unsigned size, const xmlChar *name,
                   unsigned hashValue, int aindex) {
    xmlAttrHashBucket *table = ctxt->attrHash;
    xmlAttrHashBucket *bucket;
    unsigned hindex;

    hindex = hashValue & (size - 1);
    bucket = &table[hindex];

    while (bucket->index >= 0) {
        const xmlChar **atts = &ctxt->atts[bucket->index];

        if (name == atts[0])
            return(bucket->index);

        hindex++;
        bucket++;
        if (hindex >= size) {
            hindex = 0;
            bucket = table;
        }
    }

    bucket->index = aindex;

    return(INT_MAX);
}

/**
 * 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? '/>'
 *
 * @param ctxt  an HTML parser context
 * @returns 0 in case of success, -1 in case of error and 1 if discarded
 */

static void
htmlParseStartTag(htmlParserCtxtPtr ctxt) {
    const xmlChar *name;
    const xmlChar *attname;
    xmlChar *attvalue;
    const xmlChar **atts;
    int nbatts = 0;
    int maxatts;
    int i;
    int discardtag = 0;

    ctxt->endCheckState = 0;

    SKIP(1);

    atts = ctxt->atts;
    maxatts = ctxt->maxatts;

    GROW;
    name = htmlParseHTMLName(ctxt, 0).name;
    if (name == NULL)
        return;

    if ((ctxt->options & HTML_PARSE_HTML5) == 0) {
        /*
         * 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) &&
            (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 ((ctxt->input->cur < ctxt->input->end) &&
           (CUR != '>') &&
	   ((CUR != '/') || (NXT(1) != '>')) &&
           (PARSER_STOPPED(ctxt) == 0)) {
        xmlHashedString hattname;

        /*  unexpected-solidus-in-tag */
        if (CUR == '/') {
            SKIP(1);
            SKIP_BLANKS;
            continue;
        }
	GROW;
	hattname = htmlParseAttribute(ctxt, &attvalue);
        attname = hattname.name;

        if (attname != NULL) {
	    /*
	     * Add the pair to atts
	     */
	    if (nbatts + 4 > maxatts) {
	        const xmlChar **tmp;
                unsigned *utmp;
                int newSize;

                newSize = xmlGrowCapacity(maxatts,
                                          sizeof(tmp[0]) * 2 + sizeof(utmp[0]),
                                          11, HTML_MAX_ATTRS);
		if (newSize < 0) {
		    htmlErrMemory(ctxt);
		    goto failed;
		}
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
                if (newSize < 2)
                    newSize = 2;
#endif
	        tmp = xmlRealloc(atts, newSize * sizeof(tmp[0]) * 2);
		if (tmp == NULL) {
		    htmlErrMemory(ctxt);
		    goto failed;
		}
                atts = tmp;
		ctxt->atts = tmp;

	        utmp = xmlRealloc(ctxt->attallocs, newSize * sizeof(utmp[0]));
		if (utmp == NULL) {
		    htmlErrMemory(ctxt);
		    goto failed;
		}
                ctxt->attallocs = utmp;

                maxatts = newSize * 2;
		ctxt->maxatts = maxatts;
	    }

            ctxt->attallocs[nbatts/2] = hattname.hashValue;
	    atts[nbatts++] = attname;
	    atts[nbatts++] = attvalue;

            attvalue = NULL;
	}

failed:
        if (attvalue != NULL)
            xmlFree(attvalue);

	SKIP_BLANKS;
    }

    if (ctxt->input->cur >= ctxt->input->end) {
        discardtag = 1;
        goto done;
    }

    /*
     * Verify that attribute names are unique.
     */
    if (nbatts > 2) {
        unsigned attrHashSize;
        int j, k;

        attrHashSize = 4;
        while (attrHashSize / 2 < (unsigned) nbatts / 2)
            attrHashSize *= 2;

        if (attrHashSize > ctxt->attrHashMax) {
            xmlAttrHashBucket *tmp;

            tmp = xmlRealloc(ctxt->attrHash, attrHashSize * sizeof(tmp[0]));
            if (tmp == NULL) {
                htmlErrMemory(ctxt);
                goto done;
            }

            ctxt->attrHash = tmp;
            ctxt->attrHashMax = attrHashSize;
        }

        memset(ctxt->attrHash, -1, attrHashSize * sizeof(ctxt->attrHash[0]));

        for (i = 0, j = 0, k = 0; i < nbatts; i += 2, k++) {
            unsigned hashValue;
            int res;

            attname = atts[i];
            hashValue = ctxt->attallocs[k] | 0x80000000;

            res = htmlAttrHashInsert(ctxt, attrHashSize, attname,
                                    hashValue, j);
            if (res < 0)
                continue;

            if (res == INT_MAX) {
                atts[j] = atts[i];
                atts[j+1] = atts[i+1];
                j += 2;
            } else {
                xmlFree((xmlChar *) atts[i+1]);
            }
        }

        nbatts = j;
    }

    if (nbatts > 0) {
        atts[nbatts] = NULL;
        atts[nbatts + 1] = NULL;

    /*
     * Apple's new libiconv is so broken that you routinely run into
     * issues when fuzz testing (by accident with an uninstrumented
     * libiconv). Here's a harmless (?) example:
     *
     * printf '>'             | iconv -f shift_jis -t utf-8 | hexdump -C
     * printf '\xfc\x00\x00'  | iconv -f shift_jis -t utf-8 | hexdump -C
     * printf '>\xfc\x00\x00' | iconv -f shift_jis -t utf-8 | hexdump -C
     *
     * The last command fails to detect the illegal sequence.
     */
#if !defined(__APPLE__) || \
    !defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION)
        /*
         * Handle specific association to the META tag
         */
        if (((ctxt->input->flags & XML_INPUT_HAS_ENCODING) == 0) &&
            (strcmp((char *) name, "meta") == 0)) {
            htmlCheckMeta(ctxt, atts);
        }
#endif
    }

    /*
     * SAX: Start of Element !
     */
    if (!discardtag) {
        if (ctxt->options & HTML_PARSE_HTML5) {
            if (ctxt->nameNr > 0)
                htmlnamePop(ctxt);
        }

	htmlnamePush(ctxt, name);
	if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL)) {
	    if (nbatts != 0)
		ctxt->sax->startElement(ctxt->userData, name, atts);
	    else
		ctxt->sax->startElement(ctxt->userData, name, NULL);
	}
    }

done:
    if (atts != NULL) {
        for (i = 1;i < nbatts;i += 2) {
	    if (atts[i] != NULL)
		xmlFree((xmlChar *) atts[i]);
	}
    }
}

/**
 * parse an end of tag
 *
 * [42] ETag ::= '</' Name S? '>'
 *
 * With namespace
 *
 * [NS 9] ETag ::= '</' QName S? '>'
 *
 * @param ctxt  an HTML parser context
 * @returns 1 if the current level should be closed.
 */

static void
htmlParseEndTag(htmlParserCtxtPtr ctxt)
{
    const xmlChar *name;
    const xmlChar *oldname;
    int i;

    ctxt->endCheckState = 0;

    SKIP(2);

    if (ctxt->input->cur >= ctxt->input->end) {
        htmlStartCharData(ctxt);
        if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
            (ctxt->sax->characters != NULL))
            ctxt->sax->characters(ctxt->userData,
                                  BAD_CAST "</", 2);
        return;
    }

    if (CUR == '>') {
        SKIP(1);
        return;
    }

    if (!IS_ASCII_LETTER(CUR)) {
        htmlParseComment(ctxt, /* bogus */ 1);
        return;
    }

    name = htmlParseHTMLName(ctxt, 0).name;
    if (name == NULL)
        return;

    /*
     * Parse and ignore attributes.
     */
    SKIP_BLANKS;
    while ((ctxt->input->cur < ctxt->input->end) &&
           (CUR != '>') &&
	   ((CUR != '/') || (NXT(1) != '>')) &&
           (ctxt->instate != XML_PARSER_EOF)) {
        xmlChar *attvalue = NULL;

        /*  unexpected-solidus-in-tag */
        if (CUR == '/') {
            SKIP(1);
            SKIP_BLANKS;
            continue;
        }
	GROW;
	htmlParseAttribute(ctxt, &attvalue);
        if (attvalue != NULL)
            xmlFree(attvalue);

	SKIP_BLANKS;
    }

    if (CUR == '>') {
        SKIP(1);
    } else if ((CUR == '/') && (NXT(1) == '>')) {
        SKIP(2);
    } else {
        return;
    }

    if (ctxt->options & HTML_PARSE_HTML5) {
        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
            ctxt->sax->endElement(ctxt->userData, name);
        return;
    }

    /*
     * 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;
    }

    /*
     * 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);
        return;
    }


    /*
     * Check for auto-closure of HTML elements.
     */

    htmlAutoCloseOnClose(ctxt, name);

    /*
     * Well formedness constraints, opening and closing must match.
     * With the exception that the autoclose may have popped stuff out
     * of the stack.
     */
    if ((ctxt->name != NULL) && (!xmlStrEqual(ctxt->name, name))) {
        htmlParseErr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
                     "Opening and ending tag mismatch: %s and %s\n",
                     name, ctxt->name);
    }

    /*
     * SAX: End of Tag
     */
    oldname = ctxt->name;
    if ((oldname != NULL) && (xmlStrEqual(oldname, name))) {
	htmlParserFinishElementParsing(ctxt);
        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
            ctxt->sax->endElement(ctxt->userData, name);
        htmlnamePop(ctxt);
    }
}

/**
 * Parse a content: comment, sub-element, reference or text.
 * New version for non recursive htmlParseElementInternal
 *
 * @param ctxt  an HTML parser context
 */

static void
htmlParseContent(htmlParserCtxtPtr ctxt) {
    GROW;

    while ((PARSER_STOPPED(ctxt) == 0) &&
           (ctxt->input->cur < ctxt->input->end)) {
        int mode;

        mode = ctxt->endCheckState;

        if ((mode == 0) && (CUR == '<')) {
            if (NXT(1) == '/') {
	        htmlParseEndTag(ctxt);
            } else if (NXT(1) == '!') {
                /*
                 * Sometimes DOCTYPE arrives in the middle of the document
                 */
                if ((UPP(2) == 'D') && (UPP(3) == 'O') &&
                    (UPP(4) == 'C') && (UPP(5) == 'T') &&
                    (UPP(6) == 'Y') && (UPP(7) == 'P') &&
                    (UPP(8) == 'E')) {
                    htmlParseDocTypeDecl(ctxt);
                } else if ((NXT(2) == '-') && (NXT(3) == '-')) {
                    SKIP(4);
                    htmlParseComment(ctxt, /* bogus */ 0);
                } else {
                    SKIP(2);
                    htmlParseComment(ctxt, /* bogus */ 1);
                }
            } else if (NXT(1) == '?') {
                SKIP(1);
                htmlParseComment(ctxt, /* bogus */ 1);
            } else if (IS_ASCII_LETTER(NXT(1))) {
                htmlParseElementInternal(ctxt);
            } else {
                htmlStartCharData(ctxt);
                if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
                    (ctxt->sax->characters != NULL))
                    ctxt->sax->characters(ctxt->userData, BAD_CAST "<", 1);
                SKIP(1);
            }
        } else {
            htmlParseCharData(ctxt, /* partial */ 0);
        }

        SHRINK;
        GROW;
    }

    if (ctxt->input->cur >= ctxt->input->end)
        htmlAutoCloseOnEnd(ctxt);
}

/**
 * Parse an HTML element, new version, non recursive
 *
 * @param ctxt  an HTML parser context
 */
static int
htmlParseElementInternal(htmlParserCtxtPtr ctxt) {
    const xmlChar *name;
    const htmlElemDesc * info;
    htmlParserNodeInfo node_info = { NULL, 0, 0, 0, 0 };

    if ((ctxt == NULL) || (ctxt->input == NULL))
	return(0);

    /* 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;
    }

    htmlParseStartTag(ctxt);
    name = ctxt->name;
    if (name == NULL)
        return(0);

    if (ctxt->record_info)
        htmlNodeInfoPush(ctxt, &node_info);

    /*
     * Check for an Empty Element labeled the XML/SGML way
     */
    if ((CUR == '/') && (NXT(1) == '>')) {
        SKIP(2);
        htmlParserFinishElementParsing(ctxt);
        if ((ctxt->options & HTML_PARSE_HTML5) == 0) {
            if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
                ctxt->sax->endElement(ctxt->userData, name);
        }
	htmlnamePop(ctxt);
	return(0);
    }

    if (CUR != '>')
        return(0);
    SKIP(1);

    /*
     * Lookup the info for that element.
     */
    info = htmlTagLookup(name);

    /*
     * Check for an Empty Element from DTD definition
     */
    if ((info != NULL) && (info->empty)) {
        htmlParserFinishElementParsing(ctxt);
        if ((ctxt->options & HTML_PARSE_HTML5) == 0) {
            if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL))
                ctxt->sax->endElement(ctxt->userData, name);
        }
	htmlnamePop(ctxt);
	return(0);
    }

    if (info != NULL)
        ctxt->endCheckState = info->dataMode;

    return(1);
}

/**
 * This is kept for compatibility with previous code versions
 *
 * @deprecated Internal function, don't use.
 *
 * @param ctxt  an HTML parser context
 */
void
htmlParseElement(htmlParserCtxt *ctxt) {
    const xmlChar *oldptr;
    int depth;

    if ((ctxt == NULL) || (ctxt->input == NULL))
	return;

    if (htmlParseElementInternal(ctxt) == 0)
        return;

    /*
     * Parse the content of the element:
     */
    depth = ctxt->nameNr;
    while (CUR != 0) {
	oldptr = ctxt->input->cur;
	htmlParseContent(ctxt);
	if (oldptr==ctxt->input->cur) break;
	if (ctxt->nameNr < depth) break;
    }

    if (CUR == 0) {
	htmlAutoCloseOnEnd(ctxt);
    }
}

/**
 * @param ctxt  parser context
 * @param input  parser input
 * @returns a node list.
 */
xmlNode *
htmlCtxtParseContentInternal(htmlParserCtxt *ctxt, xmlParserInput *input) {
    xmlNodePtr root;
    xmlNodePtr list = NULL;
    xmlChar *rootName = BAD_CAST "#root";

    root = xmlNewDocNode(ctxt->myDoc, NULL, rootName, NULL);
    if (root == NULL) {
        htmlErrMemory(ctxt);
        return(NULL);
    }

    if (xmlCtxtPushInput(ctxt, input) < 0) {
        xmlFreeNode(root);
        return(NULL);
    }

    htmlnamePush(ctxt, rootName);
    nodePush(ctxt, root);

    htmlParseContent(ctxt);

    /*
     * Only check for truncated multi-byte sequences
     */
    xmlParserCheckEOF(ctxt, XML_ERR_INTERNAL_ERROR);

    /* TODO: Use xmlCtxtIsCatastrophicError */
    if (ctxt->errNo != XML_ERR_NO_MEMORY) {
        xmlNodePtr cur;

        /*
         * Unlink newly created node list.
         */
        list = root->children;
        root->children = NULL;
        root->last = NULL;
        for (cur = list; cur != NULL; cur = cur->next)
            cur->parent = NULL;
    }

    nodePop(ctxt);
    htmlnamePop(ctxt);

    xmlCtxtPopInput(ctxt);

    xmlFreeNode(root);
    return(list);
}

/**
 * Parse an HTML document and invoke the SAX handlers. This is useful
 * if you're only interested in custom SAX callbacks. If you want a
 * document tree, use #htmlCtxtParseDocument.
 *
 * @param ctxt  an HTML parser context
 * @returns 0, -1 in case of error.
 */
int
htmlParseDocument(htmlParserCtxt *ctxt) {
    if ((ctxt == NULL) || (ctxt->input == NULL))
	return(-1);

    if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) {
        ctxt->sax->setDocumentLocator(ctxt->userData,
                (xmlSAXLocator *) &xmlDefaultSAXLocator);
    }

    xmlDetectEncoding(ctxt);

    /*
     * TODO: Implement HTML5 prescan algorithm
     */

    /*
     * This is wrong but matches long-standing behavior. In most
     * cases, a document starting with an XML declaration will
     * specify UTF-8. The HTML5 prescan algorithm handles
     * XML declarations in a better way.
     */
    if (((ctxt->input->flags & XML_INPUT_HAS_ENCODING) == 0) &&
        (xmlStrncmp(ctxt->input->cur, BAD_CAST "<?xm", 4) == 0))
        xmlSwitchEncoding(ctxt, XML_CHAR_ENCODING_UTF8);

    /*
     * Wipe out everything which is before the first '<'
     */
    SKIP_BLANKS;

    if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
	ctxt->sax->startDocument(ctxt->userData);

    /*
     * Parse possible comments, PIs or doctype declarations
     * before any content.
     */
    ctxt->instate = XML_PARSER_MISC;
    while (CUR == '<') {
        if (NXT(1) == '!') {
            if ((NXT(2) == '-') && (NXT(3) == '-')) {
                SKIP(4);
                htmlParseComment(ctxt, /* bogus */ 0);
            } else if ((UPP(2) == 'D') && (UPP(3) == 'O') &&
                       (UPP(4) == 'C') && (UPP(5) == 'T') &&
                       (UPP(6) == 'Y') && (UPP(7) == 'P') &&
                       (UPP(8) == 'E')) {
                htmlParseDocTypeDecl(ctxt);
                ctxt->instate = XML_PARSER_PROLOG;
            } else {
                SKIP(2);
                htmlParseComment(ctxt, /* bogus */ 1);
            }
        } else if (NXT(1) == '?') {
            SKIP(1);
            htmlParseComment(ctxt, /* bogus */ 1);
        } else {
            break;
        }
	SKIP_BLANKS;
        GROW;
    }

    /*
     * Time to start parsing the tree itself
     */
    ctxt->instate = XML_PARSER_CONTENT;
    htmlParseContent(ctxt);

    /*
     * Only check for truncated multi-byte sequences
     */
    xmlParserCheckEOF(ctxt, XML_ERR_INTERNAL_ERROR);

    /*
     * SAX: end of the document processing.
     */
    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
        ctxt->sax->endDocument(ctxt->userData);

    if (! ctxt->wellFormed) return(-1);
    return(0);
}


/************************************************************************
 *									*
 *			Parser contexts handling			*
 *									*
 ************************************************************************/

/**
 * Initialize a parser context
 *
 * @param ctxt  an HTML parser context
 * @param sax  SAX handler
 * @param userData  user data
 * @returns 0 in case of success and -1 in case of error
 */
static int
htmlInitParserCtxt(htmlParserCtxtPtr ctxt, const htmlSAXHandler *sax,
                   void *userData)
{
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    size_t initialNodeTabSize = 1;
#else
    size_t initialNodeTabSize = 10;
#endif

    if (ctxt == NULL) return(-1);
    memset(ctxt, 0, sizeof(htmlParserCtxt));

    ctxt->dict = xmlDictCreate();
    if (ctxt->dict == NULL)
	return(-1);

    if (ctxt->sax == NULL)
        ctxt->sax = (htmlSAXHandler *) xmlMalloc(sizeof(htmlSAXHandler));
    if (ctxt->sax == NULL)
	return(-1);
    if (sax == NULL) {
        memset(ctxt->sax, 0, sizeof(htmlSAXHandler));
        xmlSAX2InitHtmlDefaultSAXHandler(ctxt->sax);
        ctxt->userData = ctxt;
    } else {
        memcpy(ctxt->sax, sax, sizeof(htmlSAXHandler));
        ctxt->userData = userData ? userData : ctxt;
    }

    /* Allocate the Input stack */
    ctxt->inputTab = (htmlParserInputPtr *)
                      xmlMalloc(sizeof(htmlParserInputPtr));
    if (ctxt->inputTab == NULL)
	return(-1);
    ctxt->inputNr = 0;
    ctxt->inputMax = 1;
    ctxt->input = NULL;
    ctxt->version = NULL;
    ctxt->encoding = NULL;
    ctxt->standalone = -1;
    ctxt->instate = XML_PARSER_START;

    /* Allocate the Node stack */
    ctxt->nodeTab = xmlMalloc(initialNodeTabSize * sizeof(htmlNodePtr));
    if (ctxt->nodeTab == NULL)
	return(-1);
    ctxt->nodeNr = 0;
    ctxt->nodeMax = initialNodeTabSize;
    ctxt->node = NULL;

    /* Allocate the Name stack */
    ctxt->nameTab = xmlMalloc(initialNodeTabSize * sizeof(xmlChar *));
    if (ctxt->nameTab == NULL)
	return(-1);
    ctxt->nameNr = 0;
    ctxt->nameMax = initialNodeTabSize;
    ctxt->name = NULL;

    ctxt->nodeInfoTab = NULL;
    ctxt->nodeInfoNr  = 0;
    ctxt->nodeInfoMax = 0;

    ctxt->myDoc = NULL;
    ctxt->wellFormed = 1;
    ctxt->replaceEntities = 0;
    ctxt->keepBlanks = xmlKeepBlanksDefaultValue;
    ctxt->html = INSERT_INITIAL;
    ctxt->vctxt.flags = XML_VCTXT_USE_PCTXT;
    ctxt->vctxt.userData = ctxt;
    ctxt->vctxt.error = xmlParserValidityError;
    ctxt->vctxt.warning = xmlParserValidityWarning;
    ctxt->record_info = 0;
    ctxt->validate = 0;
    ctxt->checkIndex = 0;
    ctxt->catalogs = NULL;
    xmlInitNodeInfoSeq(&ctxt->node_seq);
    return(0);
}

/**
 * Free all the memory used by a parser context. However the parsed
 * document in `ctxt->myDoc` is not freed.
 *
 * @param ctxt  an HTML parser context
 */
void
htmlFreeParserCtxt(htmlParserCtxt *ctxt)
{
    xmlFreeParserCtxt(ctxt);
}

/**
 * Allocate and initialize a new HTML parser context.
 *
 * This can be used to parse HTML documents into DOM trees with
 * functions like #xmlCtxtReadFile or #xmlCtxtReadMemory.
 *
 * See #htmlCtxtUseOptions for parser options.
 *
 * See #xmlCtxtSetErrorHandler for advanced error handling.
 *
 * See #htmlNewSAXParserCtxt for custom SAX parsers.
 *
 * @returns the htmlParserCtxt or NULL in case of allocation error
 */
htmlParserCtxt *
htmlNewParserCtxt(void)
{
    return(htmlNewSAXParserCtxt(NULL, NULL));
}

/**
 * Allocate and initialize a new HTML SAX parser context. If `userData`
 * is NULL, the parser context will be passed as user data.
 *
 * @since 2.11.0
 *
 * If you want support older versions, it's best to invoke
 * #htmlNewParserCtxt and set `ctxt->sax` with struct assignment.
 *
 * Also see #htmlNewParserCtxt.
 *
 * @param sax  SAX handler
 * @param userData  user data
 * @returns the htmlParserCtxt or NULL in case of allocation error
 */
htmlParserCtxt *
htmlNewSAXParserCtxt(const htmlSAXHandler *sax, void *userData)
{
    xmlParserCtxtPtr ctxt;

    xmlInitParser();

    ctxt = (xmlParserCtxtPtr) xmlMalloc(sizeof(xmlParserCtxt));
    if (ctxt == NULL)
	return(NULL);
    memset(ctxt, 0, sizeof(xmlParserCtxt));
    if (htmlInitParserCtxt(ctxt, sax, userData) < 0) {
        htmlFreeParserCtxt(ctxt);
	return(NULL);
    }
    return(ctxt);
}

static htmlParserCtxtPtr
htmlCreateMemoryParserCtxtInternal(const char *url,
                                   const char *buffer, size_t size,
                                   const char *encoding) {
    xmlParserCtxtPtr ctxt;
    xmlParserInputPtr input;

    if (buffer == NULL)
	return(NULL);

    ctxt = htmlNewParserCtxt();
    if (ctxt == NULL)
	return(NULL);

    input = xmlCtxtNewInputFromMemory(ctxt, url, buffer, size, encoding, 0);
    if (input == NULL) {
	xmlFreeParserCtxt(ctxt);
        return(NULL);
    }

    if (xmlCtxtPushInput(ctxt, input) < 0) {
        xmlFreeInputStream(input);
        xmlFreeParserCtxt(ctxt);
        return(NULL);
    }

    return(ctxt);
}

/**
 * Create a parser context for an HTML in-memory document. The input
 * buffer must not contain any terminating null bytes.
 *
 * @deprecated Use #htmlNewParserCtxt and #htmlCtxtReadMemory.
 *
 * @param buffer  a pointer to a char array
 * @param size  the size of the array
 * @returns the new parser context or NULL
 */
htmlParserCtxt *
htmlCreateMemoryParserCtxt(const char *buffer, int size) {
    if (size <= 0)
	return(NULL);

    return(htmlCreateMemoryParserCtxtInternal(NULL, buffer, size, NULL));
}

/**
 * Create a parser context for a null-terminated string.
 *
 * @param str  a pointer to an array of xmlChar
 * @param url  URL of the document (optional)
 * @param encoding  encoding (optional)
 * @returns the new parser context or NULL if a memory allocation failed.
 */
static htmlParserCtxtPtr
htmlCreateDocParserCtxt(const xmlChar *str, const char *url,
                        const char *encoding) {
    xmlParserCtxtPtr ctxt;
    xmlParserInputPtr input;

    if (str == NULL)
	return(NULL);

    ctxt = htmlNewParserCtxt();
    if (ctxt == NULL)
	return(NULL);

    input = xmlCtxtNewInputFromString(ctxt, url, (const char *) str,
                                      encoding, 0);
    if (input == NULL) {
	xmlFreeParserCtxt(ctxt);
	return(NULL);
    }

    if (xmlCtxtPushInput(ctxt, input) < 0) {
        xmlFreeInputStream(input);
        xmlFreeParserCtxt(ctxt);
        return(NULL);
    }

    return(ctxt);
}

#ifdef LIBXML_PUSH_ENABLED
/************************************************************************
 *									*
 *	Progressive parsing interfaces				*
 *									*
 ************************************************************************/

typedef enum {
    LSTATE_TAG_NAME = 0,
    LSTATE_BEFORE_ATTR_NAME,
    LSTATE_ATTR_NAME,
    LSTATE_AFTER_ATTR_NAME,
    LSTATE_BEFORE_ATTR_VALUE,
    LSTATE_ATTR_VALUE_DQUOTED,
    LSTATE_ATTR_VALUE_SQUOTED,
    LSTATE_ATTR_VALUE_UNQUOTED
} xmlLookupStates;

/**
 * Check whether there's enough data in the input buffer to finish parsing
 * a tag. This has to take quotes into account.
 *
 * @param ctxt  an HTML parser context
 */
static int
htmlParseLookupGt(xmlParserCtxtPtr ctxt) {
    const xmlChar *cur;
    const xmlChar *end = ctxt->input->end;
    int state = ctxt->endCheckState;
    size_t index;

    if (ctxt->checkIndex == 0)
        cur = ctxt->input->cur + 2; /* Skip '<a' or '</' */
    else
        cur = ctxt->input->cur + ctxt->checkIndex;

    while (cur < end) {
        int c = *cur++;

        if (state != LSTATE_ATTR_VALUE_SQUOTED &&
            state != LSTATE_ATTR_VALUE_DQUOTED) {
            if (c == '/' &&
                state != LSTATE_BEFORE_ATTR_VALUE &&
                state != LSTATE_ATTR_VALUE_UNQUOTED) {
                state = LSTATE_BEFORE_ATTR_NAME;
                continue;
            } else if (c == '>') {
                ctxt->checkIndex = 0;
                ctxt->endCheckState = 0;
                return(0);
            }
        }

        switch (state) {
            case LSTATE_TAG_NAME:
                if (IS_WS_HTML(c))
                    state = LSTATE_BEFORE_ATTR_NAME;
                break;

            case LSTATE_BEFORE_ATTR_NAME:
                if (!IS_WS_HTML(c))
                    state = LSTATE_ATTR_NAME;
                break;

            case LSTATE_ATTR_NAME:
                if (c == '=')
                    state = LSTATE_BEFORE_ATTR_VALUE;
                else if (IS_WS_HTML(c))
                    state = LSTATE_AFTER_ATTR_NAME;
                break;

            case LSTATE_AFTER_ATTR_NAME:
                if (c == '=')
                    state = LSTATE_BEFORE_ATTR_VALUE;
                else if (!IS_WS_HTML(c))
                    state = LSTATE_ATTR_NAME;
                break;

            case LSTATE_BEFORE_ATTR_VALUE:
                if (c == '"')
                    state = LSTATE_ATTR_VALUE_DQUOTED;
                else if (c == '\'')
                    state = LSTATE_ATTR_VALUE_SQUOTED;
                else if (!IS_WS_HTML(c))
                    state = LSTATE_ATTR_VALUE_UNQUOTED;
                break;

            case LSTATE_ATTR_VALUE_DQUOTED:
                if (c == '"')
                    state = LSTATE_BEFORE_ATTR_NAME;
                break;

            case LSTATE_ATTR_VALUE_SQUOTED:
                if (c == '\'')
                    state = LSTATE_BEFORE_ATTR_NAME;
                break;

            case LSTATE_ATTR_VALUE_UNQUOTED:
                if (IS_WS_HTML(c))
                    state = LSTATE_BEFORE_ATTR_NAME;
                break;
        }
    }

    index = cur - ctxt->input->cur;
    if (index > LONG_MAX) {
        ctxt->checkIndex = 0;
        ctxt->endCheckState = 0;
        return(0);
    }
    ctxt->checkIndex = index;
    ctxt->endCheckState = state;
    return(-1);
}

/**
 * Check whether the input buffer contains a string.
 *
 * @param ctxt  an XML parser context
 * @param startDelta  delta to apply at the start
 * @param str  string
 * @param strLen  length of string
 * @param extraLen  extra length
 */
static int
htmlParseLookupString(xmlParserCtxtPtr ctxt, size_t startDelta,
                      const char *str, size_t strLen, size_t extraLen) {
    const xmlChar *end = ctxt->input->end;
    const xmlChar *cur, *term;
    size_t index, rescan;
    int ret;

    if (ctxt->checkIndex == 0) {
        cur = ctxt->input->cur + startDelta;
    } else {
        cur = ctxt->input->cur + ctxt->checkIndex;
    }

    term = BAD_CAST strstr((const char *) cur, str);
    if ((term != NULL) &&
        ((size_t) (ctxt->input->end - term) >= extraLen + 1)) {
        ctxt->checkIndex = 0;

        if (term - ctxt->input->cur > INT_MAX / 2)
            ret = INT_MAX / 2;
        else
            ret = term - ctxt->input->cur;

        return(ret);
    }

    /* Rescan (strLen + extraLen - 1) characters. */
    rescan = strLen + extraLen - 1;
    if ((size_t) (end - cur) <= rescan)
        end = cur;
    else
        end -= rescan;
    index = end - ctxt->input->cur;
    if (index > INT_MAX / 2) {
        ctxt->checkIndex = 0;
        ret = INT_MAX / 2;
    } else {
        ctxt->checkIndex = index;
        ret = -1;
    }

    return(ret);
}

/**
 * Try to find a comment end tag in the input stream
 * The search includes "-->" as well as WHATWG-recommended
 * incorrectly-closed tags.
 *
 * @param ctxt  an HTML parser context
 * @returns the index to the current parsing point if the full
 * sequence is available, -1 otherwise.
 */
static int
htmlParseLookupCommentEnd(htmlParserCtxtPtr ctxt)
{
    int mark = 0;
    int offset;

    while (1) {
	mark = htmlParseLookupString(ctxt, 2, "--", 2, 0);
	if (mark < 0)
            break;
        /*
         * <!-->    is a complete comment, but
         * <!--!>   is not
         * <!---!>  is not
         * <!----!> is
         */
        if ((NXT(mark+2) == '>') ||
	    ((mark >= 4) && (NXT(mark+2) == '!') && (NXT(mark+3) == '>'))) {
            ctxt->checkIndex = 0;
	    break;
	}
        offset = (NXT(mark+2) == '!') ? 3 : 2;
        if (mark + offset >= ctxt->input->end - ctxt->input->cur) {
	    ctxt->checkIndex = mark;
            return(-1);
        }
	ctxt->checkIndex = mark + 1;
    }
    return mark;
}


/**
 * Try to progress on parsing
 *
 * @param ctxt  an HTML parser context
 * @param terminate  last chunk indicator
 * @returns zero if no parsing was possible
 */
static void
htmlParseTryOrFinish(htmlParserCtxtPtr ctxt, int terminate) {
    while (PARSER_STOPPED(ctxt) == 0) {
        htmlParserInputPtr in;
        size_t avail;

	in = ctxt->input;
	if (in == NULL) break;
	avail = in->end - in->cur;

        switch (ctxt->instate) {
            case XML_PARSER_EOF:
	        /*
		 * Document parsing is done !
		 */
	        return;

            case XML_PARSER_START:
                /*
                 * Very first chars read from the document flow.
                 */
                if ((!terminate) && (avail < 4))
                    return;

                xmlDetectEncoding(ctxt);

                /*
                 * TODO: Implement HTML5 prescan algorithm
                 */

                /*
                 * This is wrong but matches long-standing behavior. In most
                 * cases, a document starting with an XML declaration will
                 * specify UTF-8. The HTML5 prescan algorithm handles
                 * XML declarations in a better way.
                 */
                if (((ctxt->input->flags & XML_INPUT_HAS_ENCODING) == 0) &&
                    (xmlStrncmp(ctxt->input->cur, BAD_CAST "<?xm", 4) == 0)) {
                    xmlSwitchEncoding(ctxt, XML_CHAR_ENCODING_UTF8);
                }

                /* fall through */

            case XML_PARSER_XML_DECL:
                if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) {
                    ctxt->sax->setDocumentLocator(ctxt->userData,
                            (xmlSAXLocator *) &xmlDefaultSAXLocator);
                }
		if ((ctxt->sax) && (ctxt->sax->startDocument) &&
	            (!ctxt->disableSAX))
		    ctxt->sax->startDocument(ctxt->userData);

                /* Allow callback to modify state for tests */
                if ((ctxt->instate == XML_PARSER_START) ||
                    (ctxt->instate == XML_PARSER_XML_DECL))
                    ctxt->instate = XML_PARSER_MISC;
		break;

            case XML_PARSER_START_TAG:
		if ((!terminate) &&
		    (htmlParseLookupGt(ctxt) < 0))
		    return;

                htmlParseElementInternal(ctxt);

		ctxt->instate = XML_PARSER_CONTENT;
                break;

            case XML_PARSER_MISC: /* initial */
            case XML_PARSER_PROLOG: /* before html */
            case XML_PARSER_CONTENT: {
                int mode;

                if ((ctxt->instate == XML_PARSER_MISC) ||
                    (ctxt->instate == XML_PARSER_PROLOG)) {
                    SKIP_BLANKS;
                    avail = in->end - in->cur;
                }

		if (avail < 1)
		    return;
                /*
                 * Note that endCheckState is also used by
                 * xmlParseLookupGt.
                 */
                mode = ctxt->endCheckState;

                if (mode != 0) {
                    if (htmlParseCharData(ctxt, !terminate) == 0)
                        return;
		} else if (in->cur[0] == '<') {
                    int next;

                    if (avail < 2) {
                        if (!terminate)
                            return;
                        next = ' ';
                    } else {
                        next = in->cur[1];
                    }

                    if (next == '!') {
                        if ((!terminate) && (avail < 4))
                            return;
                        if ((in->cur[2] == '-') && (in->cur[3] == '-')) {
                            if ((!terminate) &&
                                (htmlParseLookupCommentEnd(ctxt) < 0))
                                return;
                            SKIP(4);
                            htmlParseComment(ctxt, /* bogus */ 0);
                            /* don't change state */
                            break;
                        }

                        if ((!terminate) && (avail < 9))
                            return;
                        if ((UPP(2) == 'D') && (UPP(3) == 'O') &&
                            (UPP(4) == 'C') && (UPP(5) == 'T') &&
                            (UPP(6) == 'Y') && (UPP(7) == 'P') &&
                            (UPP(8) == 'E')) {
                            if ((!terminate) &&
                                (htmlParseLookupString(ctxt, 9, ">", 1,
                                                       0) < 0))
                                return;
                            htmlParseDocTypeDecl(ctxt);
                            if (ctxt->instate == XML_PARSER_MISC)
                                ctxt->instate = XML_PARSER_PROLOG;
                        } else {
                            if ((!terminate) &&
                                (htmlParseLookupString(ctxt, 2, ">", 1, 0) < 0))
                                return;
                            SKIP(2);
                            htmlParseComment(ctxt, /* bogus */ 1);
                        }
                    } else if (next == '?') {
                        if ((!terminate) &&
                            (htmlParseLookupString(ctxt, 2, ">", 1, 0) < 0))
                            return;
                        SKIP(1);
                        htmlParseComment(ctxt, /* bogus */ 1);
                        /* don't change state */
                    } else if (next == '/') {
                        ctxt->instate = XML_PARSER_END_TAG;
                        ctxt->checkIndex = 0;
                    } else if (IS_ASCII_LETTER(next)) {
                        ctxt->instate = XML_PARSER_START_TAG;
                        ctxt->checkIndex = 0;
                    } else {
                        ctxt->instate = XML_PARSER_CONTENT;
                        htmlStartCharData(ctxt);
                        if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
                            (ctxt->sax->characters != NULL))
                            ctxt->sax->characters(ctxt->userData,
                                                  BAD_CAST "<", 1);
                        SKIP(1);
                    }
                } else {
                    ctxt->instate = XML_PARSER_CONTENT;
                    /*
                     * We follow the logic of the XML push parser
                     */
		    if (avail < HTML_PARSER_BIG_BUFFER_SIZE) {
                        if ((!terminate) &&
                            (htmlParseLookupString(ctxt, 0, "<", 1, 0) < 0))
                            return;
                    }
                    ctxt->checkIndex = 0;
                    if (htmlParseCharData(ctxt, !terminate) == 0)
                        return;
		}

		break;
	    }

            case XML_PARSER_END_TAG:
		if ((!terminate) &&
		    (htmlParseLookupGt(ctxt) < 0))
		    return;
		htmlParseEndTag(ctxt);
		ctxt->instate = XML_PARSER_CONTENT;
		ctxt->checkIndex = 0;
	        break;

	    default:
		htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
			     "HPP: internal error\n", NULL, NULL);
		ctxt->instate = XML_PARSER_EOF;
		break;
	}
    }
}

/**
 * Parse a chunk of memory in push parser mode.
 *
 * Assumes that the parser context was initialized with
 * #htmlCreatePushParserCtxt.
 *
 * The last chunk, which will often be empty, must be marked with
 * the `terminate` flag. With the default SAX callbacks, the resulting
 * document will be available in `ctxt->myDoc`. This pointer will not
 * be freed by the library.
 *
 * If the document isn't well-formed, `ctxt->myDoc` is set to NULL.
 *
 * Since 2.14.0, #xmlCtxtGetDocument can be used to retrieve the
 * result document.
 *
 * @param ctxt  an HTML parser context
 * @param chunk  chunk of memory
 * @param size  size of chunk in bytes
 * @param terminate  last chunk indicator
 * @returns an xmlParserErrors code (0 on success).
 */
int
htmlParseChunk(htmlParserCtxt *ctxt, const char *chunk, int size,
              int terminate) {
    if ((ctxt == NULL) ||
        (ctxt->input == NULL) || (ctxt->input->buf == NULL) ||
        (size < 0) ||
        ((size > 0) && (chunk == NULL)))
	return(XML_ERR_ARGUMENT);
    if (PARSER_STOPPED(ctxt) != 0)
        return(ctxt->errNo);

    if (size > 0)  {
	size_t pos = ctxt->input->cur - ctxt->input->base;
	int res;

	res = xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
        xmlBufUpdateInput(ctxt->input->buf->buffer, ctxt->input, pos);
	if (res < 0) {
            htmlParseErr(ctxt, ctxt->input->buf->error,
                         "xmlParserInputBufferPush failed", NULL, NULL);
	    return (ctxt->errNo);
	}
    }

    htmlParseTryOrFinish(ctxt, terminate);

    if ((terminate) && (ctxt->instate != XML_PARSER_EOF)) {
        htmlAutoCloseOnEnd(ctxt);

        /*
         * Only check for truncated multi-byte sequences
         */
        xmlParserCheckEOF(ctxt, XML_ERR_INTERNAL_ERROR);

        if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
            ctxt->sax->endDocument(ctxt->userData);

	ctxt->instate = XML_PARSER_EOF;
    }

    return((xmlParserErrors) ctxt->errNo);
}

/************************************************************************
 *									*
 *			User entry points				*
 *									*
 ************************************************************************/

/**
 * Create a parser context for using the HTML parser in push mode.
 *
 * @param sax  a SAX handler (optional)
 * @param user_data  The user data returned on SAX callbacks (optional)
 * @param chunk  a pointer to an array of chars (optional)
 * @param size  number of chars in the array
 * @param filename  only used for error reporting (optional)
 * @param enc  encoding (deprecated, pass XML_CHAR_ENCODING_NONE)
 * @returns the new parser context or NULL if a memory allocation
 * failed.
 */
htmlParserCtxt *
htmlCreatePushParserCtxt(htmlSAXHandler *sax, void *user_data,
                         const char *chunk, int size, const char *filename,
			 xmlCharEncoding enc) {
    htmlParserCtxtPtr ctxt;
    htmlParserInputPtr input;
    const char *encoding;

    ctxt = htmlNewSAXParserCtxt(sax, user_data);
    if (ctxt == NULL)
	return(NULL);

    encoding = xmlGetCharEncodingName(enc);
    input = xmlNewPushInput(filename, chunk, size);
    if (input == NULL) {
	htmlFreeParserCtxt(ctxt);
	return(NULL);
    }

    if (xmlCtxtPushInput(ctxt, input) < 0) {
        xmlFreeInputStream(input);
        xmlFreeParserCtxt(ctxt);
        return(NULL);
    }

    if (encoding != NULL)
        xmlSwitchEncodingName(ctxt, encoding);

    return(ctxt);
}
#endif /* LIBXML_PUSH_ENABLED */

/**
 * 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.
 *
 * @deprecated Use #htmlNewSAXParserCtxt and #htmlCtxtReadDoc.
 *
 * @param cur  a pointer to an array of xmlChar
 * @param encoding  a free form C string describing the HTML document encoding, or NULL
 * @param sax  the SAX handler block
 * @param userData  if using SAX, this pointer will be provided on callbacks.
 * @returns the resulting document tree unless SAX is NULL or the document is
 *     not well formed.
 */

xmlDoc *
htmlSAXParseDoc(const xmlChar *cur, const char *encoding,
                htmlSAXHandler *sax, void *userData) {
    htmlDocPtr ret;
    htmlParserCtxtPtr ctxt;

    if (cur == NULL)
        return(NULL);

    ctxt = htmlCreateDocParserCtxt(cur, NULL, encoding);
    if (ctxt == NULL)
        return(NULL);

    if (sax != NULL) {
        *ctxt->sax = *sax;
        ctxt->userData = userData;
    }

    htmlParseDocument(ctxt);
    ret = ctxt->myDoc;
    htmlFreeParserCtxt(ctxt);

    return(ret);
}

/**
 * Parse an HTML in-memory document and build a tree.
 *
 * @deprecated Use #htmlReadDoc.
 *
 * This function uses deprecated global parser options.
 *
 * @param cur  a pointer to an array of xmlChar
 * @param encoding  the encoding (optional)
 * @returns the resulting document tree
 */

xmlDoc *
htmlParseDoc(const xmlChar *cur, const char *encoding) {
    return(htmlSAXParseDoc(cur, encoding, NULL, NULL));
}


/**
 * Create a parser context to read from a file.
 *
 * @deprecated Use #htmlNewParserCtxt and #htmlCtxtReadFile.
 *
 * A non-NULL encoding overrides encoding declarations in the document.
 *
 * Automatic support for ZLIB/Compress compressed document is provided
 * by default if found at compile-time.
 *
 * @param filename  the filename
 * @param encoding  optional encoding
 * @returns the new parser context or NULL if a memory allocation failed.
 */
htmlParserCtxt *
htmlCreateFileParserCtxt(const char *filename, const char *encoding)
{
    htmlParserCtxtPtr ctxt;
    htmlParserInputPtr input;

    if (filename == NULL)
        return(NULL);

    ctxt = htmlNewParserCtxt();
    if (ctxt == NULL) {
	return(NULL);
    }

    input = xmlCtxtNewInputFromUrl(ctxt, filename, NULL, encoding, 0);
    if (input == NULL) {
	xmlFreeParserCtxt(ctxt);
	return(NULL);
    }
    if (xmlCtxtPushInput(ctxt, input) < 0) {
        xmlFreeInputStream(input);
        xmlFreeParserCtxt(ctxt);
        return(NULL);
    }

    return(ctxt);
}

/**
 * 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.
 *
 * @deprecated Use #htmlNewSAXParserCtxt and #htmlCtxtReadFile.
 *
 * @param filename  the filename
 * @param encoding  encoding (optional)
 * @param sax  the SAX handler block
 * @param userData  if using SAX, this pointer will be provided on callbacks.
 * @returns the resulting document tree unless SAX is NULL or the document is
 *     not well formed.
 */

xmlDoc *
htmlSAXParseFile(const char *filename, const char *encoding, htmlSAXHandler *sax,
                 void *userData) {
    htmlDocPtr ret;
    htmlParserCtxtPtr ctxt;
    htmlSAXHandlerPtr oldsax = NULL;

    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);
}

/**
 * Parse an HTML file and build a tree.
 *
 * @param filename  the filename
 * @param encoding  encoding (optional)
 * @returns the resulting document tree
 */

xmlDoc *
htmlParseFile(const char *filename, const char *encoding) {
    return(htmlSAXParseFile(filename, encoding, NULL, NULL));
}

/**
 * Set and return the previous value for handling HTML omitted tags.
 *
 * @deprecated Use HTML_PARSE_NOIMPLIED
 *
 * @param val  int 0 or 1
 * @returns the last value for 0 for no handling, 1 for auto insertion.
 */

int
htmlHandleOmittedElem(int val) {
    int old = htmlOmittedDefaultValue;

    htmlOmittedDefaultValue = val;
    return(old);
}

/**
 * @deprecated Don't use.
 *
 * @param parent  HTML parent element
 * @param elt  HTML element
 * @returns 1
 */
int
htmlElementAllowedHere(const htmlElemDesc* parent ATTRIBUTE_UNUSED,
                       const xmlChar* elt ATTRIBUTE_UNUSED) {
    return(1);
}

/**
 * @deprecated Don't use.
 *
 * @param parent  HTML parent element
 * @param elt  HTML element
 * @returns HTML_VALID
 */
htmlStatus
htmlElementStatusHere(const htmlElemDesc* parent ATTRIBUTE_UNUSED,
                      const htmlElemDesc* elt ATTRIBUTE_UNUSED) {
    return(HTML_VALID);
}

/**
 * @deprecated Don't use.
 *
 * @param elt  HTML element
 * @param attr  HTML attribute
 * @param legacy  whether to allow deprecated attributes
 * @returns HTML_VALID
 */
htmlStatus
htmlAttrAllowed(const htmlElemDesc* elt ATTRIBUTE_UNUSED,
                const xmlChar* attr ATTRIBUTE_UNUSED,
                int legacy ATTRIBUTE_UNUSED) {
    return(HTML_VALID);
}

/**
 * @deprecated Don't use.
 *
 * @param node  an xmlNode in a tree
 * @param legacy  whether to allow deprecated elements (YES is faster here
 *	for Element nodes)
 * @returns HTML_VALID
 */
htmlStatus
htmlNodeStatus(xmlNode *node ATTRIBUTE_UNUSED,
               int legacy ATTRIBUTE_UNUSED) {
    return(HTML_VALID);
}

/************************************************************************
 *									*
 *	New set (2.6.0) of simpler and more flexible APIs		*
 *									*
 ************************************************************************/

/**
 * Reset a parser context
 *
 * Same as #xmlCtxtReset.
 *
 * @param ctxt  an HTML parser context
 */
void
htmlCtxtReset(htmlParserCtxt *ctxt)
{
    xmlCtxtReset(ctxt);
}

static int
htmlCtxtSetOptionsInternal(xmlParserCtxtPtr ctxt, int options, int keepMask)
{
    int allMask;

    if (ctxt == NULL)
        return(-1);

    allMask = HTML_PARSE_RECOVER |
              HTML_PARSE_HTML5 |
              HTML_PARSE_NODEFDTD |
              HTML_PARSE_NOERROR |
              HTML_PARSE_NOWARNING |
              HTML_PARSE_PEDANTIC |
              HTML_PARSE_NOBLANKS |
              HTML_PARSE_NONET |
              HTML_PARSE_NOIMPLIED |
              HTML_PARSE_COMPACT |
              HTML_PARSE_HUGE |
              HTML_PARSE_IGNORE_ENC |
              HTML_PARSE_BIG_LINES;

    ctxt->options = (ctxt->options & keepMask) | (options & allMask);

    /*
     * For some options, struct members are historically the source
     * of truth. See xmlCtxtSetOptionsInternal.
     */
    ctxt->keepBlanks = (options & HTML_PARSE_NOBLANKS) ? 0 : 1;

    /*
     * Recover from character encoding errors
     */
    ctxt->recovery = 1;

    /*
     * Changing SAX callbacks is a bad idea. This should be fixed.
     */
    if (options & HTML_PARSE_NOBLANKS) {
        ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
    }
    if (options & HTML_PARSE_HUGE) {
        if (ctxt->dict != NULL)
            xmlDictSetLimit(ctxt->dict, 0);
    }

    /*
     * It would be useful to allow this feature.
     */
    ctxt->dictNames = 0;

    /*
     * Allow XML_PARSE_NOENT which many users set on the HTML parser.
     */
    return(options & ~allMask & ~XML_PARSE_NOENT);
}

/**
 * Applies the options to the parser context. Unset options are
 * cleared.
 *
 * @since 2.14.0
 *
 * With older versions, you can use #htmlCtxtUseOptions.
 *
 * @param ctxt  an HTML parser context
 * @param options  a bitmask of htmlParserOption values
 * @returns 0 in case of success, the set of unknown or unimplemented options
 *         in case of error.
 */
int
htmlCtxtSetOptions(htmlParserCtxt *ctxt, int options)
{
    return(htmlCtxtSetOptionsInternal(ctxt, options, 0));
}

/**
 * Applies the options to the parser context. The following options
 * are never cleared and can only be enabled:
 *
 * @deprecated Use #htmlCtxtSetOptions.
 *
 * - HTML_PARSE_NODEFDTD
 * - HTML_PARSE_NOERROR
 * - HTML_PARSE_NOWARNING
 * - HTML_PARSE_NOIMPLIED
 * - HTML_PARSE_COMPACT
 * - HTML_PARSE_HUGE
 * - HTML_PARSE_IGNORE_ENC
 * - HTML_PARSE_BIG_LINES
 *
 * @param ctxt  an HTML parser context
 * @param options  a combination of htmlParserOption values
 * @returns 0 in case of success, the set of unknown or unimplemented options
 *         in case of error.
 */
int
htmlCtxtUseOptions(htmlParserCtxt *ctxt, int options)
{
    int keepMask;

    /*
     * For historic reasons, some options can only be enabled.
     */
    keepMask = HTML_PARSE_NODEFDTD |
               HTML_PARSE_NOERROR |
               HTML_PARSE_NOWARNING |
               HTML_PARSE_NOIMPLIED |
               HTML_PARSE_COMPACT |
               HTML_PARSE_HUGE |
               HTML_PARSE_IGNORE_ENC |
               HTML_PARSE_BIG_LINES;

    return(htmlCtxtSetOptionsInternal(ctxt, options, keepMask));
}

/**
 * Parse an HTML document and return the resulting document tree.
 *
 * @since 2.13.0
 *
 * @param ctxt  an HTML parser context
 * @param input  parser input
 * @returns the resulting document tree or NULL
 */
xmlDoc *
htmlCtxtParseDocument(htmlParserCtxt *ctxt, xmlParserInput *input)
{
    htmlDocPtr ret;

    if ((ctxt == NULL) || (input == NULL)) {
        xmlFatalErr(ctxt, XML_ERR_ARGUMENT, NULL);
        xmlFreeInputStream(input);
        return(NULL);
    }

    /* assert(ctxt->inputNr == 0); */
    while (ctxt->inputNr > 0)
        xmlFreeInputStream(xmlCtxtPopInput(ctxt));

    if (xmlCtxtPushInput(ctxt, input) < 0) {
        xmlFreeInputStream(input);
        return(NULL);
    }

    ctxt->html = INSERT_INITIAL;
    htmlParseDocument(ctxt);

    ret = xmlCtxtGetDocument(ctxt);

    /* assert(ctxt->inputNr == 1); */
    while (ctxt->inputNr > 0)
        xmlFreeInputStream(xmlCtxtPopInput(ctxt));

    return(ret);
}

/**
 * Convenience function to parse an HTML document from a zero-terminated
 * string.
 *
 * See #htmlCtxtReadDoc for details.
 *
 * @param str  a pointer to a zero terminated string
 * @param url  only used for error reporting (optoinal)
 * @param encoding  the document encoding (optional)
 * @param options  a combination of htmlParserOption values
 * @returns the resulting document tree.
 */
xmlDoc *
htmlReadDoc(const xmlChar *str, const char *url, const char *encoding,
            int options)
{
    htmlParserCtxtPtr ctxt;
    xmlParserInputPtr input;
    htmlDocPtr doc = NULL;

    ctxt = htmlNewParserCtxt();
    if (ctxt == NULL)
        return(NULL);

    htmlCtxtUseOptions(ctxt, options);

    input = xmlCtxtNewInputFromString(ctxt, url, (const char *) str, encoding,
                                      XML_INPUT_BUF_STATIC);

    if (input != NULL)
        doc = htmlCtxtParseDocument(ctxt, input);

    htmlFreeParserCtxt(ctxt);
    return(doc);
}

/**
 * Convenience function to parse an HTML file from the filesystem,
 * the network or a global user-defined resource loader.
 *
 * See #htmlCtxtReadFile for details.
 *
 * @param filename  a file or URL
 * @param encoding  the document encoding (optional)
 * @param options  a combination of htmlParserOption values
 * @returns the resulting document tree.
 */
xmlDoc *
htmlReadFile(const char *filename, const char *encoding, int options)
{
    htmlParserCtxtPtr ctxt;
    xmlParserInputPtr input;
    htmlDocPtr doc = NULL;

    ctxt = htmlNewParserCtxt();
    if (ctxt == NULL)
        return(NULL);

    htmlCtxtUseOptions(ctxt, options);

    input = xmlCtxtNewInputFromUrl(ctxt, filename, NULL, encoding, 0);

    if (input != NULL)
        doc = htmlCtxtParseDocument(ctxt, input);

    htmlFreeParserCtxt(ctxt);
    return(doc);
}

/**
 * Convenience function to parse an HTML document from memory.
 * The input buffer must not contain any terminating null bytes.
 *
 * See #htmlCtxtReadMemory for details.
 *
 * @param buffer  a pointer to a char array
 * @param size  the size of the array
 * @param url  only used for error reporting (optional)
 * @param encoding  the document encoding, or NULL
 * @param options  a combination of htmlParserOption values
 * @returns the resulting document tree
 */
xmlDoc *
htmlReadMemory(const char *buffer, int size, const char *url,
               const char *encoding, int options)
{
    htmlParserCtxtPtr ctxt;
    xmlParserInputPtr input;
    htmlDocPtr doc = NULL;

    if (size < 0)
	return(NULL);

    ctxt = htmlNewParserCtxt();
    if (ctxt == NULL)
        return(NULL);

    htmlCtxtUseOptions(ctxt, options);

    input = xmlCtxtNewInputFromMemory(ctxt, url, buffer, size, encoding,
                                      XML_INPUT_BUF_STATIC);

    if (input != NULL)
        doc = htmlCtxtParseDocument(ctxt, input);

    htmlFreeParserCtxt(ctxt);
    return(doc);
}

/**
 * Convenience function to parse an HTML document from a
 * file descriptor.
 *
 * NOTE that the file descriptor will not be closed when the
 * context is freed or reset.
 *
 * See #htmlCtxtReadFd for details.
 *
 * @param fd  an open file descriptor
 * @param url  only used for error reporting (optional)
 * @param encoding  the document encoding, or NULL
 * @param options  a combination of htmlParserOption values
 * @returns the resulting document tree
 */
xmlDoc *
htmlReadFd(int fd, const char *url, const char *encoding, int options)
{
    htmlParserCtxtPtr ctxt;
    xmlParserInputPtr input;
    htmlDocPtr doc = NULL;

    ctxt = htmlNewParserCtxt();
    if (ctxt == NULL)
        return(NULL);

    htmlCtxtUseOptions(ctxt, options);

    input = xmlCtxtNewInputFromFd(ctxt, url, fd, encoding, 0);

    if (input != NULL)
        doc = htmlCtxtParseDocument(ctxt, input);

    htmlFreeParserCtxt(ctxt);
    return(doc);
}

/**
 * Convenience function to parse an HTML document from I/O functions
 * and context.
 *
 * See #htmlCtxtReadIO for details.
 *
 * @param ioread  an I/O read function
 * @param ioclose  an I/O close function (optional)
 * @param ioctx  an I/O handler
 * @param url  only used for error reporting (optional)
 * @param encoding  the document encoding (optional)
 * @param options  a combination of htmlParserOption values
 * @returns the resulting document tree
 */
xmlDoc *
htmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
          void *ioctx, const char *url, const char *encoding, int options)
{
    htmlParserCtxtPtr ctxt;
    xmlParserInputPtr input;
    htmlDocPtr doc = NULL;

    ctxt = htmlNewParserCtxt();
    if (ctxt == NULL)
        return (NULL);

    htmlCtxtUseOptions(ctxt, options);

    input = xmlCtxtNewInputFromIO(ctxt, url, ioread, ioclose, ioctx,
                                  encoding, 0);

    if (input != NULL)
        doc = htmlCtxtParseDocument(ctxt, input);

    htmlFreeParserCtxt(ctxt);
    return(doc);
}

/**
 * Parse an HTML in-memory document and build a tree.
 *
 * See #htmlCtxtUseOptions for details.
 *
 * @param ctxt  an HTML parser context
 * @param str  a pointer to a zero terminated string
 * @param URL  only used for error reporting (optional)
 * @param encoding  the document encoding (optional)
 * @param options  a combination of htmlParserOption values
 * @returns the resulting document tree
 */
xmlDoc *
htmlCtxtReadDoc(xmlParserCtxt *ctxt, const xmlChar *str,
                const char *URL, const char *encoding, int options)
{
    xmlParserInputPtr input;

    if (ctxt == NULL)
        return (NULL);

    htmlCtxtReset(ctxt);
    htmlCtxtUseOptions(ctxt, options);

    input = xmlCtxtNewInputFromString(ctxt, URL, (const char *) str,
                                      encoding, 0);
    if (input == NULL)
        return(NULL);

    return(htmlCtxtParseDocument(ctxt, input));
}

/**
 * Parse an HTML file from the filesystem, the network or a
 * user-defined resource loader.
 *
 * See #htmlCtxtUseOptions for details.
 *
 * @param ctxt  an HTML parser context
 * @param filename  a file or URL
 * @param encoding  the document encoding (optional)
 * @param options  a combination of htmlParserOption values
 * @returns the resulting document tree
 */
xmlDoc *
htmlCtxtReadFile(xmlParserCtxt *ctxt, const char *filename,
                const char *encoding, int options)
{
    xmlParserInputPtr input;

    if (ctxt == NULL)
        return (NULL);

    htmlCtxtReset(ctxt);
    htmlCtxtUseOptions(ctxt, options);

    input = xmlCtxtNewInputFromUrl(ctxt, filename, NULL, encoding, 0);
    if (input == NULL)
        return(NULL);

    return(htmlCtxtParseDocument(ctxt, input));
}

/**
 * Parse an HTML in-memory document and build a tree. The input buffer must
 * not contain any terminating null bytes.
 *
 * See #htmlCtxtUseOptions for details.
 *
 * @param ctxt  an HTML parser context
 * @param buffer  a pointer to a char array
 * @param size  the size of the array
 * @param URL  only used for error reporting (optional)
 * @param encoding  the document encoding (optinal)
 * @param options  a combination of htmlParserOption values
 * @returns the resulting document tree
 */
xmlDoc *
htmlCtxtReadMemory(xmlParserCtxt *ctxt, const char *buffer, int size,
                  const char *URL, const char *encoding, int options)
{
    xmlParserInputPtr input;

    if ((ctxt == NULL) || (size < 0))
        return (NULL);

    htmlCtxtReset(ctxt);
    htmlCtxtUseOptions(ctxt, options);

    input = xmlCtxtNewInputFromMemory(ctxt, URL, buffer, size, encoding,
                                      XML_INPUT_BUF_STATIC);
    if (input == NULL)
        return(NULL);

    return(htmlCtxtParseDocument(ctxt, input));
}

/**
 * Parse an HTML from a file descriptor and build a tree.
 *
 * See #htmlCtxtUseOptions for details.
 *
 * NOTE that the file descriptor will not be closed when the
 * context is freed or reset.
 *
 * @param ctxt  an HTML parser context
 * @param fd  an open file descriptor
 * @param URL  only used for error reporting (optional)
 * @param encoding  the document encoding (optinal)
 * @param options  a combination of htmlParserOption values
 * @returns the resulting document tree
 */
xmlDoc *
htmlCtxtReadFd(xmlParserCtxt *ctxt, int fd,
              const char *URL, const char *encoding, int options)
{
    xmlParserInputPtr input;

    if (ctxt == NULL)
        return(NULL);

    htmlCtxtReset(ctxt);
    htmlCtxtUseOptions(ctxt, options);

    input = xmlCtxtNewInputFromFd(ctxt, URL, fd, encoding, 0);
    if (input == NULL)
        return(NULL);

    return(htmlCtxtParseDocument(ctxt, input));
}

/**
 * Parse an HTML document from I/O functions and source and build a tree.
 *
 * See #htmlCtxtUseOptions for details.
 *
 * @param ctxt  an HTML parser context
 * @param ioread  an I/O read function
 * @param ioclose  an I/O close function
 * @param ioctx  an I/O handler
 * @param URL  the base URL to use for the document
 * @param encoding  the document encoding, or NULL
 * @param options  a combination of htmlParserOption values
 * @returns the resulting document tree
 */
xmlDoc *
htmlCtxtReadIO(xmlParserCtxt *ctxt, xmlInputReadCallback ioread,
              xmlInputCloseCallback ioclose, void *ioctx,
	      const char *URL,
              const char *encoding, int options)
{
    xmlParserInputPtr input;

    if (ctxt == NULL)
        return (NULL);

    htmlCtxtReset(ctxt);
    htmlCtxtUseOptions(ctxt, options);

    input = xmlCtxtNewInputFromIO(ctxt, URL, ioread, ioclose, ioctx,
                                  encoding, 0);
    if (input == NULL)
        return(NULL);

    return(htmlCtxtParseDocument(ctxt, input));
}

#endif /* LIBXML_HTML_ENABLED */