/*

 * HTMLparser.c : an HTML 4.0 non-verifying parser

 *

 * See Copyright for the status of this software.

 *

 * daniel@veillard.com

 */

#define IN_LIBXML

#include "XmlEnglibxml.h"

#ifdef LIBXML_HTML_ENABLED

#include <string.h>

#if defined(HAVE_CTYPE_H)

#include <ctype.h>

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_SYS_STAT_H

#include <sys/stat.h>

#endif

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_ZLIB_H

#include <zlib.h>

#endif

#include "Libxml2_globals.h"

#include "Libxml2_xmlmemory.h"

#include "Libxml2_tree.h"

#include "Libxml2_parser.h"

#include "Libxml2_parserInternals.h"

#include "Libxml2_xmlerror.h"

#include "Libxml2_HTMLparser.h"

#include "Libxml2_HTMLtree.h"

#include "Libxml2_entities.h"

#include "Libxml2_encoding.h"

#include "Libxml2_valid.h"

#include "Libxml2_xmlIO.h"

#include "Libxml2_uri.h"

#define HTML_MAX_NAMELEN 1000

#define HTML_PARSER_BIG_BUFFER_SIZE 1000

#define HTML_PARSER_BUFFER_SIZE 100

/* #define DEBUG */

/* #define DEBUG_PUSH */

static const int htmlOmittedDefaultValue = 1;

xmlChar * htmlDecodeEntities(htmlParserCtxtPtr ctxt, int len,

			     xmlChar end, xmlChar  end2, xmlChar end3);

static void htmlParseComment(htmlParserCtxtPtr ctxt);

/************************************************************************

 *									*

 * 		Some factorized error routines				*

 *									*

 ************************************************************************/

/**

 * htmlErrMemory:

 * @ctxt:  an HTML parser context

 * @extra:  extra informations

 *

 * Handle a redefinition of attribute error

 */

static void

htmlErrMemory(xmlParserCtxtPtr ctxt, const char *extra)

{

    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

        (ctxt->instate == XML_PARSER_EOF))

	return;

    if (ctxt != NULL) {

        ctxt->errNo = XML_ERR_NO_MEMORY;

        ctxt->instate = XML_PARSER_EOF;

        ctxt->disableSAX = 1;

    }

    if (extra)

        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,

                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,

                        NULL, NULL, 0, 0,

                        "Memory allocation failed : %s\n", extra);

    else

        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,

                        XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,

                        NULL, NULL, 0, 0, "Memory allocation failed\n");

}

/**

 * htmlParseErr:

 * @ctxt:  an HTML parser context

 * @error:  the error number

 * @msg:  the error message

 * @str1:  string infor

 * @str2:  string infor

 *

 * Handle a fatal parser error, i.e. violating Well-Formedness constraints

 */

static void

htmlParseErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,

             const char *msg, const xmlChar *str1, const xmlChar *str2)

{

    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

        (ctxt->instate == XML_PARSER_EOF))

	return;

    ctxt->errNo = error;

    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_HTML, error,

                    XML_ERR_ERROR, NULL, 0,

		    (const char *) str1, (const char *) str2,

		    NULL, 0, 0,

		    msg, str1, str2);

    ctxt->wellFormed = 0;

}

/**

 * htmlParseErrInt:

 * @ctxt:  an HTML parser context

 * @error:  the error number

 * @msg:  the error message

 * @val:  integer info

 *

 * Handle a fatal parser error, i.e. violating Well-Formedness constraints

 */

static void

htmlParseErrInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,

             const char *msg, int val)

{

    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

        (ctxt->instate == XML_PARSER_EOF))

	return;

    ctxt->errNo = error;

    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_HTML, error,

                    XML_ERR_ERROR, NULL, 0, NULL, NULL,

		    NULL, val, 0, msg, val);

    ctxt->wellFormed = 0;

}

/************************************************************************

 *									*

 * 		Parser stacks related functions and macros		*

 *									*

 ************************************************************************/

/**

 * htmlnamePush:

 * @ctxt:  an HTML parser context

 * @value:  the element name

 *

 * Pushes a new element name on top of the name stack

 *

 * Returns 0 in case of error, the index in the stack otherwise

 */

static int

htmlnamePush(htmlParserCtxtPtr ctxt, const xmlChar * value)

