/*

 * error.c: module displaying/handling XML parser errors

 *

 * See Copyright for the status of this software.

 *

 * Daniel Veillard <daniel@veillard.com>

 */

#define IN_LIBXML

#include "XmlEnglibxml.h"

#include <string.h>

#include <stdarg.h>

//#include "Libxml2_parser.h"

//#include "Libxml2_xmlerror.h"

//#include "Libxml2_xmlmemory.h"

#include "Libxml2_globals.h"

void xmlGenericErrorDefaultFunc (void *ctx ATTRIBUTE_UNUSED,

                 const char *msg,

                 ...);

#define XML_GET_VAR_STR(msg, str) {         \

    int       size;                         \

    int       chars;                        \

    char      *larger;                      \

    va_list   ap;                           \

                                            \

    str = (char *) xmlMalloc(150);          \

    if (str != NULL) {                      \

                                            \

    size = 150;                             \

                                            \

    while (1) {                             \

    va_start(ap, msg);                      \

    chars = vsnprintf(str, size, msg, ap);  \

    va_end(ap);                             \

    if ((chars > -1) && (chars < size))     \

        break;                              \

    if (chars > -1)                         \

        size += chars + 1;                  \

    else                                    \

        size += 100;                        \

    if ((larger = (char *) xmlRealloc(str, size)) == NULL) {\

        break;                              \

    }                                       \

    str = larger;                           \

    }}                                  \

}

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

 *                                                                      *

 *          Handling of out of context errors                           *

 *                                                                      *

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

/**

 * xmlGenericErrorDefaultFunc:

 * @ctx:  an error context

 * @msg:  the message to display/transmit

 * @...:  extra parameters for the message display

 *

 * Default handler for out of context error messages.

 */

void

xmlGenericErrorDefaultFunc(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {

#ifdef XMLENGINE_DISABLE_STDOUT

    // TODO: LOGGING: do logging here

    return;

#else

    va_list args;

    if (xmlGenericErrorContext == NULL)

    xmlGenericErrorContext = (void *) stderr;

    va_start(args, msg);

    vfprintf((FILE *)xmlGenericErrorContext, msg, args);

    va_end(args);

    if(ctx) return;

#endif

}

/**

 * initGenericErrorDefaultFunc:

 * @handler:  the handler

 *

 * Set or reset (if NULL) the default handler for generic errors

 * to the builtin error function.

 */

void

initGenericErrorDefaultFunc(xmlGenericErrorFunc * handler)

{

    if (handler == NULL)

        xmlGenericError = xmlGenericErrorDefaultFunc;

    else

        xmlGenericError = (*handler);

}

/**

 * xmlSetGenericErrorFunc:

 * @ctx:  the new error handling context

 * @handler:  the new handler function

 *

 * Function to reset the handler and the error context for out of

 * context error messages.

 * This simply means that @handler will be called for subsequent

 * error messages while not parsing nor validating. And @ctx will

 * be passed as first argument to @handler

 * One can simply force messages to be emitted to another FILE * than

 * stderr by setting @ctx to this file handle and @handler to NULL.

 */

void

xmlSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler) {

    xmlGenericErrorContext = ctx;

    if (handler != NULL)

    xmlGenericError = handler;

    else

    xmlGenericError = xmlGenericErrorDefaultFunc;

}

/**

 * xmlSetStructuredErrorFunc:

 * @ctx:  the new error handling context

 * @handler:  the new handler function

 *

 * Function to reset the handler and the error context for out of

 * context structured error messages.

 * This simply means that @handler will be called for subsequent

 * error messages while not parsing nor validating. And @ctx will

 * be passed as first argument to @handler

 */

void

xmlSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) {

    xmlGenericErrorContext = ctx;

    xmlStructuredError = handler;

}

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

 *                                  *

 *          Handling of parsing errors          *

 *                                  *

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

/**

 * xmlParserPrintFileInfo:

 * @input:  an xmlParserInputPtr input

 *

 * Displays the associated file and line informations for the current input

 */

void

