buf.c File Reference

#include "libxml.h"
#include <string.h>
#include <limits.h>
#include <ctype.h>
#include <stdlib.h>
#include <libxml/tree.h>
#include <libxml/globals.h>
#include <libxml/parserInternals.h>
#include "buf.h"
#include "elfgcchack.h"

Include dependency graph for buf.c:

Go to the source code of this file.

Classes
struct	_xmlBuf

Macros
#define	IN_LIBXML
#define	WITH_BUFFER_COMPAT
#define	UPDATE_COMPAT(buf)
#define	CHECK_COMPAT(buf)
#define	bottom_buf

Functions
static void	xmlBufMemoryError (xmlBufPtr buf, const char *extra)
static void	xmlBufOverflowError (xmlBufPtr buf, const char *extra)
xmlBufPtr	xmlBufCreate (void)
xmlBufPtr	xmlBufCreateSize (size_t size)
xmlChar *	xmlBufDetach (xmlBufPtr buf)
xmlBufPtr	xmlBufCreateStatic (void *mem, size_t size)
int	xmlBufGetAllocationScheme (xmlBufPtr buf)
int	xmlBufSetAllocationScheme (xmlBufPtr buf, xmlBufferAllocationScheme scheme)
void	xmlBufFree (xmlBufPtr buf)
void	xmlBufEmpty (xmlBufPtr buf)
size_t	xmlBufShrink (xmlBufPtr buf, size_t len)
static size_t	xmlBufGrowInternal (xmlBufPtr buf, size_t len)
int	xmlBufGrow (xmlBufPtr buf, int len)
int	xmlBufInflate (xmlBufPtr buf, size_t len)
size_t	xmlBufDump (FILE *file, xmlBufPtr buf)
xmlChar *	xmlBufContent (const xmlBuf *buf)
xmlChar *	xmlBufEnd (xmlBufPtr buf)
int	xmlBufAddLen (xmlBufPtr buf, size_t len)
int	xmlBufErase (xmlBufPtr buf, size_t len)
size_t	xmlBufLength (const xmlBufPtr buf)
size_t	xmlBufUse (const xmlBufPtr buf)
size_t	xmlBufAvail (const xmlBufPtr buf)
int	xmlBufIsEmpty (const xmlBufPtr buf)
int	xmlBufResize (xmlBufPtr buf, size_t size)
int	xmlBufAdd (xmlBufPtr buf, const xmlChar *str, int len)
int	xmlBufAddHead (xmlBufPtr buf, const xmlChar *str, int len)
int	xmlBufCat (xmlBufPtr buf, const xmlChar *str)
int	xmlBufCCat (xmlBufPtr buf, const char *str)
int	xmlBufWriteCHAR (xmlBufPtr buf, const xmlChar *string)
int	xmlBufWriteChar (xmlBufPtr buf, const char *string)
int	xmlBufWriteQuotedString (xmlBufPtr buf, const xmlChar *string)
xmlBufPtr	xmlBufFromBuffer (xmlBufferPtr buffer)
xmlBufferPtr	xmlBufBackToBuffer (xmlBufPtr buf)
int	xmlBufMergeBuffer (xmlBufPtr buf, xmlBufferPtr buffer)
int	xmlBufResetInput (xmlBufPtr buf, xmlParserInputPtr input)
size_t	xmlBufGetInputBase (xmlBufPtr buf, xmlParserInputPtr input)
int	xmlBufSetInputBaseCur (xmlBufPtr buf, xmlParserInputPtr input, size_t base, size_t cur)

Macro Definition Documentation

bottom_buf

#define bottom_buf

Definition at line 1350 of file buf.c.

CHECK_COMPAT

#define CHECK_COMPAT

(

buf

)

Value:

if (buf->size != (size_t) buf->compat_size)     \
         if (buf->compat_size < INT_MAX)            \
         buf->size = buf->compat_size;          \
     if (buf->use != (size_t) buf->compat_use)          \
         if (buf->compat_use < INT_MAX)             \
         buf->use = buf->compat_use;

Definition at line 71 of file buf.c.

IN_LIBXML

#define IN_LIBXML

Definition at line 15 of file buf.c.

UPDATE_COMPAT

#define UPDATE_COMPAT

(

buf

)

Value:

if (buf->size < INT_MAX) buf->compat_size = buf->size; \
     else buf->compat_size = INT_MAX;               \
     if (buf->use < INT_MAX) buf->compat_use = buf->use; \
     else buf->compat_use = INT_MAX;

Definition at line 60 of file buf.c.

WITH_BUFFER_COMPAT

#define WITH_BUFFER_COMPAT

Definition at line 33 of file buf.c.

Function Documentation

xmlBufAdd()

int xmlBufAdd	(	xmlBufPtr	buf,
		const xmlChar *	str,
		int	len
	)

