1 /*
2 * error.c: module displaying/handling XML parser errors
3 *
4 * See Copyright for the status of this software.
5 *
6 * Daniel Veillard <daniel@veillard.com>
7 */
8
9 #define IN_LIBXML
10 #include "libxml.h"
11
12 #include <string.h>
13 #include <stdarg.h>
14 #include <libxml/parser.h>
15 #include <libxml/xmlerror.h>
16 #include <libxml/xmlmemory.h>
17
18 #include "private/error.h"
19
20 #define XML_MAX_ERRORS 100
21
22 #define XML_GET_VAR_STR(msg, str) { \
23 int size, prev_size = -1; \
24 int chars; \
25 char *larger; \
26 va_list ap; \
27 \
28 str = (char *) xmlMalloc(150); \
29 if (str != NULL) { \
30 \
31 size = 150; \
32 \
33 while (size < 64000) { \
34 va_start(ap, msg); \
35 chars = vsnprintf(str, size, msg, ap); \
36 va_end(ap); \
37 if ((chars > -1) && (chars < size)) { \
38 if (prev_size == chars) { \
39 break; \
40 } else { \
41 prev_size = chars; \
42 } \
43 } \
44 if (chars > -1) \
45 size += chars + 1; \
46 else \
47 size += 100; \
48 if ((larger = (char *) xmlRealloc(str, size)) == NULL) {\
49 break; \
50 } \
51 str = larger; \
52 }} \
53 }
54
55 /************************************************************************
56 * *
57 * Handling of out of context errors *
58 * *
59 ************************************************************************/
60
61 /**
62 * xmlGenericErrorDefaultFunc:
63 * @ctx: an error context
64 * @msg: the message to display/transmit
65 * @...: extra parameters for the message display
66 *
67 * Default handler for out of context error messages.
68 */
69 void
70 xmlGenericErrorDefaultFunc(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {
71 va_list args;
72
73 if (xmlGenericErrorContext == NULL)
74 xmlGenericErrorContext = (void *) stderr;
75
76 va_start(args, msg);
77 vfprintf((FILE *)xmlGenericErrorContext, msg, args);
78 va_end(args);
79 }
80
81 /**
82 * initGenericErrorDefaultFunc:
83 * @handler: the handler
84 *
85 * DEPRECATED: Use xmlSetGenericErrorFunc.
86 *
87 * Set or reset (if NULL) the default handler for generic errors
88 * to the builtin error function.
89 */
90 void
91 initGenericErrorDefaultFunc(xmlGenericErrorFunc * handler)
92 {
93 if (handler == NULL)
94 xmlGenericError = xmlGenericErrorDefaultFunc;
95 else
96 xmlGenericError = (*handler);
97 }
98
99 /**
100 * xmlSetGenericErrorFunc:
101 * @ctx: the new error handling context
102 * @handler: the new handler function
103 *
104 * Function to reset the handler and the error context for out of
105 * context error messages.
106 * This simply means that @handler will be called for subsequent
107 * error messages while not parsing nor validating. And @ctx will
108 * be passed as first argument to @handler
109 * One can simply force messages to be emitted to another FILE * than
110 * stderr by setting @ctx to this file handle and @handler to NULL.
111 * For multi-threaded applications, this must be set separately for each thread.
112 */
113 void
114 xmlSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler) {
115 xmlGenericErrorContext = ctx;
116 if (handler != NULL)
117 xmlGenericError = handler;
118 else
119 xmlGenericError = xmlGenericErrorDefaultFunc;
120 }
121
122 /**
123 * xmlSetStructuredErrorFunc:
124 * @ctx: the new error handling context
125 * @handler: the new handler function
126 *
127 * Function to reset the handler and the error context for out of
128 * context structured error messages.
129 * This simply means that @handler will be called for subsequent
130 * error messages while not parsing nor validating. And @ctx will
131 * be passed as first argument to @handler
132 * For multi-threaded applications, this must be set separately for each thread.
133 */
134 void
135 xmlSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) {
136 xmlStructuredErrorContext = ctx;
137 xmlStructuredError = handler;
138 }
139
140 /************************************************************************
141 * *
142 * Handling of parsing errors *
143 * *
144 ************************************************************************/
145
146 /**
147 * xmlParserPrintFileInfo:
148 * @input: an xmlParserInputPtr input
149 *
150 * Displays the associated file and line information for the current input
151 */
152
153 void
154 xmlParserPrintFileInfo(xmlParserInputPtr input) {
155 if (input != NULL) {
156 if (input->filename)
157 xmlGenericError(xmlGenericErrorContext,
158 "%s:%d: ", input->filename,
159 input->line);
160 else
161 xmlGenericError(xmlGenericErrorContext,
162 "Entity: line %d: ", input->line);
163 }
164 }
165
166 /**
167 * xmlParserPrintFileContextInternal:
168 * @input: an xmlParserInputPtr input
169 *
170 * Displays current context within the input content for error tracking
171 */
172
173 static void
174 xmlParserPrintFileContextInternal(xmlParserInputPtr input ,
175 xmlGenericErrorFunc channel, void *data ) {
176 const xmlChar *cur, *base, *start;
177 unsigned int n, col; /* GCC warns if signed, because compared with sizeof() */
178 xmlChar content[81]; /* space for 80 chars + line terminator */
179 xmlChar *ctnt;
180
181 if ((input == NULL) || (input->cur == NULL))
182 return;
183
184 cur = input->cur;
185 base = input->base;
186 /* skip backwards over any end-of-lines */
187 while ((cur > base) && ((*(cur) == '\n') || (*(cur) == '\r'))) {
188 cur--;
189 }
190 n = 0;
191 /* search backwards for beginning-of-line (to max buff size) */
192 while ((n < sizeof(content) - 1) && (cur > base) &&
193 (*cur != '\n') && (*cur != '\r')) {
194 cur--;
195 n++;
196 }
197 if ((n > 0) && ((*cur == '\n') || (*cur == '\r'))) {
198 cur++;
199 } else {
200 /* skip over continuation bytes */
201 while ((cur < input->cur) && ((*cur & 0xC0) == 0x80))
202 cur++;
203 }
204 /* calculate the error position in terms of the current position */
205 col = input->cur - cur;
206 /* search forward for end-of-line (to max buff size) */
207 n = 0;
208 start = cur;
209 /* copy selected text to our buffer */
210 while ((*cur != 0) && (*(cur) != '\n') && (*(cur) != '\r')) {
211 int len = input->end - cur;
212 int c = xmlGetUTF8Char(cur, &len);
213
214 if ((c < 0) || (n + len > sizeof(content)-1))
215 break;
216 cur += len;
217 n += len;
218 }
219 memcpy(content, start, n);
220 content[n] = 0;
221 /* print out the selected text */
222 channel(data ,"%s\n", content);
223 /* create blank line with problem pointer */
224 n = 0;
225 ctnt = content;
226 /* (leave buffer space for pointer + line terminator) */
227 while ((n<col) && (n++ < sizeof(content)-2) && (*ctnt != 0)) {
228 if (*(ctnt) != '\t')
229 *(ctnt) = ' ';
230 ctnt++;
231 }
232 *ctnt++ = '^';
233 *ctnt = 0;
234 channel(data ,"%s\n", content);
235 }
236
237 /**
238 * xmlParserPrintFileContext:
239 * @input: an xmlParserInputPtr input
240 *
241 * Displays current context within the input content for error tracking
242 */
243 void
244 xmlParserPrintFileContext(xmlParserInputPtr input) {
245 xmlParserPrintFileContextInternal(input, xmlGenericError,
246 xmlGenericErrorContext);
247 }
248
249 /**
250 * xmlReportError:
251 * @err: the error
252 * @ctx: the parser context or NULL
253 * @str: the formatted error message
254 *
255 * Report an error with its context, replace the 4 old error/warning
256 * routines.
257 */
258 static void
259 xmlReportError(xmlErrorPtr err, xmlParserCtxtPtr ctxt, const char *str,
260 xmlGenericErrorFunc channel, void *data)
261 {
262 char *file = NULL;
263 int line = 0;
264 int code = -1;
265 int domain;
266 const xmlChar *name = NULL;
267 xmlNodePtr node;
268 xmlErrorLevel level;
269 xmlParserInputPtr input = NULL;
270 xmlParserInputPtr cur = NULL;
271
272 if (err == NULL)
273 return;
274
275 if (channel == NULL) {
276 channel = xmlGenericError;
277 data = xmlGenericErrorContext;
278 }
279 file = err->file;
280 line = err->line;
281 code = err->code;
282 domain = err->domain;
283 level = err->level;
284 node = err->node;
285
286 if (code == XML_ERR_OK)
287 return;
288
289 if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
290 name = node->name;
291
292 /*
293 * Maintain the compatibility with the legacy error handling
294 */
295 if (ctxt != NULL) {
296 input = ctxt->input;
297 if ((input != NULL) && (input->filename == NULL) &&
298 (ctxt->inputNr > 1)) {
299 cur = input;
300 input = ctxt->inputTab[ctxt->inputNr - 2];
301 }
302 if (input != NULL) {
303 if (input->filename)
304 channel(data, "%s:%d: ", input->filename, input->line);
305 else if ((line != 0) && (domain == XML_FROM_PARSER))
306 channel(data, "Entity: line %d: ", input->line);
307 }
308 } else {
309 if (file != NULL)
310 channel(data, "%s:%d: ", file, line);
311 else if ((line != 0) &&
312 ((domain == XML_FROM_PARSER) || (domain == XML_FROM_SCHEMASV)||
313 (domain == XML_FROM_SCHEMASP)||(domain == XML_FROM_DTD) ||
314 (domain == XML_FROM_RELAXNGP)||(domain == XML_FROM_RELAXNGV)))
315 channel(data, "Entity: line %d: ", line);
316 }
317 if (name != NULL) {
318 channel(data, "element %s: ", name);
319 }
320 switch (domain) {
321 case XML_FROM_PARSER:
322 channel(data, "parser ");
323 break;
324 case XML_FROM_NAMESPACE:
325 channel(data, "namespace ");
326 break;
327 case XML_FROM_DTD:
328 case XML_FROM_VALID:
329 channel(data, "validity ");
330 break;
331 case XML_FROM_HTML:
332 channel(data, "HTML parser ");
333 break;
334 case XML_FROM_MEMORY:
335 channel(data, "memory ");
336 break;
337 case XML_FROM_OUTPUT:
338 channel(data, "output ");
339 break;
340 case XML_FROM_IO:
341 channel(data, "I/O ");
342 break;
343 case XML_FROM_XINCLUDE:
344 channel(data, "XInclude ");
345 break;
346 case XML_FROM_XPATH:
347 channel(data, "XPath ");
348 break;
349 case XML_FROM_XPOINTER:
350 channel(data, "parser ");
351 break;
352 case XML_FROM_REGEXP:
353 channel(data, "regexp ");
354 break;
355 case XML_FROM_MODULE:
356 channel(data, "module ");
357 break;
358 case XML_FROM_SCHEMASV:
359 channel(data, "Schemas validity ");
360 break;
361 case XML_FROM_SCHEMASP:
362 channel(data, "Schemas parser ");
363 break;
364 case XML_FROM_RELAXNGP:
365 channel(data, "Relax-NG parser ");
366 break;
367 case XML_FROM_RELAXNGV:
368 channel(data, "Relax-NG validity ");
369 break;
370 case XML_FROM_CATALOG:
371 channel(data, "Catalog ");
372 break;
373 case XML_FROM_C14N:
374 channel(data, "C14N ");
375 break;
376 case XML_FROM_XSLT:
377 channel(data, "XSLT ");
378 break;
379 case XML_FROM_I18N:
380 channel(data, "encoding ");
381 break;
382 case XML_FROM_SCHEMATRONV:
383 channel(data, "schematron ");
384 break;
385 case XML_FROM_BUFFER:
386 channel(data, "internal buffer ");
387 break;
388 case XML_FROM_URI:
389 channel(data, "URI ");
390 break;
391 default:
392 break;
393 }
394 switch (level) {
395 case XML_ERR_NONE:
396 channel(data, ": ");
397 break;
398 case XML_ERR_WARNING:
399 channel(data, "warning : ");
400 break;
401 case XML_ERR_ERROR:
402 channel(data, "error : ");
403 break;
404 case XML_ERR_FATAL:
405 channel(data, "error : ");
406 break;
407 }
408 if (str != NULL) {
409 int len;
410 len = xmlStrlen((const xmlChar *)str);
411 if ((len > 0) && (str[len - 1] != '\n'))
412 channel(data, "%s\n", str);
413 else
414 channel(data, "%s", str);
415 } else {
416 channel(data, "%s\n", "out of memory error");
417 }
418
419 if (ctxt != NULL) {
420 xmlParserPrintFileContextInternal(input, channel, data);
421 if (cur != NULL) {
422 if (cur->filename)
423 channel(data, "%s:%d: \n", cur->filename, cur->line);
424 else if ((line != 0) && (domain == XML_FROM_PARSER))
425 channel(data, "Entity: line %d: \n", cur->line);
426 xmlParserPrintFileContextInternal(cur, channel, data);
427 }
428 }
429 if ((domain == XML_FROM_XPATH) && (err->str1 != NULL) &&
430 (err->int1 < 100) &&
431 (err->int1 < xmlStrlen((const xmlChar *)err->str1))) {
432 xmlChar buf[150];
433 int i;
434
435 channel(data, "%s\n", err->str1);
436 for (i=0;i < err->int1;i++)
437 buf[i] = ' ';
438 buf[i++] = '^';
439 buf[i] = 0;
440 channel(data, "%s\n", buf);
441 }
442 }
443
444 /**
445 * __xmlRaiseError:
446 * @schannel: the structured callback channel
447 * @channel: the old callback channel
448 * @data: the callback data
449 * @ctx: the parser context or NULL
450 * @ctx: the parser context or NULL
451 * @domain: the domain for the error
452 * @code: the code for the error
453 * @level: the xmlErrorLevel for the error
454 * @file: the file source of the error (or NULL)
455 * @line: the line of the error or 0 if N/A
456 * @str1: extra string info
457 * @str2: extra string info
458 * @str3: extra string info
459 * @int1: extra int info
460 * @col: column number of the error or 0 if N/A
461 * @msg: the message to display/transmit
462 * @...: extra parameters for the message display
463 *
464 * Update the appropriate global or contextual error structure,
465 * then forward the error message down the parser or generic
466 * error callback handler
467 */
468 void
469 __xmlRaiseError(xmlStructuredErrorFunc schannel,
470 xmlGenericErrorFunc channel, void *data, void *ctx,
471 void *nod, int domain, int code, xmlErrorLevel level,
472 const char *file, int line, const char *str1,
473 const char *str2, const char *str3, int int1, int col,
474 const char *msg, ...)
475 {
476 xmlParserCtxtPtr ctxt = NULL;
477 xmlNodePtr node = (xmlNodePtr) nod;
478 char *str = NULL;
479 xmlParserInputPtr input = NULL;
480 xmlErrorPtr to = &xmlLastError;
481 xmlNodePtr baseptr = NULL;
482
483 if (code == XML_ERR_OK)
484 return;
485 if ((xmlGetWarningsDefaultValue == 0) && (level == XML_ERR_WARNING))
486 return;
487 if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
488 (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
489 (domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) {
490 ctxt = (xmlParserCtxtPtr) ctx;
491
492 if (ctxt != NULL) {
493 if (level == XML_ERR_WARNING) {
494 if (ctxt->nbWarnings >= XML_MAX_ERRORS)
495 return;
496 ctxt->nbWarnings += 1;
497 } else {
498 if (ctxt->nbErrors >= XML_MAX_ERRORS)
499 return;
500 ctxt->nbErrors += 1;
501 }
502
503 if ((schannel == NULL) && (ctxt->sax != NULL) &&
504 (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
505 (ctxt->sax->serror != NULL)) {
506 schannel = ctxt->sax->serror;
507 data = ctxt->userData;
508 }
509 }
510 }
511 /*
512 * Check if structured error handler set
513 */
514 if (schannel == NULL) {
515 schannel = xmlStructuredError;
516 /*
517 * if user has defined handler, change data ptr to user's choice
518 */
519 if (schannel != NULL)
520 data = xmlStructuredErrorContext;
521 }
522 /*
523 * Formatting the message
524 */
525 if (msg == NULL) {
526 str = (char *) xmlStrdup(BAD_CAST "No error message provided");
527 } else {
528 XML_GET_VAR_STR(msg, str);
529 }
530
531 /*
532 * specific processing if a parser context is provided
533 */
534 if (ctxt != NULL) {
535 if (file == NULL) {
536 input = ctxt->input;
537 if ((input != NULL) && (input->filename == NULL) &&
538 (ctxt->inputNr > 1)) {
539 input = ctxt->inputTab[ctxt->inputNr - 2];
540 }
541 if (input != NULL) {
542 file = input->filename;
543 line = input->line;
544 col = input->col;
545 }
546 }
547 to = &ctxt->lastError;
548 } else if ((node != NULL) && (file == NULL)) {
549 int i;
550
551 if ((node->doc != NULL) && (node->doc->URL != NULL)) {
552 baseptr = node;
553 /* file = (const char *) node->doc->URL; */
554 }
555 for (i = 0;
556 ((i < 10) && (node != NULL) && (node->type != XML_ELEMENT_NODE));
557 i++)
558 node = node->parent;
559 if ((baseptr == NULL) && (node != NULL) &&
560 (node->doc != NULL) && (node->doc->URL != NULL))
561 baseptr = node;
562
563 if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
564 line = node->line;
565 if ((line == 0) || (line == 65535))
566 line = xmlGetLineNo(node);
567 }
568
569 /*
570 * Save the information about the error
571 */
572 xmlResetError(to);
573 to->domain = domain;
574 to->code = code;
575 to->message = str;
576 to->level = level;
577 if (file != NULL)
578 to->file = (char *) xmlStrdup((const xmlChar *) file);
579 else if (baseptr != NULL) {
580 #ifdef LIBXML_XINCLUDE_ENABLED
581 /*
582 * We check if the error is within an XInclude section and,
583 * if so, attempt to print out the href of the XInclude instead
584 * of the usual "base" (doc->URL) for the node (bug 152623).
585 */
586 xmlNodePtr prev = baseptr;
587 char *href = NULL;
588 int inclcount = 0;
589 while (prev != NULL) {
590 if (prev->prev == NULL)
591 prev = prev->parent;
592 else {
593 prev = prev->prev;
594 if (prev->type == XML_XINCLUDE_START) {
595 if (inclcount > 0) {
596 --inclcount;
597 } else {
598 href = (char *) xmlGetProp(prev, BAD_CAST "href");
599 if (href != NULL)
600 break;
601 }
602 } else if (prev->type == XML_XINCLUDE_END)
603 inclcount++;
604 }
605 }
606 if (href != NULL)
607 to->file = href;
608 else
609 #endif
610 to->file = (char *) xmlStrdup(baseptr->doc->URL);
611 if ((to->file == NULL) && (node != NULL) && (node->doc != NULL)) {
612 to->file = (char *) xmlStrdup(node->doc->URL);
613 }
614 }
615 to->line = line;
616 if (str1 != NULL)
617 to->str1 = (char *) xmlStrdup((const xmlChar *) str1);
618 if (str2 != NULL)
619 to->str2 = (char *) xmlStrdup((const xmlChar *) str2);
620 if (str3 != NULL)
621 to->str3 = (char *) xmlStrdup((const xmlChar *) str3);
622 to->int1 = int1;
623 to->int2 = col;
624 to->node = node;
625 to->ctxt = ctx;
626
627 if (to != &xmlLastError)
628 xmlCopyError(to,&xmlLastError);
629
630 if (schannel != NULL) {
631 schannel(data, to);
632 return;
633 }
634
635 /*
636 * Find the callback channel if channel param is NULL
637 */
638 if ((ctxt != NULL) && (channel == NULL) &&
639 (xmlStructuredError == NULL) && (ctxt->sax != NULL)) {
640 if (level == XML_ERR_WARNING)
641 channel = ctxt->sax->warning;
642 else
643 channel = ctxt->sax->error;
644 data = ctxt->userData;
645 } else if (channel == NULL) {
646 channel = xmlGenericError;
647 if (ctxt != NULL) {
648 data = ctxt;
649 } else {
650 data = xmlGenericErrorContext;
651 }
652 }
653 if (channel == NULL)
654 return;
655
656 if ((channel == xmlParserError) ||
657 (channel == xmlParserWarning) ||
658 (channel == xmlParserValidityError) ||
659 (channel == xmlParserValidityWarning))
660 xmlReportError(to, ctxt, str, NULL, NULL);
661 else if (((void(*)(void)) channel == (void(*)(void)) fprintf) ||
662 (channel == xmlGenericErrorDefaultFunc))
663 xmlReportError(to, ctxt, str, channel, data);
664 else
665 channel(data, "%s", str);
666 }
667
668 /**
669 * __xmlSimpleError:
670 * @domain: where the error comes from
671 * @code: the error code
672 * @node: the context node
673 * @extra: extra information
674 *
675 * Handle an out of memory condition
676 */
677 void
678 __xmlSimpleError(int domain, int code, xmlNodePtr node,
679 const char *msg, const char *extra)
680 {
681
682 if (code == XML_ERR_NO_MEMORY) {
683 if (extra)
684 __xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
685 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
686 NULL, NULL, 0, 0,
687 "Memory allocation failed : %s\n", extra);
688 else
689 __xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
690 XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
691 NULL, NULL, 0, 0, "Memory allocation failed\n");
692 } else {
693 __xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
694 code, XML_ERR_ERROR, NULL, 0, extra,
695 NULL, NULL, 0, 0, msg, extra);
696 }
697 }
698 /**
699 * xmlParserError:
700 * @ctx: an XML parser context
701 * @msg: the message to display/transmit
702 * @...: extra parameters for the message display
703 *
704 * Display and format an error messages, gives file, line, position and
705 * extra parameters.
706 */
707 void
708 xmlParserError(void *ctx, const char *msg, ...)
709 {
710 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
711 xmlParserInputPtr input = NULL;
712 xmlParserInputPtr cur = NULL;
713 char * str;
714
715 if (ctxt != NULL) {
716 input = ctxt->input;
717 if ((input != NULL) && (input->filename == NULL) &&
718 (ctxt->inputNr > 1)) {
719 cur = input;
720 input = ctxt->inputTab[ctxt->inputNr - 2];
721 }
722 xmlParserPrintFileInfo(input);
723 }
724
725 xmlGenericError(xmlGenericErrorContext, "error: ");
726 XML_GET_VAR_STR(msg, str);
727 xmlGenericError(xmlGenericErrorContext, "%s", str);
728 if (str != NULL)
729 xmlFree(str);
730
731 if (ctxt != NULL) {
732 xmlParserPrintFileContext(input);
733 if (cur != NULL) {
734 xmlParserPrintFileInfo(cur);
735 xmlGenericError(xmlGenericErrorContext, "\n");
736 xmlParserPrintFileContext(cur);
737 }
738 }
739 }
740
741 /**
742 * xmlParserWarning:
743 * @ctx: an XML parser context
744 * @msg: the message to display/transmit
745 * @...: extra parameters for the message display
746 *
747 * Display and format a warning messages, gives file, line, position and
748 * extra parameters.
749 */
750 void
751 xmlParserWarning(void *ctx, const char *msg, ...)
752 {
753 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
754 xmlParserInputPtr input = NULL;
755 xmlParserInputPtr cur = NULL;
756 char * str;
757
758 if (ctxt != NULL) {
759 input = ctxt->input;
760 if ((input != NULL) && (input->filename == NULL) &&
761 (ctxt->inputNr > 1)) {
762 cur = input;
763 input = ctxt->inputTab[ctxt->inputNr - 2];
764 }
765 xmlParserPrintFileInfo(input);
766 }
767
768 xmlGenericError(xmlGenericErrorContext, "warning: ");
769 XML_GET_VAR_STR(msg, str);
770 xmlGenericError(xmlGenericErrorContext, "%s", str);
771 if (str != NULL)
772 xmlFree(str);
773
774 if (ctxt != NULL) {
775 xmlParserPrintFileContext(input);
776 if (cur != NULL) {
777 xmlParserPrintFileInfo(cur);
778 xmlGenericError(xmlGenericErrorContext, "\n");
779 xmlParserPrintFileContext(cur);
780 }
781 }
782 }
783
784 /************************************************************************
785 * *
786 * Handling of validation errors *
787 * *
788 ************************************************************************/
789
790 /**
791 * xmlParserValidityError:
792 * @ctx: an XML parser context
793 * @msg: the message to display/transmit
794 * @...: extra parameters for the message display
795 *
796 * Display and format an validity error messages, gives file,
797 * line, position and extra parameters.
798 */
799 void
800 xmlParserValidityError(void *ctx, const char *msg, ...)
801 {
802 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
803 xmlParserInputPtr input = NULL;
804 char * str;
805 int len = xmlStrlen((const xmlChar *) msg);
806 static int had_info = 0;
807
808 if ((len > 1) && (msg[len - 2] != ':')) {
809 if (ctxt != NULL) {
810 input = ctxt->input;
811 if ((input->filename == NULL) && (ctxt->inputNr > 1))
812 input = ctxt->inputTab[ctxt->inputNr - 2];
813
814 if (had_info == 0) {
815 xmlParserPrintFileInfo(input);
816 }
817 }
818 xmlGenericError(xmlGenericErrorContext, "validity error: ");
819 had_info = 0;
820 } else {
821 had_info = 1;
822 }
823
824 XML_GET_VAR_STR(msg, str);
825 xmlGenericError(xmlGenericErrorContext, "%s", str);
826 if (str != NULL)
827 xmlFree(str);
828
829 if ((ctxt != NULL) && (input != NULL)) {
830 xmlParserPrintFileContext(input);
831 }
832 }
833
834 /**
835 * xmlParserValidityWarning:
836 * @ctx: an XML parser context
837 * @msg: the message to display/transmit
838 * @...: extra parameters for the message display
839 *
840 * Display and format a validity warning messages, gives file, line,
841 * position and extra parameters.
842 */
843 void
844 xmlParserValidityWarning(void *ctx, const char *msg, ...)
845 {
846 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
847 xmlParserInputPtr input = NULL;
848 char * str;
849 int len = xmlStrlen((const xmlChar *) msg);
850
851 if ((ctxt != NULL) && (len != 0) && (msg[len - 1] != ':')) {
852 input = ctxt->input;
853 if ((input->filename == NULL) && (ctxt->inputNr > 1))
854 input = ctxt->inputTab[ctxt->inputNr - 2];
855
856 xmlParserPrintFileInfo(input);
857 }
858
859 xmlGenericError(xmlGenericErrorContext, "validity warning: ");
860 XML_GET_VAR_STR(msg, str);
861 xmlGenericError(xmlGenericErrorContext, "%s", str);
862 if (str != NULL)
863 xmlFree(str);
864
865 if (ctxt != NULL) {
866 xmlParserPrintFileContext(input);
867 }
868 }
869
870
871 /************************************************************************
872 * *
873 * Extended Error Handling *
874 * *
875 ************************************************************************/
876
877 /**
878 * xmlGetLastError:
879 *
880 * Get the last global error registered. This is per thread if compiled
881 * with thread support.
882 *
883 * Returns a pointer to the error
884 */
885 const xmlError *
886 xmlGetLastError(void)
887 {
888 if (xmlLastError.code == XML_ERR_OK)
889 return (NULL);
890 return (&xmlLastError);
891 }
892
893 /**
894 * xmlResetError:
895 * @err: pointer to the error.
896 *
897 * Cleanup the error.
898 */
899 void
900 xmlResetError(xmlErrorPtr err)
901 {
902 if (err == NULL)
903 return;
904 if (err->code == XML_ERR_OK)
905 return;
906 if (err->message != NULL)
907 xmlFree(err->message);
908 if (err->file != NULL)
909 xmlFree(err->file);
910 if (err->str1 != NULL)
911 xmlFree(err->str1);
912 if (err->str2 != NULL)
913 xmlFree(err->str2);
914 if (err->str3 != NULL)
915 xmlFree(err->str3);
916 memset(err, 0, sizeof(xmlError));
917 err->code = XML_ERR_OK;
918 }
919
920 /**
921 * xmlResetLastError:
922 *
923 * Cleanup the last global error registered. For parsing error
924 * this does not change the well-formedness result.
925 */
926 void
927 xmlResetLastError(void)
928 {
929 if (xmlLastError.code == XML_ERR_OK)
930 return;
931 xmlResetError(&xmlLastError);
932 }
933
934 /**
935 * xmlCtxtGetLastError:
936 * @ctx: an XML parser context
937 *
938 * Get the last parsing error registered.
939 *
940 * Returns NULL if no error occurred or a pointer to the error
941 */
942 const xmlError *
943 xmlCtxtGetLastError(void *ctx)
944 {
945 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
946
947 if (ctxt == NULL)
948 return (NULL);
949 if (ctxt->lastError.code == XML_ERR_OK)
950 return (NULL);
951 return (&ctxt->lastError);
952 }
953
954 /**
955 * xmlCtxtResetLastError:
956 * @ctx: an XML parser context
957 *
958 * Cleanup the last global error registered. For parsing error
959 * this does not change the well-formedness result.
960 */
961 void
962 xmlCtxtResetLastError(void *ctx)
963 {
964 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
965
966 if (ctxt == NULL)
967 return;
968 ctxt->errNo = XML_ERR_OK;
969 if (ctxt->lastError.code == XML_ERR_OK)
970 return;
971 xmlResetError(&ctxt->lastError);
972 }
973
974 /**
975 * xmlCopyError:
976 * @from: a source error
977 * @to: a target error
978 *
979 * Save the original error to the new place.
980 *
981 * Returns 0 in case of success and -1 in case of error.
982 */
983 int
984 xmlCopyError(const xmlError *from, xmlErrorPtr to) {
985 char *message, *file, *str1, *str2, *str3;
986
987 if ((from == NULL) || (to == NULL))
988 return(-1);
989
990 message = (char *) xmlStrdup((xmlChar *) from->message);
991 file = (char *) xmlStrdup ((xmlChar *) from->file);
992 str1 = (char *) xmlStrdup ((xmlChar *) from->str1);
993 str2 = (char *) xmlStrdup ((xmlChar *) from->str2);
994 str3 = (char *) xmlStrdup ((xmlChar *) from->str3);
995
996 if (to->message != NULL)
997 xmlFree(to->message);
998 if (to->file != NULL)
999 xmlFree(to->file);
1000 if (to->str1 != NULL)
1001 xmlFree(to->str1);
1002 if (to->str2 != NULL)
1003 xmlFree(to->str2);
1004 if (to->str3 != NULL)
1005 xmlFree(to->str3);
1006 to->domain = from->domain;
1007 to->code = from->code;
1008 to->level = from->level;
1009 to->line = from->line;
1010 to->node = from->node;
1011 to->int1 = from->int1;
1012 to->int2 = from->int2;
1013 to->node = from->node;
1014 to->ctxt = from->ctxt;
1015 to->message = message;
1016 to->file = file;
1017 to->str1 = str1;
1018 to->str2 = str2;
1019 to->str3 = str3;
1020
1021 return 0;
1022 }
1023