{

    if (ctxt->nameNr >= ctxt->nameMax) {

        void* allocTmp; // DONE: Fix xmlRealloc

        allocTmp = xmlRealloc((xmlChar**)ctxt->nameTab,

                               ctxt->nameMax * 2 * sizeof(ctxt->nameTab[0]));

        if (!allocTmp) {

            htmlErrMemory(ctxt, NULL);

            return (0);

        }

        ctxt->nameMax *= 2;

        ctxt->nameTab = (const xmlChar**) allocTmp;

    }

    ctxt->nameTab[ctxt->nameNr] = value;

    ctxt->name = value;

    return (ctxt->nameNr++);

}

/**

 * htmlnamePop:

 * @ctxt: an HTML parser context

 *

 * Pops the top element name from the name stack

 *

 * Returns the name just removed

 */

static const xmlChar *

htmlnamePop(htmlParserCtxtPtr ctxt)

{

    const xmlChar *ret;

    if (ctxt->nameNr <= 0)

        return (0);

    ctxt->nameNr--;

    if (ctxt->nameNr < 0)

        return (0);

    if (ctxt->nameNr > 0)

        ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];

    else

        ctxt->name = NULL;

    ret = ctxt->nameTab[ctxt->nameNr];

    ctxt->nameTab[ctxt->nameNr] = 0;

    return (ret);

}

/*

 * 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

 *

 *   CURRENT Returns the current char value, with the full decoding of

 *           UTF-8 if we are using this mode. It returns an int.

 *   NEXT    Skip to the next character, this does the proper decoding

 *           in UTF-8 mode. It also pop-up unfinished entities on the fly.

 *   NEXTL(l) Skip the current unicode character of l xmlChars long.

 *   COPY(to) copy one char to *to, increment CUR_PTR and to accordingly

 */

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

#define SKIP(val) ctxt->nbChars += (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 SHRINK if ((ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \

		   (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \

	xmlParserInputShrink(ctxt->input)

#define GROW if ((ctxt->progressive == 0) &&				\

		 (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK))	\

	xmlParserInputGrow(ctxt->input, INPUT_CHUNK)

#define CURRENT ((int) (*ctxt->input->cur))

#define SKIP_BLANKS htmlSkipBlankChars(ctxt)

/* Inported from XML */

/* #define CUR (ctxt->token ? ctxt->token : (int) (*ctxt->input->cur)) */

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

#define NEXT xmlNextChar(ctxt)

#define RAW (ctxt->token ? -1 : (*ctxt->input->cur))

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

#define CUR_PTR ctxt->input->cur

#define NEXTL(l) do {							\

    if (*(ctxt->input->cur) == '\n') {					\

	ctxt->input->line++; ctxt->input->col = 1;			\

    } else ctxt->input->col++;						\

    ctxt->token = 0; ctxt->input->cur += l; ctxt->nbChars++;		\

  } while (0)

/************

    \

    if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);	\

    if (*ctxt->input->cur == '&') xmlParserHandleReference(ctxt);

 ************/

#define CUR_CHAR(l) htmlCurrentChar(ctxt, &l)

#define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)

#define COPY_BUF(l,b,i,v)						\

    if (l == 1) b[i++] = (xmlChar) v;					\

    else i += xmlCopyChar(l,&b[i],v)

/**

 * htmlCurrentChar:

 * @ctxt:  the HTML parser context

 * @len:  pointer to the length of the char read

 *

 * The current char value, if using UTF-8 this may actually span multiple

 * bytes in the input buffer. Implement the end of line normalization:

 * 2.11 End-of-Line Handling

 * If the encoding is unspecified, in the case we find an ISO-Latin-1

 * char, then the encoding converter is plugged in automatically.

 *

 * Returns the current char value and its length

 */

static int