xmlBufAdd: @buf: the buffer to dump @str: the xmlChar string @len: the number of xmlChar to add

Add a string range to 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.

Definition at line 868 of file buf.c.

                                                      {
    unsigned int needSize;

    if ((str == NULL) || (buf == NULL) || (buf->error))
    return -1;
    CHECK_COMPAT(buf)

    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return -1;
    if (len < -1) {
#ifdef DEBUG_BUFFER
        xmlGenericError(xmlGenericErrorContext,
        "xmlBufAdd: len < 0\n");
#endif
    return -1;
    }
    if (len == 0) return 0;

    if (len < 0)
        len = xmlStrlen(str);

    if (len < 0) return -1;
    if (len == 0) 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[buf->use], str, len*sizeof(xmlChar));
    buf->use += len;
    buf->content[buf->use] = 0;
    UPDATE_COMPAT(buf)
    return 0;
}

Referenced by xmlBufCat(), xmlBufMergeBuffer(), and xmlBufWriteQuotedString().

xmlBufAddHead()

int xmlBufAddHead	(	xmlBufPtr	buf,
		const xmlChar *	str,
		int	len
	)

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.

Definition at line 928 of file buf.c.

                                                          {
    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;
}

xmlBufAddLen()

int xmlBufAddLen	(	xmlBufPtr	buf,
		size_t	len
	)

xmlBufAddLen: @buf: the buffer @len: the size which were added at the end

Sometime data may be added at the end of the buffer without using the xmlBuf APIs that is used to expand the used space and set the zero terminating at the end of the buffer

Returns -1 in case of error and 0 otherwise

Definition at line 621 of file buf.c.

                                        {
    if ((buf == NULL) || (buf->error))
        return(-1);
    CHECK_COMPAT(buf)
    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);
}

Referenced by xmlCharEncFirstLineInput(), and xmlCharEncInput().

xmlBufAvail()

size_t xmlBufAvail

(

const xmlBufPtr

buf

)

xmlBufAvail: @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

Returns the amount or 0 if none or an error occurred

Definition at line 708 of file buf.c.

{
    if ((!buf) || (buf->error))
        return 0;
    CHECK_COMPAT(buf)

    return(buf->size - buf->use);
}

Referenced by xmlCharEncFirstLineInput(), and xmlCharEncInput().

xmlBufBackToBuffer()

xmlBufferPtr xmlBufBackToBuffer

(

xmlBufPtr

buf

)

xmlBufBackToBuffer: @buf: new buffer wrapping the old one

Function to be called once internal processing had been done to update back the buffer provided by the user. This can lead to a failure in case the size accumulated in the xmlBuf is larger than what an xmlBuffer can support on 64 bits (INT_MAX) The xmlBufPtr @buf wrapper is deallocated by this call in any case.

Returns the old xmlBufferPtr unless the call failed and NULL is returned

Definition at line 1204 of file buf.c.

                                  {
    xmlBufferPtr ret;

    if (buf == NULL)
        return(NULL);
    CHECK_COMPAT(buf)
    if ((buf->error) || (buf->buffer == NULL)) {
        xmlBufFree(buf);
        return(NULL);
    }

    ret = buf->buffer;
    /*
     * What to do in case of error in the buffer ???
     */
    if (buf->use > INT_MAX) {
        /*
         * Worse case, we really allocated and used more than the
         * maximum allowed memory for an xmlBuffer on this architecture.
         * Keep the buffer but provide a truncated size value.
         */
        xmlBufOverflowError(buf, "Used size too big for xmlBuffer");
        ret->use = INT_MAX;
        ret->size = INT_MAX;
    } else if (buf->size > INT_MAX) {
        /*
         * milder case, we allocated more than the maximum allowed memory
         * for an xmlBuffer on this architecture, but used less than the
         * limit.
         * Keep the buffer but provide a truncated size value.
         */
        xmlBufOverflowError(buf, "Allocated size too big for xmlBuffer");
        ret->use = (int) buf->use;
        ret->size = INT_MAX;
    } else {
        ret->use = (int) buf->use;
        ret->size = (int) buf->size;
    }
    ret->alloc = buf->alloc;
    ret->content = buf->content;
    ret->contentIO = buf->contentIO;
    xmlFree(buf);
    return(ret);
}

xmlBufCat()

int xmlBufCat	(	xmlBufPtr	buf,
		const xmlChar *	str
	)

xmlBufCat: @buf: the buffer to add to @str: the xmlChar string

Append a zero terminated string to an XML buffer.

Returns 0 successful, a positive error code number otherwise and -1 in case of internal or API error.

Definition at line 1007 of file buf.c.

                                             {
    if ((buf == NULL) || (buf->error))
        return(-1);
    CHECK_COMPAT(buf)
    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return -1;
    if (str == NULL) return -1;
    return xmlBufAdd(buf, str, -1);
}

