/*

 * xmlsave.c: Implemetation of the document serializer

 *

 * See Copyright for the status of this software.

 *

 * daniel@veillard.com

 */

#define IN_LIBXML

#include "XmlEnglibxml.h"

#include <string.h>

#include "Libxml2_globals.h"

//#include "Libxml2_xmlmemory.h"

#include "Libxml2_parserInternals.h"

//#include "Libxml2_tree.h"

//#include "Libxml2_xmlIO.h"

#include "Libxml2_xmlsave.h"

#ifdef LIBXML_HTML_ENABLED

#include "Libxml2_HTMLtree.h"

#endif

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

 *                                  *

 *          XHTML detection                 *

 *                                  *

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

#define XHTML_STRICT_PUBLIC_ID BAD_CAST \

   "-//W3C//DTD XHTML 1.0 Strict//EN"

#define XHTML_STRICT_SYSTEM_ID BAD_CAST \

   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"

#define XHTML_FRAME_PUBLIC_ID BAD_CAST \

   "-//W3C//DTD XHTML 1.0 Frameset//EN"

#define XHTML_FRAME_SYSTEM_ID BAD_CAST \

   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd"

#define XHTML_TRANS_PUBLIC_ID BAD_CAST \

   "-//W3C//DTD XHTML 1.0 Transitional//EN"

#define XHTML_TRANS_SYSTEM_ID BAD_CAST \

   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"

#define XHTML_NS_NAME BAD_CAST "http://www.w3.org/1999/xhtml"

/**

 * xmlIsXHTML:

 * @systemID:  the system identifier

 * @publicID:  the public identifier

 *

 * Try to find if the document correspond to an XHTML DTD

 *

 * Returns 1 if true, 0 if not and -1 in case of error

 */

int

xmlIsXHTML(const xmlChar *systemID, const xmlChar *publicID) {

    if ((systemID == NULL) && (publicID == NULL))

    return(-1);

    if (publicID != NULL) {

    if (xmlStrEqual(publicID, XHTML_STRICT_PUBLIC_ID)) return(1);

    if (xmlStrEqual(publicID, XHTML_FRAME_PUBLIC_ID)) return(1);

    if (xmlStrEqual(publicID, XHTML_TRANS_PUBLIC_ID)) return(1);

    }

    if (systemID != NULL) {

    if (xmlStrEqual(systemID, XHTML_STRICT_SYSTEM_ID)) return(1);

    if (xmlStrEqual(systemID, XHTML_FRAME_SYSTEM_ID)) return(1);

    if (xmlStrEqual(systemID, XHTML_TRANS_SYSTEM_ID)) return(1);

    }

    return(0);

}

#ifdef LIBXML_OUTPUT_ENABLED

#define TODO                                \

    xmlGenericError(xmlGenericErrorContext,             \

        "Unimplemented block at %s:%d\n",               \

            __FILE__, __LINE__);

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

 *                                  *

 *          Output error handlers               *

 *                                  *

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

/**

 * xmlSaveErrMemory:

 * @extra:  extra informations

 *

 * Handle an out of memory condition

 */

static void

xmlSaveErrMemory(const char *extra)

{

    __xmlSimpleError(XML_FROM_OUTPUT, XML_ERR_NO_MEMORY, NULL, NULL, extra);

}

/**

 * xmlSaveErr:

 * @code:  the error number

 * @node:  the location of the error.

 * @extra:  extra informations

 *

 * Handle an out of memory condition

 *

 */

static void

xmlSaveErr(int code, xmlNodePtr node, const char *extra)

{

    const char *msg = NULL;

    switch(code) {

        case XML_SAVE_NOT_UTF8:

        msg = EMBED_ERRTXT("string is not in UTF-8");

        break;

    case XML_SAVE_CHAR_INVALID:

        msg = EMBED_ERRTXT("invalid character value");

        break;

    case XML_SAVE_UNKNOWN_ENCODING:

        msg = EMBED_ERRTXT("unknown encoding %s");

        break;

    case XML_SAVE_NO_DOCTYPE:

        msg = EMBED_ERRTXT("document has no DOCTYPE");

        break;

    default:

        msg = EMBED_ERRTXT("unexpected error number");

    }

    __xmlSimpleError(XML_FROM_OUTPUT, code, node, msg, extra);

}

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

 *                                  *

 *          Special escaping routines           *

 *                                  *

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

