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