Referenced by xmlBufWriteCHAR(), and xmlBufWriteQuotedString().

xmlBufCCat()

int xmlBufCCat	(	xmlBufPtr	buf,
		const char *	str
	)

xmlBufCCat: @buf: the buffer to dump @str: the C char string

Append a zero terminated C string to an XML buffer.

Returns 0 successful, a positive error code number otherwise and -1 in case of internal or API error.

Definition at line 1027 of file buf.c.

                                           {
    const char *cur;

    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,
        "xmlBufCCat: str == NULL\n");
#endif
    return -1;
    }
    for (cur = str;*cur != 0;cur++) {
        if (buf->use  + 10 >= buf->size) {
            if (!xmlBufResize(buf, buf->use+10)){
        xmlBufMemoryError(buf, "growing buffer");
                return XML_ERR_NO_MEMORY;
            }
        }
        buf->content[buf->use++] = *cur;
    }
    buf->content[buf->use] = 0;
    UPDATE_COMPAT(buf)
    return 0;
}

Referenced by xmlBufWriteChar(), and xmlBufWriteQuotedString().

xmlBufContent()

xmlChar* xmlBufContent

(

const xmlBuf *

buf

)

xmlBufContent: @buf: the buffer

Function to extract the content of a buffer

Returns the internal content

Definition at line 582 of file buf.c.

{
    if ((!buf) || (buf->error))
        return NULL;

    return(buf->content);
}

Referenced by xmlCharEncFirstLineInput(), xmlCharEncInput(), xmlParserInputGrow(), xmlParserInputShrink(), and xsltSaveResultToString().

xmlBufCreate()

xmlBufPtr xmlBufCreate

(

void

)

xmlBufCreate:

routine to create an XML buffer. returns the new structure.

Definition at line 122 of file buf.c.

                   {
    xmlBufPtr ret;

    ret = (xmlBufPtr) xmlMalloc(sizeof(xmlBuf));
    if (ret == NULL) {
    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;
    ret->alloc = xmlBufferAllocScheme;
    ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar));
    if (ret->content == NULL) {
    xmlBufMemoryError(ret, "creating buffer");
    xmlFree(ret);
        return(NULL);
    }
    ret->content[0] = 0;
    ret->contentIO = NULL;
    return(ret);
}

Referenced by xmlSwitchInputEncodingInt().

xmlBufCreateSize()

xmlBufPtr xmlBufCreateSize

(

size_t

size

)

xmlBufCreateSize: @size: initial size of buffer

routine to create an XML buffer. returns the new structure.

Definition at line 156 of file buf.c.

                              {
    xmlBufPtr ret;

    ret = (xmlBufPtr) xmlMalloc(sizeof(xmlBuf));
    if (ret == NULL) {
    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+2 : 0);         /* +1 for ending null */
    ret->compat_size = (int) ret->size;
    if (ret->size){
        ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar));
        if (ret->content == NULL) {
        xmlBufMemoryError(ret, "creating buffer");
            xmlFree(ret);
            return(NULL);
        }
        ret->content[0] = 0;
    } else
    ret->content = NULL;
    ret->contentIO = NULL;
    return(ret);
}

xmlBufCreateStatic()

xmlBufPtr xmlBufCreateStatic	(	void *	mem,
		size_t	size
	)

xmlBufCreateStatic: @mem: the memory area @size: the size in byte

routine to create an XML buffer from an immutable memory area. The area won't be modified nor copied, and is expected to be present until the end of the buffer lifetime.

returns the new structure.

Definition at line 231 of file buf.c.

                                           {
    xmlBufPtr ret;

    if (mem == NULL)
        return(NULL);

    ret = (xmlBufPtr) xmlMalloc(sizeof(xmlBuf));
    if (ret == NULL) {
    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;
    ret->alloc = XML_BUFFER_ALLOC_IMMUTABLE;
    ret->content = (xmlChar *) mem;
    ret->error = 0;
    ret->buffer = NULL;
    return(ret);
}

xmlBufDetach()

xmlChar* xmlBufDetach

(

xmlBufPtr

buf

)

xmlBufDetach: @buf: the buffer

Remove the string contained in a buffer and give it back to the caller. The buffer is reset to an empty content. This doesn't work with immutable buffers as they can't be reset.

Returns the previous string contained by the buffer.

Definition at line 196 of file buf.c.

                            {
    xmlChar *ret;

    if (buf == NULL)
        return(NULL);
    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)
        return(NULL);
    if (buf->buffer != NULL)
        return(NULL);
    if (buf->error)
        return(NULL);

    ret = buf->content;
    buf->content = NULL;
    buf->size = 0;
    buf->use = 0;
    buf->compat_use = 0;
    buf->compat_size = 0;

    return ret;
}

xmlBufDump()

size_t xmlBufDump	(	FILE *	file,
		xmlBufPtr	buf
	)

Definition at line 548 of file buf.c.

                                      {
    size_t ret;

    if ((buf == NULL) || (buf->error != 0)) {
#ifdef DEBUG_BUFFER
        xmlGenericError(xmlGenericErrorContext,
        "xmlBufDump: buf == NULL or in error\n");
#endif
    return(0);
    }
    if (buf->content == NULL) {
#ifdef DEBUG_BUFFER
        xmlGenericError(xmlGenericErrorContext,
        "xmlBufDump: buf->content == NULL\n");
#endif
    return(0);
    }
    CHECK_COMPAT(buf)
    if (file == NULL)
    file = stdout;
    ret = fwrite(buf->content, sizeof(xmlChar), buf->use, file);
    return(ret);
}

xmlBufEmpty()

void xmlBufEmpty

(

xmlBufPtr

buf

)

xmlBufEmpty: @buf: the buffer

empty a buffer.

Definition at line 355 of file buf.c.

                           {
    if ((buf == NULL) || (buf->error != 0)) return;
    if (buf->content == NULL) return;
    CHECK_COMPAT(buf)
    buf->use = 0;
    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) {
        buf->content = BAD_CAST "";
    } else if ((buf->alloc == XML_BUFFER_ALLOC_IO) &&
               (buf->contentIO != NULL)) {
        size_t start_buf = buf->content - buf->contentIO;

    buf->size += start_buf;
        buf->content = buf->contentIO;
        buf->content[0] = 0;
    } else {
        buf->content[0] = 0;
    }
    UPDATE_COMPAT(buf)
}

xmlBufEnd()

xmlChar* xmlBufEnd

(

xmlBufPtr

buf

)

xmlBufEnd: @buf: the buffer

Function to extract the end of the content of a buffer

Returns the end of the internal content or NULL in case of error

Definition at line 600 of file buf.c.

{
    if ((!buf) || (buf->error))
        return NULL;
    CHECK_COMPAT(buf)

    return(&buf->content[buf->use]);
}

Referenced by xmlCharEncFirstLineInput(), xmlCharEncInput(), xmlParserInputGrow(), and xmlParserInputShrink().

xmlBufErase()

int xmlBufErase	(	xmlBufPtr	buf,
		size_t	len
	)

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

Definition at line 646 of file buf.c.

                                       {
    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);
}

xmlBufFree()

void xmlBufFree

(

xmlBufPtr

buf

)

xmlBufFree: @buf: the buffer to free

Frees an XML buffer. It frees both the content and the structure which encapsulate it.

Definition at line 329 of file buf.c.

                          {
    if (buf == NULL) {
#ifdef DEBUG_BUFFER
        xmlGenericError(xmlGenericErrorContext,
        "xmlBufFree: buf == NULL\n");
#endif
    return;
    }

    if ((buf->alloc == XML_BUFFER_ALLOC_IO) &&
        (buf->contentIO != NULL)) {
        xmlFree(buf->contentIO);
    } else if ((buf->content != NULL) &&
        (buf->alloc != XML_BUFFER_ALLOC_IMMUTABLE)) {
        xmlFree(buf->content);
    }
    xmlFree(buf);
}

Referenced by xmlBufBackToBuffer().

xmlBufFromBuffer()

xmlBufPtr xmlBufFromBuffer

(

xmlBufferPtr

buffer

)

xmlBufFromBuffer: @buffer: incoming old buffer to convert to a new one

Helper routine to switch from the old buffer structures in use in various APIs. It creates a wrapper xmlBufPtr which will be used for internal processing until the xmlBufBackToBuffer() is issued.

Returns a new xmlBufPtr unless the call failed and NULL is returned

Definition at line 1167 of file buf.c.

                                      {
    xmlBufPtr ret;

    if (buffer == NULL)
        return(NULL);

    ret = (xmlBufPtr) xmlMalloc(sizeof(xmlBuf));
    if (ret == NULL) {
    xmlBufMemoryError(NULL, "creating buffer");
        return(NULL);
    }
    ret->use = buffer->use;
    ret->size = buffer->size;
    ret->compat_use = buffer->use;
    ret->compat_size = buffer->size;
    ret->error = 0;
    ret->buffer = buffer;
    ret->alloc = buffer->alloc;
    ret->content = buffer->content;
    ret->contentIO = buffer->contentIO;

    return(ret);
}

xmlBufGetAllocationScheme()

int xmlBufGetAllocationScheme

(

xmlBufPtr

buf

)

xmlBufGetAllocationScheme: @buf: the buffer

Get the buffer allocation scheme

Returns the scheme or -1 in case of error

