error.c

   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"