/*

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

 *

 * See Copyright for the status of this software.

 *

 * daniel@veillard.com

 * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

 */

#define IN_LIBXML

#include "xmlenglibxml.h"

#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 <stdapis/libxml2/libxml2_globals.h>

#include <stdapis/libxml2/libxml2_xmlmemory.h>

#include <stdapis/libxml2/libxml2_tree.h>

#include <stdapis/libxml2/libxml2_parser.h>

#include <stdapis/libxml2/libxml2_parserinternals.h>

#include <stdapis/libxml2/libxml2_xmlerror.h>

#include "libxml2_xmlerror2.h"

#include "libxml2_htmlparser.h"

#include "libxml2_htmltree.h"

#include "libxml2_entities.h"

#include <stdapis/libxml2/libxml2_encoding.h>

#include <stdapis/libxml2/libxml2_valid.h>

#include <stdapis/libxml2/libxml2_xmlio.h>

#include <stdapis/libxml2/libxml2_uri.h>

#define HTML_MAX_NAMELEN 1000

#define HTML_PARSER_BIG_BUFFER_SIZE 1000

#define HTML_PARSER_BUFFER_SIZE 100

#ifdef LIBXML_HTML_ENABLED

/* #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:

 * @param ctxt an HTML parser context

 * @param extra extra informations

 *

 * Handle a redefinition of attribute error

 */

void

htmlErrMemory(xmlParserCtxtPtr ctxt, const char *extra); // moved to XSLT-enabled part of this file

/**

 * htmlParseErr:

 * @param ctxt an HTML parser context

 * @param error the error number

 * @param msg the error message

 * @param str1 string infor

 * @param 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:

 * @param ctxt an HTML parser context

 * @param error the error number

 * @param msg the error message

 * @param 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:

 * @param ctxt an HTML parser context

 * @param 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:

 * @param 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. 

 *   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:

 * @param ctxt the HTML parser context

 * @param 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:

 * @param 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);

}

#endif  /* defined(LIBXML_HTML_ENABLED */

#if defined(LIBXML_HTML_ENABLED) || defined(XMLENGINE_XSLT)

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

 *                                                                      *

 *      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",

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

static const char* const col_attrs[] = { ATTRS, "span", "width", CELLHALIGN, CELLVALIGN, NULL } ;

static const char* const col_elt[] = { "col", NULL } ;

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

static const char* const compact_attrs[] = { ATTRS, "compact", NULL } ;

static const char* const dl_contents[] = { "dt", "dd", NULL } ;

static const char* const compact_attr[] = { "compact", NULL } ;

static const char* const label_attr[] = { "label", NULL } ;

static const char* const fieldset_contents[] = { FLOW, "legend" } ;

static const char* const font_attrs[] = { COREATTRS, I18N, "size", "color", "face" , NULL } ;

static const char* const form_contents[] = { HEADING, LIST, INLINE, "pre", "p", "div", "center", "noscript", "noframes", "blockquote", "isindex", "hr", "table", "fieldset", "address", NULL } ;

static const char* const form_attrs[] = { ATTRS, "method", "enctype", "accept", "name", "onsubmit", "onreset", "accept-charset", NULL } ;

static const char* const frame_attrs[] = { COREATTRS, "longdesc", "name", "src", "frameborder", "marginwidth", "marginheight", "noresize", "scrolling" , NULL } ;

static const char* const frameset_attrs[] = { COREATTRS, "rows", "cols", "onload", "onunload", NULL } ;