static unsigned char *

xmlSerializeHexCharRef(unsigned char *out, int val) {

    unsigned char *ptr;

    *out++ = '&';

    *out++ = '#';

    *out++ = 'x';

    if (val < 0x10) ptr = out;

    else if (val < 0x100) ptr = out + 1;

    else if (val < 0x1000) ptr = out + 2;

    else if (val < 0x10000) ptr = out + 3;

    else if (val < 0x100000) ptr = out + 4;

    else ptr = out + 5;

    out = ptr + 1;

    while (val > 0) {

        // TODO: KO: OPTIMIZE: Isn't that

        //          bval = (val & 0xF)

        //          *ptr-- = bval + (bval < 10 ? '0'; 'A'-10)

        //        much more efficient???

    switch (val & 0xF) {

        case 0: *ptr-- = '0'; break;

        case 1: *ptr-- = '1'; break;

        case 2: *ptr-- = '2'; break;

        case 3: *ptr-- = '3'; break;

        case 4: *ptr-- = '4'; break;

        case 5: *ptr-- = '5'; break;

        case 6: *ptr-- = '6'; break;

        case 7: *ptr-- = '7'; break;

        case 8: *ptr-- = '8'; break;

        case 9: *ptr-- = '9'; break;

        case 0xA: *ptr-- = 'A'; break;

        case 0xB: *ptr-- = 'B'; break;

        case 0xC: *ptr-- = 'C'; break;

        case 0xD: *ptr-- = 'D'; break;

        case 0xE: *ptr-- = 'E'; break;

        case 0xF: *ptr-- = 'F'; break;

        default: *ptr-- = '0'; break;

    }

    val >>= 4;

    }

    *out++ = ';';

    *out = 0;

    return(out);

}

/**

 * xmlAttrSerializeTxtContent:

 * @buf:  the XML buffer output

 * @doc:  the document

 * @attr: the attribute node

 * @string: the text content

 *

 * Serialize text attribute values to an xml simple buffer

 *

 * (Previously this function was in xmlsave.c)

 */

void

xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr doc,

                           xmlAttrPtr attr, const xmlChar * string)

