?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
switch4g: completely re-writen
[tomato.git] / release / src / router / libxml2 / error.c
blobcbcf5c9633535454af06cad22c96a4c4025ac6ed
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"
Tomato firmware and modifications.