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 ...) 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 xmlGenericErrorDefaultFunc(void * ctx ATTRIBUTE_UNUSED,const char * msg,...)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 initGenericErrorDefaultFunc(xmlGenericErrorFunc * handler)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 xmlSetGenericErrorFunc(void * ctx,xmlGenericErrorFunc handler)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 xmlSetStructuredErrorFunc(void * ctx,xmlStructuredErrorFunc handler)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 xmlParserPrintFileInfo(xmlParserInputPtr input)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 xmlParserPrintFileContextInternal(xmlParserInputPtr input,xmlGenericErrorFunc channel,void * data)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 xmlParserPrintFileContext(xmlParserInputPtr input)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 xmlReportError(xmlErrorPtr err,xmlParserCtxtPtr ctxt,const char * str,xmlGenericErrorFunc channel,void * data)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 __xmlRaiseError(xmlStructuredErrorFunc schannel,xmlGenericErrorFunc channel,void * data,void * ctx,void * nod,int domain,int code,xmlErrorLevel level,const char * file,int line,const char * str1,const char * str2,const char * str3,int int1,int col,const char * msg,...)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 __xmlSimpleError(int domain,int code,xmlNodePtr node,const char * msg,const char * extra)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 xmlParserError(void * ctx,const char * msg,...)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 xmlParserWarning(void * ctx,const char * msg,...)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 xmlParserValidityError(void * ctx,const char * msg,...)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 xmlParserValidityWarning(void * ctx,const char * msg,...)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 xmlGetLastError(void)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 xmlResetError(xmlErrorPtr err)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 xmlResetLastError(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 xmlCtxtGetLastError(void * ctx)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 xmlCtxtResetLastError(void * ctx)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 xmlCopyError(xmlErrorPtr from,xmlErrorPtr to)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" 999