Definition at line 267 of file buf.c.

                                         {
    if (buf == NULL) {
#ifdef DEBUG_BUFFER
        xmlGenericError(xmlGenericErrorContext,
        "xmlBufGetAllocationScheme: buf == NULL\n");
#endif
        return(-1);
    }
    return(buf->alloc);
}

xmlBufGetInputBase()

size_t xmlBufGetInputBase	(	xmlBufPtr	buf,
		xmlParserInputPtr	input
	)

xmlBufGetInputBase: @buf: an xmlBufPtr @input: an xmlParserInputPtr

Get the base of the @input relative to the beginning of the buffer

Returns the size_t corresponding to the displacement

Definition at line 1304 of file buf.c.

                                                           {
    size_t base;

    if ((input == NULL) || (buf == NULL) || (buf->error))
        return(-1);
    CHECK_COMPAT(buf)
    base = input->base - buf->content;
    /*
     * We could do some pointer arithmetic checks but that's probably
     * sufficient.
     */
    if (base > buf->size) {
        xmlBufOverflowError(buf, "Input reference outside of the buffer");
        base = 0;
    }
    return(base);
}

Referenced by xmlCtxtResetPush().

xmlBufGrow()

int xmlBufGrow	(	xmlBufPtr	buf,
		int	len
	)

xmlBufGrow: @buf: the buffer @len: the minimum free size to allocate

Grow the available space of an XML buffer, @len is the target value This is been kept compatible with xmlBufferGrow() as much as possible

Returns -1 in case of error or the length made available otherwise

Definition at line 509 of file buf.c.

                                   {
    size_t ret;

    if ((buf == NULL) || (len < 0)) return(-1);
    if (len == 0)
        return(0);
    ret = xmlBufGrowInternal(buf, len);
    if (buf->error != 0)
        return(-1);
    return((int) ret);
}

Referenced by xmlCharEncFirstLineInput(), and xmlCharEncInput().

xmlBufGrowInternal()

static size_t xmlBufGrowInternal ( xmlBufPtr  buf, size_t  len  )

static

xmlBufGrowInternal: @buf: the buffer @len: the minimum free size to allocate

Grow the available space of an XML buffer, @len is the target value Error checking should be done on buf->error since using the return value doesn't work that well

Returns 0 in case of error or the length made available otherwise

Definition at line 437 of file buf.c.

                                              {
    size_t size;
    xmlChar *newbuf;

    if ((buf == NULL) || (buf->error != 0)) return(0);
    CHECK_COMPAT(buf)

    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return(0);
    if (buf->use + len < buf->size)
        return(buf->size - buf->use);

    /*
     * Windows has a BIG problem on realloc timing, so we try to double
     * the buffer size (if that's enough) (bug 146697)
     * Apparently BSD too, and it's probably best for linux too
     * On an embedded system this may be something to change
     */
#if 1
    if (buf->size > (size_t) len)
        size = buf->size * 2;
    else
        size = buf->use + len + 100;
#else
    size = buf->use + len + 100;
#endif

    if (buf->alloc == XML_BUFFER_ALLOC_BOUNDED) {
        /*
     * Used to provide parsing limits
     */
        if ((buf->use + len >= XML_MAX_TEXT_LENGTH) ||
        (buf->size >= XML_MAX_TEXT_LENGTH)) {
        xmlBufMemoryError(buf, "buffer error: text too long\n");
        return(0);
    }
    if (size >= XML_MAX_TEXT_LENGTH)
        size = XML_MAX_TEXT_LENGTH;
    }
    if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) {
        size_t start_buf = buf->content - buf->contentIO;

    newbuf = (xmlChar *) xmlRealloc(buf->contentIO, start_buf + size);
    if (newbuf == NULL) {
        xmlBufMemoryError(buf, "growing buffer");
        return(0);
    }
    buf->contentIO = newbuf;
    buf->content = newbuf + start_buf;
    } else {
    newbuf = (xmlChar *) xmlRealloc(buf->content, size);
    if (newbuf == NULL) {
        xmlBufMemoryError(buf, "growing buffer");
        return(0);
    }
    buf->content = newbuf;
    }
    buf->size = size;
    UPDATE_COMPAT(buf)
    return(buf->size - buf->use);
}

Referenced by xmlBufGrow(), and xmlBufInflate().

xmlBufInflate()

int xmlBufInflate	(	xmlBufPtr	buf,
		size_t	len
	)

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

Definition at line 531 of file buf.c.

                                         {
    if (buf == NULL) return(-1);
    xmlBufGrowInternal(buf, len + buf->size);
    if (buf->error)
        return(-1);
    return(0);
}

xmlBufIsEmpty()

int xmlBufIsEmpty

(

const xmlBufPtr

buf

)

xmlBufIsEmpty: @buf: the buffer

Tell if a buffer is empty

Returns 0 if no, 1 if yes and -1 in case of error

Definition at line 726 of file buf.c.

