Annotation of embedaddon/libxml2/error.c, revision 1.1.1.1
1.1 misho 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) && (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 = xmlStructuredErrorContext;
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: }
577: to->line = line;
578: if (str1 != NULL)
579: to->str1 = (char *) xmlStrdup((const xmlChar *) str1);
580: if (str2 != NULL)
581: to->str2 = (char *) xmlStrdup((const xmlChar *) str2);
582: if (str3 != NULL)
583: to->str3 = (char *) xmlStrdup((const xmlChar *) str3);
584: to->int1 = int1;
585: to->int2 = col;
586: to->node = node;
587: to->ctxt = ctx;
588:
589: if (to != &xmlLastError)
590: xmlCopyError(to,&xmlLastError);
591:
592: /*
593: * Find the callback channel if channel param is NULL
594: */
595: if ((ctxt != NULL) && (channel == NULL) &&
596: (xmlStructuredError == NULL) && (ctxt->sax != NULL)) {
597: if (level == XML_ERR_WARNING)
598: channel = ctxt->sax->warning;
599: else
600: channel = ctxt->sax->error;
601: data = ctxt->userData;
602: } else if (channel == NULL) {
603: if ((schannel == NULL) && (xmlStructuredError != NULL)) {
604: schannel = xmlStructuredError;
605: data = xmlStructuredErrorContext;
606: } else {
607: channel = xmlGenericError;
608: if (!data) {
609: data = xmlGenericErrorContext;
610: }
611: }
612: }
613: if (schannel != NULL) {
614: schannel(data, to);
615: return;
616: }
617: if (channel == NULL)
618: return;
619:
620: if ((channel == xmlParserError) ||
621: (channel == xmlParserWarning) ||
622: (channel == xmlParserValidityError) ||
623: (channel == xmlParserValidityWarning))
624: xmlReportError(to, ctxt, str, NULL, NULL);
625: else if ((channel == (xmlGenericErrorFunc) fprintf) ||
626: (channel == xmlGenericErrorDefaultFunc))
627: xmlReportError(to, ctxt, str, channel, data);
628: else
629: channel(data, "%s", str);
630: }
631:
632: /**
633: * __xmlSimpleError:
634: * @domain: where the error comes from
635: * @code: the error code
636: * @node: the context node
637: * @extra: extra informations
638: *
639: * Handle an out of memory condition
640: */
641: void
642: __xmlSimpleError(int domain, int code, xmlNodePtr node,
643: const char *msg, const char *extra)
644: {
645:
646: if (code == XML_ERR_NO_MEMORY) {
647: if (extra)
648: __xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
649: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
650: NULL, NULL, 0, 0,
651: "Memory allocation failed : %s\n", extra);
652: else
653: __xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
654: XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL,
655: NULL, NULL, 0, 0, "Memory allocation failed\n");
656: } else {
657: __xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
658: code, XML_ERR_ERROR, NULL, 0, extra,
659: NULL, NULL, 0, 0, msg, extra);
660: }
661: }
662: /**
663: * xmlParserError:
664: * @ctx: an XML parser context
665: * @msg: the message to display/transmit
666: * @...: extra parameters for the message display
667: *
668: * Display and format an error messages, gives file, line, position and
669: * extra parameters.
670: */
671: void XMLCDECL
672: xmlParserError(void *ctx, const char *msg, ...)
673: {
674: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
675: xmlParserInputPtr input = NULL;
676: xmlParserInputPtr cur = NULL;
677: char * str;
678:
679: if (ctxt != NULL) {
680: input = ctxt->input;
681: if ((input != NULL) && (input->filename == NULL) &&
682: (ctxt->inputNr > 1)) {
683: cur = input;
684: input = ctxt->inputTab[ctxt->inputNr - 2];
685: }
686: xmlParserPrintFileInfo(input);
687: }
688:
689: xmlGenericError(xmlGenericErrorContext, "error: ");
690: XML_GET_VAR_STR(msg, str);
691: xmlGenericError(xmlGenericErrorContext, "%s", str);
692: if (str != NULL)
693: xmlFree(str);
694:
695: if (ctxt != NULL) {
696: xmlParserPrintFileContext(input);
697: if (cur != NULL) {
698: xmlParserPrintFileInfo(cur);
699: xmlGenericError(xmlGenericErrorContext, "\n");
700: xmlParserPrintFileContext(cur);
701: }
702: }
703: }
704:
705: /**
706: * xmlParserWarning:
707: * @ctx: an XML parser context
708: * @msg: the message to display/transmit
709: * @...: extra parameters for the message display
710: *
711: * Display and format a warning messages, gives file, line, position and
712: * extra parameters.
713: */
714: void XMLCDECL
715: xmlParserWarning(void *ctx, const char *msg, ...)
716: {
717: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
718: xmlParserInputPtr input = NULL;
719: xmlParserInputPtr cur = NULL;
720: char * str;
721:
722: if (ctxt != NULL) {
723: input = ctxt->input;
724: if ((input != NULL) && (input->filename == NULL) &&
725: (ctxt->inputNr > 1)) {
726: cur = input;
727: input = ctxt->inputTab[ctxt->inputNr - 2];
728: }
729: xmlParserPrintFileInfo(input);
730: }
731:
732: xmlGenericError(xmlGenericErrorContext, "warning: ");
733: XML_GET_VAR_STR(msg, str);
734: xmlGenericError(xmlGenericErrorContext, "%s", str);
735: if (str != NULL)
736: xmlFree(str);
737:
738: if (ctxt != NULL) {
739: xmlParserPrintFileContext(input);
740: if (cur != NULL) {
741: xmlParserPrintFileInfo(cur);
742: xmlGenericError(xmlGenericErrorContext, "\n");
743: xmlParserPrintFileContext(cur);
744: }
745: }
746: }
747:
748: /************************************************************************
749: * *
750: * Handling of validation errors *
751: * *
752: ************************************************************************/
753:
754: /**
755: * xmlParserValidityError:
756: * @ctx: an XML parser context
757: * @msg: the message to display/transmit
758: * @...: extra parameters for the message display
759: *
760: * Display and format an validity error messages, gives file,
761: * line, position and extra parameters.
762: */
763: void XMLCDECL
764: xmlParserValidityError(void *ctx, const char *msg, ...)
765: {
766: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
767: xmlParserInputPtr input = NULL;
768: char * str;
769: int len = xmlStrlen((const xmlChar *) msg);
770: static int had_info = 0;
771:
772: if ((len > 1) && (msg[len - 2] != ':')) {
773: if (ctxt != NULL) {
774: input = ctxt->input;
775: if ((input->filename == NULL) && (ctxt->inputNr > 1))
776: input = ctxt->inputTab[ctxt->inputNr - 2];
777:
778: if (had_info == 0) {
779: xmlParserPrintFileInfo(input);
780: }
781: }
782: xmlGenericError(xmlGenericErrorContext, "validity error: ");
783: had_info = 0;
784: } else {
785: had_info = 1;
786: }
787:
788: XML_GET_VAR_STR(msg, str);
789: xmlGenericError(xmlGenericErrorContext, "%s", str);
790: if (str != NULL)
791: xmlFree(str);
792:
793: if ((ctxt != NULL) && (input != NULL)) {
794: xmlParserPrintFileContext(input);
795: }
796: }
797:
798: /**
799: * xmlParserValidityWarning:
800: * @ctx: an XML parser context
801: * @msg: the message to display/transmit
802: * @...: extra parameters for the message display
803: *
804: * Display and format a validity warning messages, gives file, line,
805: * position and extra parameters.
806: */
807: void XMLCDECL
808: xmlParserValidityWarning(void *ctx, const char *msg, ...)
809: {
810: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
811: xmlParserInputPtr input = NULL;
812: char * str;
813: int len = xmlStrlen((const xmlChar *) msg);
814:
815: if ((ctxt != NULL) && (len != 0) && (msg[len - 1] != ':')) {
816: input = ctxt->input;
817: if ((input->filename == NULL) && (ctxt->inputNr > 1))
818: input = ctxt->inputTab[ctxt->inputNr - 2];
819:
820: xmlParserPrintFileInfo(input);
821: }
822:
823: xmlGenericError(xmlGenericErrorContext, "validity warning: ");
824: XML_GET_VAR_STR(msg, str);
825: xmlGenericError(xmlGenericErrorContext, "%s", str);
826: if (str != NULL)
827: xmlFree(str);
828:
829: if (ctxt != NULL) {
830: xmlParserPrintFileContext(input);
831: }
832: }
833:
834:
835: /************************************************************************
836: * *
837: * Extended Error Handling *
838: * *
839: ************************************************************************/
840:
841: /**
842: * xmlGetLastError:
843: *
844: * Get the last global error registered. This is per thread if compiled
845: * with thread support.
846: *
847: * Returns NULL if no error occured or a pointer to the error
848: */
849: xmlErrorPtr
850: xmlGetLastError(void)
851: {
852: if (xmlLastError.code == XML_ERR_OK)
853: return (NULL);
854: return (&xmlLastError);
855: }
856:
857: /**
858: * xmlResetError:
859: * @err: pointer to the error.
860: *
861: * Cleanup the error.
862: */
863: void
864: xmlResetError(xmlErrorPtr err)
865: {
866: if (err == NULL)
867: return;
868: if (err->code == XML_ERR_OK)
869: return;
870: if (err->message != NULL)
871: xmlFree(err->message);
872: if (err->file != NULL)
873: xmlFree(err->file);
874: if (err->str1 != NULL)
875: xmlFree(err->str1);
876: if (err->str2 != NULL)
877: xmlFree(err->str2);
878: if (err->str3 != NULL)
879: xmlFree(err->str3);
880: memset(err, 0, sizeof(xmlError));
881: err->code = XML_ERR_OK;
882: }
883:
884: /**
885: * xmlResetLastError:
886: *
887: * Cleanup the last global error registered. For parsing error
888: * this does not change the well-formedness result.
889: */
890: void
891: xmlResetLastError(void)
892: {
893: if (xmlLastError.code == XML_ERR_OK)
894: return;
895: xmlResetError(&xmlLastError);
896: }
897:
898: /**
899: * xmlCtxtGetLastError:
900: * @ctx: an XML parser context
901: *
902: * Get the last parsing error registered.
903: *
904: * Returns NULL if no error occured or a pointer to the error
905: */
906: xmlErrorPtr
907: xmlCtxtGetLastError(void *ctx)
908: {
909: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
910:
911: if (ctxt == NULL)
912: return (NULL);
913: if (ctxt->lastError.code == XML_ERR_OK)
914: return (NULL);
915: return (&ctxt->lastError);
916: }
917:
918: /**
919: * xmlCtxtResetLastError:
920: * @ctx: an XML parser context
921: *
922: * Cleanup the last global error registered. For parsing error
923: * this does not change the well-formedness result.
924: */
925: void
926: xmlCtxtResetLastError(void *ctx)
927: {
928: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
929:
930: if (ctxt == NULL)
931: return;
932: ctxt->errNo = XML_ERR_OK;
933: if (ctxt->lastError.code == XML_ERR_OK)
934: return;
935: xmlResetError(&ctxt->lastError);
936: }
937:
938: /**
939: * xmlCopyError:
940: * @from: a source error
941: * @to: a target error
942: *
943: * Save the original error to the new place.
944: *
945: * Returns 0 in case of success and -1 in case of error.
946: */
947: int
948: xmlCopyError(xmlErrorPtr from, xmlErrorPtr to) {
949: char *message, *file, *str1, *str2, *str3;
950:
951: if ((from == NULL) || (to == NULL))
952: return(-1);
953:
954: message = (char *) xmlStrdup((xmlChar *) from->message);
955: file = (char *) xmlStrdup ((xmlChar *) from->file);
956: str1 = (char *) xmlStrdup ((xmlChar *) from->str1);
957: str2 = (char *) xmlStrdup ((xmlChar *) from->str2);
958: str3 = (char *) xmlStrdup ((xmlChar *) from->str3);
959:
960: if (to->message != NULL)
961: xmlFree(to->message);
962: if (to->file != NULL)
963: xmlFree(to->file);
964: if (to->str1 != NULL)
965: xmlFree(to->str1);
966: if (to->str2 != NULL)
967: xmlFree(to->str2);
968: if (to->str3 != NULL)
969: xmlFree(to->str3);
970: to->domain = from->domain;
971: to->code = from->code;
972: to->level = from->level;
973: to->line = from->line;
974: to->node = from->node;
975: to->int1 = from->int1;
976: to->int2 = from->int2;
977: to->node = from->node;
978: to->ctxt = from->ctxt;
979: to->message = message;
980: to->file = file;
981: to->str1 = str1;
982: to->str2 = str2;
983: to->str3 = str3;
984:
985: return 0;
986: }
987:
988: #define bottom_error
989: #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