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 (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) 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) &&
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: */
452: void 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: */
648: void
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: */
678: void XMLCDECL
679: xmlParserError(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: */
721: void XMLCDECL
722: xmlParserWarning(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: */
770: void XMLCDECL
771: xmlParserValidityError(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: */
814: void XMLCDECL
815: xmlParserValidityWarning(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: */
856: xmlErrorPtr
857: xmlGetLastError(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: */
870: void
871: xmlResetError(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: */
897: void
898: xmlResetLastError(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: */
913: xmlErrorPtr
914: xmlCtxtGetLastError(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: */
932: void
933: xmlCtxtResetLastError(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: */
954: int
955: xmlCopyError(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"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to error.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2