PageRenderTime 85ms CodeModel.GetById 7ms app.highlight 71ms RepoModel.GetById 1ms app.codeStats 0ms

/error.c

https://bitbucket.org/vaporoid/libxml2
C | 996 lines | 682 code | 71 blank | 243 comment | 341 complexity | 00ccd7999f590786183ffe1ee5762d5f MD5 | raw file
  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) &&
296	         ((domain == XML_FROM_PARSER) || (domain == XML_FROM_SCHEMASV)||
297		  (domain == XML_FROM_SCHEMASP)||(domain == XML_FROM_DTD) ||
298		  (domain == XML_FROM_RELAXNGP)||(domain == XML_FROM_RELAXNGV)))
299            channel(data, "Entity: line %d: ", line);
300    }
301    if (name != NULL) {
302        channel(data, "element %s: ", name);
303    }
304    switch (domain) {
305        case XML_FROM_PARSER:
306            channel(data, "parser ");
307            break;
308        case XML_FROM_NAMESPACE:
309            channel(data, "namespace ");
310            break;
311        case XML_FROM_DTD:
312        case XML_FROM_VALID:
313            channel(data, "validity ");
314            break;
315        case XML_FROM_HTML:
316            channel(data, "HTML parser ");
317            break;
318        case XML_FROM_MEMORY:
319            channel(data, "memory ");
320            break;
321        case XML_FROM_OUTPUT:
322            channel(data, "output ");
323            break;
324        case XML_FROM_IO:
325            channel(data, "I/O ");
326            break;
327        case XML_FROM_XINCLUDE:
328            channel(data, "XInclude ");
329            break;
330        case XML_FROM_XPATH:
331            channel(data, "XPath ");
332            break;
333        case XML_FROM_XPOINTER:
334            channel(data, "parser ");
335            break;
336        case XML_FROM_REGEXP:
337            channel(data, "regexp ");
338            break;
339        case XML_FROM_MODULE:
340            channel(data, "module ");
341            break;
342        case XML_FROM_SCHEMASV:
343            channel(data, "Schemas validity ");
344            break;
345        case XML_FROM_SCHEMASP:
346            channel(data, "Schemas parser ");
347            break;
348        case XML_FROM_RELAXNGP:
349            channel(data, "Relax-NG parser ");
350            break;
351        case XML_FROM_RELAXNGV:
352            channel(data, "Relax-NG validity ");
353            break;
354        case XML_FROM_CATALOG:
355            channel(data, "Catalog ");
356            break;
357        case XML_FROM_C14N:
358            channel(data, "C14N ");
359            break;
360        case XML_FROM_XSLT:
361            channel(data, "XSLT ");
362            break;
363        case XML_FROM_I18N:
364            channel(data, "encoding ");
365            break;
366        case XML_FROM_SCHEMATRONV:
367            channel(data, "schematron ");
368            break;
369        case XML_FROM_BUFFER:
370            channel(data, "internal buffer ");
371            break;
372        case XML_FROM_URI:
373            channel(data, "URI ");
374            break;
375        default:
376            break;
377    }
378    switch (level) {
379        case XML_ERR_NONE:
380            channel(data, ": ");
381            break;
382        case XML_ERR_WARNING:
383            channel(data, "warning : ");
384            break;
385        case XML_ERR_ERROR:
386            channel(data, "error : ");
387            break;
388        case XML_ERR_FATAL:
389            channel(data, "error : ");
390            break;
391    }
392    if (str != NULL) {
393        int len;
394	len = xmlStrlen((const xmlChar *)str);
395	if ((len > 0) && (str[len - 1] != '\n'))
396	    channel(data, "%s\n", str);
397	else
398	    channel(data, "%s", str);
399    } else {
400        channel(data, "%s\n", "out of memory error");
401    }
402
403    if (ctxt != NULL) {
404        xmlParserPrintFileContextInternal(input, channel, data);
405        if (cur != NULL) {
406            if (cur->filename)
407                channel(data, "%s:%d: \n", cur->filename, cur->line);
408            else if ((line != 0) && (domain == XML_FROM_PARSER))
409                channel(data, "Entity: line %d: \n", cur->line);
410            xmlParserPrintFileContextInternal(cur, channel, data);
411        }
412    }
413    if ((domain == XML_FROM_XPATH) && (err->str1 != NULL) &&
414        (err->int1 < 100) &&
415	(err->int1 < xmlStrlen((const xmlChar *)err->str1))) {
416	xmlChar buf[150];
417	int i;
418
419	channel(data, "%s\n", err->str1);
420	for (i=0;i < err->int1;i++)
421	     buf[i] = ' ';
422	buf[i++] = '^';
423	buf[i] = 0;
424	channel(data, "%s\n", buf);
425    }
426}
427
428/**
429 * __xmlRaiseError:
430 * @schannel: the structured callback channel
431 * @channel: the old callback channel
432 * @data: the callback data
433 * @ctx: the parser context or NULL
434 * @ctx: the parser context or NULL
435 * @domain: the domain for the error
436 * @code: the code for the error
437 * @level: the xmlErrorLevel for the error
438 * @file: the file source of the error (or NULL)
439 * @line: the line of the error or 0 if N/A
440 * @str1: extra string info
441 * @str2: extra string info
442 * @str3: extra string info
443 * @int1: extra int info
444 * @col: column number of the error or 0 if N/A
445 * @msg:  the message to display/transmit
446 * @...:  extra parameters for the message display
447 *
448 * Update the appropriate global or contextual error structure,
449 * then forward the error message down the parser or generic
450 * error callback handler
451 */
452void XMLCDECL
453__xmlRaiseError(xmlStructuredErrorFunc schannel,
454              xmlGenericErrorFunc channel, void *data, void *ctx,
455              void *nod, int domain, int code, xmlErrorLevel level,
456              const char *file, int line, const char *str1,
457              const char *str2, const char *str3, int int1, int col,
458	      const char *msg, ...)
459{
460    xmlParserCtxtPtr ctxt = NULL;
461    xmlNodePtr node = (xmlNodePtr) nod;
462    char *str = NULL;
463    xmlParserInputPtr input = NULL;
464    xmlErrorPtr to = &xmlLastError;
465    xmlNodePtr baseptr = NULL;
466
467    if (code == XML_ERR_OK)
468        return;
469    if ((xmlGetWarningsDefaultValue == 0) && (level == XML_ERR_WARNING))
470        return;
471    if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
472        (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
473	(domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) {
474	ctxt = (xmlParserCtxtPtr) ctx;
475	if ((schannel == NULL) && (ctxt != NULL) && (ctxt->sax != NULL) &&
476	    (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
477	    (ctxt->sax->serror != NULL)) {
478	    schannel = ctxt->sax->serror;
479	    data = ctxt->userData;
480	}
481    }
482    /*
483     * Check if structured error handler set
484     */
485    if (schannel == NULL) {
486	schannel = xmlStructuredError;
487	/*
488	 * if user has defined handler, change data ptr to user's choice
489	 */
490	if (schannel != NULL)
491	    data = xmlStructuredErrorContext;
492    }
493    /*
494     * Formatting the message
495     */
496    if (msg == NULL) {
497        str = (char *) xmlStrdup(BAD_CAST "No error message provided");
498    } else {
499        XML_GET_VAR_STR(msg, str);
500    }
501
502    /*
503     * specific processing if a parser context is provided
504     */
505    if (ctxt != NULL) {
506        if (file == NULL) {
507            input = ctxt->input;
508            if ((input != NULL) && (input->filename == NULL) &&
509                (ctxt->inputNr > 1)) {
510                input = ctxt->inputTab[ctxt->inputNr - 2];
511            }
512            if (input != NULL) {
513                file = input->filename;
514                line = input->line;
515                col = input->col;
516            }
517        }
518        to = &ctxt->lastError;
519    } else if ((node != NULL) && (file == NULL)) {
520	int i;
521
522	if ((node->doc != NULL) && (node->doc->URL != NULL)) {
523	    baseptr = node;
524/*	    file = (const char *) node->doc->URL; */
525	}
526	for (i = 0;
527	     ((i < 10) && (node != NULL) && (node->type != XML_ELEMENT_NODE));
528	     i++)
529	     node = node->parent;
530        if ((baseptr == NULL) && (node != NULL) &&
531	    (node->doc != NULL) && (node->doc->URL != NULL))
532	    baseptr = node;
533
534	if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
535	    line = node->line;
536	if ((line == 0) || (line == 65535))
537	    line = xmlGetLineNo(node);
538    }
539
540    /*
541     * Save the information about the error
542     */
543    xmlResetError(to);
544    to->domain = domain;
545    to->code = code;
546    to->message = str;
547    to->level = level;
548    if (file != NULL)
549        to->file = (char *) xmlStrdup((const xmlChar *) file);
550    else if (baseptr != NULL) {
551#ifdef LIBXML_XINCLUDE_ENABLED
552	/*
553	 * We check if the error is within an XInclude section and,
554	 * if so, attempt to print out the href of the XInclude instead
555	 * of the usual "base" (doc->URL) for the node (bug 152623).
556	 */
557        xmlNodePtr prev = baseptr;
558	int inclcount = 0;
559	while (prev != NULL) {
560	    if (prev->prev == NULL)
561	        prev = prev->parent;
562	    else {
563	        prev = prev->prev;
564		if (prev->type == XML_XINCLUDE_START) {
565		    if (--inclcount < 0)
566		        break;
567		} else if (prev->type == XML_XINCLUDE_END)
568		    inclcount++;
569	    }
570	}
571	if (prev != NULL) {
572	    if (prev->type == XML_XINCLUDE_START) {
573		prev->type = XML_ELEMENT_NODE;
574		to->file = (char *) xmlGetProp(prev, BAD_CAST "href");
575		prev->type = XML_XINCLUDE_START;
576	    } else {
577		to->file = (char *) xmlGetProp(prev, BAD_CAST "href");
578	    }
579	} else
580#endif
581	    to->file = (char *) xmlStrdup(baseptr->doc->URL);
582	if ((to->file == NULL) && (node != NULL) && (node->doc != NULL)) {
583	    to->file = (char *) xmlStrdup(node->doc->URL);
584	}
585    }
586    to->line = line;
587    if (str1 != NULL)
588        to->str1 = (char *) xmlStrdup((const xmlChar *) str1);
589    if (str2 != NULL)
590        to->str2 = (char *) xmlStrdup((const xmlChar *) str2);
591    if (str3 != NULL)
592        to->str3 = (char *) xmlStrdup((const xmlChar *) str3);
593    to->int1 = int1;
594    to->int2 = col;
595    to->node = node;
596    to->ctxt = ctx;
597
598    if (to != &xmlLastError)
599        xmlCopyError(to,&xmlLastError);
600
601    if (schannel != NULL) {
602	schannel(data, to);
603	return;
604    }
605
606    /*
607     * Find the callback channel if channel param is NULL
608     */
609    if ((ctxt != NULL) && (channel == NULL) &&
610        (xmlStructuredError == NULL) && (ctxt->sax != NULL)) {
611        if (level == XML_ERR_WARNING)
612	    channel = ctxt->sax->warning;
613        else
614	    channel = ctxt->sax->error;
615	data = ctxt->userData;
616    } else if (channel == NULL) {
617	channel = xmlGenericError;
618	if (ctxt != NULL) {
619	    data = ctxt;
620	} else {
621	    data = xmlGenericErrorContext;
622	}
623    }
624    if (channel == NULL)
625        return;
626
627    if ((channel == xmlParserError) ||
628        (channel == xmlParserWarning) ||
629	(channel == xmlParserValidityError) ||
630	(channel == xmlParserValidityWarning))
631	xmlReportError(to, ctxt, str, NULL, NULL);
632    else if ((channel == (xmlGenericErrorFunc) fprintf) ||
633             (channel == xmlGenericErrorDefaultFunc))
634	xmlReportError(to, ctxt, str, channel, data);
635    else
636	channel(data, "%s", str);
637}
638
639/**
640 * __xmlSimpleError:
641 * @domain: where the error comes from
642 * @code: the error code
643 * @node: the context node
644 * @extra:  extra informations
645 *
646 * Handle an out of memory condition
647 */
648void
649__xmlSimpleError(int domain, int code, xmlNodePtr node,
650                 const char *msg, const char *extra)
651{
652
653    if (code == XML_ERR_NO_MEMORY) {
654	if (extra)
655	    __xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
656			    XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
657			    NULL, NULL, 0, 0,
658			    "Memory allocation failed : %s\n", extra);
659	else
660	    __xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
661			    XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
662			    NULL, NULL, 0, 0, "Memory allocation failed\n");
663    } else {
664	__xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
665			code, XML_ERR_ERROR, NULL, 0, extra,
666			NULL, NULL, 0, 0, msg, extra);
667    }
668}
669/**
670 * xmlParserError:
671 * @ctx:  an XML parser context
672 * @msg:  the message to display/transmit
673 * @...:  extra parameters for the message display
674 *
675 * Display and format an error messages, gives file, line, position and
676 * extra parameters.
677 */
678void XMLCDECL
679xmlParserError(void *ctx, const char *msg, ...)
680{
681    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
682    xmlParserInputPtr input = NULL;
683    xmlParserInputPtr cur = NULL;
684    char * str;
685
686    if (ctxt != NULL) {
687	input = ctxt->input;
688	if ((input != NULL) && (input->filename == NULL) &&
689	    (ctxt->inputNr > 1)) {
690	    cur = input;
691	    input = ctxt->inputTab[ctxt->inputNr - 2];
692	}
693	xmlParserPrintFileInfo(input);
694    }
695
696    xmlGenericError(xmlGenericErrorContext, "error: ");
697    XML_GET_VAR_STR(msg, str);
698    xmlGenericError(xmlGenericErrorContext, "%s", str);
699    if (str != NULL)
700	xmlFree(str);
701
702    if (ctxt != NULL) {
703	xmlParserPrintFileContext(input);
704	if (cur != NULL) {
705	    xmlParserPrintFileInfo(cur);
706	    xmlGenericError(xmlGenericErrorContext, "\n");
707	    xmlParserPrintFileContext(cur);
708	}
709    }
710}
711
712/**
713 * xmlParserWarning:
714 * @ctx:  an XML parser context
715 * @msg:  the message to display/transmit
716 * @...:  extra parameters for the message display
717 *
718 * Display and format a warning messages, gives file, line, position and
719 * extra parameters.
720 */
721void XMLCDECL
722xmlParserWarning(void *ctx, const char *msg, ...)
723{
724    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
725    xmlParserInputPtr input = NULL;
726    xmlParserInputPtr cur = NULL;
727    char * str;
728
729    if (ctxt != NULL) {
730	input = ctxt->input;
731	if ((input != NULL) && (input->filename == NULL) &&
732	    (ctxt->inputNr > 1)) {
733	    cur = input;
734	    input = ctxt->inputTab[ctxt->inputNr - 2];
735	}
736	xmlParserPrintFileInfo(input);
737    }
738
739    xmlGenericError(xmlGenericErrorContext, "warning: ");
740    XML_GET_VAR_STR(msg, str);
741    xmlGenericError(xmlGenericErrorContext, "%s", str);
742    if (str != NULL)
743	xmlFree(str);
744
745    if (ctxt != NULL) {
746	xmlParserPrintFileContext(input);
747	if (cur != NULL) {
748	    xmlParserPrintFileInfo(cur);
749	    xmlGenericError(xmlGenericErrorContext, "\n");
750	    xmlParserPrintFileContext(cur);
751	}
752    }
753}
754
755/************************************************************************
756 *									*
757 *			Handling of validation errors			*
758 *									*
759 ************************************************************************/
760
761/**
762 * xmlParserValidityError:
763 * @ctx:  an XML parser context
764 * @msg:  the message to display/transmit
765 * @...:  extra parameters for the message display
766 *
767 * Display and format an validity error messages, gives file,
768 * line, position and extra parameters.
769 */
770void XMLCDECL
771xmlParserValidityError(void *ctx, const char *msg, ...)
772{
773    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
774    xmlParserInputPtr input = NULL;
775    char * str;
776    int len = xmlStrlen((const xmlChar *) msg);
777    static int had_info = 0;
778
779    if ((len > 1) && (msg[len - 2] != ':')) {
780	if (ctxt != NULL) {
781	    input = ctxt->input;
782	    if ((input->filename == NULL) && (ctxt->inputNr > 1))
783		input = ctxt->inputTab[ctxt->inputNr - 2];
784
785	    if (had_info == 0) {
786		xmlParserPrintFileInfo(input);
787	    }
788	}
789	xmlGenericError(xmlGenericErrorContext, "validity error: ");
790	had_info = 0;
791    } else {
792	had_info = 1;
793    }
794
795    XML_GET_VAR_STR(msg, str);
796    xmlGenericError(xmlGenericErrorContext, "%s", str);
797    if (str != NULL)
798	xmlFree(str);
799
800    if ((ctxt != NULL) && (input != NULL)) {
801	xmlParserPrintFileContext(input);
802    }
803}
804
805/**
806 * xmlParserValidityWarning:
807 * @ctx:  an XML parser context
808 * @msg:  the message to display/transmit
809 * @...:  extra parameters for the message display
810 *
811 * Display and format a validity warning messages, gives file, line,
812 * position and extra parameters.
813 */
814void XMLCDECL
815xmlParserValidityWarning(void *ctx, const char *msg, ...)
816{
817    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
818    xmlParserInputPtr input = NULL;
819    char * str;
820    int len = xmlStrlen((const xmlChar *) msg);
821
822    if ((ctxt != NULL) && (len != 0) && (msg[len - 1] != ':')) {
823	input = ctxt->input;
824	if ((input->filename == NULL) && (ctxt->inputNr > 1))
825	    input = ctxt->inputTab[ctxt->inputNr - 2];
826
827	xmlParserPrintFileInfo(input);
828    }
829
830    xmlGenericError(xmlGenericErrorContext, "validity warning: ");
831    XML_GET_VAR_STR(msg, str);
832    xmlGenericError(xmlGenericErrorContext, "%s", str);
833    if (str != NULL)
834	xmlFree(str);
835
836    if (ctxt != NULL) {
837	xmlParserPrintFileContext(input);
838    }
839}
840
841
842/************************************************************************
843 *									*
844 *			Extended Error Handling				*
845 *									*
846 ************************************************************************/
847
848/**
849 * xmlGetLastError:
850 *
851 * Get the last global error registered. This is per thread if compiled
852 * with thread support.
853 *
854 * Returns NULL if no error occured or a pointer to the error
855 */
856xmlErrorPtr
857xmlGetLastError(void)
858{
859    if (xmlLastError.code == XML_ERR_OK)
860        return (NULL);
861    return (&xmlLastError);
862}
863
864/**
865 * xmlResetError:
866 * @err: pointer to the error.
867 *
868 * Cleanup the error.
869 */
870void
871xmlResetError(xmlErrorPtr err)
872{
873    if (err == NULL)
874        return;
875    if (err->code == XML_ERR_OK)
876        return;
877    if (err->message != NULL)
878        xmlFree(err->message);
879    if (err->file != NULL)
880        xmlFree(err->file);
881    if (err->str1 != NULL)
882        xmlFree(err->str1);
883    if (err->str2 != NULL)
884        xmlFree(err->str2);
885    if (err->str3 != NULL)
886        xmlFree(err->str3);
887    memset(err, 0, sizeof(xmlError));
888    err->code = XML_ERR_OK;
889}
890
891/**
892 * xmlResetLastError:
893 *
894 * Cleanup the last global error registered. For parsing error
895 * this does not change the well-formedness result.
896 */
897void
898xmlResetLastError(void)
899{
900    if (xmlLastError.code == XML_ERR_OK)
901        return;
902    xmlResetError(&xmlLastError);
903}
904
905/**
906 * xmlCtxtGetLastError:
907 * @ctx:  an XML parser context
908 *
909 * Get the last parsing error registered.
910 *
911 * Returns NULL if no error occured or a pointer to the error
912 */
913xmlErrorPtr
914xmlCtxtGetLastError(void *ctx)
915{
916    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
917
918    if (ctxt == NULL)
919        return (NULL);
920    if (ctxt->lastError.code == XML_ERR_OK)
921        return (NULL);
922    return (&ctxt->lastError);
923}
924
925/**
926 * xmlCtxtResetLastError:
927 * @ctx:  an XML parser context
928 *
929 * Cleanup the last global error registered. For parsing error
930 * this does not change the well-formedness result.
931 */
932void
933xmlCtxtResetLastError(void *ctx)
934{
935    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
936
937    if (ctxt == NULL)
938        return;
939    ctxt->errNo = XML_ERR_OK;
940    if (ctxt->lastError.code == XML_ERR_OK)
941        return;
942    xmlResetError(&ctxt->lastError);
943}
944
945/**
946 * xmlCopyError:
947 * @from:  a source error
948 * @to:  a target error
949 *
950 * Save the original error to the new place.
951 *
952 * Returns 0 in case of success and -1 in case of error.
953 */
954int
955xmlCopyError(xmlErrorPtr from, xmlErrorPtr to) {
956    char *message, *file, *str1, *str2, *str3;
957
958    if ((from == NULL) || (to == NULL))
959        return(-1);
960
961    message = (char *) xmlStrdup((xmlChar *) from->message);
962    file = (char *) xmlStrdup ((xmlChar *) from->file);
963    str1 = (char *) xmlStrdup ((xmlChar *) from->str1);
964    str2 = (char *) xmlStrdup ((xmlChar *) from->str2);
965    str3 = (char *) xmlStrdup ((xmlChar *) from->str3);
966
967    if (to->message != NULL)
968        xmlFree(to->message);
969    if (to->file != NULL)
970        xmlFree(to->file);
971    if (to->str1 != NULL)
972        xmlFree(to->str1);
973    if (to->str2 != NULL)
974        xmlFree(to->str2);
975    if (to->str3 != NULL)
976        xmlFree(to->str3);
977    to->domain = from->domain;
978    to->code = from->code;
979    to->level = from->level;
980    to->line = from->line;
981    to->node = from->node;
982    to->int1 = from->int1;
983    to->int2 = from->int2;
984    to->node = from->node;
985    to->ctxt = from->ctxt;
986    to->message = message;
987    to->file = file;
988    to->str1 = str1;
989    to->str2 = str2;
990    to->str3 = str3;
991
992    return 0;
993}
994
995#define bottom_error
996#include "elfgcchack.h"