htmlCurrentChar(xmlParserCtxtPtr ctxt, int *len) {

    if (ctxt->instate == XML_PARSER_EOF)

	return(0);

    if (ctxt->token != 0) {

	*len = 0;

	return(ctxt->token);

    }	

    if (ctxt->charset == XML_CHAR_ENCODING_UTF8) {

	/*

	 * We are supposed to handle UTF8, check it's valid

	 * From rfc2044: encoding of the Unicode values on UTF-8:

	 *

	 * UCS-4 range (hex.)           UTF-8 octet sequence (binary)

	 * 0000 0000-0000 007F   0xxxxxxx

	 * 0000 0080-0000 07FF   110xxxxx 10xxxxxx

	 * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx 

	 *

	 * Check for the 0x110000 limit too

	 */

	const unsigned char *cur = ctxt->input->cur;

	unsigned char c;

	unsigned int val;

	c = *cur;

	if (c & 0x80) {

	    if (cur[1] == 0)

		xmlParserInputGrow(ctxt->input, INPUT_CHUNK);

	    if ((cur[1] & 0xc0) != 0x80)

		goto encoding_error;

	    if ((c & 0xe0) == 0xe0) {

		if (cur[2] == 0)

		    xmlParserInputGrow(ctxt->input, INPUT_CHUNK);

		if ((cur[2] & 0xc0) != 0x80)

		    goto encoding_error;

		if ((c & 0xf0) == 0xf0) {

		    if (cur[3] == 0)

			xmlParserInputGrow(ctxt->input, INPUT_CHUNK);

		    if (((c & 0xf8) != 0xf0) ||

			((cur[3] & 0xc0) != 0x80))

			goto encoding_error;

		    /* 4-byte code */

		    *len = 4;

		    val = (cur[0] & 0x7) << 18;

		    val |= (cur[1] & 0x3f) << 12;

		    val |= (cur[2] & 0x3f) << 6;

		    val |= cur[3] & 0x3f;

		} else {

		  /* 3-byte code */

		    *len = 3;

		    val = (cur[0] & 0xf) << 12;

		    val |= (cur[1] & 0x3f) << 6;

		    val |= cur[2] & 0x3f;

		}

	    } else {

	      /* 2-byte code */

		*len = 2;

		val = (cur[0] & 0x1f) << 6;

		val |= cur[1] & 0x3f;

	    }

	    if (!IS_CHAR(val)) {

	        htmlParseErrInt(ctxt, XML_ERR_INVALID_CHAR,

				"Char 0x%X out of allowed range\n", val);

        }

	    return(val);

	} else {

	    /* 1-byte code */

	    *len = 1;

	    return((int) *ctxt->input->cur);

	}

    }

    /*

     * Assume it's a fixed length encoding (1) with

     * a compatible encoding for the ASCII set, since

     * XML constructs only use < 128 chars

     */

    *len = 1;

    if ((int) *ctxt->input->cur < 0x80)

	return((int) *ctxt->input->cur);

    /*

     * Humm this is bad, do an automatic flow conversion

     */

    xmlSwitchEncoding(ctxt, XML_CHAR_ENCODING_8859_1);

    ctxt->charset = XML_CHAR_ENCODING_UTF8;

    return(xmlCurrentChar(ctxt, len));

encoding_error:

    /*

     * If we detect an UTF8 error that probably mean that the

     * input encoding didn't get properly advertized in the

     * declaration header. Report the error and switch the encoding

     * to ISO-Latin-1 (if you don't like this policy, just declare the

     * encoding !)

     */

    htmlParseErr(ctxt, XML_ERR_INVALID_ENCODING,

		 "Input is not proper UTF-8, indicate encoding !\n",

		 NULL, NULL);

    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL)) {

	ctxt->sax->error(ctxt->userData, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",

			ctxt->input->cur[0], ctxt->input->cur[1],

			ctxt->input->cur[2], ctxt->input->cur[3]);

    }

    ctxt->charset = XML_CHAR_ENCODING_8859_1; 

    *len = 1;

    return((int) *ctxt->input->cur);

}

/**

 * htmlSkipBlankChars:

 * @ctxt:  the HTML parser context

 *

 * skip all blanks character found at that point in the input streams.

 *

 * Returns the number of space chars skipped

 */

static int

