999 lines
27 KiB
C
999 lines
27 KiB
C
|
/*
|
||
|
|
* 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 "libxml.h"
|
||
|
|
|
||
|
|
#include <string.h>
|
||
|
|
#include <stdarg.h>
|
||
|
|
#include <libxml/parser.h>
|
||
|
|
#include <libxml/xmlerror.h>
|
||
|
|
#include <libxml/xmlmemory.h>
|
||
|
|
#include <libxml/globals.h>
|
||
|
|
|
||
|
|
void XMLCDECL xmlGenericErrorDefaultFunc (void *ctx ATTRIBUTE_UNUSED,
|
||
|
|
const char *msg,
|
||
|
|
...) LIBXML_ATTR_FORMAT(2,3);
|
||
|
|
|
||
|
|
#define XML_GET_VAR_STR(msg, str) { \
|
||
|
|
int size, prev_size = -1; \
|
||
|
|
int chars; \
|
||
|
|
char *larger; \
|
||
|
|
va_list ap; \
|
||
|
|
\
|
||
|
|
str = (char *) xmlMalloc(150); \
|
||
|
|
if (str != NULL) { \
|
||
|
|
\
|
||
|
|
size = 150; \
|
||
|
|
\
|
||
|
|
while (size < 64000) { \
|
||
|
|
va_start(ap, msg); \
|
||
|
|
chars = vsnprintf(str, size, msg, ap); \
|
||
|
|
va_end(ap); \
|
||
|
|
if ((chars > -1) && (chars < size)) { \
|
||
|
|
if (prev_size == chars) { \
|
||
|
|
break; \
|
||
|
|
} else { \
|
||
|
|
prev_size = chars; \
|
||
|
|
} \
|
||
|
|
} \
|
||
|
|
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 XMLCDECL
|
||
|
|
xmlGenericErrorDefaultFunc(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {
|
||
|
|
va_list args;
|
||
|
|
|
||
|
|
if (xmlGenericErrorContext == NULL)
|
||
|
|
xmlGenericErrorContext = (void *) stderr;
|
||
|
|
|
||
|
|
va_start(args, msg);
|
||
|
|
vfprintf((FILE *)xmlGenericErrorContext, msg, args);
|
||
|
|
va_end(args);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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.
|
||
|
|
* For multi-threaded applications, this must be set separately for each thread.
|
||
|
|
*/
|
||
|
|
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
|
||
|
|
* For multi-threaded applications, this must be set separately for each thread.
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
xmlSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) {
|
||
|
|
xmlStructuredErrorContext = ctx;
|
||
|
|
xmlStructuredError = handler;
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************
|
||
|
|
* *
|
||
|
|
* Handling of parsing errors *
|
||
|
|
* *
|
||
|
|
************************************************************************/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* xmlParserPrintFileInfo:
|
||
|
|
* @input: an xmlParserInputPtr input
|
||
|
|
*
|
||
|
|
* Displays the associated file and line information 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) || (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);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* xmlParserPrintFileContext:
|
||
|
|
* @input: an xmlParserInputPtr input
|
||
|
|
*
|
||
|
|
* Displays current context within the input content for error tracking
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
xmlParserPrintFileContext(xmlParserInputPtr input) {
|
||
|
|
xmlParserPrintFileContextInternal(input, xmlGenericError,
|
||
|
|
xmlGenericErrorContext);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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.
|
||
|
|
*/
|
||
|
|
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) {
|
||
|
|
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);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* __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
|
||
|
|
* @col: column number of the error or 0 if N/A
|
||
|
|
* @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 XMLCDECL
|
||
|
|
__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 col,
|
||
|
|
const char *msg, ...)
|
||
|
|
{
|
||
|
|
xmlParserCtxtPtr ctxt = NULL;
|
||
|
|
xmlNodePtr node = (xmlNodePtr) nod;
|
||
|
|
char *str = NULL;
|
||
|
|
xmlParserInputPtr input = NULL;
|
||
|
|
xmlErrorPtr to = &xmlLastError;
|
||
|
|
xmlNodePtr baseptr = NULL;
|
||
|
|
|
||
|
|
if (code == XML_ERR_OK)
|
||
|
|
return;
|
||
|
|
if ((xmlGetWarningsDefaultValue == 0) && (level == XML_ERR_WARNING))
|
||
|
|
return;
|
||
|
|
if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
|
||
|
|
(domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
|
||
|
|
(domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) {
|
||
|
|
ctxt = (xmlParserCtxtPtr) ctx;
|
||
|
|
if ((schannel == NULL) && (ctxt != NULL) && (ctxt->sax != NULL) &&
|
||
|
|
(ctxt->sax->initialized == XML_SAX2_MAGIC) &&
|
||
|
|
(ctxt->sax->serror != NULL)) {
|
||
|
|
schannel = ctxt->sax->serror;
|
||
|
|
data = ctxt->userData;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
* Check if structured error handler set
|
||
|
|
*/
|
||
|
|
if (schannel == NULL) {
|
||
|
|
schannel = xmlStructuredError;
|
||
|
|
/*
|
||
|
|
* if user has defined handler, change data ptr to user's choice
|
||
|
|
*/
|
||
|
|
if (schannel != NULL)
|
||
|
|
data = xmlStructuredErrorContext;
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
* Formatting the message
|
||
|
|
*/
|
||
|
|
if (msg == NULL) {
|
||
|
|
str = (char *) xmlStrdup(BAD_CAST "No error message provided");
|
||
|
|
} else {
|
||
|
|
XML_GET_VAR_STR(msg, str);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* 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;
|
||
|
|
col = input->col;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
to = &ctxt->lastError;
|
||
|
|
} else if ((node != NULL) && (file == NULL)) {
|
||
|
|
int i;
|
||
|
|
|
||
|
|
if ((node->doc != NULL) && (node->doc->URL != NULL)) {
|
||
|
|
baseptr = node;
|
||
|
|
/* file = (const char *) node->doc->URL; */
|
||
|
|
}
|
||
|
|
for (i = 0;
|
||
|
|
((i < 10) && (node != NULL) && (node->type != XML_ELEMENT_NODE));
|
||
|
|
i++)
|
||
|
|
node = node->parent;
|
||
|
|
if ((baseptr == NULL) && (node != NULL) &&
|
||
|
|
(node->doc != NULL) && (node->doc->URL != NULL))
|
||
|
|
baseptr = node;
|
||
|
|
|
||
|
|
if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
|
||
|
|
line = node->line;
|
||
|
|
if ((line == 0) || (line == 65535))
|
||
|
|
line = xmlGetLineNo(node);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Save the information about the error
|
||
|
|
*/
|
||
|
|
xmlResetError(to);
|
||
|
|
to->domain = domain;
|
||
|
|
to->code = code;
|
||
|
|
to->message = str;
|
||
|
|
to->level = level;
|
||
|
|
if (file != NULL)
|
||
|
|
to->file = (char *) xmlStrdup((const xmlChar *) file);
|
||
|
|
else if (baseptr != NULL) {
|
||
|
|
#ifdef LIBXML_XINCLUDE_ENABLED
|
||
|
|
/*
|
||
|
|
* We check if the error is within an XInclude section and,
|
||
|
|
* if so, attempt to print out the href of the XInclude instead
|
||
|
|
* of the usual "base" (doc->URL) for the node (bug 152623).
|
||
|
|
*/
|
||
|
|
xmlNodePtr prev = baseptr;
|
||
|
|
char *href = NULL;
|
||
|
|
int inclcount = 0;
|
||
|
|
while (prev != NULL) {
|
||
|
|
if (prev->prev == NULL)
|
||
|
|
prev = prev->parent;
|
||
|
|
else {
|
||
|
|
prev = prev->prev;
|
||
|
|
if (prev->type == XML_XINCLUDE_START) {
|
||
|
|
if (inclcount > 0) {
|
||
|
|
--inclcount;
|
||
|
|
} else {
|
||
|
|
href = (char *) xmlGetProp(prev, BAD_CAST "href");
|
||
|
|
if (href != NULL)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} else if (prev->type == XML_XINCLUDE_END)
|
||
|
|
inclcount++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (href != NULL)
|
||
|
|
to->file = href;
|
||
|
|
else
|
||
|
|
#endif
|
||
|
|
to->file = (char *) xmlStrdup(baseptr->doc->URL);
|
||
|
|
if ((to->file == NULL) && (node != NULL) && (node->doc != NULL)) {
|
||
|
|
to->file = (char *) xmlStrdup(node->doc->URL);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
to->line = line;
|
||
|
|
if (str1 != NULL)
|
||
|
|
to->str1 = (char *) xmlStrdup((const xmlChar *) str1);
|
||
|
|
if (str2 != NULL)
|
||
|
|
to->str2 = (char *) xmlStrdup((const xmlChar *) str2);
|
||
|
|
if (str3 != NULL)
|
||
|
|
to->str3 = (char *) xmlStrdup((const xmlChar *) str3);
|
||
|
|
to->int1 = int1;
|
||
|
|
to->int2 = col;
|
||
|
|
to->node = node;
|
||
|
|
to->ctxt = ctx;
|
||
|
|
|
||
|
|
if (to != &xmlLastError)
|
||
|
|
xmlCopyError(to,&xmlLastError);
|
||
|
|
|
||
|
|
if (schannel != NULL) {
|
||
|
|
schannel(data, to);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Find the callback channel if channel param is NULL
|
||
|
|
*/
|
||
|
|
if ((ctxt != NULL) && (channel == NULL) &&
|
||
|
|
(xmlStructuredError == NULL) && (ctxt->sax != NULL)) {
|
||
|
|
if (level == XML_ERR_WARNING)
|
||
|
|
channel = ctxt->sax->warning;
|
||
|
|
else
|
||
|
|
channel = ctxt->sax->error;
|
||
|
|
data = ctxt->userData;
|
||
|
|
} else if (channel == NULL) {
|
||
|
|
channel = xmlGenericError;
|
||
|
|
if (ctxt != NULL) {
|
||
|
|
data = ctxt;
|
||
|
|
} else {
|
||
|
|
data = xmlGenericErrorContext;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (channel == NULL)
|
||
|
|
return;
|
||
|
|
|
||
|
|
if ((channel == xmlParserError) ||
|
||
|
|
(channel == xmlParserWarning) ||
|
||
|
|
(channel == xmlParserValidityError) ||
|
||
|
|
(channel == xmlParserValidityWarning))
|
||
|
|
xmlReportError(to, ctxt, str, NULL, NULL);
|
||
|
|
else if (((void(*)(void)) channel == (void(*)(void)) fprintf) ||
|
||
|
|
(channel == xmlGenericErrorDefaultFunc))
|
||
|
|
xmlReportError(to, ctxt, str, channel, data);
|
||
|
|
else
|
||
|
|
channel(data, "%s", str);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* __xmlSimpleError:
|
||
|
|
* @domain: where the error comes from
|
||
|
|
* @code: the error code
|
||
|
|
* @node: the context node
|
||
|
|
* @extra: extra information
|
||
|
|
*
|
||
|
|
* Handle an out of memory condition
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
__xmlSimpleError(int domain, int code, xmlNodePtr node,
|
||
|
|
const char *msg, const char *extra)
|
||
|
|
{
|
||
|
|
|
||
|
|
if (code == XML_ERR_NO_MEMORY) {
|
||
|
|
if (extra)
|
||
|
|
__xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
|
||
|
|
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, NULL, node, domain,
|
||
|
|
XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
|
||
|
|
NULL, NULL, 0, 0, "Memory allocation failed\n");
|
||
|
|
} else {
|
||
|
|
__xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
|
||
|
|
code, XML_ERR_ERROR, NULL, 0, extra,
|
||
|
|
NULL, NULL, 0, 0, msg, extra);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* xmlParserError:
|
||
|
|
* @ctx: an XML parser context
|
||
|
|
* @msg: the message to display/transmit
|
||
|
|
* @...: extra parameters for the message display
|
||
|
|
*
|
||
|
|
* Display and format an error messages, gives file, line, position and
|
||
|
|
* extra parameters.
|
||
|
|
*/
|
||
|
|
void XMLCDECL
|
||
|
|
xmlParserError(void *ctx, const char *msg, ...)
|
||
|
|
{
|
||
|
|
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
|
||
|
|
xmlParserInputPtr input = NULL;
|
||
|
|
xmlParserInputPtr cur = NULL;
|
||
|
|
char * str;
|
||
|
|
|
||
|
|
if (ctxt != NULL) {
|
||
|
|
input = ctxt->input;
|
||
|
|
if ((input != NULL) && (input->filename == NULL) &&
|
||
|
|
(ctxt->inputNr > 1)) {
|
||
|
|
cur = input;
|
||
|
|
input = ctxt->inputTab[ctxt->inputNr - 2];
|
||
|
|
}
|
||
|
|
xmlParserPrintFileInfo(input);
|
||
|
|
}
|
||
|
|
|
||
|
|
xmlGenericError(xmlGenericErrorContext, "error: ");
|
||
|
|
XML_GET_VAR_STR(msg, str);
|
||
|
|
xmlGenericError(xmlGenericErrorContext, "%s", str);
|
||
|
|
if (str != NULL)
|
||
|
|
xmlFree(str);
|
||
|
|
|
||
|
|
if (ctxt != NULL) {
|
||
|
|
xmlParserPrintFileContext(input);
|
||
|
|
if (cur != NULL) {
|
||
|
|
xmlParserPrintFileInfo(cur);
|
||
|
|
xmlGenericError(xmlGenericErrorContext, "\n");
|
||
|
|
xmlParserPrintFileContext(cur);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* xmlParserWarning:
|
||
|
|
* @ctx: an XML parser context
|
||
|
|
* @msg: the message to display/transmit
|
||
|
|
* @...: extra parameters for the message display
|
||
|
|
*
|
||
|
|
* Display and format a warning messages, gives file, line, position and
|
||
|
|
* extra parameters.
|
||
|
|
*/
|
||
|
|
void XMLCDECL
|
||
|
|
xmlParserWarning(void *ctx, const char *msg, ...)
|
||
|
|
{
|
||
|
|
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
|
||
|
|
xmlParserInputPtr input = NULL;
|
||
|
|
xmlParserInputPtr cur = NULL;
|
||
|
|
char * str;
|
||
|
|
|
||
|
|
if (ctxt != NULL) {
|
||
|
|
input = ctxt->input;
|
||
|
|
if ((input != NULL) && (input->filename == NULL) &&
|
||
|
|
(ctxt->inputNr > 1)) {
|
||
|
|
cur = input;
|
||
|
|
input = ctxt->inputTab[ctxt->inputNr - 2];
|
||
|
|
}
|
||
|
|
xmlParserPrintFileInfo(input);
|
||
|
|
}
|
||
|
|
|
||
|
|
xmlGenericError(xmlGenericErrorContext, "warning: ");
|
||
|
|
XML_GET_VAR_STR(msg, str);
|
||
|
|
xmlGenericError(xmlGenericErrorContext, "%s", str);
|
||
|
|
if (str != NULL)
|
||
|
|
xmlFree(str);
|
||
|
|
|
||
|
|
if (ctxt != NULL) {
|
||
|
|
xmlParserPrintFileContext(input);
|
||
|
|
if (cur != NULL) {
|
||
|
|
xmlParserPrintFileInfo(cur);
|
||
|
|
xmlGenericError(xmlGenericErrorContext, "\n");
|
||
|
|
xmlParserPrintFileContext(cur);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************
|
||
|
|
* *
|
||
|
|
* Handling of validation errors *
|
||
|
|
* *
|
||
|
|
************************************************************************/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* xmlParserValidityError:
|
||
|
|
* @ctx: an XML parser context
|
||
|
|
* @msg: the message to display/transmit
|
||
|
|
* @...: extra parameters for the message display
|
||
|
|
*
|
||
|
|
* Display and format an validity error messages, gives file,
|
||
|
|
* line, position and extra parameters.
|
||
|
|
*/
|
||
|
|
void XMLCDECL
|
||
|
|
xmlParserValidityError(void *ctx, const char *msg, ...)
|
||
|
|
{
|
||
|
|
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
|
||
|
|
xmlParserInputPtr input = NULL;
|
||
|
|
char * str;
|
||
|
|
int len = xmlStrlen((const xmlChar *) msg);
|
||
|
|
static int had_info = 0;
|
||
|
|
|
||
|
|
if ((len > 1) && (msg[len - 2] != ':')) {
|
||
|
|
if (ctxt != NULL) {
|
||
|
|
input = ctxt->input;
|
||
|
|
if ((input->filename == NULL) && (ctxt->inputNr > 1))
|
||
|
|
input = ctxt->inputTab[ctxt->inputNr - 2];
|
||
|
|
|
||
|
|
if (had_info == 0) {
|
||
|
|
xmlParserPrintFileInfo(input);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
xmlGenericError(xmlGenericErrorContext, "validity error: ");
|
||
|
|
had_info = 0;
|
||
|
|
} else {
|
||
|
|
had_info = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
XML_GET_VAR_STR(msg, str);
|
||
|
|
xmlGenericError(xmlGenericErrorContext, "%s", str);
|
||
|
|
if (str != NULL)
|
||
|
|
xmlFree(str);
|
||
|
|
|
||
|
|
if ((ctxt != NULL) && (input != NULL)) {
|
||
|
|
xmlParserPrintFileContext(input);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* xmlParserValidityWarning:
|
||
|
|
* @ctx: an XML parser context
|
||
|
|
* @msg: the message to display/transmit
|
||
|
|
* @...: extra parameters for the message display
|
||
|
|
*
|
||
|
|
* Display and format a validity warning messages, gives file, line,
|
||
|
|
* position and extra parameters.
|
||
|
|
*/
|
||
|
|
void XMLCDECL
|
||
|
|
xmlParserValidityWarning(void *ctx, const char *msg, ...)
|
||
|
|
{
|
||
|
|
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
|
||
|
|
xmlParserInputPtr input = NULL;
|
||
|
|
char * str;
|
||
|
|
int len = xmlStrlen((const xmlChar *) msg);
|
||
|
|
|
||
|
|
if ((ctxt != NULL) && (len != 0) && (msg[len - 1] != ':')) {
|
||
|
|
input = ctxt->input;
|
||
|
|
if ((input->filename == NULL) && (ctxt->inputNr > 1))
|
||
|
|
input = ctxt->inputTab[ctxt->inputNr - 2];
|
||
|
|
|
||
|
|
xmlParserPrintFileInfo(input);
|
||
|
|
}
|
||
|
|
|
||
|
|
xmlGenericError(xmlGenericErrorContext, "validity warning: ");
|
||
|
|
XML_GET_VAR_STR(msg, str);
|
||
|
|
xmlGenericError(xmlGenericErrorContext, "%s", str);
|
||
|
|
if (str != NULL)
|
||
|
|
xmlFree(str);
|
||
|
|
|
||
|
|
if (ctxt != NULL) {
|
||
|
|
xmlParserPrintFileContext(input);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/************************************************************************
|
||
|
|
* *
|
||
|
|
* Extended Error Handling *
|
||
|
|
* *
|
||
|
|
************************************************************************/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* xmlGetLastError:
|
||
|
|
*
|
||
|
|
* Get the last global error registered. This is per thread if compiled
|
||
|
|
* with thread support.
|
||
|
|
*
|
||
|
|
* Returns NULL if no error occurred or a pointer to the error
|
||
|
|
*/
|
||
|
|
xmlErrorPtr
|
||
|
|
xmlGetLastError(void)
|
||
|
|
{
|
||
|
|
if (xmlLastError.code == XML_ERR_OK)
|
||
|
|
return (NULL);
|
||
|
|
return (&xmlLastError);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* xmlResetError:
|
||
|
|
* @err: pointer to the error.
|
||
|
|
*
|
||
|
|
* Cleanup the error.
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
xmlResetError(xmlErrorPtr err)
|
||
|
|
{
|
||
|
|
if (err == NULL)
|
||
|
|
return;
|
||
|
|
if (err->code == XML_ERR_OK)
|
||
|
|
return;
|
||
|
|
if (err->message != NULL)
|
||
|
|
xmlFree(err->message);
|
||
|
|
if (err->file != NULL)
|
||
|
|
xmlFree(err->file);
|
||
|
|
if (err->str1 != NULL)
|
||
|
|
xmlFree(err->str1);
|
||
|
|
if (err->str2 != NULL)
|
||
|
|
xmlFree(err->str2);
|
||
|
|
if (err->str3 != NULL)
|
||
|
|
xmlFree(err->str3);
|
||
|
|
memset(err, 0, sizeof(xmlError));
|
||
|
|
err->code = XML_ERR_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* xmlResetLastError:
|
||
|
|
*
|
||
|
|
* Cleanup the last global error registered. For parsing error
|
||
|
|
* this does not change the well-formedness result.
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
xmlResetLastError(void)
|
||
|
|
{
|
||
|
|
if (xmlLastError.code == XML_ERR_OK)
|
||
|
|
return;
|
||
|
|
xmlResetError(&xmlLastError);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* xmlCtxtGetLastError:
|
||
|
|
* @ctx: an XML parser context
|
||
|
|
*
|
||
|
|
* Get the last parsing error registered.
|
||
|
|
*
|
||
|
|
* Returns NULL if no error occurred or a pointer to the error
|
||
|
|
*/
|
||
|
|
xmlErrorPtr
|
||
|
|
xmlCtxtGetLastError(void *ctx)
|
||
|
|
{
|
||
|
|
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
|
||
|
|
|
||
|
|
if (ctxt == NULL)
|
||
|
|
return (NULL);
|
||
|
|
if (ctxt->lastError.code == XML_ERR_OK)
|
||
|
|
return (NULL);
|
||
|
|
return (&ctxt->lastError);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* xmlCtxtResetLastError:
|
||
|
|
* @ctx: an XML parser context
|
||
|
|
*
|
||
|
|
* Cleanup the last global error registered. For parsing error
|
||
|
|
* this does not change the well-formedness result.
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
xmlCtxtResetLastError(void *ctx)
|
||
|
|
{
|
||
|
|
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
|
||
|
|
|
||
|
|
if (ctxt == NULL)
|
||
|
|
return;
|
||
|
|
ctxt->errNo = XML_ERR_OK;
|
||
|
|
if (ctxt->lastError.code == XML_ERR_OK)
|
||
|
|
return;
|
||
|
|
xmlResetError(&ctxt->lastError);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* xmlCopyError:
|
||
|
|
* @from: a source error
|
||
|
|
* @to: a target error
|
||
|
|
*
|
||
|
|
* Save the original error to the new place.
|
||
|
|
*
|
||
|
|
* Returns 0 in case of success and -1 in case of error.
|
||
|
|
*/
|
||
|
|
int
|
||
|
|
xmlCopyError(xmlErrorPtr from, xmlErrorPtr to) {
|
||
|
|
char *message, *file, *str1, *str2, *str3;
|
||
|
|
|
||
|
|
if ((from == NULL) || (to == NULL))
|
||
|
|
return(-1);
|
||
|
|
|
||
|
|
message = (char *) xmlStrdup((xmlChar *) from->message);
|
||
|
|
file = (char *) xmlStrdup ((xmlChar *) from->file);
|
||
|
|
str1 = (char *) xmlStrdup ((xmlChar *) from->str1);
|
||
|
|
str2 = (char *) xmlStrdup ((xmlChar *) from->str2);
|
||
|
|
str3 = (char *) xmlStrdup ((xmlChar *) from->str3);
|
||
|
|
|
||
|
|
if (to->message != NULL)
|
||
|
|
xmlFree(to->message);
|
||
|
|
if (to->file != NULL)
|
||
|
|
xmlFree(to->file);
|
||
|
|
if (to->str1 != NULL)
|
||
|
|
xmlFree(to->str1);
|
||
|
|
if (to->str2 != NULL)
|
||
|
|
xmlFree(to->str2);
|
||
|
|
if (to->str3 != NULL)
|
||
|
|
xmlFree(to->str3);
|
||
|
|
to->domain = from->domain;
|
||
|
|
to->code = from->code;
|
||
|
|
to->level = from->level;
|
||
|
|
to->line = from->line;
|
||
|
|
to->node = from->node;
|
||
|
|
to->int1 = from->int1;
|
||
|
|
to->int2 = from->int2;
|
||
|
|
to->node = from->node;
|
||
|
|
to->ctxt = from->ctxt;
|
||
|
|
to->message = message;
|
||
|
|
to->file = file;
|
||
|
|
to->str1 = str1;
|
||
|
|
to->str2 = str2;
|
||
|
|
to->str3 = str3;
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
#define bottom_error
|
||
|
|
#include "elfgcchack.h"
|