xmlParserPrintFileInfo(xmlParserInputPtr input) {

    if (input != NULL) {

    if (input->filename)

        xmlGenericError(xmlGenericErrorContext,

            "%s:%d: ", input->filename,

            input->line);

    else

        xmlGenericError(xmlGenericErrorContext,

            "Entity: line %d: ", input->line);

    }

}

/**

 * xmlParserPrintFileContext:

 * @input:  an xmlParserInputPtr input

 *

 * Displays current context within the input content for error tracking

 */

static void

xmlParserPrintFileContextInternal(xmlParserInputPtr input ,

        xmlGenericErrorFunc channel, void *data ) {

    const xmlChar *cur, *base;

    unsigned int n, col;    /* GCC warns if signed, because compared with sizeof() */

    xmlChar  content[81]; /* space for 80 chars + line terminator */

    xmlChar *ctnt;

    if (input == NULL) return;

    cur = input->cur;

    base = input->base;

    /* skip backwards over any end-of-lines */

    while ((cur > base) && ((*(cur) == '\n') || (*(cur) == '\r'))) {

    cur--;

    }

    n = 0;

    /* search backwards for beginning-of-line (to max buff size) */

    while ((n++ < (sizeof(content)-1)) && (cur > base) &&

           (*(cur) != '\n') && (*(cur) != '\r'))

        cur--;

    if ((*(cur) == '\n') || (*(cur) == '\r')) cur++;

    /* calculate the error position in terms of the current position */

    col = input->cur - cur;

    /* search forward for end-of-line (to max buff size) */

    n = 0;

    ctnt = content;

    /* copy selected text to our buffer */

    while ((*cur != 0) && (*(cur) != '\n') &&

           (*(cur) != '\r') && (n < sizeof(content)-1)) {

        *ctnt++ = *cur++;

    n++;

    }

    *ctnt = 0;

    /* print out the selected text */

    channel(data ,"%s\n", content);

    /* create blank line with problem pointer */

    n = 0;

    ctnt = content;

    /* (leave buffer space for pointer + line terminator) */

    while ((n<col) && (n++ < sizeof(content)-2) && (*ctnt != 0)) {

    if (*(ctnt) != '\t')

        *(ctnt) = ' ';

    ctnt++;

    }

    *ctnt++ = '^';

    *ctnt = 0;

    channel(data ,"%s\n", content);

}

/**

 * xmlParserPrintFileContext:

 * @input:  an xmlParserInputPtr input

 *

 * Displays current context within the input content for error tracking

 */

void

xmlParserPrintFileContext(xmlParserInputPtr input) {

   xmlParserPrintFileContextInternal(input, xmlGenericError,

                                     xmlGenericErrorContext);

}

//TODO: xmlReportError is required for debug/non-Symbian releases only

/**

 * xmlReportError:

 * @err: the error

 * @ctx: the parser context or NULL

 * @str: the formatted error message

 *

 * Report an erro with its context, replace the 4 old error/warning

 * routines.

 */

static void

xmlReportError(xmlErrorPtr err, xmlParserCtxtPtr ctxt, const char *str,

               xmlGenericErrorFunc channel, void *data)

{

    char *file = NULL;

    int line = 0;

    int code = -1;

    int domain;

    const xmlChar *name = NULL;

    xmlNodePtr node;

    xmlErrorLevel level;

    xmlParserInputPtr input = NULL;

    xmlParserInputPtr cur = NULL;

    if (err == NULL)

        return;

    if (channel == NULL) { // TODO: LOGGING: setup Symbian specific logger callback here

        channel = xmlGenericError;

        data = xmlGenericErrorContext;

    }

    file = err->file;

#ifdef LIBXML_ENABLE_NODE_LINEINFO

    line = err->line;

#endif

    code = err->code;

    domain = err->domain;

    level = err->level;

    node = (xmlNodePtr)err->node;

    if (code == XML_ERR_OK)

        return;

    if ((node != NULL) && (node->type == XML_ELEMENT_NODE))

        name = node->name;

    /*

     * Maintain the compatibility with the legacy error handling

     */

    if (ctxt != NULL) {

        input = ctxt->input;

        if ((input != NULL) && (input->filename == NULL) &&

            (ctxt->inputNr > 1)) {

            cur = input;

            input = ctxt->inputTab[ctxt->inputNr - 2];

        }

        if (input != NULL) {

            if (input->filename)

                channel(data, "%s:%d: ", input->filename, input->line);

            else if ((line != 0) && (domain == XML_FROM_PARSER))

                channel(data, "Entity: line %d: ", input->line);

        }

    } else {

        if (file != NULL)

            channel(data, "%s:%d: ", file, line);

        else if ((line != 0) && (domain == XML_FROM_PARSER))

            channel(data, "Entity: line %d: ", line);

    }

    if (name != NULL) {

        channel(data, "element %s: ", name);

    }

    if (code == XML_ERR_OK)

        return;

    switch (domain) {

        case XML_FROM_PARSER:

            channel(data, "parser ");

            break;

        case XML_FROM_NAMESPACE:

            channel(data, "namespace ");

            break;

        case XML_FROM_DTD:

        case XML_FROM_VALID:

            channel(data, "validity ");

            break;

        case XML_FROM_HTML:

            channel(data, "HTML parser ");

            break;

        case XML_FROM_MEMORY:

            channel(data, "memory ");

            break;

        case XML_FROM_OUTPUT:

            channel(data, "output ");

            break;

        case XML_FROM_IO:

            channel(data, "I/O ");

            break;

        case XML_FROM_XINCLUDE:

            channel(data, "XInclude ");

            break;

        case XML_FROM_XPATH:

            channel(data, "XPath ");

            break;

        case XML_FROM_XPOINTER:

            channel(data, "parser ");

            break;

        case XML_FROM_REGEXP:

            channel(data, "regexp ");

            break;

        case XML_FROM_SCHEMASV:

            channel(data, "Schemas validity ");

            break;

        case XML_FROM_SCHEMASP:

            channel(data, "Schemas parser ");

            break;

        case XML_FROM_RELAXNGP:

            channel(data, "Relax-NG parser ");

            break;

        case XML_FROM_RELAXNGV:

            channel(data, "Relax-NG validity ");

            break;

        case XML_FROM_CATALOG:

            channel(data, "Catalog ");

            break;

        case XML_FROM_C14N:

            channel(data, "C14N ");

            break;

        case XML_FROM_XSLT:

            channel(data, "XSLT ");

            break;

        default:

            break;

    }

    if (code == XML_ERR_OK)

        return;

    switch (level) {

        case XML_ERR_NONE:

            channel(data, ": ");

            break;

        case XML_ERR_WARNING:

            channel(data, "warning : ");

            break;

        case XML_ERR_ERROR:

            channel(data, "error : ");

            break;

        case XML_ERR_FATAL:

            channel(data, "error : ");

            break;

    }

    if (code == XML_ERR_OK)

        return;

    if (str != NULL) {

        int len;

        len = xmlStrlen((const xmlChar *)str);

        if ((len > 0) && (str[len - 1] != '\n'))

            channel(data, "%s\n", str);

        else

            channel(data, "%s", str);

    } else {

        channel(data, "%s\n", "out of memory error");

    }

    if (code == XML_ERR_OK)

        return;

    if (ctxt != NULL) {

        xmlParserPrintFileContextInternal(input, channel, data);

        if (cur != NULL) {

            if (cur->filename)

                channel(data, "%s:%d: \n", cur->filename, cur->line);

            else if ((line != 0) && (domain == XML_FROM_PARSER))

                channel(data, "Entity: line %d: \n", cur->line);

            xmlParserPrintFileContextInternal(cur, channel, data);

        }

    }

    if ((domain == XML_FROM_XPATH) &&

        (err->str1 != NULL) &&

        (err->int1 < 100) &&

        (err->int1 < xmlStrlen((const xmlChar *)err->str1)))

    {

        // TODO: buffers on the stack - maybe dangerous on Symbian!

        xmlChar buf[150];

        int i;

        channel(data, "%s\n", err->str1);

        for (i=0;i < err->int1;i++)

             buf[i] = ' ';

        buf[i++] = '^';

        buf[i] = 0;

        channel(data, "%s\n", buf);

    }

}