htmlSkipBlankChars(xmlParserCtxtPtr ctxt) {

    int res = 0;

    while (IS_BLANK_CH(*(ctxt->input->cur))) {

	if ((*ctxt->input->cur == 0) &&

	    (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) {

		xmlPopInput(ctxt);

	} else {

	    if (*(ctxt->input->cur) == '\n') {

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

	    } else ctxt->input->col++;

	    ctxt->input->cur++;

	    ctxt->nbChars++;

	    if (*ctxt->input->cur == 0)

		xmlParserInputGrow(ctxt->input, INPUT_CHUNK);

	}

	res++;

    }

    return(res);

}

/************************************************************************

 *									*

 * 		The list of HTML elements and their properties		*

 *									*

 ************************************************************************/

/*

 *  Start Tag: 1 means the start tag can be ommited

 *  End Tag:   1 means the end tag can be ommited

 *             2 means it's forbidden (empty elements)

 *             3 means the tag is stylistic and should be closed easily

 *  Depr:      this element is deprecated

 *  DTD:       1 means that this element is valid only in the Loose DTD

 *             2 means that this element is valid only in the Frameset DTD

 *

 * Name,Start Tag,End Tag,Save End,Empty,Deprecated,DTD,inline,Description

	, subElements , impliedsubelt , Attributes, userdata

 */

/* Definitions and a couple of vars for HTML Elements */

#define FONTSTYLE "tt", "i", "b", "u", "s", "strike", "big", "small"

#define PHRASE "em", "strong", "dfn", "code", "samp", "kbd", "var", "cite", "abbr", "acronym"

#define SPECIAL "a", "img", "applet", "object", "font", "basefont", "br", "script", "map", "q", "sub", "sup", "span", "bdo", "iframe"

#define INLINE PCDATA FONTSTYLE PHRASE SPECIAL FORMCTRL

#define BLOCK HEADING LIST "pre", "p", "dl", "div", "center", "noscript", "noframes", "blockquote", "form", "isindex", "hr", "table", "fieldset", "address"

#define FORMCTRL "input", "select", "textarea", "label", "button"

#define PCDATA

#define HEADING "h1", "h2", "h3", "h4", "h5", "h6"

#define LIST "ul", "ol", "dir", "menu"

#define MODIFIER

#define FLOW BLOCK,INLINE

#define EMPTY NULL

// TO DO libxslt added 2nd const in between

static const char* const html_flow [] = { FLOW, NULL } ;

static const char* const html_inline [] = { INLINE, NULL } ;

/* placeholders: elts with content but no subelements */

static const char* const html_pcdata[] = { NULL } ;

#define html_cdata html_pcdata

/* ... and for HTML Attributes */

#define COREATTRS "id", "class", "style", "title"

#define I18N "lang", "dir"

#define EVENTS "onclick", "ondblclick", "onmousedown", "onmouseup", "onmouseover", "onmouseout", "onkeypress", "onkeydown", "onkeyup"

#define ATTRS COREATTRS,I18N,EVENTS

#define CELLHALIGN "align", "char", "charoff"

#define CELLVALIGN "valign"

static const char* const html_attrs [] = { ATTRS, NULL } ;

static const char* const core_i18n_attrs [] = { COREATTRS, I18N, NULL } ;

static const char* const core_attrs [] = { COREATTRS, NULL } ;

static const char* const i18n_attrs [] = { I18N, NULL } ;

/* Other declarations that should go inline ... */

static const char* const a_attrs[] = { ATTRS, "charset", "type", "name",

	"href", "hreflang", "rel", "rev", "accesskey", "shape", "coords",

	"tabindex", "onfocus", "onblur", NULL } ;

static const char* const target_attr[] = { "target", NULL } ;

static const char* const rows_cols_attr[] = { "rows", "cols", NULL } ;

static const char* const alt_attr[] = { "alt", NULL } ;

static const char* const src_alt_attrs[] = { "src", "alt", NULL } ;

static const char* const href_attrs[] = { "href", NULL } ;

static const char* const clear_attrs[] = { "clear", NULL } ;

static const char* const inline_p[] = { INLINE, "p", NULL } ;

static const char* const flow_param[] = { FLOW, "param", NULL } ;

static const char* const applet_attrs[] = { COREATTRS , "codebase",

		"archive", "alt", "name", "height", "width", "align",

		"hspace", "vspace", NULL } ;

static const char* const area_attrs[] = { "shape", "coords", "href", "nohref",

	"tabindex", "accesskey", "onfocus", "onblur", NULL } ;

static const char* const basefont_attrs[] =

	{ "id", "size", "color", "face", NULL } ;

static const char* const quote_attrs[] = { ATTRS, "cite", NULL } ;

static const char* const body_contents[] = { FLOW, "ins", "del", NULL } ;

static const char* const body_attrs[] = { ATTRS, "onload", "onunload", NULL } ;

static const char* const body_depr[] = { "background", "bgcolor", "text",

	"link", "vlink", "alink", NULL } ;

static const char* const button_attrs[] = { ATTRS, "name", "value", "type",