error.c File Reference

#include "libxml.h"
#include <string.h>
#include <stdarg.h>
#include <libxml/parser.h>
#include <libxml/xmlerror.h>
#include <libxml/xmlmemory.h>
#include <libxml/globals.h>

Include dependency graph for error.c:

Go to the source code of this file.

Macros
#define	IN_LIBXML
#define	XML_GET_VAR_STR(msg, str)

Functions
void XMLCDECL	xmlGenericErrorDefaultFunc (void *ctx ATTRIBUTE_UNUSED, const char *msg,...) LIBXML_ATTR_FORMAT(2
void	initGenericErrorDefaultFunc (xmlGenericErrorFunc *handler)
void	xmlSetGenericErrorFunc (void *ctx, xmlGenericErrorFunc handler)
void	xmlSetStructuredErrorFunc (void *ctx, xmlStructuredErrorFunc handler)
void	xmlParserPrintFileInfo (xmlParserInputPtr input)
static void	xmlParserPrintFileContextInternal (xmlParserInputPtr input, xmlGenericErrorFunc channel, void *data)
void	xmlParserPrintFileContext (xmlParserInputPtr input)
static void	xmlReportError (xmlErrorPtr err, xmlParserCtxtPtr ctxt, const char *str, xmlGenericErrorFunc channel, void *data)

Macro Definition Documentation

IN_LIBXML

#define IN_LIBXML

Definition at line 9 of file error.c.

XML_GET_VAR_STR

#define XML_GET_VAR_STR	(		msg,
			str
	)

Definition at line 23 of file error.c.

Function Documentation

initGenericErrorDefaultFunc()

void initGenericErrorDefaultFunc

(

xmlGenericErrorFunc *

handler

)

initGenericErrorDefaultFunc: @handler: the handler

Set or reset (if NULL) the default handler for generic errors to the builtin error function.

Definition at line 90 of file error.c.

{
    if (handler == NULL)
        xmlGenericError = xmlGenericErrorDefaultFunc;
    else
        xmlGenericError = (*handler);
}

Referenced by xmlInitParser().

xmlGenericErrorDefaultFunc()

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

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.

Definition at line 71 of file error.c.

                                                                             {
    va_list args;
 
    if (xmlGenericErrorContext == NULL)
    xmlGenericErrorContext = (void *) stderr;
 
    va_start(args, msg);
    vfprintf((FILE *)xmlGenericErrorContext, msg, args);
    va_end(args);
}

Referenced by initGenericErrorDefaultFunc(), xmlSetGenericErrorFunc(), and xmlThrDefSetGenericErrorFunc().

xmlParserPrintFileContext()

void xmlParserPrintFileContext

(

xmlParserInputPtr

input

)

xmlParserPrintFileContext: @input: an xmlParserInputPtr input

Displays current context within the input content for error tracking

Definition at line 230 of file error.c.

                                                   {
   xmlParserPrintFileContextInternal(input, xmlGenericError,
                                     xmlGenericErrorContext);
}

xmlParserPrintFileContextInternal()

static void xmlParserPrintFileContextInternal ( xmlParserInputPtr  input, xmlGenericErrorFunc  channel, void *  data  )

static

xmlParserPrintFileContext: @input: an xmlParserInputPtr input

Displays current context within the input content for error tracking

Definition at line 173 of file error.c.

                                                  {
    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) || (input->cur == 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);
}

Referenced by xmlParserPrintFileContext(), and xmlReportError().

xmlParserPrintFileInfo()

void xmlParserPrintFileInfo

(

xmlParserInputPtr

input

)

xmlParserPrintFileInfo: @input: an xmlParserInputPtr input

Displays the associated file and line information for the current input

Definition at line 153 of file error.c.

                                                {
    if (input != NULL) {
    if (input->filename)
        xmlGenericError(xmlGenericErrorContext,
            "%s:%d: ", input->filename,
            input->line);
    else
        xmlGenericError(xmlGenericErrorContext,
            "Entity: line %d: ", input->line);
    }
}

xmlReportError()

static void xmlReportError ( xmlErrorPtr  err, xmlParserCtxtPtr  ctxt, const char *  str, xmlGenericErrorFunc  channel, void *  data  )

static

xmlReportError: @err: the error @ctx: the parser context or NULL @str: the formatted error message

Report an error with its context, replace the 4 old error/warning routines.

Definition at line 245 of file error.c.

{
    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) {
    channel = xmlGenericError;
    data = xmlGenericErrorContext;
    }
    file = err->file;
    line = err->line;
    code = err->code;
    domain = err->domain;
    level = err->level;
    node = 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) || (domain == XML_FROM_SCHEMASV)||
          (domain == XML_FROM_SCHEMASP)||(domain == XML_FROM_DTD) ||
          (domain == XML_FROM_RELAXNGP)||(domain == XML_FROM_RELAXNGV)))
            channel(data, "Entity: line %d: ", line);
    }
    if (name != NULL) {
        channel(data, "element %s: ", name);
    }
    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_MODULE:
            channel(data, "module ");
            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;
        case XML_FROM_I18N:
            channel(data, "encoding ");
            break;
        case XML_FROM_SCHEMATRONV:
            channel(data, "schematron ");
            break;
        case XML_FROM_BUFFER:
            channel(data, "internal buffer ");
            break;
        case XML_FROM_URI:
            channel(data, "URI ");
            break;
        default:
            break;
    }
    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 (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 (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))) {
    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);
    }
}

xmlSetGenericErrorFunc()

void xmlSetGenericErrorFunc	(	void *	ctx,
		xmlGenericErrorFunc	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. For multi-threaded applications, this must be set separately for each thread.

Definition at line 113 of file error.c.

                                                               {
    xmlGenericErrorContext = ctx;
    if (handler != NULL)
    xmlGenericError = handler;
    else
    xmlGenericError = xmlGenericErrorDefaultFunc;
}

xmlSetStructuredErrorFunc()

void xmlSetStructuredErrorFunc	(	void *	ctx,
		xmlStructuredErrorFunc	handler
	)

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 For multi-threaded applications, this must be set separately for each thread.

Definition at line 134 of file error.c.

                                                                     {
    xmlStructuredErrorContext = ctx;
    xmlStructuredError = handler;
}