/**

 * __xmlRaiseError:

 * @schannel: the structured callback channel

 * @channel: the old callback channel

 * @data: the callback data

 * @ctx: the parser context or NULL

 * @ctx: the parser context or NULL

 * @domain: the domain for the error

 * @code: the code for the error

 * @level: the xmlErrorLevel for the error

 * @file: the file source of the error (or NULL)

 * @line: the line of the error or 0 if N/A

 * @str1: extra string info

 * @str2: extra string info

 * @str3: extra string info

 * @int1: extra int info

 * @int2: extra int info

 * @msg:  the message to display/transmit

 * @...:  extra parameters for the message display

 *

 * Update the appropriate global or contextual error structure,

 * then forward the error message down the parser or generic

 * error callback handler

 */

void

__xmlRaiseError(xmlStructuredErrorFunc schannel,

              xmlGenericErrorFunc channel, void *data, void *ctx,

              void *nod, int domain, int code, xmlErrorLevel level,

              const char *file, int line, const char *str1,

              const char *str2, const char *str3, int int1, int int2,

          const char *msg, ...)

{

    xmlParserCtxtPtr ctxt = NULL;

    xmlNodePtr node = (xmlNodePtr) nod;

    char *str = NULL;

    xmlParserInputPtr input = NULL;

    xmlErrorPtr to = &xmlLastError;

    xmlChar *base = NULL;

// XMLENGINE: BEGIN NEW CODE

    if(domain == XML_FROM_XPATH)

        return; // no output, just return NULL

// XMLENGINE: END NEW CODE

    if ((xmlGetWarningsDefaultValue == 0) && (level == XML_ERR_WARNING))

        return;

    if ((domain == XML_FROM_PARSER) ||

        (domain == XML_FROM_HTML) ||   // TODO: Remove HTML-related code

        (domain == XML_FROM_DTD) ||

        (domain == XML_FROM_NAMESPACE) ||

        (domain == XML_FROM_IO))

    {

        ctxt = (xmlParserCtxtPtr) ctx;

        if ((schannel == NULL) && (ctxt != NULL) &&

            (ctxt->sax != NULL)&& (ctxt->sax->initialized == XML_SAX2_MAGIC))

               schannel = ctxt->sax->serror;

    }

    if (schannel == NULL)

        schannel = xmlStructuredError;

    if ((domain == XML_FROM_VALID) &&

        ((channel == xmlParserValidityError) || (channel == xmlParserValidityWarning)))

    {

        ctxt = (xmlParserCtxtPtr) ctx;

        if ((schannel == NULL) &&

            (ctxt != NULL) &&

            (ctxt->sax != NULL) &&

            (ctxt->sax->initialized == XML_SAX2_MAGIC))

        {

            schannel = ctxt->sax->serror;

        }

    }

    if (code == XML_ERR_OK)

        return;

    /*

     * Formatting the message

     */

#ifndef XMLENGINE_EXCLUDE_EMBED_MSG

    if (msg == NULL) {

#else

    if (msg == NULL || msg == __embedded_errtxt_replacement) {

#endif

        str = (char *) xmlStrdup(BAD_CAST "No error message provided");

    } else {

        //XML_GET_VAR_STR(msg, str); //this causes panic when OOM

        str = (char *) xmlStrdup(BAD_CAST msg);

    }

    /*

     * specific processing if a parser context is provided

     */

    if (ctxt != NULL) {

        if (file == NULL) {

            input = ctxt->input;

            if ((input != NULL) &&

                (input->filename == NULL) &&

                (ctxt->inputNr > 1))

            {

                input = ctxt->inputTab[ctxt->inputNr - 2];

            }

            if (input != NULL) {

                file = input->filename;

                line = input->line;

            }

        }