{

    xmlChar *base, *cur;

    if (string == NULL)

        return;

    base = cur = (xmlChar *) string;

    while (*cur != 0) {

        if (*cur == '\n') {

            if (base != cur)

                xmlBufferAdd(buf, base, cur - base);

            xmlBufferAdd(buf, BAD_CAST "
", 5);

            cur++;

            base = cur;

        } else if (*cur == '\r') {

            if (base != cur)

                xmlBufferAdd(buf, base, cur - base);

            xmlBufferAdd(buf, BAD_CAST "
", 5);

            cur++;

            base = cur;

        } else if (*cur == '\t') {

            if (base != cur)

                xmlBufferAdd(buf, base, cur - base);

            xmlBufferAdd(buf, BAD_CAST "	", 4);

            cur++;

            base = cur;

        } else if (*cur == '"') {

            if (base != cur)

                xmlBufferAdd(buf, base, cur - base);

            xmlBufferAdd(buf, BAD_CAST """, 6);

            cur++;

            base = cur;

        } else if (*cur == '<') {

            if (base != cur)

                xmlBufferAdd(buf, base, cur - base);

            xmlBufferAdd(buf, BAD_CAST "<", 4);

            cur++;

            base = cur;

        } else if (*cur == '>') {

            if (base != cur)

                xmlBufferAdd(buf, base, cur - base);

            xmlBufferAdd(buf, BAD_CAST ">", 4);

            cur++;

            base = cur;

        } else if (*cur == '&') {

            if (base != cur)

                xmlBufferAdd(buf, base, cur - base);

            xmlBufferAdd(buf, BAD_CAST "&", 5);

            cur++;

            base = cur;

        } else if ((*cur >= 0x80) && ((doc == NULL) ||

                                      (doc->encoding == NULL))) {

            /*

             * We assume we have UTF-8 content.

             */

            unsigned char tmp[10];

            int val = 0, l = 1;

            if (base != cur)

                xmlBufferAdd(buf, base, cur - base);

            if (*cur < 0xC0) {

                xmlSaveErr(XML_SAVE_NOT_UTF8, (xmlNodePtr) attr, NULL);

                if (doc != NULL)

                    doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");

        xmlSerializeHexCharRef(tmp, *cur);

                xmlBufferAdd(buf, (xmlChar *) tmp, -1);

                cur++;

                base = cur;

                continue;

            } else if (*cur < 0xE0) {

                val = (cur[0]) & 0x1F;

                val <<= 6;

                val |= (cur[1]) & 0x3F;

                l = 2;

            } else if (*cur < 0xF0) {

                val = (cur[0]) & 0x0F;

                val <<= 6;

                val |= (cur[1]) & 0x3F;

                val <<= 6;

                val |= (cur[2]) & 0x3F;

                l = 3;

            } else if (*cur < 0xF8) {

                val = (cur[0]) & 0x07;

                val <<= 6;

                val |= (cur[1]) & 0x3F;

                val <<= 6;

                val |= (cur[2]) & 0x3F;

                val <<= 6;

                val |= (cur[3]) & 0x3F;

                l = 4;

            }

            if ((l == 1) || (!IS_CHAR(val))) {

                xmlSaveErr(XML_SAVE_CHAR_INVALID, (xmlNodePtr) attr, NULL);

                if (doc != NULL)

                    doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");

        xmlSerializeHexCharRef(tmp, *cur);

                xmlBufferAdd(buf, (xmlChar *) tmp, -1);

                cur++;

                base = cur;

                continue;

            }

            /*

             * We could do multiple things here. Just save

             * as a char ref

             */

        xmlSerializeHexCharRef(tmp, val);

            xmlBufferAdd(buf, (xmlChar *) tmp, -1);

            cur += l;

            base = cur;

        } else {

            cur++;

        }

    }

    if (base != cur)

        xmlBufferAdd(buf, base, cur - base);

}

/**

 * xmlEscapeEntities:

 * @out:  a pointer to an array of bytes to store the result

 * @outlen:  the length of @out

 * @in:  a pointer to an array of unescaped UTF-8 bytes

 * @inlen:  the length of @in

 *

 * Take a block of UTF-8 chars in and escape them. Used when there is no

 * encoding specified.

 *

 * Returns 0 if success, or -1 otherwise

 * The value of @inlen after return is the number of octets consumed

 *     if the return value is positive, else unpredictable.

 * The value of @outlen after return is the number of octets consumed.

 */

static int

xmlEscapeEntities(unsigned char* out, int *outlen,

                 const xmlChar* in, int *inlen) {

    unsigned char* outstart = out;

    const unsigned char* base = in;

    unsigned char* outend = out + *outlen;

    const unsigned char* inend;

    int val;

    inend = in + (*inlen);

    while ((in < inend) && (out < outend)) {

        if (*in == '<') {

        if (outend - out < 4) break;

        *out++ = '&';

        *out++ = 'l';

        *out++ = 't';

        *out++ = ';';

        in++;

        continue;

    } else if (*in == '>') {

        if (outend - out < 4) break;

        *out++ = '&';

        *out++ = 'g';

        *out++ = 't';

        *out++ = ';';

        in++;

        continue;

    } else if (*in == '&') {

        if (outend - out < 5) break;

        *out++ = '&';

        *out++ = 'a';

        *out++ = 'm';

        *out++ = 'p';

        *out++ = ';';

        in++;

        continue;

    } else if (((*in >= 0x20) && (*in < 0x80)) ||

               (*in == '\n') || (*in == '\t')) {

        /*

         * default case, just copy !

         */

        *out++ = *in++;

        continue;

    } else if (*in >= 0x80) {

        /*

         * We assume we have UTF-8 input.

         */

        if (outend - out < 10) break;

        if (*in < 0xC0) {

        xmlSaveErr(XML_SAVE_NOT_UTF8, NULL, NULL);

        in++;

        goto error;

        } else if (*in < 0xE0) {

        if (inend - in < 2) break;

        val = (in[0]) & 0x1F;

        val <<= 6;

        val |= (in[1]) & 0x3F;

        in += 2;

        } else if (*in < 0xF0) {

        if (inend - in < 3) break;

        val = (in[0]) & 0x0F;

        val <<= 6;

        val |= (in[1]) & 0x3F;

        val <<= 6;

        val |= (in[2]) & 0x3F;

        in += 3;

        } else if (*in < 0xF8) {

        if (inend - in < 4) break;

        val = (in[0]) & 0x07;

        val <<= 6;

        val |= (in[1]) & 0x3F;

        val <<= 6;

        val |= (in[2]) & 0x3F;

        val <<= 6;

        val |= (in[3]) & 0x3F;

        in += 4;

        } else {

        xmlSaveErr(XML_SAVE_CHAR_INVALID, NULL, NULL);

        in++;

        goto error;

        }

        if (!IS_CHAR(val)) {

        xmlSaveErr(XML_SAVE_CHAR_INVALID, NULL, NULL);

        in++;

        goto error;

        }

        /*

         * We could do multiple things here. Just save as a char ref

         */

        out = xmlSerializeHexCharRef(out, val);

    } else if (IS_BYTE_CHAR(*in)) {

        if (outend - out < 6) break;

        out = xmlSerializeHexCharRef(out, *in++);

    } else {

        xmlGenericError(xmlGenericErrorContext,

        "xmlEscapeEntities : char out of range\n");

        in++;

        goto error;

    }

    }

    *outlen = out - outstart;

    *inlen = in - base;

    return(0);

error:

    *outlen = out - outstart;

    *inlen = in - base;

    return(-1);

}

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

 *                                                                      *

 *          Allocation and deallocation                                 *

 *                                                                      *

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

/**

 * xmlSaveCtxtInit:

 * @ctxt: the saving context

 *

 * Initialize a saving context

 *

 * OOM: never

 */

//static

// TODO: Optimize: Too much memory is allocated during saves

void

xmlSaveCtxtInit(xmlSaveCtxtPtr ctxt)

{

    int i;

    if (ctxt == NULL) return;

    if ((ctxt->encoding == NULL) && (ctxt->escape == NULL))

        ctxt->escape = xmlEscapeEntities;

    if (xmlTreeIndentString == NULL) {

        memset(&ctxt->indent[0], 0, MAX_INDENT + 1);

    } else {

    ctxt->indent_size = xmlStrlen((const xmlChar *) xmlTreeIndentString);

    ctxt->indent_nr = MAX_INDENT / ctxt->indent_size;

    for (i = 0;i < ctxt->indent_nr;i++)

        memcpy(&ctxt->indent[i * ctxt->indent_size], xmlTreeIndentString,

           ctxt->indent_size);

        ctxt->indent[ctxt->indent_nr * ctxt->indent_size] = 0;

    }

}

/**

 * xmlFreeSaveCtxt:

 *

 * Free a saving context, destroying the ouptut in any remaining buffer

 */

static void

xmlFreeSaveCtxt(xmlSaveCtxtPtr ctxt)

{

    if (ctxt == NULL) return;

    if (ctxt->encoding != NULL)

        xmlFree((char *) ctxt->encoding);

    if (ctxt->buf != NULL)

        xmlOutputBufferClose(ctxt->buf);

    xmlFree(ctxt);

}

/**

 * xmlNewSaveCtxt:

 *

 * Create a new saving context

 *

 * Returns the new structure or NULL in case of error

 */

static xmlSaveCtxtPtr

xmlNewSaveCtxt(const char *encoding, int options)

{

    xmlSaveCtxtPtr ret;

    ret = (xmlSaveCtxtPtr) xmlMalloc(sizeof(xmlSaveCtxt));

    if (ret == NULL) {

    xmlSaveErrMemory("creating saving context");

    return ( NULL );

    }

    memset(ret, 0, sizeof(xmlSaveCtxt));

    ret->options = options;

    if (encoding != NULL) {

        ret->handler = xmlFindCharEncodingHandler(encoding);

    if (ret->handler == NULL) {

        xmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);

            xmlFreeSaveCtxt(ret);

        return(NULL);

    }

        ret->encoding = xmlStrdup((const xmlChar *)encoding);

    ret->escape = xmlEscapeEntities;

    }

    xmlSaveCtxtInit(ret);

    return(ret);

}

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

 *                                  *

 *          Dumping XML tree content to a simple buffer     *