{
    if ((!buf) || (buf->error))
        return(-1);
    CHECK_COMPAT(buf)

    return(buf->use == 0);
}

Referenced by xmlSwitchInputEncodingInt().

xmlBufLength()

size_t xmlBufLength

(

const xmlBufPtr

buf

)

xmlBufLength: @buf: the buffer

Function to get the length of a buffer

Returns the length of data in the internal content

Definition at line 668 of file buf.c.

{
    if ((!buf) || (buf->error))
        return 0;
    CHECK_COMPAT(buf)

    return(buf->use);
}

xmlBufMemoryError()

static void xmlBufMemoryError ( xmlBufPtr  buf, const char *  extra  )

static

xmlBufMemoryError: @extra: extra information

Handle an out of memory condition To be improved...

Definition at line 92 of file buf.c.

{
    __xmlSimpleError(XML_FROM_BUFFER, XML_ERR_NO_MEMORY, NULL, NULL, extra);
    if ((buf) && (buf->error == 0))
        buf->error = XML_ERR_NO_MEMORY;
}

Referenced by xmlBufAdd(), xmlBufAddHead(), xmlBufCCat(), xmlBufCreate(), xmlBufCreateSize(), xmlBufCreateStatic(), xmlBufFromBuffer(), xmlBufGrowInternal(), and xmlBufResize().

xmlBufMergeBuffer()

int xmlBufMergeBuffer	(	xmlBufPtr	buf,
		xmlBufferPtr	buffer
	)

xmlBufMergeBuffer: @buf: an xmlBufPtr @buffer: the buffer to consume into @buf

The content of @buffer is appended to @buf and @buffer is freed

Returns -1 in case of error, 0 otherwise, in any case @buffer is freed

Definition at line 1259 of file buf.c.

                                                      {
    int ret = 0;

    if ((buf == NULL) || (buf->error)) {
    xmlBufferFree(buffer);
        return(-1);
    }
    CHECK_COMPAT(buf)
    if ((buffer != NULL) && (buffer->content != NULL) &&
             (buffer->use > 0)) {
        ret = xmlBufAdd(buf, buffer->content, buffer->use);
    }
    xmlBufferFree(buffer);
    return(ret);
}

xmlBufOverflowError()

static void xmlBufOverflowError ( xmlBufPtr  buf, const char *  extra  )

static

xmlBufOverflowError: @extra: extra information

Handle a buffer overflow error To be improved...

Definition at line 107 of file buf.c.

{
    __xmlSimpleError(XML_FROM_BUFFER, XML_BUF_OVERFLOW, NULL, NULL, extra);
    if ((buf) && (buf->error == 0))
        buf->error = XML_BUF_OVERFLOW;
}

Referenced by xmlBufBackToBuffer(), and xmlBufGetInputBase().

xmlBufResetInput()

int xmlBufResetInput	(	xmlBufPtr	buf,
		xmlParserInputPtr	input
	)

xmlBufResetInput: @buf: an xmlBufPtr @input: an xmlParserInputPtr

Update the input to use the current set of pointers from the buffer.

Returns -1 in case of error, 0 otherwise

Definition at line 1285 of file buf.c.

                                                         {
    if ((input == NULL) || (buf == NULL) || (buf->error))
        return(-1);
    CHECK_COMPAT(buf)
    input->base = input->cur = buf->content;
    input->end = &buf->content[buf->use];
    return(0);
}

Referenced by xmlCreateMemoryParserCtxt(), xmlCtxtResetPush(), xmlNewInputFromFile(), xmlNewIOInputStream(), and xmlSwitchInputEncodingInt().

xmlBufResize()

int xmlBufResize	(	xmlBufPtr	buf,
		size_t	size
	)

xmlBufResize: @buf: the buffer to resize @size: the desired size

Resize a buffer to accommodate minimum size of @size.

Returns 0 in case of problems, 1 otherwise

Definition at line 745 of file buf.c.

