Roll libxml to bdec2183f34b37ee89ae1d330c6ad2bb4d76605f

third_party/libxml/src/xmlIO.c

 /*
  * xmlIO.c : implementation of the I/O interfaces used by the parser
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  *
  * 14 Nov 2000 ht - for VMS, truncated name of long functions to under 32 char
  */
 
@@ skipping 1586 matching lines @@
         return ( NULL );
     }
 
     z_err = deflateInit2( &buff->zctrl, compression, Z_DEFLATED,
                             DFLT_WBITS, DFLT_MEM_LVL, Z_DEFAULT_STRATEGY );
     if ( z_err != Z_OK ) {
         xmlChar msg[500];
         xmlFreeZMemBuff( buff );
         buff = NULL;
         xmlStrPrintf(msg, 500,
-                    (const xmlChar *) "xmlCreateZMemBuff:  %s %d\n",
+                    "xmlCreateZMemBuff:  %s %d\n",
                     "Error initializing compression context.  ZLIB error:",
                     z_err );
         xmlIOErr(XML_IO_WRITE, (const char *) msg);
         return ( NULL );
     }
 
     /*  Set the header data.  The CRC will be needed for the trailer  */
     buff->crc = crc32( 0L, NULL, 0 );
     hdr_lgth = snprintf( (char *)buff->zbuff, buff->size,
                         "%c%c%c%c%c%c%c%c%c%c",
@@ skipping 47 matching lines @@
     if ( tmp_ptr != NULL ) {
         rc = 0;
         buff->size  = new_size;
         buff->zbuff = tmp_ptr;
         buff->zctrl.next_out  = tmp_ptr + cur_used;
         buff->zctrl.avail_out = new_size - cur_used;
     }
     else {
         xmlChar msg[500];
         xmlStrPrintf(msg, 500,
-                    (const xmlChar *) "xmlZMemBuffExtend:  %s %lu bytes.\n",
+                    "xmlZMemBuffExtend:  %s %lu bytes.\n",
                     "Allocation failure extending output buffer to",
                     new_size );
         xmlIOErr(XML_IO_WRITE, (const char *) msg);
     }
 
     return ( rc );
 }
 
 /**
  * xmlZMemBuffAppend
@@ skipping 25 matching lines @@
         min_accept = buff->zctrl.avail_in / DFLT_ZLIB_RATIO;
         if ( buff->zctrl.avail_out <= min_accept ) {
             if ( xmlZMemBuffExtend( buff, buff->size ) == -1 )
                 return ( -1 );
         }
 
         z_err = deflate( &buff->zctrl, Z_NO_FLUSH );
         if ( z_err != Z_OK ) {
             xmlChar msg[500];
             xmlStrPrintf(msg, 500,
-                        (const xmlChar *) "xmlZMemBuffAppend:  %s %d %s - %d",
+                        "xmlZMemBuffAppend:  %s %d %s - %d",
                         "Compression error while appending",
                         len, "bytes to buffer.  ZLIB error", z_err );
             xmlIOErr(XML_IO_WRITE, (const char *) msg);
             return ( -1 );
         }
     }
 
     buff->crc = crc32( buff->crc, (unsigned char *)src, len );
 
     return ( len );
@@ skipping 52 matching lines @@
         append_reverse_ulong( buff, buff->crc );
         append_reverse_ulong( buff, buff->zctrl.total_in );
 
         zlgth = buff->zctrl.next_out - buff->zbuff;
         *data_ref = (char *)buff->zbuff;
     }
 
     else {
         xmlChar msg[500];
         xmlStrPrintf(msg, 500,
-                    (const xmlChar *) "xmlZMemBuffGetContent:  %s - %d\n",
+                    "xmlZMemBuffGetContent:  %s - %d\n",
                     "Error flushing zlib buffers.  Error code", z_err );
         xmlIOErr(XML_IO_WRITE, (const char *) msg);
     }
 
     return ( zlgth );
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 #endif  /*  HAVE_ZLIB_H  */
 
 #ifdef LIBXML_OUTPUT_ENABLED
@@ skipping 184 matching lines @@
         if ( ctxt->compression > 0 )
             len = xmlZMemBuffAppend( ctxt->doc_buff, buffer, len );
 
         else
 #endif
             len = xmlOutputBufferWrite( ctxt->doc_buff, len, buffer );
 
         if ( len < 0 ) {
             xmlChar msg[500];
             xmlStrPrintf(msg, 500,
-                        (const xmlChar *) "xmlIOHTTPWrite:  %s\n%s '%s'.\n",
+                        "xmlIOHTTPWrite:  %s\n%s '%s'.\n",
                         "Error appending to internal buffer.",
                         "Error sending document to URI",
                         ctxt->uri );
             xmlIOErr(XML_IO_WRITE, (const char *) msg);
         }
     }
 
     return ( len );
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
@@ skipping 51 matching lines @@
         /*  Pull the data out of the memory output buffer  */
 
         xmlOutputBufferPtr      dctxt = ctxt->doc_buff;
         http_content = (char *) xmlBufContent(dctxt->buffer);
         content_lgth = xmlBufUse(dctxt->buffer);
     }
 
     if ( http_content == NULL ) {
         xmlChar msg[500];
         xmlStrPrintf(msg, 500,
-                     (const xmlChar *) "xmlIOHTTPCloseWrite:  %s '%s' %s '%s'.\n",
+                     "xmlIOHTTPCloseWrite:  %s '%s' %s '%s'.\n",
                      "Error retrieving content.\nUnable to",
                      http_mthd, "data to URI", ctxt->uri );
         xmlIOErr(XML_IO_WRITE, (const char *) msg);
     }
 
     else {
 
         http_ctxt = xmlNanoHTTPMethod( ctxt->uri, http_mthd, http_content,
                                         &content_type, content_encoding,
                                         content_lgth );
@@ skipping 51 matching lines @@
                 free( dump_name );
             }
 #endif  /*  DEBUG_HTTP  */
 
             http_rtn = xmlNanoHTTPReturnCode( http_ctxt );
             if ( ( http_rtn >= 200 ) && ( http_rtn < 300 ) )
                 close_rc = 0;
             else {
                 xmlChar msg[500];
                 xmlStrPrintf(msg, 500,
-    (const xmlChar *) "xmlIOHTTPCloseWrite: HTTP '%s' of %d %s\n'%s' %s %d\n",
+                      "xmlIOHTTPCloseWrite: HTTP '%s' of %d %s\n'%s' %s %d\n",
                             http_mthd, content_lgth,
                             "bytes to URI", ctxt->uri,
                             "failed.  HTTP return code:", http_rtn );
                 xmlIOErr(XML_IO_WRITE, (const char *) msg);
             }
 
             xmlNanoHTTPClose( http_ctxt );
             xmlFree( content_type );
         }
     }
@@ skipping 2023 matching lines @@
         }
     }
     input = xmlDefaultExternalEntityLoader((const char *) resource, ID, ctxt);
     if (resource != (xmlChar *) URL)
         xmlFree(resource);
     return(input);
 }
 
 #define bottom_xmlIO
 #include "elfgcchack.h"