blob: 9606f1357e0ed50529268060533f36e32a410ed8 [file] [log] [blame]
Owen Taylor3473f882001-02-23 17:55:21 +00001/*
2 * error.c: module displaying/handling XML parser errors
3 *
4 * See Copyright for the status of this software.
5 *
Daniel Veillardc5d64342001-06-24 12:13:24 +00006 * Daniel Veillard <daniel@veillard.com>
Owen Taylor3473f882001-02-23 17:55:21 +00007 */
8
Daniel Veillard34ce8be2002-03-18 19:37:11 +00009#define IN_LIBXML
Bjorn Reese70a9da52001-04-21 16:57:29 +000010#include "libxml.h"
Owen Taylor3473f882001-02-23 17:55:21 +000011
Daniel Veillard2b8c4a12003-10-02 22:28:19 +000012#include <string.h>
Owen Taylor3473f882001-02-23 17:55:21 +000013#include <stdarg.h>
14#include <libxml/parser.h>
15#include <libxml/xmlerror.h>
Daniel Veillarde356c282001-03-10 12:32:04 +000016#include <libxml/xmlmemory.h>
Daniel Veillard3c01b1d2001-10-17 15:58:35 +000017#include <libxml/globals.h>
Owen Taylor3473f882001-02-23 17:55:21 +000018
Daniel Veillardffa3c742005-07-21 13:24:09 +000019void XMLCDECL xmlGenericErrorDefaultFunc (void *ctx ATTRIBUTE_UNUSED,
Daniel Veillard635ef722001-10-29 11:48:19 +000020 const char *msg,
David Kilzer4472c3a2016-05-13 15:13:17 +080021 ...) LIBXML_ATTR_FORMAT(2,3);
Daniel Veillard635ef722001-10-29 11:48:19 +000022
Daniel Veillard1c43dbf2001-06-05 17:12:52 +000023#define XML_GET_VAR_STR(msg, str) { \
Daniel Veillarddbf7bfe2005-10-28 08:25:51 +000024 int size, prev_size = -1; \
Daniel Veillard1c43dbf2001-06-05 17:12:52 +000025 int chars; \
26 char *larger; \
27 va_list ap; \
28 \
29 str = (char *) xmlMalloc(150); \
Daniel Veillard2b8c4a12003-10-02 22:28:19 +000030 if (str != NULL) { \
Daniel Veillard1c43dbf2001-06-05 17:12:52 +000031 \
32 size = 150; \
33 \
Daniel Veillardfa750972008-04-03 07:31:25 +000034 while (size < 64000) { \
Daniel Veillard1c43dbf2001-06-05 17:12:52 +000035 va_start(ap, msg); \
Daniel Veillardf8e3db02012-09-11 13:26:36 +080036 chars = vsnprintf(str, size, msg, ap); \
Daniel Veillard1c43dbf2001-06-05 17:12:52 +000037 va_end(ap); \
Daniel Veillarddbf7bfe2005-10-28 08:25:51 +000038 if ((chars > -1) && (chars < size)) { \
39 if (prev_size == chars) { \
40 break; \
41 } else { \
42 prev_size = chars; \
43 } \
44 } \
Daniel Veillard1c43dbf2001-06-05 17:12:52 +000045 if (chars > -1) \
46 size += chars + 1; \
47 else \
48 size += 100; \
49 if ((larger = (char *) xmlRealloc(str, size)) == NULL) {\
Daniel Veillard2b8c4a12003-10-02 22:28:19 +000050 break; \
Daniel Veillard1c43dbf2001-06-05 17:12:52 +000051 } \
52 str = larger; \
Daniel Veillard2b8c4a12003-10-02 22:28:19 +000053 }} \
Daniel Veillard1c43dbf2001-06-05 17:12:52 +000054}
Bjorn Reese570ff082001-06-05 12:45:55 +000055
Owen Taylor3473f882001-02-23 17:55:21 +000056/************************************************************************
Daniel Veillardf8e3db02012-09-11 13:26:36 +080057 * *
58 * Handling of out of context errors *
59 * *
Owen Taylor3473f882001-02-23 17:55:21 +000060 ************************************************************************/
61
62/**
63 * xmlGenericErrorDefaultFunc:
64 * @ctx: an error context
65 * @msg: the message to display/transmit
66 * @...: extra parameters for the message display
Daniel Veillardf8e3db02012-09-11 13:26:36 +080067 *
Owen Taylor3473f882001-02-23 17:55:21 +000068 * Default handler for out of context error messages.
69 */
Daniel Veillardffa3c742005-07-21 13:24:09 +000070void XMLCDECL
Daniel Veillardc86a4fa2001-03-26 16:28:29 +000071xmlGenericErrorDefaultFunc(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {
Owen Taylor3473f882001-02-23 17:55:21 +000072 va_list args;
73
74 if (xmlGenericErrorContext == NULL)
75 xmlGenericErrorContext = (void *) stderr;
76
77 va_start(args, msg);
78 vfprintf((FILE *)xmlGenericErrorContext, msg, args);
79 va_end(args);
80}
81
Daniel Veillard9d06d302002-01-22 18:15:52 +000082/**
83 * initGenericErrorDefaultFunc:
84 * @handler: the handler
Daniel Veillardf8e3db02012-09-11 13:26:36 +080085 *
Daniel Veillard9d06d302002-01-22 18:15:52 +000086 * Set or reset (if NULL) the default handler for generic errors
Daniel Veillard7424eb62003-01-24 14:14:52 +000087 * to the builtin error function.
Daniel Veillard9d06d302002-01-22 18:15:52 +000088 */
Daniel Veillardd0463562001-10-13 09:15:48 +000089void
Daniel Veillarddb5850a2002-01-18 11:49:26 +000090initGenericErrorDefaultFunc(xmlGenericErrorFunc * handler)
Daniel Veillardd0463562001-10-13 09:15:48 +000091{
Daniel Veillarddb5850a2002-01-18 11:49:26 +000092 if (handler == NULL)
93 xmlGenericError = xmlGenericErrorDefaultFunc;
94 else
Daniel Veillardda0ff5d2004-04-20 09:45:26 +000095 xmlGenericError = (*handler);
Daniel Veillardd0463562001-10-13 09:15:48 +000096}
Owen Taylor3473f882001-02-23 17:55:21 +000097
98/**
99 * xmlSetGenericErrorFunc:
100 * @ctx: the new error handling context
101 * @handler: the new handler function
102 *
103 * Function to reset the handler and the error context for out of
104 * context error messages.
105 * This simply means that @handler will be called for subsequent
106 * error messages while not parsing nor validating. And @ctx will
107 * be passed as first argument to @handler
108 * One can simply force messages to be emitted to another FILE * than
109 * stderr by setting @ctx to this file handle and @handler to NULL.
Daniel Veillardda3b29a2004-08-14 11:15:13 +0000110 * For multi-threaded applications, this must be set separately for each thread.
Owen Taylor3473f882001-02-23 17:55:21 +0000111 */
112void
113xmlSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler) {
114 xmlGenericErrorContext = ctx;
115 if (handler != NULL)
116 xmlGenericError = handler;
117 else
118 xmlGenericError = xmlGenericErrorDefaultFunc;
119}
120
Daniel Veillard659e71e2003-10-10 14:10:40 +0000121/**
122 * xmlSetStructuredErrorFunc:
123 * @ctx: the new error handling context
124 * @handler: the new handler function
125 *
126 * Function to reset the handler and the error context for out of
127 * context structured error messages.
128 * This simply means that @handler will be called for subsequent
129 * error messages while not parsing nor validating. And @ctx will
130 * be passed as first argument to @handler
Daniel Veillardda3b29a2004-08-14 11:15:13 +0000131 * For multi-threaded applications, this must be set separately for each thread.
Daniel Veillard659e71e2003-10-10 14:10:40 +0000132 */
133void
134xmlSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) {
Wang Lam1de382e2009-08-24 17:34:25 +0200135 xmlStructuredErrorContext = ctx;
Daniel Veillard659e71e2003-10-10 14:10:40 +0000136 xmlStructuredError = handler;
137}
138
Owen Taylor3473f882001-02-23 17:55:21 +0000139/************************************************************************
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800140 * *
141 * Handling of parsing errors *
142 * *
Owen Taylor3473f882001-02-23 17:55:21 +0000143 ************************************************************************/
144
145/**
146 * xmlParserPrintFileInfo:
147 * @input: an xmlParserInputPtr input
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800148 *
Owen Taylor3473f882001-02-23 17:55:21 +0000149 * Displays the associated file and line informations for the current input
150 */
151
152void
153xmlParserPrintFileInfo(xmlParserInputPtr input) {
154 if (input != NULL) {
155 if (input->filename)
156 xmlGenericError(xmlGenericErrorContext,
157 "%s:%d: ", input->filename,
158 input->line);
159 else
160 xmlGenericError(xmlGenericErrorContext,
161 "Entity: line %d: ", input->line);
162 }
163}
164
165/**
166 * xmlParserPrintFileContext:
167 * @input: an xmlParserInputPtr input
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800168 *
Owen Taylor3473f882001-02-23 17:55:21 +0000169 * Displays current context within the input content for error tracking
170 */
171
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000172static void
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800173xmlParserPrintFileContextInternal(xmlParserInputPtr input ,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000174 xmlGenericErrorFunc channel, void *data ) {
Daniel Veillard561b7f82002-03-20 21:55:57 +0000175 const xmlChar *cur, *base;
William M. Brackc1939562003-08-05 15:52:22 +0000176 unsigned int n, col; /* GCC warns if signed, because compared with sizeof() */
William M. Brack3dd57f72003-05-13 02:06:18 +0000177 xmlChar content[81]; /* space for 80 chars + line terminator */
Daniel Veillard2be30642001-03-27 00:32:28 +0000178 xmlChar *ctnt;
Owen Taylor3473f882001-02-23 17:55:21 +0000179
Pavel Raiskupc4184ba2015-12-01 13:24:44 +0100180 if ((input == NULL) || (input->cur == NULL))
181 return;
Daniel Veillardce0b0d02015-11-20 15:01:22 +0800182
Owen Taylor3473f882001-02-23 17:55:21 +0000183 cur = input->cur;
184 base = input->base;
Daniel Veillard2be30642001-03-27 00:32:28 +0000185 /* skip backwards over any end-of-lines */
William M. Brackc1939562003-08-05 15:52:22 +0000186 while ((cur > base) && ((*(cur) == '\n') || (*(cur) == '\r'))) {
Daniel Veillard561b7f82002-03-20 21:55:57 +0000187 cur--;
Owen Taylor3473f882001-02-23 17:55:21 +0000188 }
189 n = 0;
William M. Brack3dd57f72003-05-13 02:06:18 +0000190 /* search backwards for beginning-of-line (to max buff size) */
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800191 while ((n++ < (sizeof(content)-1)) && (cur > base) &&
192 (*(cur) != '\n') && (*(cur) != '\r'))
Owen Taylor3473f882001-02-23 17:55:21 +0000193 cur--;
William M. Brackc1939562003-08-05 15:52:22 +0000194 if ((*(cur) == '\n') || (*(cur) == '\r')) cur++;
William M. Brack3dd57f72003-05-13 02:06:18 +0000195 /* calculate the error position in terms of the current position */
196 col = input->cur - cur;
197 /* search forward for end-of-line (to max buff size) */
Owen Taylor3473f882001-02-23 17:55:21 +0000198 n = 0;
Daniel Veillard2be30642001-03-27 00:32:28 +0000199 ctnt = content;
William M. Brack3dd57f72003-05-13 02:06:18 +0000200 /* copy selected text to our buffer */
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800201 while ((*cur != 0) && (*(cur) != '\n') &&
202 (*(cur) != '\r') && (n < sizeof(content)-1)) {
Daniel Veillard561b7f82002-03-20 21:55:57 +0000203 *ctnt++ = *cur++;
204 n++;
Owen Taylor3473f882001-02-23 17:55:21 +0000205 }
Daniel Veillard2be30642001-03-27 00:32:28 +0000206 *ctnt = 0;
William M. Brack3dd57f72003-05-13 02:06:18 +0000207 /* print out the selected text */
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000208 channel(data ,"%s\n", content);
Daniel Veillard2be30642001-03-27 00:32:28 +0000209 /* create blank line with problem pointer */
Owen Taylor3473f882001-02-23 17:55:21 +0000210 n = 0;
Daniel Veillard7533cc82001-04-24 15:52:00 +0000211 ctnt = content;
William M. Brack3dd57f72003-05-13 02:06:18 +0000212 /* (leave buffer space for pointer + line terminator) */
213 while ((n<col) && (n++ < sizeof(content)-2) && (*ctnt != 0)) {
William M. Brackc1939562003-08-05 15:52:22 +0000214 if (*(ctnt) != '\t')
215 *(ctnt) = ' ';
William M. Brack69848302003-09-22 00:24:51 +0000216 ctnt++;
Owen Taylor3473f882001-02-23 17:55:21 +0000217 }
William M. Brack3dd57f72003-05-13 02:06:18 +0000218 *ctnt++ = '^';
219 *ctnt = 0;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000220 channel(data ,"%s\n", content);
Owen Taylor3473f882001-02-23 17:55:21 +0000221}
222
Daniel Veillard561b7f82002-03-20 21:55:57 +0000223/**
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000224 * xmlParserPrintFileContext:
225 * @input: an xmlParserInputPtr input
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800226 *
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000227 * Displays current context within the input content for error tracking
Daniel Veillard561b7f82002-03-20 21:55:57 +0000228 */
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000229void
230xmlParserPrintFileContext(xmlParserInputPtr input) {
231 xmlParserPrintFileContextInternal(input, xmlGenericError,
232 xmlGenericErrorContext);
Daniel Veillard561b7f82002-03-20 21:55:57 +0000233}
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000234
235/**
236 * xmlReportError:
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000237 * @err: the error
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000238 * @ctx: the parser context or NULL
239 * @str: the formatted error message
240 *
241 * Report an erro with its context, replace the 4 old error/warning
242 * routines.
243 */
244static void
Daniel Veillard4c004142003-10-07 11:33:24 +0000245xmlReportError(xmlErrorPtr err, xmlParserCtxtPtr ctxt, const char *str,
246 xmlGenericErrorFunc channel, void *data)
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000247{
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000248 char *file = NULL;
249 int line = 0;
250 int code = -1;
251 int domain;
Daniel Veillard4c004142003-10-07 11:33:24 +0000252 const xmlChar *name = NULL;
253 xmlNodePtr node;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000254 xmlErrorLevel level;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000255 xmlParserInputPtr input = NULL;
256 xmlParserInputPtr cur = NULL;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000257
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000258 if (err == NULL)
259 return;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000260
Daniel Veillard4c004142003-10-07 11:33:24 +0000261 if (channel == NULL) {
262 channel = xmlGenericError;
263 data = xmlGenericErrorContext;
264 }
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000265 file = err->file;
266 line = err->line;
267 code = err->code;
268 domain = err->domain;
269 level = err->level;
Daniel Veillard4c004142003-10-07 11:33:24 +0000270 node = err->node;
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000271
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000272 if (code == XML_ERR_OK)
273 return;
274
Daniel Veillard4c004142003-10-07 11:33:24 +0000275 if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
276 name = node->name;
277
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000278 /*
279 * Maintain the compatibility with the legacy error handling
280 */
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000281 if (ctxt != NULL) {
282 input = ctxt->input;
283 if ((input != NULL) && (input->filename == NULL) &&
284 (ctxt->inputNr > 1)) {
285 cur = input;
286 input = ctxt->inputTab[ctxt->inputNr - 2];
287 }
288 if (input != NULL) {
289 if (input->filename)
290 channel(data, "%s:%d: ", input->filename, input->line);
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000291 else if ((line != 0) && (domain == XML_FROM_PARSER))
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000292 channel(data, "Entity: line %d: ", input->line);
293 }
294 } else {
295 if (file != NULL)
296 channel(data, "%s:%d: ", file, line);
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800297 else if ((line != 0) &&
Daniel Veillard97fa5b32012-08-14 11:01:07 +0800298 ((domain == XML_FROM_PARSER) || (domain == XML_FROM_SCHEMASV)||
299 (domain == XML_FROM_SCHEMASP)||(domain == XML_FROM_DTD) ||
300 (domain == XML_FROM_RELAXNGP)||(domain == XML_FROM_RELAXNGV)))
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000301 channel(data, "Entity: line %d: ", line);
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000302 }
Daniel Veillard4c004142003-10-07 11:33:24 +0000303 if (name != NULL) {
304 channel(data, "element %s: ", name);
305 }
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000306 switch (domain) {
307 case XML_FROM_PARSER:
308 channel(data, "parser ");
309 break;
310 case XML_FROM_NAMESPACE:
311 channel(data, "namespace ");
312 break;
313 case XML_FROM_DTD:
Daniel Veillard72b9e292003-10-28 15:44:17 +0000314 case XML_FROM_VALID:
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000315 channel(data, "validity ");
316 break;
317 case XML_FROM_HTML:
318 channel(data, "HTML parser ");
319 break;
320 case XML_FROM_MEMORY:
321 channel(data, "memory ");
322 break;
323 case XML_FROM_OUTPUT:
324 channel(data, "output ");
325 break;
326 case XML_FROM_IO:
327 channel(data, "I/O ");
328 break;
329 case XML_FROM_XINCLUDE:
330 channel(data, "XInclude ");
331 break;
332 case XML_FROM_XPATH:
333 channel(data, "XPath ");
334 break;
335 case XML_FROM_XPOINTER:
336 channel(data, "parser ");
337 break;
338 case XML_FROM_REGEXP:
339 channel(data, "regexp ");
340 break;
Daniel Veillardce1648b2005-01-04 15:10:22 +0000341 case XML_FROM_MODULE:
342 channel(data, "module ");
343 break;
Daniel Veillardd0c9c322003-10-10 00:49:42 +0000344 case XML_FROM_SCHEMASV:
Daniel Veillard87db3a82003-10-10 10:52:58 +0000345 channel(data, "Schemas validity ");
Daniel Veillardd0c9c322003-10-10 00:49:42 +0000346 break;
347 case XML_FROM_SCHEMASP:
Daniel Veillard87db3a82003-10-10 10:52:58 +0000348 channel(data, "Schemas parser ");
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000349 break;
Daniel Veillard4c004142003-10-07 11:33:24 +0000350 case XML_FROM_RELAXNGP:
351 channel(data, "Relax-NG parser ");
352 break;
353 case XML_FROM_RELAXNGV:
Daniel Veillardd0c9c322003-10-10 00:49:42 +0000354 channel(data, "Relax-NG validity ");
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000355 break;
356 case XML_FROM_CATALOG:
357 channel(data, "Catalog ");
358 break;
359 case XML_FROM_C14N:
360 channel(data, "C14N ");
361 break;
362 case XML_FROM_XSLT:
363 channel(data, "XSLT ");
364 break;
Daniel Veillard1fc3ed02005-08-24 12:46:09 +0000365 case XML_FROM_I18N:
366 channel(data, "encoding ");
367 break;
Daniel Veillard57560382012-07-24 11:44:23 +0800368 case XML_FROM_SCHEMATRONV:
369 channel(data, "schematron ");
370 break;
371 case XML_FROM_BUFFER:
372 channel(data, "internal buffer ");
373 break;
374 case XML_FROM_URI:
375 channel(data, "URI ");
376 break;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000377 default:
378 break;
379 }
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000380 switch (level) {
381 case XML_ERR_NONE:
382 channel(data, ": ");
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000383 break;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000384 case XML_ERR_WARNING:
385 channel(data, "warning : ");
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000386 break;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000387 case XML_ERR_ERROR:
388 channel(data, "error : ");
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000389 break;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000390 case XML_ERR_FATAL:
391 channel(data, "error : ");
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000392 break;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000393 }
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000394 if (str != NULL) {
Daniel Veillard828ce832003-10-08 19:19:10 +0000395 int len;
396 len = xmlStrlen((const xmlChar *)str);
397 if ((len > 0) && (str[len - 1] != '\n'))
Daniel Veillard828ce832003-10-08 19:19:10 +0000398 channel(data, "%s\n", str);
Daniel Veillarda8856222003-10-08 19:26:03 +0000399 else
400 channel(data, "%s", str);
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000401 } else {
Daniel Veillard828ce832003-10-08 19:19:10 +0000402 channel(data, "%s\n", "out of memory error");
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000403 }
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000404
405 if (ctxt != NULL) {
406 xmlParserPrintFileContextInternal(input, channel, data);
407 if (cur != NULL) {
408 if (cur->filename)
409 channel(data, "%s:%d: \n", cur->filename, cur->line);
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000410 else if ((line != 0) && (domain == XML_FROM_PARSER))
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000411 channel(data, "Entity: line %d: \n", cur->line);
412 xmlParserPrintFileContextInternal(cur, channel, data);
413 }
414 }
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000415 if ((domain == XML_FROM_XPATH) && (err->str1 != NULL) &&
416 (err->int1 < 100) &&
417 (err->int1 < xmlStrlen((const xmlChar *)err->str1))) {
418 xmlChar buf[150];
419 int i;
420
421 channel(data, "%s\n", err->str1);
422 for (i=0;i < err->int1;i++)
423 buf[i] = ' ';
424 buf[i++] = '^';
425 buf[i] = 0;
426 channel(data, "%s\n", buf);
427 }
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000428}
429
430/**
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000431 * __xmlRaiseError:
William M. Brackd233e392004-05-16 03:12:08 +0000432 * @schannel: the structured callback channel
Daniel Veillard659e71e2003-10-10 14:10:40 +0000433 * @channel: the old callback channel
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000434 * @data: the callback data
435 * @ctx: the parser context or NULL
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000436 * @ctx: the parser context or NULL
437 * @domain: the domain for the error
438 * @code: the code for the error
439 * @level: the xmlErrorLevel for the error
440 * @file: the file source of the error (or NULL)
441 * @line: the line of the error or 0 if N/A
442 * @str1: extra string info
443 * @str2: extra string info
444 * @str3: extra string info
445 * @int1: extra int info
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800446 * @col: column number of the error or 0 if N/A
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000447 * @msg: the message to display/transmit
448 * @...: extra parameters for the message display
449 *
William M. Brackd233e392004-05-16 03:12:08 +0000450 * Update the appropriate global or contextual error structure,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000451 * then forward the error message down the parser or generic
452 * error callback handler
453 */
Daniel Veillardffa3c742005-07-21 13:24:09 +0000454void XMLCDECL
Daniel Veillard659e71e2003-10-10 14:10:40 +0000455__xmlRaiseError(xmlStructuredErrorFunc schannel,
456 xmlGenericErrorFunc channel, void *data, void *ctx,
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000457 void *nod, int domain, int code, xmlErrorLevel level,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000458 const char *file, int line, const char *str1,
Aleksey Sanin8fdc32a2005-01-05 15:37:55 +0000459 const char *str2, const char *str3, int int1, int col,
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000460 const char *msg, ...)
461{
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000462 xmlParserCtxtPtr ctxt = NULL;
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000463 xmlNodePtr node = (xmlNodePtr) nod;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000464 char *str = NULL;
465 xmlParserInputPtr input = NULL;
466 xmlErrorPtr to = &xmlLastError;
William M. Brackd0407522004-10-02 03:54:00 +0000467 xmlNodePtr baseptr = NULL;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000468
Dmitry V. Levin111d7052011-02-23 22:14:19 +0800469 if (code == XML_ERR_OK)
470 return;
Daniel Veillardb5fa0202003-12-08 17:41:29 +0000471 if ((xmlGetWarningsDefaultValue == 0) && (level == XML_ERR_WARNING))
472 return;
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000473 if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
474 (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
Daniel Veillard370ba3d2004-10-25 16:23:56 +0000475 (domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) {
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000476 ctxt = (xmlParserCtxtPtr) ctx;
Daniel Veillard659e71e2003-10-10 14:10:40 +0000477 if ((schannel == NULL) && (ctxt != NULL) && (ctxt->sax != NULL) &&
Dmitry V. Levin241d4a12011-02-23 22:30:59 +0800478 (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
479 (ctxt->sax->serror != NULL)) {
Daniel Veillard659e71e2003-10-10 14:10:40 +0000480 schannel = ctxt->sax->serror;
Dmitry V. Levin241d4a12011-02-23 22:30:59 +0800481 data = ctxt->userData;
482 }
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000483 }
William M. Brackcd3628b2004-07-25 21:07:29 +0000484 /*
485 * Check if structured error handler set
486 */
487 if (schannel == NULL) {
Daniel Veillardf88d8cf2003-12-08 10:25:02 +0000488 schannel = xmlStructuredError;
William M. Brackcd3628b2004-07-25 21:07:29 +0000489 /*
490 * if user has defined handler, change data ptr to user's choice
491 */
492 if (schannel != NULL)
Wang Lam1de382e2009-08-24 17:34:25 +0200493 data = xmlStructuredErrorContext;
William M. Brackcd3628b2004-07-25 21:07:29 +0000494 }
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000495 /*
496 * Formatting the message
497 */
498 if (msg == NULL) {
499 str = (char *) xmlStrdup(BAD_CAST "No error message provided");
500 } else {
501 XML_GET_VAR_STR(msg, str);
502 }
503
504 /*
505 * specific processing if a parser context is provided
506 */
507 if (ctxt != NULL) {
508 if (file == NULL) {
509 input = ctxt->input;
510 if ((input != NULL) && (input->filename == NULL) &&
511 (ctxt->inputNr > 1)) {
512 input = ctxt->inputTab[ctxt->inputNr - 2];
513 }
514 if (input != NULL) {
515 file = input->filename;
516 line = input->line;
Aleksey Sanin8fdc32a2005-01-05 15:37:55 +0000517 col = input->col;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000518 }
519 }
520 to = &ctxt->lastError;
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000521 } else if ((node != NULL) && (file == NULL)) {
522 int i;
Daniel Veillard4c004142003-10-07 11:33:24 +0000523
Daniel Veillarddbee0f12005-06-27 13:42:57 +0000524 if ((node->doc != NULL) && (node->doc->URL != NULL)) {
William M. Brackd0407522004-10-02 03:54:00 +0000525 baseptr = node;
Daniel Veillard8ce01ce2005-08-25 20:14:38 +0000526/* file = (const char *) node->doc->URL; */
Daniel Veillarddbee0f12005-06-27 13:42:57 +0000527 }
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000528 for (i = 0;
529 ((i < 10) && (node != NULL) && (node->type != XML_ELEMENT_NODE));
530 i++)
531 node = node->parent;
William M. Brackd0407522004-10-02 03:54:00 +0000532 if ((baseptr == NULL) && (node != NULL) &&
Daniel Veillard4c004142003-10-07 11:33:24 +0000533 (node->doc != NULL) && (node->doc->URL != NULL))
William M. Brackd0407522004-10-02 03:54:00 +0000534 baseptr = node;
Daniel Veillard4c004142003-10-07 11:33:24 +0000535
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000536 if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
Daniel Veillard3e35f8e2003-10-21 00:05:38 +0000537 line = node->line;
Daniel Veillard968a03a2012-08-13 12:41:33 +0800538 if ((line == 0) || (line == 65535))
539 line = xmlGetLineNo(node);
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000540 }
541
542 /*
William M. Brackd233e392004-05-16 03:12:08 +0000543 * Save the information about the error
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000544 */
545 xmlResetError(to);
546 to->domain = domain;
547 to->code = code;
548 to->message = str;
549 to->level = level;
550 if (file != NULL)
551 to->file = (char *) xmlStrdup((const xmlChar *) file);
William M. Brackd0407522004-10-02 03:54:00 +0000552 else if (baseptr != NULL) {
553#ifdef LIBXML_XINCLUDE_ENABLED
554 /*
555 * We check if the error is within an XInclude section and,
556 * if so, attempt to print out the href of the XInclude instead
557 * of the usual "base" (doc->URL) for the node (bug 152623).
558 */
559 xmlNodePtr prev = baseptr;
560 int inclcount = 0;
561 while (prev != NULL) {
562 if (prev->prev == NULL)
563 prev = prev->parent;
564 else {
565 prev = prev->prev;
566 if (prev->type == XML_XINCLUDE_START) {
567 if (--inclcount < 0)
568 break;
569 } else if (prev->type == XML_XINCLUDE_END)
570 inclcount++;
571 }
572 }
573 if (prev != NULL) {
Daniel Veillard8ce01ce2005-08-25 20:14:38 +0000574 if (prev->type == XML_XINCLUDE_START) {
575 prev->type = XML_ELEMENT_NODE;
576 to->file = (char *) xmlGetProp(prev, BAD_CAST "href");
577 prev->type = XML_XINCLUDE_START;
578 } else {
579 to->file = (char *) xmlGetProp(prev, BAD_CAST "href");
580 }
William M. Brackd0407522004-10-02 03:54:00 +0000581 } else
582#endif
583 to->file = (char *) xmlStrdup(baseptr->doc->URL);
Daniel Veillard8ce01ce2005-08-25 20:14:38 +0000584 if ((to->file == NULL) && (node != NULL) && (node->doc != NULL)) {
585 to->file = (char *) xmlStrdup(node->doc->URL);
586 }
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000587 }
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000588 to->line = line;
589 if (str1 != NULL)
590 to->str1 = (char *) xmlStrdup((const xmlChar *) str1);
591 if (str2 != NULL)
592 to->str2 = (char *) xmlStrdup((const xmlChar *) str2);
593 if (str3 != NULL)
594 to->str3 = (char *) xmlStrdup((const xmlChar *) str3);
595 to->int1 = int1;
Aleksey Sanin8fdc32a2005-01-05 15:37:55 +0000596 to->int2 = col;
Daniel Veillard4c004142003-10-07 11:33:24 +0000597 to->node = node;
Daniel Veillardcd6ff282003-10-08 22:38:13 +0000598 to->ctxt = ctx;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000599
Daniel Veillardd34b0b82004-01-02 20:26:01 +0000600 if (to != &xmlLastError)
601 xmlCopyError(to,&xmlLastError);
602
Dmitry V. Levinc2a0fdc2011-02-23 22:44:05 +0800603 if (schannel != NULL) {
604 schannel(data, to);
605 return;
606 }
607
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000608 /*
William M. Brackcd3628b2004-07-25 21:07:29 +0000609 * Find the callback channel if channel param is NULL
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000610 */
Wang Lam1de382e2009-08-24 17:34:25 +0200611 if ((ctxt != NULL) && (channel == NULL) &&
612 (xmlStructuredError == NULL) && (ctxt->sax != NULL)) {
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000613 if (level == XML_ERR_WARNING)
614 channel = ctxt->sax->warning;
615 else
616 channel = ctxt->sax->error;
Daniel Veillard4c004142003-10-07 11:33:24 +0000617 data = ctxt->userData;
Daniel Veillardbb5abab2003-10-03 22:21:51 +0000618 } else if (channel == NULL) {
Dmitry V. Levinc2a0fdc2011-02-23 22:44:05 +0800619 channel = xmlGenericError;
Pietro Cerutti890faa52012-08-27 13:24:08 +0800620 if (ctxt != NULL) {
621 data = ctxt;
622 } else {
Dmitry V. Levinc2a0fdc2011-02-23 22:44:05 +0800623 data = xmlGenericErrorContext;
Pietro Cerutti890faa52012-08-27 13:24:08 +0800624 }
Daniel Veillard659e71e2003-10-10 14:10:40 +0000625 }
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000626 if (channel == NULL)
627 return;
628
629 if ((channel == xmlParserError) ||
630 (channel == xmlParserWarning) ||
631 (channel == xmlParserValidityError) ||
632 (channel == xmlParserValidityWarning))
Daniel Veillard4c004142003-10-07 11:33:24 +0000633 xmlReportError(to, ctxt, str, NULL, NULL);
634 else if ((channel == (xmlGenericErrorFunc) fprintf) ||
635 (channel == xmlGenericErrorDefaultFunc))
636 xmlReportError(to, ctxt, str, channel, data);
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000637 else
638 channel(data, "%s", str);
639}
Daniel Veillard561b7f82002-03-20 21:55:57 +0000640
Daniel Veillarde356c282001-03-10 12:32:04 +0000641/**
Daniel Veillard18ec16e2003-10-07 23:16:40 +0000642 * __xmlSimpleError:
643 * @domain: where the error comes from
644 * @code: the error code
645 * @node: the context node
646 * @extra: extra informations
647 *
648 * Handle an out of memory condition
649 */
650void
651__xmlSimpleError(int domain, int code, xmlNodePtr node,
652 const char *msg, const char *extra)
653{
654
655 if (code == XML_ERR_NO_MEMORY) {
656 if (extra)
Daniel Veillard659e71e2003-10-10 14:10:40 +0000657 __xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
Daniel Veillard18ec16e2003-10-07 23:16:40 +0000658 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
659 NULL, NULL, 0, 0,
660 "Memory allocation failed : %s\n", extra);
661 else
Daniel Veillard659e71e2003-10-10 14:10:40 +0000662 __xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
Daniel Veillard18ec16e2003-10-07 23:16:40 +0000663 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
664 NULL, NULL, 0, 0, "Memory allocation failed\n");
665 } else {
Daniel Veillard659e71e2003-10-10 14:10:40 +0000666 __xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
Daniel Veillard18ec16e2003-10-07 23:16:40 +0000667 code, XML_ERR_ERROR, NULL, 0, extra,
668 NULL, NULL, 0, 0, msg, extra);
669 }
670}
671/**
Owen Taylor3473f882001-02-23 17:55:21 +0000672 * xmlParserError:
673 * @ctx: an XML parser context
674 * @msg: the message to display/transmit
675 * @...: extra parameters for the message display
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800676 *
Owen Taylor3473f882001-02-23 17:55:21 +0000677 * Display and format an error messages, gives file, line, position and
678 * extra parameters.
679 */
Daniel Veillardffa3c742005-07-21 13:24:09 +0000680void XMLCDECL
Owen Taylor3473f882001-02-23 17:55:21 +0000681xmlParserError(void *ctx, const char *msg, ...)
682{
683 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
684 xmlParserInputPtr input = NULL;
685 xmlParserInputPtr cur = NULL;
Daniel Veillarde356c282001-03-10 12:32:04 +0000686 char * str;
Owen Taylor3473f882001-02-23 17:55:21 +0000687
688 if (ctxt != NULL) {
689 input = ctxt->input;
690 if ((input != NULL) && (input->filename == NULL) &&
691 (ctxt->inputNr > 1)) {
692 cur = input;
693 input = ctxt->inputTab[ctxt->inputNr - 2];
694 }
695 xmlParserPrintFileInfo(input);
696 }
697
698 xmlGenericError(xmlGenericErrorContext, "error: ");
Daniel Veillard1c43dbf2001-06-05 17:12:52 +0000699 XML_GET_VAR_STR(msg, str);
Daniel Veillard635ef722001-10-29 11:48:19 +0000700 xmlGenericError(xmlGenericErrorContext, "%s", str);
Daniel Veillard9e7160d2001-03-18 23:17:47 +0000701 if (str != NULL)
702 xmlFree(str);
Owen Taylor3473f882001-02-23 17:55:21 +0000703
704 if (ctxt != NULL) {
705 xmlParserPrintFileContext(input);
706 if (cur != NULL) {
707 xmlParserPrintFileInfo(cur);
708 xmlGenericError(xmlGenericErrorContext, "\n");
709 xmlParserPrintFileContext(cur);
710 }
711 }
712}
713
714/**
715 * xmlParserWarning:
716 * @ctx: an XML parser context
717 * @msg: the message to display/transmit
718 * @...: extra parameters for the message display
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800719 *
Owen Taylor3473f882001-02-23 17:55:21 +0000720 * Display and format a warning messages, gives file, line, position and
721 * extra parameters.
722 */
Daniel Veillardffa3c742005-07-21 13:24:09 +0000723void XMLCDECL
Owen Taylor3473f882001-02-23 17:55:21 +0000724xmlParserWarning(void *ctx, const char *msg, ...)
725{
726 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
727 xmlParserInputPtr input = NULL;
728 xmlParserInputPtr cur = NULL;
Daniel Veillarde356c282001-03-10 12:32:04 +0000729 char * str;
Owen Taylor3473f882001-02-23 17:55:21 +0000730
731 if (ctxt != NULL) {
732 input = ctxt->input;
733 if ((input != NULL) && (input->filename == NULL) &&
734 (ctxt->inputNr > 1)) {
735 cur = input;
736 input = ctxt->inputTab[ctxt->inputNr - 2];
737 }
738 xmlParserPrintFileInfo(input);
739 }
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800740
Owen Taylor3473f882001-02-23 17:55:21 +0000741 xmlGenericError(xmlGenericErrorContext, "warning: ");
Daniel Veillard1c43dbf2001-06-05 17:12:52 +0000742 XML_GET_VAR_STR(msg, str);
Daniel Veillard635ef722001-10-29 11:48:19 +0000743 xmlGenericError(xmlGenericErrorContext, "%s", str);
Daniel Veillard9e7160d2001-03-18 23:17:47 +0000744 if (str != NULL)
745 xmlFree(str);
Owen Taylor3473f882001-02-23 17:55:21 +0000746
747 if (ctxt != NULL) {
748 xmlParserPrintFileContext(input);
749 if (cur != NULL) {
750 xmlParserPrintFileInfo(cur);
751 xmlGenericError(xmlGenericErrorContext, "\n");
752 xmlParserPrintFileContext(cur);
753 }
754 }
755}
756
757/************************************************************************
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800758 * *
759 * Handling of validation errors *
760 * *
Owen Taylor3473f882001-02-23 17:55:21 +0000761 ************************************************************************/
762
763/**
764 * xmlParserValidityError:
765 * @ctx: an XML parser context
766 * @msg: the message to display/transmit
767 * @...: extra parameters for the message display
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800768 *
Owen Taylor3473f882001-02-23 17:55:21 +0000769 * Display and format an validity error messages, gives file,
770 * line, position and extra parameters.
771 */
Daniel Veillardffa3c742005-07-21 13:24:09 +0000772void XMLCDECL
Owen Taylor3473f882001-02-23 17:55:21 +0000773xmlParserValidityError(void *ctx, const char *msg, ...)
774{
775 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
776 xmlParserInputPtr input = NULL;
Daniel Veillard9e7160d2001-03-18 23:17:47 +0000777 char * str;
Daniel Veillard76575762002-09-05 14:21:15 +0000778 int len = xmlStrlen((const xmlChar *) msg);
779 static int had_info = 0;
Owen Taylor3473f882001-02-23 17:55:21 +0000780
Daniel Veillard76575762002-09-05 14:21:15 +0000781 if ((len > 1) && (msg[len - 2] != ':')) {
782 if (ctxt != NULL) {
783 input = ctxt->input;
784 if ((input->filename == NULL) && (ctxt->inputNr > 1))
785 input = ctxt->inputTab[ctxt->inputNr - 2];
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800786
Daniel Veillard76575762002-09-05 14:21:15 +0000787 if (had_info == 0) {
788 xmlParserPrintFileInfo(input);
789 }
790 }
791 xmlGenericError(xmlGenericErrorContext, "validity error: ");
Daniel Veillard76575762002-09-05 14:21:15 +0000792 had_info = 0;
793 } else {
794 had_info = 1;
Owen Taylor3473f882001-02-23 17:55:21 +0000795 }
796
Daniel Veillard1c43dbf2001-06-05 17:12:52 +0000797 XML_GET_VAR_STR(msg, str);
Daniel Veillard635ef722001-10-29 11:48:19 +0000798 xmlGenericError(xmlGenericErrorContext, "%s", str);
Daniel Veillard9e7160d2001-03-18 23:17:47 +0000799 if (str != NULL)
800 xmlFree(str);
Owen Taylor3473f882001-02-23 17:55:21 +0000801
Daniel Veillard76575762002-09-05 14:21:15 +0000802 if ((ctxt != NULL) && (input != NULL)) {
Owen Taylor3473f882001-02-23 17:55:21 +0000803 xmlParserPrintFileContext(input);
804 }
805}
806
807/**
808 * xmlParserValidityWarning:
809 * @ctx: an XML parser context
810 * @msg: the message to display/transmit
811 * @...: extra parameters for the message display
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800812 *
Owen Taylor3473f882001-02-23 17:55:21 +0000813 * Display and format a validity warning messages, gives file, line,
814 * position and extra parameters.
815 */
Daniel Veillardffa3c742005-07-21 13:24:09 +0000816void XMLCDECL
Owen Taylor3473f882001-02-23 17:55:21 +0000817xmlParserValidityWarning(void *ctx, const char *msg, ...)
818{
819 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
820 xmlParserInputPtr input = NULL;
Daniel Veillard9e7160d2001-03-18 23:17:47 +0000821 char * str;
Daniel Veillard76575762002-09-05 14:21:15 +0000822 int len = xmlStrlen((const xmlChar *) msg);
Owen Taylor3473f882001-02-23 17:55:21 +0000823
Daniel Veillard76575762002-09-05 14:21:15 +0000824 if ((ctxt != NULL) && (len != 0) && (msg[len - 1] != ':')) {
Owen Taylor3473f882001-02-23 17:55:21 +0000825 input = ctxt->input;
826 if ((input->filename == NULL) && (ctxt->inputNr > 1))
827 input = ctxt->inputTab[ctxt->inputNr - 2];
828
829 xmlParserPrintFileInfo(input);
830 }
Daniel Veillardf8e3db02012-09-11 13:26:36 +0800831
Owen Taylor3473f882001-02-23 17:55:21 +0000832 xmlGenericError(xmlGenericErrorContext, "validity warning: ");
Daniel Veillard1c43dbf2001-06-05 17:12:52 +0000833 XML_GET_VAR_STR(msg, str);
Daniel Veillard635ef722001-10-29 11:48:19 +0000834 xmlGenericError(xmlGenericErrorContext, "%s", str);
Daniel Veillard9e7160d2001-03-18 23:17:47 +0000835 if (str != NULL)
836 xmlFree(str);
Owen Taylor3473f882001-02-23 17:55:21 +0000837
838 if (ctxt != NULL) {
839 xmlParserPrintFileContext(input);
840 }
841}
842
843
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000844/************************************************************************
845 * *
846 * Extended Error Handling *
847 * *
848 ************************************************************************/
849
850/**
851 * xmlGetLastError:
852 *
853 * Get the last global error registered. This is per thread if compiled
854 * with thread support.
855 *
856 * Returns NULL if no error occured or a pointer to the error
857 */
858xmlErrorPtr
859xmlGetLastError(void)
860{
861 if (xmlLastError.code == XML_ERR_OK)
862 return (NULL);
863 return (&xmlLastError);
864}
865
866/**
867 * xmlResetError:
868 * @err: pointer to the error.
869 *
870 * Cleanup the error.
871 */
872void
873xmlResetError(xmlErrorPtr err)
874{
875 if (err == NULL)
876 return;
877 if (err->code == XML_ERR_OK)
878 return;
879 if (err->message != NULL)
880 xmlFree(err->message);
881 if (err->file != NULL)
882 xmlFree(err->file);
883 if (err->str1 != NULL)
884 xmlFree(err->str1);
885 if (err->str2 != NULL)
886 xmlFree(err->str2);
887 if (err->str3 != NULL)
888 xmlFree(err->str3);
889 memset(err, 0, sizeof(xmlError));
890 err->code = XML_ERR_OK;
891}
892
893/**
894 * xmlResetLastError:
895 *
896 * Cleanup the last global error registered. For parsing error
897 * this does not change the well-formedness result.
898 */
899void
900xmlResetLastError(void)
901{
902 if (xmlLastError.code == XML_ERR_OK)
903 return;
904 xmlResetError(&xmlLastError);
905}
906
907/**
908 * xmlCtxtGetLastError:
909 * @ctx: an XML parser context
910 *
911 * Get the last parsing error registered.
912 *
913 * Returns NULL if no error occured or a pointer to the error
914 */
915xmlErrorPtr
916xmlCtxtGetLastError(void *ctx)
917{
918 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
919
920 if (ctxt == NULL)
921 return (NULL);
922 if (ctxt->lastError.code == XML_ERR_OK)
923 return (NULL);
924 return (&ctxt->lastError);
925}
926
927/**
928 * xmlCtxtResetLastError:
929 * @ctx: an XML parser context
930 *
931 * Cleanup the last global error registered. For parsing error
932 * this does not change the well-formedness result.
933 */
934void
935xmlCtxtResetLastError(void *ctx)
936{
937 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
938
939 if (ctxt == NULL)
940 return;
Daniel Veillard26b06872010-03-15 15:59:07 +0100941 ctxt->errNo = XML_ERR_OK;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000942 if (ctxt->lastError.code == XML_ERR_OK)
943 return;
944 xmlResetError(&ctxt->lastError);
945}
946
947/**
948 * xmlCopyError:
949 * @from: a source error
950 * @to: a target error
951 *
952 * Save the original error to the new place.
953 *
954 * Returns 0 in case of success and -1 in case of error.
955 */
956int
957xmlCopyError(xmlErrorPtr from, xmlErrorPtr to) {
William M. Bracka3215c72004-07-31 16:24:01 +0000958 char *message, *file, *str1, *str2, *str3;
959
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000960 if ((from == NULL) || (to == NULL))
961 return(-1);
William M. Bracka3215c72004-07-31 16:24:01 +0000962
963 message = (char *) xmlStrdup((xmlChar *) from->message);
964 file = (char *) xmlStrdup ((xmlChar *) from->file);
965 str1 = (char *) xmlStrdup ((xmlChar *) from->str1);
966 str2 = (char *) xmlStrdup ((xmlChar *) from->str2);
967 str3 = (char *) xmlStrdup ((xmlChar *) from->str3);
968
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000969 if (to->message != NULL)
970 xmlFree(to->message);
971 if (to->file != NULL)
972 xmlFree(to->file);
973 if (to->str1 != NULL)
974 xmlFree(to->str1);
975 if (to->str2 != NULL)
976 xmlFree(to->str2);
977 if (to->str3 != NULL)
978 xmlFree(to->str3);
979 to->domain = from->domain;
980 to->code = from->code;
981 to->level = from->level;
982 to->line = from->line;
Daniel Veillard4c004142003-10-07 11:33:24 +0000983 to->node = from->node;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000984 to->int1 = from->int1;
985 to->int2 = from->int2;
Daniel Veillard4c004142003-10-07 11:33:24 +0000986 to->node = from->node;
987 to->ctxt = from->ctxt;
William M. Bracka3215c72004-07-31 16:24:01 +0000988 to->message = message;
989 to->file = file;
990 to->str1 = str1;
991 to->str2 = str2;
992 to->str3 = str3;
993
994 return 0;
Daniel Veillard2b8c4a12003-10-02 22:28:19 +0000995}
996
Daniel Veillard5d4644e2005-04-01 13:11:58 +0000997#define bottom_error
998#include "elfgcchack.h"