{
    unsigned int newSize;
    xmlChar* rebuf = NULL;
    size_t start_buf;

    if ((buf == NULL) || (buf->error))
        return(0);
    CHECK_COMPAT(buf)

    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return(0);
    if (buf->alloc == XML_BUFFER_ALLOC_BOUNDED) {
        /*
     * Used to provide parsing limits
     */
        if (size >= XML_MAX_TEXT_LENGTH) {
        xmlBufMemoryError(buf, "buffer error: text too long\n");
        return(0);
    }
    }

    /* Don't resize if we don't have to */
    if (size < buf->size)
        return 1;

    /* figure out new size */
    switch (buf->alloc){
    case XML_BUFFER_ALLOC_IO:
    case XML_BUFFER_ALLOC_DOUBLEIT:
        /*take care of empty case*/
        newSize = (buf->size ? buf->size*2 : size + 10);
        while (size > newSize) {
            if (newSize > UINT_MAX / 2) {
                xmlBufMemoryError(buf, "growing buffer");
                return 0;
            }
            newSize *= 2;
        }
        break;
    case XML_BUFFER_ALLOC_EXACT:
        newSize = size+10;
        break;
        case XML_BUFFER_ALLOC_HYBRID:
            if (buf->use < BASE_BUFFER_SIZE)
                newSize = size;
            else {
                newSize = buf->size * 2;
                while (size > newSize) {
                    if (newSize > UINT_MAX / 2) {
                        xmlBufMemoryError(buf, "growing buffer");
                        return 0;
                    }
                    newSize *= 2;
                }
            }
            break;

    default:
        newSize = size+10;
        break;
    }

    if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) {
        start_buf = buf->content - buf->contentIO;

        if (start_buf > newSize) {
        /* move data back to start */
        memmove(buf->contentIO, buf->content, buf->use);
        buf->content = buf->contentIO;
        buf->content[buf->use] = 0;
        buf->size += start_buf;
    } else {
        rebuf = (xmlChar *) xmlRealloc(buf->contentIO, start_buf + newSize);
        if (rebuf == NULL) {
        xmlBufMemoryError(buf, "growing buffer");
        return 0;
        }
        buf->contentIO = rebuf;
        buf->content = rebuf + start_buf;
    }
    } else {
    if (buf->content == NULL) {
        rebuf = (xmlChar *) xmlMallocAtomic(newSize);
    } else if (buf->size - buf->use < 100) {
        rebuf = (xmlChar *) xmlRealloc(buf->content, newSize);
        } else {
        /*
         * if we are reallocating a buffer far from being full, it's
         * better to make a new allocation and copy only the used range
         * and free the old one.
         */
        rebuf = (xmlChar *) xmlMallocAtomic(newSize);
        if (rebuf != NULL) {
        memcpy(rebuf, buf->content, buf->use);
        xmlFree(buf->content);
        rebuf[buf->use] = 0;
        }
    }
    if (rebuf == NULL) {
        xmlBufMemoryError(buf, "growing buffer");
        return 0;
    }
    buf->content = rebuf;
    }
    buf->size = newSize;
    UPDATE_COMPAT(buf)

    return 1;
}

Referenced by xmlBufAdd(), xmlBufAddHead(), and xmlBufCCat().

xmlBufSetAllocationScheme()

int xmlBufSetAllocationScheme	(	xmlBufPtr	buf,
		xmlBufferAllocationScheme	scheme
	)

xmlBufSetAllocationScheme: @buf: the buffer to tune @scheme: allocation scheme to use

Sets the allocation scheme for this buffer

returns 0 in case of success and -1 in case of failure

Definition at line 288 of file buf.c.

                                                            {
    if ((buf == NULL) || (buf->error != 0)) {
#ifdef DEBUG_BUFFER
        xmlGenericError(xmlGenericErrorContext,
        "xmlBufSetAllocationScheme: buf == NULL or in error\n");
#endif
        return(-1);
    }
    if ((buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) ||
        (buf->alloc == XML_BUFFER_ALLOC_IO))
        return(-1);
    if ((scheme == XML_BUFFER_ALLOC_DOUBLEIT) ||
        (scheme == XML_BUFFER_ALLOC_EXACT) ||
        (scheme == XML_BUFFER_ALLOC_HYBRID) ||
        (scheme == XML_BUFFER_ALLOC_IMMUTABLE) ||
    (scheme == XML_BUFFER_ALLOC_BOUNDED)) {
    buf->alloc = scheme;
        if (buf->buffer)
            buf->buffer->alloc = scheme;
        return(0);
    }
    /*
     * Switching a buffer ALLOC_IO has the side effect of initializing
     * the contentIO field with the current content
     */
    if (scheme == XML_BUFFER_ALLOC_IO) {
        buf->alloc = XML_BUFFER_ALLOC_IO;
        buf->contentIO = buf->content;
    }
    return(-1);
}

xmlBufSetInputBaseCur()

int xmlBufSetInputBaseCur	(	xmlBufPtr	buf,
		xmlParserInputPtr	input,
		size_t	base,
		size_t	cur
	)

xmlBufSetInputBaseCur: @buf: an xmlBufPtr @input: an xmlParserInputPtr @base: the base value relative to the beginning of the buffer @cur: the cur value relative to the beginning of the buffer

Update the input to use the base and cur relative to the buffer after a possible reallocation of its content

Returns -1 in case of error, 0 otherwise

Definition at line 1335 of file buf.c.

                                               {
    if (input == NULL)
        return(-1);
    if ((buf == NULL) || (buf->error)) {
        input->base = input->cur = input->end = BAD_CAST "";
        return(-1);
    }
    CHECK_COMPAT(buf)
    input->base = &buf->content[base];
    input->cur = input->base + cur;
    input->end = &buf->content[buf->use];
    return(0);
}

Referenced by xmlCtxtResetPush().

xmlBufShrink()

size_t xmlBufShrink	(	xmlBufPtr	buf,
		size_t	len
	)

xmlBufShrink: @buf: the buffer to dump @len: the number of xmlChar to remove

Remove the beginning of an XML buffer. NOTE that this routine behaviour differs from xmlBufferShrink() as it will return 0 on error instead of -1 due to size_t being used as the return type.

Returns the number of byte removed or 0 in case of failure

Definition at line 388 of file buf.c.

                                        {
    if ((buf == NULL) || (buf->error != 0)) return(0);
    CHECK_COMPAT(buf)
    if (len == 0) return(0);
    if (len > buf->use) return(0);

    buf->use -= len;
    if ((buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) ||
        ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL))) {
    /*
     * we just move the content pointer, but also make sure
     * the perceived buffer size has shrunk accordingly
     */
        buf->content += len;
    buf->size -= len;

        /*
     * sometimes though it maybe be better to really shrink
     * on IO buffers
     */
    if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) {
        size_t start_buf = buf->content - buf->contentIO;
        if (start_buf >= buf->size) {
        memmove(buf->contentIO, &buf->content[0], buf->use);
        buf->content = buf->contentIO;
        buf->content[buf->use] = 0;
        buf->size += start_buf;
        }
    }
    } else {
    memmove(buf->content, &buf->content[len], buf->use);
    buf->content[buf->use] = 0;
    }
    UPDATE_COMPAT(buf)
    return(len);
}

Referenced by xmlCharEncFirstLineInput(), xmlCharEncInput(), xmlParserInputShrink(), and xmlSwitchInputEncodingInt().

xmlBufUse()

size_t xmlBufUse

(

const xmlBufPtr

buf

)

xmlBufUse: @buf: the buffer

Function to get the length of a buffer

Returns the length of data in the internal content

Definition at line 687 of file buf.c.

{
    if ((!buf) || (buf->error))
        return 0;
    CHECK_COMPAT(buf)

    return(buf->use);
}

Referenced by xmlCharEncFirstLineInput(), xmlCharEncInput(), xmlParserInputGrow(), xmlParserInputShrink(), xmlSwitchInputEncodingInt(), and xsltSaveResultToString().

xmlBufWriteCHAR()

int xmlBufWriteCHAR	(	xmlBufPtr	buf,
		const xmlChar *	string
	)

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.

Definition at line 1067 of file buf.c.

                                                      {
    if ((buf == NULL) || (buf->error))
        return(-1);
    CHECK_COMPAT(buf)
    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)
        return(-1);
    return(xmlBufCat(buf, string));
}

xmlBufWriteChar()

int xmlBufWriteChar	(	xmlBufPtr	buf,
		const char *	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.

Definition at line 1088 of file buf.c.

                                                   {
    if ((buf == NULL) || (buf->error))
        return(-1);
    CHECK_COMPAT(buf)
    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)
        return(-1);
    return(xmlBufCCat(buf, string));
}

xmlBufWriteQuotedString()

int xmlBufWriteQuotedString	(	xmlBufPtr	buf,
		const xmlChar *	string
	)

xmlBufWriteQuotedString: @buf: the XML buffer output @string: the string to add

routine which manage and grows an output buffer. This one writes a quoted or double quoted xmlChar string, checking first if it holds quote or double-quotes internally

Returns 0 if successful, a positive error code number otherwise and -1 in case of internal or API error.

Definition at line 1111 of file buf.c.

                                                              {
    const xmlChar *cur, *base;
    if ((buf == NULL) || (buf->error))
        return(-1);
    CHECK_COMPAT(buf)
    if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)
        return(-1);
    if (xmlStrchr(string, '\"')) {
        if (xmlStrchr(string, '\'')) {
#ifdef DEBUG_BUFFER
        xmlGenericError(xmlGenericErrorContext,
 "xmlBufWriteQuotedString: string contains quote and double-quotes !\n");
#endif
        xmlBufCCat(buf, "\"");
            base = cur = string;
            while(*cur != 0){
                if(*cur == '"'){
                    if (base != cur)
                        xmlBufAdd(buf, base, cur - base);
                    xmlBufAdd(buf, BAD_CAST """, 6);
                    cur++;
                    base = cur;
                }
                else {
                    cur++;
                }
            }
            if (base != cur)
                xmlBufAdd(buf, base, cur - base);
        xmlBufCCat(buf, "\"");
    }
        else{
        xmlBufCCat(buf, "\'");
            xmlBufCat(buf, string);
        xmlBufCCat(buf, "\'");
        }
    } else {
        xmlBufCCat(buf, "\"");
        xmlBufCat(buf, string);
        xmlBufCCat(buf, "\"");
    }
    return(0);
}