error.c@ 74148

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

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

source: vbox/trunk/src/libs/libxml2-2.9.4/error.c@ 74148

Download in other formats: