mirror of
https://github.com/reactos/reactos.git
synced 2025-08-05 16:43:04 +00:00
[LIBXML2] Update to version 2.10.0. CORE-17766
This commit is contained in:
Thomas Faber
parent
608bbe1136
commit
911153da10
80 changed files with 2351 additions and 20735 deletions
221
sdk/lib/3rdparty/libxml2/buf.c
vendored
221
sdk/lib/3rdparty/libxml2/buf.c
vendored
|
|
@ -17,12 +17,8 @@
|
|||
|
||||
#include <string.h> /* for memset() only ! */
|
||||
#include <limits.h>
|
||||
#ifdef HAVE_CTYPE_H
|
||||
#include <ctype.h>
|
||||
#endif
|
||||
#ifdef HAVE_STDLIB_H
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
#include <libxml/tree.h>
|
||||
#include <libxml/globals.h>
|
||||
|
|
@ -131,12 +127,11 @@ xmlBufCreate(void) {
|
|||
xmlBufMemoryError(NULL, "creating buffer");
|
||||
return(NULL);
|
||||
}
|
||||
ret->compat_use = 0;
|
||||
ret->use = 0;
|
||||
ret->error = 0;
|
||||
ret->buffer = NULL;
|
||||
ret->size = xmlDefaultBufferSize;
|
||||
ret->compat_size = xmlDefaultBufferSize;
|
||||
UPDATE_COMPAT(ret);
|
||||
ret->alloc = xmlBufferAllocScheme;
|
||||
ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar));
|
||||
if (ret->content == NULL) {
|
||||
|
|
@ -167,13 +162,12 @@ xmlBufCreateSize(size_t size) {
|
|||
xmlBufMemoryError(NULL, "creating buffer");
|
||||
return(NULL);
|
||||
}
|
||||
ret->compat_use = 0;
|
||||
ret->use = 0;
|
||||
ret->error = 0;
|
||||
ret->buffer = NULL;
|
||||
ret->alloc = xmlBufferAllocScheme;
|
||||
ret->size = (size ? size + 1 : 0); /* +1 for ending null */
|
||||
ret->compat_size = (ret->size > INT_MAX ? INT_MAX : ret->size);
|
||||
UPDATE_COMPAT(ret);
|
||||
if (ret->size){
|
||||
ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar));
|
||||
if (ret->content == NULL) {
|
||||
|
|
@ -215,8 +209,7 @@ xmlBufDetach(xmlBufPtr buf) {
|
|||
buf->content = NULL;
|
||||
buf->size = 0;
|
||||
buf->use = 0;
|
||||
buf->compat_use = 0;
|
||||
buf->compat_size = 0;
|
||||
UPDATE_COMPAT(buf);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -245,15 +238,9 @@ xmlBufCreateStatic(void *mem, size_t size) {
|
|||
xmlBufMemoryError(NULL, "creating buffer");
|
||||
return(NULL);
|
||||
}
|
||||
if (size < INT_MAX) {
|
||||
ret->compat_use = size;
|
||||
ret->compat_size = size;
|
||||
} else {
|
||||
ret->compat_use = INT_MAX;
|
||||
ret->compat_size = INT_MAX;
|
||||
}
|
||||
ret->use = size;
|
||||
ret->size = size;
|
||||
UPDATE_COMPAT(ret);
|
||||
ret->alloc = XML_BUFFER_ALLOC_IMMUTABLE;
|
||||
ret->content = (xmlChar *) mem;
|
||||
ret->error = 0;
|
||||
|
|
@ -449,9 +436,11 @@ xmlBufGrowInternal(xmlBufPtr buf, size_t len) {
|
|||
|
||||
if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return(0);
|
||||
if (len < buf->size - buf->use)
|
||||
return(buf->size - buf->use);
|
||||
if (len > SIZE_MAX - buf->use)
|
||||
return(buf->size - buf->use - 1);
|
||||
if (len >= SIZE_MAX - buf->use) {
|
||||
xmlBufMemoryError(buf, "growing buffer past SIZE_MAX");
|
||||
return(0);
|
||||
}
|
||||
|
||||
if (buf->size > (size_t) len) {
|
||||
size = buf->size > SIZE_MAX / 2 ? SIZE_MAX : buf->size * 2;
|
||||
|
|
@ -464,7 +453,7 @@ xmlBufGrowInternal(xmlBufPtr buf, size_t len) {
|
|||
/*
|
||||
* Used to provide parsing limits
|
||||
*/
|
||||
if ((buf->use + len >= XML_MAX_TEXT_LENGTH) ||
|
||||
if ((buf->use + len + 1 >= XML_MAX_TEXT_LENGTH) ||
|
||||
(buf->size >= XML_MAX_TEXT_LENGTH)) {
|
||||
xmlBufMemoryError(buf, "buffer error: text too long\n");
|
||||
return(0);
|
||||
|
|
@ -492,7 +481,7 @@ xmlBufGrowInternal(xmlBufPtr buf, size_t len) {
|
|||
}
|
||||
buf->size = size;
|
||||
UPDATE_COMPAT(buf)
|
||||
return(buf->size - buf->use);
|
||||
return(buf->size - buf->use - 1);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -518,24 +507,6 @@ xmlBufGrow(xmlBufPtr buf, int len) {
|
|||
return((int) ret);
|
||||
}
|
||||
|
||||
/**
|
||||
* xmlBufInflate:
|
||||
* @buf: the buffer
|
||||
* @len: the minimum extra free size to allocate
|
||||
*
|
||||
* Grow the available space of an XML buffer, adding at least @len bytes
|
||||
*
|
||||
* Returns 0 if successful or -1 in case of error
|
||||
*/
|
||||
int
|
||||
xmlBufInflate(xmlBufPtr buf, size_t len) {
|
||||
if (buf == NULL) return(-1);
|
||||
xmlBufGrowInternal(buf, len + buf->size);
|
||||
if (buf->error)
|
||||
return(-1);
|
||||
return(0);
|
||||
}
|
||||
|
||||
/**
|
||||
* xmlBufDump:
|
||||
* @file: the file output
|
||||
|
|
@ -622,34 +593,9 @@ xmlBufAddLen(xmlBufPtr buf, size_t len) {
|
|||
if ((buf == NULL) || (buf->error))
|
||||
return(-1);
|
||||
CHECK_COMPAT(buf)
|
||||
if (len > (buf->size - buf->use))
|
||||
if (len >= (buf->size - buf->use))
|
||||
return(-1);
|
||||
buf->use += len;
|
||||
UPDATE_COMPAT(buf)
|
||||
if (buf->size > buf->use)
|
||||
buf->content[buf->use] = 0;
|
||||
else
|
||||
return(-1);
|
||||
return(0);
|
||||
}
|
||||
|
||||
/**
|
||||
* xmlBufErase:
|
||||
* @buf: the buffer
|
||||
* @len: the size to erase at the end
|
||||
*
|
||||
* Sometime data need to be erased at the end of the buffer
|
||||
*
|
||||
* Returns -1 in case of error and 0 otherwise
|
||||
*/
|
||||
int
|
||||
xmlBufErase(xmlBufPtr buf, size_t len) {
|
||||
if ((buf == NULL) || (buf->error))
|
||||
return(-1);
|
||||
CHECK_COMPAT(buf)
|
||||
if (len > buf->use)
|
||||
return(-1);
|
||||
buf->use -= len;
|
||||
buf->content[buf->use] = 0;
|
||||
UPDATE_COMPAT(buf)
|
||||
return(0);
|
||||
|
|
@ -698,10 +644,11 @@ xmlBufUse(const xmlBufPtr buf)
|
|||
* @buf: the buffer
|
||||
*
|
||||
* Function to find how much free space is allocated but not
|
||||
* used in the buffer. It does not account for the terminating zero
|
||||
* usually needed
|
||||
* used in the buffer. It reserves one byte for the NUL
|
||||
* terminator character that is usually needed, so there is
|
||||
* no need to subtract 1 from the result anymore.
|
||||
*
|
||||
* Returns the amount or 0 if none or an error occurred
|
||||
* Returns the amount, or 0 if none or if an error occurred.
|
||||
*/
|
||||
|
||||
size_t
|
||||
|
|
@ -711,7 +658,7 @@ xmlBufAvail(const xmlBufPtr buf)
|
|||
return 0;
|
||||
CHECK_COMPAT(buf)
|
||||
|
||||
return(buf->size - buf->use);
|
||||
return((buf->size > buf->use) ? (buf->size - buf->use - 1) : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -829,6 +776,8 @@ xmlBufResize(xmlBufPtr buf, size_t size)
|
|||
} else {
|
||||
if (buf->content == NULL) {
|
||||
rebuf = (xmlChar *) xmlMallocAtomic(newSize);
|
||||
buf->use = 0;
|
||||
rebuf[buf->use] = 0;
|
||||
} else if (buf->size - buf->use < 100) {
|
||||
rebuf = (xmlChar *) xmlRealloc(buf->content, newSize);
|
||||
} else {
|
||||
|
|
@ -892,9 +841,12 @@ xmlBufAdd(xmlBufPtr buf, const xmlChar *str, int len) {
|
|||
if (len < 0) return -1;
|
||||
if (len == 0) return 0;
|
||||
|
||||
/* Note that both buf->size and buf->use can be zero here. */
|
||||
if ((size_t) len >= buf->size - buf->use) {
|
||||
if ((size_t) len >= SIZE_MAX - buf->use)
|
||||
if ((size_t) len >= SIZE_MAX - buf->use) {
|
||||
xmlBufMemoryError(buf, "growing buffer past SIZE_MAX");
|
||||
return(-1);
|
||||
}
|
||||
needSize = buf->use + len + 1;
|
||||
if (buf->alloc == XML_BUFFER_ALLOC_BOUNDED) {
|
||||
/*
|
||||
|
|
@ -918,87 +870,6 @@ xmlBufAdd(xmlBufPtr buf, const xmlChar *str, int len) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* xmlBufAddHead:
|
||||
* @buf: the buffer
|
||||
* @str: the #xmlChar string
|
||||
* @len: the number of #xmlChar to add
|
||||
*
|
||||
* Add a string range to the beginning of an XML buffer.
|
||||
* if len == -1, the length of @str is recomputed.
|
||||
*
|
||||
* Returns 0 successful, a positive error code number otherwise
|
||||
* and -1 in case of internal or API error.
|
||||
*/
|
||||
int
|
||||
xmlBufAddHead(xmlBufPtr buf, const xmlChar *str, int len) {
|
||||
unsigned int needSize;
|
||||
|
||||
if ((buf == NULL) || (buf->error))
|
||||
return(-1);
|
||||
CHECK_COMPAT(buf)
|
||||
if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return -1;
|
||||
if (str == NULL) {
|
||||
#ifdef DEBUG_BUFFER
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlBufAddHead: str == NULL\n");
|
||||
#endif
|
||||
return -1;
|
||||
}
|
||||
if (len < -1) {
|
||||
#ifdef DEBUG_BUFFER
|
||||
xmlGenericError(xmlGenericErrorContext,
|
||||
"xmlBufAddHead: len < 0\n");
|
||||
#endif
|
||||
return -1;
|
||||
}
|
||||
if (len == 0) return 0;
|
||||
|
||||
if (len < 0)
|
||||
len = xmlStrlen(str);
|
||||
|
||||
if (len <= 0) return -1;
|
||||
|
||||
if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) {
|
||||
size_t start_buf = buf->content - buf->contentIO;
|
||||
|
||||
if (start_buf > (unsigned int) len) {
|
||||
/*
|
||||
* We can add it in the space previously shrunk
|
||||
*/
|
||||
buf->content -= len;
|
||||
memmove(&buf->content[0], str, len);
|
||||
buf->use += len;
|
||||
buf->size += len;
|
||||
UPDATE_COMPAT(buf)
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
needSize = buf->use + len + 2;
|
||||
if (needSize > buf->size){
|
||||
if (buf->alloc == XML_BUFFER_ALLOC_BOUNDED) {
|
||||
/*
|
||||
* Used to provide parsing limits
|
||||
*/
|
||||
if (needSize >= XML_MAX_TEXT_LENGTH) {
|
||||
xmlBufMemoryError(buf, "buffer error: text too long\n");
|
||||
return(-1);
|
||||
}
|
||||
}
|
||||
if (!xmlBufResize(buf, needSize)){
|
||||
xmlBufMemoryError(buf, "growing buffer");
|
||||
return XML_ERR_NO_MEMORY;
|
||||
}
|
||||
}
|
||||
|
||||
memmove(&buf->content[len], &buf->content[0], buf->use);
|
||||
memmove(&buf->content[0], str, len);
|
||||
buf->use += len;
|
||||
buf->content[buf->use] = 0;
|
||||
UPDATE_COMPAT(buf)
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* xmlBufCat:
|
||||
* @buf: the buffer to add to
|
||||
|
|
@ -1034,49 +905,6 @@ xmlBufCCat(xmlBufPtr buf, const char *str) {
|
|||
return xmlBufCat(buf, (const xmlChar *) str);
|
||||
}
|
||||
|
||||
/**
|
||||
* xmlBufWriteCHAR:
|
||||
* @buf: the XML buffer
|
||||
* @string: the string to add
|
||||
*
|
||||
* routine which manages and grows an output buffer. This one adds
|
||||
* xmlChars at the end of the buffer.
|
||||
*
|
||||
* Returns 0 if successful, a positive error code number otherwise
|
||||
* and -1 in case of internal or API error.
|
||||
*/
|
||||
int
|
||||
xmlBufWriteCHAR(xmlBufPtr buf, const xmlChar *string) {
|
||||
if ((buf == NULL) || (buf->error))
|
||||
return(-1);
|
||||
CHECK_COMPAT(buf)
|
||||
if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)
|
||||
return(-1);
|
||||
return(xmlBufCat(buf, string));
|
||||
}
|
||||
|
||||
/**
|
||||
* xmlBufWriteChar:
|
||||
* @buf: the XML buffer output
|
||||
* @string: the string to add
|
||||
*
|
||||
* routine which manage and grows an output buffer. This one add
|
||||
* C chars at the end of the array.
|
||||
*
|
||||
* Returns 0 if successful, a positive error code number otherwise
|
||||
* and -1 in case of internal or API error.
|
||||
*/
|
||||
int
|
||||
xmlBufWriteChar(xmlBufPtr buf, const char *string) {
|
||||
if ((buf == NULL) || (buf->error))
|
||||
return(-1);
|
||||
CHECK_COMPAT(buf)
|
||||
if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)
|
||||
return(-1);
|
||||
return(xmlBufCCat(buf, string));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* xmlBufWriteQuotedString:
|
||||
* @buf: the XML buffer output
|
||||
|
|
@ -1159,8 +987,7 @@ xmlBufFromBuffer(xmlBufferPtr buffer) {
|
|||
}
|
||||
ret->use = buffer->use;
|
||||
ret->size = buffer->size;
|
||||
ret->compat_use = buffer->use;
|
||||
ret->compat_size = buffer->size;
|
||||
UPDATE_COMPAT(ret);
|
||||
ret->error = 0;
|
||||
ret->buffer = buffer;
|
||||
ret->alloc = buffer->alloc;
|
||||
|
|
@ -1329,5 +1156,3 @@ xmlBufSetInputBaseCur(xmlBufPtr buf, xmlParserInputPtr input,
|
|||
return(0);
|
||||
}
|
||||
|
||||
#define bottom_buf
|
||||
#include "elfgcchack.h"
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue