Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/error.c

 /*
  * error.c: module displaying/handling XML parser errors
  *
  * See Copyright for the status of this software.
  *
  * Daniel Veillard <daniel@veillard.com>
  */
 
 #define IN_LIBXML
 #include "libxml.h"
@@ skipping 15 matching lines @@
     char      *larger;                                          \
     va_list   ap;                                               \
                                                                 \
     str = (char *) xmlMalloc(150);                              \
     if (str != NULL) {                                          \
                                                                 \
     size = 150;                                                 \
                                                                 \
     while (size < 64000) {                                      \
         va_start(ap, msg);                                      \
-        chars = vsnprintf(str, size, msg, ap);                  \
+        chars = vsnprintf(str, size, msg, ap);                  \
         va_end(ap);                                             \
         if ((chars > -1) && (chars < size)) {                   \
             if (prev_size == chars) {                           \
                 break;                                          \
             } else {                                            \
                 prev_size = chars;                              \
             }                                                   \
         }                                                       \
         if (chars > -1)                                         \
             size += chars + 1;                                  \
         else                                                    \
             size += 100;                                        \
         if ((larger = (char *) xmlRealloc(str, size)) == NULL) {\
             break;                                              \
         }                                                       \
         str = larger;                                           \
     }}                                                          \
 }
 
 /************************************************************************
- *                                                                      *
- *                      Handling of out of context errors               *
- *                                                                      *
+ *                                                                      *
+ *                      Handling of out of context errors               *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlGenericErrorDefaultFunc:
  * @ctx:  an error context
  * @msg:  the message to display/transmit
  * @...:  extra parameters for the message display
- * 
+ *
  * Default handler for out of context error messages.
  */
 void XMLCDECL
 xmlGenericErrorDefaultFunc(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {
     va_list args;
 
     if (xmlGenericErrorContext == NULL)
         xmlGenericErrorContext = (void *) stderr;
 
     va_start(args, msg);
     vfprintf((FILE *)xmlGenericErrorContext, msg, args);
     va_end(args);
 }
 
 /**
  * initGenericErrorDefaultFunc:
  * @handler:  the handler
- * 
+ *
  * Set or reset (if NULL) the default handler for generic errors
  * to the builtin error function.
  */
 void
 initGenericErrorDefaultFunc(xmlGenericErrorFunc * handler)
 {
     if (handler == NULL)
         xmlGenericError = xmlGenericErrorDefaultFunc;
     else
         xmlGenericError = (*handler);
@@ skipping 34 matching lines @@
  * be passed as first argument to @handler
  * For multi-threaded applications, this must be set separately for each thread.
  */
 void
 xmlSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) {
     xmlStructuredErrorContext = ctx;
     xmlStructuredError = handler;
 }
 
 /************************************************************************
- *                                                                      *
- *                      Handling of parsing errors                      *
- *                                                                      *
+ *                                                                      *
+ *                      Handling of parsing errors                      *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlParserPrintFileInfo:
  * @input:  an xmlParserInputPtr input
- * 
+ *
  * Displays the associated file and line informations for the current input
  */
 
 void
 xmlParserPrintFileInfo(xmlParserInputPtr input) {
     if (input != NULL) {
         if (input->filename)
             xmlGenericError(xmlGenericErrorContext,
                     "%s:%d: ", input->filename,
                     input->line);
         else
             xmlGenericError(xmlGenericErrorContext,
                     "Entity: line %d: ", input->line);
     }
 }
 
 /**
  * xmlParserPrintFileContext:
  * @input:  an xmlParserInputPtr input
- * 
+ *
  * Displays current context within the input content for error tracking
  */
 
 static void
-xmlParserPrintFileContextInternal(xmlParserInputPtr input , 
+xmlParserPrintFileContextInternal(xmlParserInputPtr input ,
                 xmlGenericErrorFunc channel, void *data ) {
     const xmlChar *cur, *base;
     unsigned int n, col;        /* GCC warns if signed, because compared with sizeof() */
     xmlChar  content[81]; /* space for 80 chars + line terminator */
     xmlChar *ctnt;
 
     if (input == NULL) return;
     cur = input->cur;
     base = input->base;
     /* skip backwards over any end-of-lines */
     while ((cur > base) && ((*(cur) == '\n') || (*(cur) == '\r'))) {
         cur--;
     }
     n = 0;
     /* search backwards for beginning-of-line (to max buff size) */
-    while ((n++ < (sizeof(content)-1)) && (cur > base) && 
-           (*(cur) != '\n') && (*(cur) != '\r'))
+    while ((n++ < (sizeof(content)-1)) && (cur > base) &&
+           (*(cur) != '\n') && (*(cur) != '\r'))
         cur--;
     if ((*(cur) == '\n') || (*(cur) == '\r')) cur++;
     /* calculate the error position in terms of the current position */
     col = input->cur - cur;
     /* search forward for end-of-line (to max buff size) */
     n = 0;
     ctnt = content;
     /* copy selected text to our buffer */
-    while ((*cur != 0) && (*(cur) != '\n') && 
-           (*(cur) != '\r') && (n < sizeof(content)-1)) {
+    while ((*cur != 0) && (*(cur) != '\n') &&
+           (*(cur) != '\r') && (n < sizeof(content)-1)) {
                 *ctnt++ = *cur++;
         n++;
     }
     *ctnt = 0;
     /* print out the selected text */
     channel(data ,"%s\n", content);
     /* create blank line with problem pointer */
     n = 0;
     ctnt = content;
     /* (leave buffer space for pointer + line terminator) */
     while ((n<col) && (n++ < sizeof(content)-2) && (*ctnt != 0)) {
         if (*(ctnt) != '\t')
             *(ctnt) = ' ';
         ctnt++;
     }
     *ctnt++ = '^';
     *ctnt = 0;
     channel(data ,"%s\n", content);
 }
 
 /**
  * xmlParserPrintFileContext:
  * @input:  an xmlParserInputPtr input
- * 
+ *
  * Displays current context within the input content for error tracking
  */
 void
 xmlParserPrintFileContext(xmlParserInputPtr input) {
    xmlParserPrintFileContextInternal(input, xmlGenericError,
                                      xmlGenericErrorContext);
 }
 
 /**
  * xmlReportError:
@@ skipping 50 matching lines @@
         }
         if (input != NULL) {
             if (input->filename)
                 channel(data, "%s:%d: ", input->filename, input->line);
             else if ((line != 0) && (domain == XML_FROM_PARSER))
                 channel(data, "Entity: line %d: ", input->line);
         }
     } else {
         if (file != NULL)
             channel(data, "%s:%d: ", file, line);
-        else if ((line != 0) && (domain == XML_FROM_PARSER))
+        else if ((line != 0) &&
+                 ((domain == XML_FROM_PARSER) || (domain == XML_FROM_SCHEMASV)||
+                  (domain == XML_FROM_SCHEMASP)||(domain == XML_FROM_DTD) ||
+                  (domain == XML_FROM_RELAXNGP)||(domain == XML_FROM_RELAXNGV)))
             channel(data, "Entity: line %d: ", line);
     }
     if (name != NULL) {
         channel(data, "element %s: ", name);
     }
     switch (domain) {
         case XML_FROM_PARSER:
             channel(data, "parser ");
             break;
         case XML_FROM_NAMESPACE:
@@ skipping 47 matching lines @@
             break;
         case XML_FROM_C14N:
             channel(data, "C14N ");
             break;
         case XML_FROM_XSLT:
             channel(data, "XSLT ");
             break;
         case XML_FROM_I18N:
             channel(data, "encoding ");
             break;
+        case XML_FROM_SCHEMATRONV:
+            channel(data, "schematron ");
+            break;
+        case XML_FROM_BUFFER:
+            channel(data, "internal buffer ");
+            break;
+        case XML_FROM_URI:
+            channel(data, "URI ");
+            break;
         default:
             break;
     }
     switch (level) {
         case XML_ERR_NONE:
             channel(data, ": ");
             break;
         case XML_ERR_WARNING:
             channel(data, "warning : ");
             break;
@@ skipping 49 matching lines @@
  * @ctx: the parser context or NULL
  * @domain: the domain for the error
  * @code: the code for the error
  * @level: the xmlErrorLevel for the error
  * @file: the file source of the error (or NULL)
  * @line: the line of the error or 0 if N/A
  * @str1: extra string info
  * @str2: extra string info
  * @str3: extra string info
  * @int1: extra int info
- * @col: column number of the error or 0 if N/A 
+ * @col: column number of the error or 0 if N/A
  * @msg:  the message to display/transmit
  * @...:  extra parameters for the message display
  *
  * Update the appropriate global or contextual error structure,
  * then forward the error message down the parser or generic
  * error callback handler
  */
 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, ...)
 {
     xmlParserCtxtPtr ctxt = NULL;
     xmlNodePtr node = (xmlNodePtr) nod;
     char *str = NULL;
     xmlParserInputPtr input = NULL;
     xmlErrorPtr to = &xmlLastError;
     xmlNodePtr baseptr = NULL;
 
+    if (code == XML_ERR_OK)
+        return;
     if ((xmlGetWarningsDefaultValue == 0) && (level == XML_ERR_WARNING))
         return;
     if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
         (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
         (domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) {
         ctxt = (xmlParserCtxtPtr) ctx;
         if ((schannel == NULL) && (ctxt != NULL) && (ctxt->sax != NULL) &&
-            (ctxt->sax->initialized == XML_SAX2_MAGIC))
+            (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
+            (ctxt->sax->serror != NULL)) {
             schannel = ctxt->sax->serror;
+            data = ctxt->userData;
+        }
     }
     /*
      * Check if structured error handler set
      */
     if (schannel == NULL) {
         schannel = xmlStructuredError;
         /*
          * if user has defined handler, change data ptr to user's choice
          */
         if (schannel != NULL)
             data = xmlStructuredErrorContext;
     }
-    if ((domain == XML_FROM_VALID) &&
-        ((channel == xmlParserValidityError) ||
-         (channel == xmlParserValidityWarning))) {
-        ctxt = (xmlParserCtxtPtr) ctx;
-        if ((schannel == NULL) && (ctxt != NULL) && (ctxt->sax != NULL) &&
-            (ctxt->sax->initialized == XML_SAX2_MAGIC))
-            schannel = ctxt->sax->serror;
-    }
-    if (code == XML_ERR_OK)
-        return;
     /*
      * Formatting the message
      */
     if (msg == NULL) {
         str = (char *) xmlStrdup(BAD_CAST "No error message provided");
     } else {
         XML_GET_VAR_STR(msg, str);
     }
 
     /*
@@ skipping 23 matching lines @@
         for (i = 0;
              ((i < 10) && (node != NULL) && (node->type != XML_ELEMENT_NODE));
              i++)
              node = node->parent;
         if ((baseptr == NULL) && (node != NULL) &&
             (node->doc != NULL) && (node->doc->URL != NULL))
             baseptr = node;
 
         if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
             line = node->line;
+        if ((line == 0) || (line == 65535))
+            line = xmlGetLineNo(node);
     }
 
     /*
      * Save the information about the error
      */
     xmlResetError(to);
     to->domain = domain;
     to->code = code;
     to->message = str;
     to->level = level;
@@ skipping 43 matching lines @@
     if (str3 != NULL)
         to->str3 = (char *) xmlStrdup((const xmlChar *) str3);
     to->int1 = int1;
     to->int2 = col;
     to->node = node;
     to->ctxt = ctx;
 
     if (to != &xmlLastError)
         xmlCopyError(to,&xmlLastError);
 
+    if (schannel != NULL) {
+        schannel(data, to);
+        return;
+    }
+
     /*
      * Find the callback channel if channel param is NULL
      */
     if ((ctxt != NULL) && (channel == NULL) &&
         (xmlStructuredError == NULL) && (ctxt->sax != NULL)) {
         if (level == XML_ERR_WARNING)
             channel = ctxt->sax->warning;
         else
             channel = ctxt->sax->error;
         data = ctxt->userData;
     } else if (channel == NULL) {
-        if ((schannel == NULL) && (xmlStructuredError != NULL)) {
-            schannel = xmlStructuredError;
-            data = xmlStructuredErrorContext;
+        channel = xmlGenericError;
+        if (ctxt != NULL) {
+            data = ctxt;
         } else {
-            channel = xmlGenericError;
-            if (!data) {
-                data = xmlGenericErrorContext;
-            }
+            data = xmlGenericErrorContext;
         }
     }
-    if (schannel != NULL) {
-        schannel(data, to);
-        return;
-    }
     if (channel == NULL)
         return;
 
     if ((channel == xmlParserError) ||
         (channel == xmlParserWarning) ||
         (channel == xmlParserValidityError) ||
         (channel == xmlParserValidityWarning))
         xmlReportError(to, ctxt, str, NULL, NULL);
     else if ((channel == (xmlGenericErrorFunc) fprintf) ||
              (channel == xmlGenericErrorDefaultFunc))
@@ skipping 30 matching lines @@
         __xmlRaiseError(NULL, NULL, NULL, NULL, node, domain,
                         code, XML_ERR_ERROR, NULL, 0, extra,
                         NULL, NULL, 0, 0, msg, extra);
     }
 }
 /**
  * xmlParserError:
  * @ctx:  an XML parser context
  * @msg:  the message to display/transmit
  * @...:  extra parameters for the message display
- * 
+ *
  * Display and format an error messages, gives file, line, position and
  * extra parameters.
  */
 void XMLCDECL
 xmlParserError(void *ctx, const char *msg, ...)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     xmlParserInputPtr input = NULL;
     xmlParserInputPtr cur = NULL;
     char * str;
@@ skipping 22 matching lines @@
             xmlParserPrintFileContext(cur);
         }
     }
 }
 
 /**
  * xmlParserWarning:
  * @ctx:  an XML parser context
  * @msg:  the message to display/transmit
  * @...:  extra parameters for the message display
- * 
+ *
  * Display and format a warning messages, gives file, line, position and
  * extra parameters.
  */
 void XMLCDECL
 xmlParserWarning(void *ctx, const char *msg, ...)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     xmlParserInputPtr input = NULL;
     xmlParserInputPtr cur = NULL;
     char * str;
 
     if (ctxt != NULL) {
         input = ctxt->input;
         if ((input != NULL) && (input->filename == NULL) &&
             (ctxt->inputNr > 1)) {
             cur = input;
             input = ctxt->inputTab[ctxt->inputNr - 2];
         }
         xmlParserPrintFileInfo(input);
     }
-        
+
     xmlGenericError(xmlGenericErrorContext, "warning: ");
     XML_GET_VAR_STR(msg, str);
     xmlGenericError(xmlGenericErrorContext, "%s", str);
     if (str != NULL)
         xmlFree(str);
 
     if (ctxt != NULL) {
         xmlParserPrintFileContext(input);
         if (cur != NULL) {
             xmlParserPrintFileInfo(cur);
             xmlGenericError(xmlGenericErrorContext, "\n");
             xmlParserPrintFileContext(cur);
         }
     }
 }
 
 /************************************************************************
- *                                                                      *
- *                      Handling of validation errors                   *
- *                                                                      *
+ *                                                                      *
+ *                      Handling of validation errors                   *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlParserValidityError:
  * @ctx:  an XML parser context
  * @msg:  the message to display/transmit
  * @...:  extra parameters for the message display
- * 
+ *
  * Display and format an validity error messages, gives file,
  * line, position and extra parameters.
  */
 void XMLCDECL
 xmlParserValidityError(void *ctx, const char *msg, ...)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     xmlParserInputPtr input = NULL;
     char * str;
     int len = xmlStrlen((const xmlChar *) msg);
     static int had_info = 0;
 
     if ((len > 1) && (msg[len - 2] != ':')) {
         if (ctxt != NULL) {
             input = ctxt->input;
             if ((input->filename == NULL) && (ctxt->inputNr > 1))
                 input = ctxt->inputTab[ctxt->inputNr - 2];
-                
+
             if (had_info == 0) {
                 xmlParserPrintFileInfo(input);
             }
         }
         xmlGenericError(xmlGenericErrorContext, "validity error: ");
         had_info = 0;
     } else {
         had_info = 1;
     }
 
     XML_GET_VAR_STR(msg, str);
     xmlGenericError(xmlGenericErrorContext, "%s", str);
     if (str != NULL)
         xmlFree(str);
 
     if ((ctxt != NULL) && (input != NULL)) {
         xmlParserPrintFileContext(input);
     }
 }
 
 /**
  * xmlParserValidityWarning:
  * @ctx:  an XML parser context
  * @msg:  the message to display/transmit
  * @...:  extra parameters for the message display
- * 
+ *
  * Display and format a validity warning messages, gives file, line,
  * position and extra parameters.
  */
 void XMLCDECL
 xmlParserValidityWarning(void *ctx, const char *msg, ...)
 {
     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
     xmlParserInputPtr input = NULL;
     char * str;
     int len = xmlStrlen((const xmlChar *) msg);
 
     if ((ctxt != NULL) && (len != 0) && (msg[len - 1] != ':')) {
         input = ctxt->input;
         if ((input->filename == NULL) && (ctxt->inputNr > 1))
             input = ctxt->inputTab[ctxt->inputNr - 2];
 
         xmlParserPrintFileInfo(input);
     }
-        
+
     xmlGenericError(xmlGenericErrorContext, "validity warning: ");
     XML_GET_VAR_STR(msg, str);
     xmlGenericError(xmlGenericErrorContext, "%s", str);
     if (str != NULL)
         xmlFree(str);
 
     if (ctxt != NULL) {
         xmlParserPrintFileContext(input);
     }
 }
@@ skipping 147 matching lines @@
     to->file = file;
     to->str1 = str1;
     to->str2 = str2;
     to->str3 = str3;
 
     return 0;
 }
 
 #define bottom_error
 #include "elfgcchack.h"