error.c@ 51271

Last change on this file since 51271 was 39921, checked in by vboxsync, 13 years ago
libxml-2.6.31 upstream fixes
Property svn:eol-style set to `native`
File size: 26.5 KB

Line
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
19	void 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 (1) { \
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	break; \
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	*/
70	void XMLCDECL
71	xmlGenericErrorDefaultFunc(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	*/
89	void
90	initGenericErrorDefaultFunc(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	*/
112	void
113	xmlSetGenericErrorFunc(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	*/
133	void
134	xmlSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) {
135	xmlGenericErrorContext = 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
152	void
153	xmlParserPrintFileInfo(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
172	static void
173	xmlParserPrintFileContextInternal(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	*/
227	void
228	xmlParserPrintFileContext(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	*/
242	static void
243	xmlReportError(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	*/
440	void 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 ((xmlGetWarningsDefaultValue == 0) && (level == XML_ERR_WARNING))
456	return;
457	if ((domain == XML_FROM_PARSER) \|\| (domain == XML_FROM_HTML) \|\|
458	(domain == XML_FROM_DTD) \|\| (domain == XML_FROM_NAMESPACE) \|\|
459	(domain == XML_FROM_IO) \|\| (domain == XML_FROM_VALID)) {
460	ctxt = (xmlParserCtxtPtr) ctx;
461	if ((schannel == NULL) && (ctxt != NULL) && (ctxt->sax != NULL) &&
462	(ctxt->sax->initialized == XML_SAX2_MAGIC))
463	schannel = ctxt->sax->serror;
464	}
465	/*
466	* Check if structured error handler set
467	*/
468	if (schannel == NULL) {
469	schannel = xmlStructuredError;
470	/*
471	* if user has defined handler, change data ptr to user's choice
472	*/
473	if (schannel != NULL)
474	data = xmlGenericErrorContext;
475	}
476	if ((domain == XML_FROM_VALID) &&
477	((channel == xmlParserValidityError) \|\|
478	(channel == xmlParserValidityWarning))) {
479	ctxt = (xmlParserCtxtPtr) ctx;
480	if ((schannel == NULL) && (ctxt != NULL) && (ctxt->sax != NULL) &&
481	(ctxt->sax->initialized == XML_SAX2_MAGIC))
482	schannel = ctxt->sax->serror;
483	}
484	if (code == XML_ERR_OK)
485	return;
486	/*
487	* Formatting the message
488	*/
489	if (msg == NULL) {
490	str = (char *) xmlStrdup(BAD_CAST "No error message provided");
491	} else {
492	XML_GET_VAR_STR(msg, str);
493	}
494
495	/*
496	* specific processing if a parser context is provided
497	*/
498	if (ctxt != NULL) {
499	if (file == NULL) {
500	input = ctxt->input;
501	if ((input != NULL) && (input->filename == NULL) &&
502	(ctxt->inputNr > 1)) {
503	input = ctxt->inputTab[ctxt->inputNr - 2];
504	}
505	if (input != NULL) {
506	file = input->filename;
507	line = input->line;
508	col = input->col;
509	}
510	}
511	to = &ctxt->lastError;
512	} else if ((node != NULL) && (file == NULL)) {
513	int i;
514
515	if ((node->doc != NULL) && (node->doc->URL != NULL)) {
516	baseptr = node;
517	/* file = (const char ) node->doc->URL; /
518	}
519	for (i = 0;
520	((i < 10) && (node != NULL) && (node->type != XML_ELEMENT_NODE));
521	i++)
522	node = node->parent;
523	if ((baseptr == NULL) && (node != NULL) &&
524	(node->doc != NULL) && (node->doc->URL != NULL))
525	baseptr = node;
526
527	if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
528	line = node->line;
529	}
530
531	/*
532	* Save the information about the error
533	*/
534	xmlResetError(to);
535	to->domain = domain;
536	to->code = code;
537	to->message = str;
538	to->level = level;
539	if (file != NULL)
540	to->file = (char ) xmlStrdup((const xmlChar ) file);
541	else if (baseptr != NULL) {
542	#ifdef LIBXML_XINCLUDE_ENABLED
543	/*
544	* We check if the error is within an XInclude section and,
545	* if so, attempt to print out the href of the XInclude instead
546	* of the usual "base" (doc->URL) for the node (bug 152623).
547	*/
548	xmlNodePtr prev = baseptr;
549	int inclcount = 0;
550	while (prev != NULL) {
551	if (prev->prev == NULL)
552	prev = prev->parent;
553	else {
554	prev = prev->prev;
555	if (prev->type == XML_XINCLUDE_START) {
556	if (--inclcount < 0)
557	break;
558	} else if (prev->type == XML_XINCLUDE_END)
559	inclcount++;
560	}
561	}
562	if (prev != NULL) {
563	if (prev->type == XML_XINCLUDE_START) {
564	prev->type = XML_ELEMENT_NODE;
565	to->file = (char *) xmlGetProp(prev, BAD_CAST "href");
566	prev->type = XML_XINCLUDE_START;
567	} else {
568	to->file = (char *) xmlGetProp(prev, BAD_CAST "href");
569	}
570	} else
571	#endif
572	to->file = (char *) xmlStrdup(baseptr->doc->URL);
573	if ((to->file == NULL) && (node != NULL) && (node->doc != NULL)) {
574	to->file = (char *) xmlStrdup(node->doc->URL);
575	}
576	file = to->file;
577	}
578	to->line = line;
579	if (str1 != NULL)
580	to->str1 = (char ) xmlStrdup((const xmlChar ) str1);
581	if (str2 != NULL)
582	to->str2 = (char ) xmlStrdup((const xmlChar ) str2);
583	if (str3 != NULL)
584	to->str3 = (char ) xmlStrdup((const xmlChar ) str3);
585	to->int1 = int1;
586	to->int2 = col;
587	to->node = node;
588	to->ctxt = ctx;
589
590	if (to != &xmlLastError)
591	xmlCopyError(to,&xmlLastError);
592
593	/*
594	* Find the callback channel if channel param is NULL
595	*/
596	if ((ctxt != NULL) && (channel == NULL) && (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	if (xmlStructuredError != NULL)
604	schannel = xmlStructuredError;
605	else
606	channel = xmlGenericError;
607	if (!data) {
608	data = xmlGenericErrorContext;
609	}
610	}
611	if (schannel != NULL) {
612	schannel(data, to);
613	return;
614	}
615	if (channel == NULL)
616	return;
617
618	if ((channel == xmlParserError) \|\|
619	(channel == xmlParserWarning) \|\|
620	(channel == xmlParserValidityError) \|\|
621	(channel == xmlParserValidityWarning))
622	xmlReportError(to, ctxt, str, NULL, NULL);
623	else if ((channel == (xmlGenericErrorFunc) fprintf) \|\|
624	(channel == xmlGenericErrorDefaultFunc))
625	xmlReportError(to, ctxt, str, channel, data);
626	else
627	channel(data, "%s", str);
628	}
629
630	/**
631	* __xmlSimpleError:
632	* @domain: where the error comes from
633	* @code: the error code
634	* @node: the context node
635	* @extra: extra informations
636	*
637	* Handle an out of memory condition
638	*/
639	void
640	__xmlSimpleError(int domain, int code, xmlNodePtr node,
641	const char msg, const char extra)
642	{
643
644	if (code == XML_ERR_NO_MEMORY) {
645	if (extra)
646	__xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
647	XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
648	NULL, NULL, 0, 0,
649	"Memory allocation failed : %s\n", extra);
650	else
651	__xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
652	XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
653	NULL, NULL, 0, 0, "Memory allocation failed\n");
654	} else {
655	__xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
656	code, XML_ERR_ERROR, NULL, 0, extra,
657	NULL, NULL, 0, 0, msg, extra);
658	}
659	}
660	/**
661	* xmlParserError:
662	* @ctx: an XML parser context
663	* @msg: the message to display/transmit
664	* @...: extra parameters for the message display
665	*
666	* Display and format an error messages, gives file, line, position and
667	* extra parameters.
668	*/
669	void XMLCDECL
670	xmlParserError(void ctx, const char msg, ...)
671	{
672	xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
673	xmlParserInputPtr input = NULL;
674	xmlParserInputPtr cur = NULL;
675	char * str;
676
677	if (ctxt != NULL) {
678	input = ctxt->input;
679	if ((input != NULL) && (input->filename == NULL) &&
680	(ctxt->inputNr > 1)) {
681	cur = input;
682	input = ctxt->inputTab[ctxt->inputNr - 2];
683	}
684	xmlParserPrintFileInfo(input);
685	}
686
687	xmlGenericError(xmlGenericErrorContext, "error: ");
688	XML_GET_VAR_STR(msg, str);
689	xmlGenericError(xmlGenericErrorContext, "%s", str);
690	if (str != NULL)
691	xmlFree(str);
692
693	if (ctxt != NULL) {
694	xmlParserPrintFileContext(input);
695	if (cur != NULL) {
696	xmlParserPrintFileInfo(cur);
697	xmlGenericError(xmlGenericErrorContext, "\n");
698	xmlParserPrintFileContext(cur);
699	}
700	}
701	}
702
703	/**
704	* xmlParserWarning:
705	* @ctx: an XML parser context
706	* @msg: the message to display/transmit
707	* @...: extra parameters for the message display
708	*
709	* Display and format a warning messages, gives file, line, position and
710	* extra parameters.
711	*/
712	void XMLCDECL
713	xmlParserWarning(void ctx, const char msg, ...)
714	{
715	xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
716	xmlParserInputPtr input = NULL;
717	xmlParserInputPtr cur = NULL;
718	char * str;
719
720	if (ctxt != NULL) {
721	input = ctxt->input;
722	if ((input != NULL) && (input->filename == NULL) &&
723	(ctxt->inputNr > 1)) {
724	cur = input;
725	input = ctxt->inputTab[ctxt->inputNr - 2];
726	}
727	xmlParserPrintFileInfo(input);
728	}
729
730	xmlGenericError(xmlGenericErrorContext, "warning: ");
731	XML_GET_VAR_STR(msg, str);
732	xmlGenericError(xmlGenericErrorContext, "%s", str);
733	if (str != NULL)
734	xmlFree(str);
735
736	if (ctxt != NULL) {
737	xmlParserPrintFileContext(input);
738	if (cur != NULL) {
739	xmlParserPrintFileInfo(cur);
740	xmlGenericError(xmlGenericErrorContext, "\n");
741	xmlParserPrintFileContext(cur);
742	}
743	}
744	}
745
746	/************************************************************************
747	* *
748	* Handling of validation errors *
749	* *
750	************************************************************************/
751
752	/**
753	* xmlParserValidityError:
754	* @ctx: an XML parser context
755	* @msg: the message to display/transmit
756	* @...: extra parameters for the message display
757	*
758	* Display and format an validity error messages, gives file,
759	* line, position and extra parameters.
760	*/
761	void XMLCDECL
762	xmlParserValidityError(void ctx, const char msg, ...)
763	{
764	xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
765	xmlParserInputPtr input = NULL;
766	char * str;
767	int len = xmlStrlen((const xmlChar *) msg);
768	static int had_info = 0;
769
770	if ((len > 1) && (msg[len - 2] != ':')) {
771	if (ctxt != NULL) {
772	input = ctxt->input;
773	if ((input->filename == NULL) && (ctxt->inputNr > 1))
774	input = ctxt->inputTab[ctxt->inputNr - 2];
775
776	if (had_info == 0) {
777	xmlParserPrintFileInfo(input);
778	}
779	}
780	xmlGenericError(xmlGenericErrorContext, "validity error: ");
781	had_info = 0;
782	} else {
783	had_info = 1;
784	}
785
786	XML_GET_VAR_STR(msg, str);
787	xmlGenericError(xmlGenericErrorContext, "%s", str);
788	if (str != NULL)
789	xmlFree(str);
790
791	if ((ctxt != NULL) && (input != NULL)) {
792	xmlParserPrintFileContext(input);
793	}
794	}
795
796	/**
797	* xmlParserValidityWarning:
798	* @ctx: an XML parser context
799	* @msg: the message to display/transmit
800	* @...: extra parameters for the message display
801	*
802	* Display and format a validity warning messages, gives file, line,
803	* position and extra parameters.
804	*/
805	void XMLCDECL
806	xmlParserValidityWarning(void ctx, const char msg, ...)
807	{
808	xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
809	xmlParserInputPtr input = NULL;
810	char * str;
811	int len = xmlStrlen((const xmlChar *) msg);
812
813	if ((ctxt != NULL) && (len != 0) && (msg[len - 1] != ':')) {
814	input = ctxt->input;
815	if ((input->filename == NULL) && (ctxt->inputNr > 1))
816	input = ctxt->inputTab[ctxt->inputNr - 2];
817
818	xmlParserPrintFileInfo(input);
819	}
820
821	xmlGenericError(xmlGenericErrorContext, "validity warning: ");
822	XML_GET_VAR_STR(msg, str);
823	xmlGenericError(xmlGenericErrorContext, "%s", str);
824	if (str != NULL)
825	xmlFree(str);
826
827	if (ctxt != NULL) {
828	xmlParserPrintFileContext(input);
829	}
830	}
831
832
833	/************************************************************************
834	* *
835	* Extended Error Handling *
836	* *
837	************************************************************************/
838
839	/**
840	* xmlGetLastError:
841	*
842	* Get the last global error registered. This is per thread if compiled
843	* with thread support.
844	*
845	* Returns NULL if no error occured or a pointer to the error
846	*/
847	xmlErrorPtr
848	xmlGetLastError(void)
849	{
850	if (xmlLastError.code == XML_ERR_OK)
851	return (NULL);
852	return (&xmlLastError);
853	}
854
855	/**
856	* xmlResetError:
857	* @err: pointer to the error.
858	*
859	* Cleanup the error.
860	*/
861	void
862	xmlResetError(xmlErrorPtr err)
863	{
864	if (err == NULL)
865	return;
866	if (err->code == XML_ERR_OK)
867	return;
868	if (err->message != NULL)
869	xmlFree(err->message);
870	if (err->file != NULL)
871	xmlFree(err->file);
872	if (err->str1 != NULL)
873	xmlFree(err->str1);
874	if (err->str2 != NULL)
875	xmlFree(err->str2);
876	if (err->str3 != NULL)
877	xmlFree(err->str3);
878	memset(err, 0, sizeof(xmlError));
879	err->code = XML_ERR_OK;
880	}
881
882	/**
883	* xmlResetLastError:
884	*
885	* Cleanup the last global error registered. For parsing error
886	* this does not change the well-formedness result.
887	*/
888	void
889	xmlResetLastError(void)
890	{
891	if (xmlLastError.code == XML_ERR_OK)
892	return;
893	xmlResetError(&xmlLastError);
894	}
895
896	/**
897	* xmlCtxtGetLastError:
898	* @ctx: an XML parser context
899	*
900	* Get the last parsing error registered.
901	*
902	* Returns NULL if no error occured or a pointer to the error
903	*/
904	xmlErrorPtr
905	xmlCtxtGetLastError(void *ctx)
906	{
907	xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
908
909	if (ctxt == NULL)
910	return (NULL);
911	if (ctxt->lastError.code == XML_ERR_OK)
912	return (NULL);
913	return (&ctxt->lastError);
914	}
915
916	/**
917	* xmlCtxtResetLastError:
918	* @ctx: an XML parser context
919	*
920	* Cleanup the last global error registered. For parsing error
921	* this does not change the well-formedness result.
922	*/
923	void
924	xmlCtxtResetLastError(void *ctx)
925	{
926	xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
927
928	if (ctxt == NULL)
929	return;
930	if (ctxt->lastError.code == XML_ERR_OK)
931	return;
932	xmlResetError(&ctxt->lastError);
933	}
934
935	/**
936	* xmlCopyError:
937	* @from: a source error
938	* @to: a target error
939	*
940	* Save the original error to the new place.
941	*
942	* Returns 0 in case of success and -1 in case of error.
943	*/
944	int
945	xmlCopyError(xmlErrorPtr from, xmlErrorPtr to) {
946	char message, file, str1, str2, *str3;
947
948	if ((from == NULL) \|\| (to == NULL))
949	return(-1);
950
951	message = (char ) xmlStrdup((xmlChar ) from->message);
952	file = (char ) xmlStrdup ((xmlChar ) from->file);
953	str1 = (char ) xmlStrdup ((xmlChar ) from->str1);
954	str2 = (char ) xmlStrdup ((xmlChar ) from->str2);
955	str3 = (char ) xmlStrdup ((xmlChar ) from->str3);
956
957	if (to->message != NULL)
958	xmlFree(to->message);
959	if (to->file != NULL)
960	xmlFree(to->file);
961	if (to->str1 != NULL)
962	xmlFree(to->str1);
963	if (to->str2 != NULL)
964	xmlFree(to->str2);
965	if (to->str3 != NULL)
966	xmlFree(to->str3);
967	to->domain = from->domain;
968	to->code = from->code;
969	to->level = from->level;
970	to->line = from->line;
971	to->node = from->node;
972	to->int1 = from->int1;
973	to->int2 = from->int2;
974	to->node = from->node;
975	to->ctxt = from->ctxt;
976	to->message = message;
977	to->file = file;
978	to->str1 = str1;
979	to->str2 = str2;
980	to->str3 = str3;
981
982	return 0;
983	}
984
985	#define bottom_error
986	#include "elfgcchack.h"

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libxml2-2.6.31/error.c@ 51271

Download in other formats: