buf.h File Reference

#include <libxml/tree.h>

Include dependency graph for buf.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
XML_HIDDEN xmlBufPtr	xmlBufCreate (void)
XML_HIDDEN xmlBufPtr	xmlBufCreateSize (size_t size)
XML_HIDDEN int	xmlBufSetAllocationScheme (xmlBufPtr buf, xmlBufferAllocationScheme scheme)
XML_HIDDEN int	xmlBufGetAllocationScheme (xmlBufPtr buf)
XML_HIDDEN void	xmlBufFree (xmlBufPtr buf)
XML_HIDDEN void	xmlBufEmpty (xmlBufPtr buf)
XML_HIDDEN int	xmlBufGrow (xmlBufPtr buf, int len)
XML_HIDDEN int	xmlBufResize (xmlBufPtr buf, size_t len)
XML_HIDDEN int	xmlBufAdd (xmlBufPtr buf, const xmlChar *str, int len)
XML_HIDDEN int	xmlBufCat (xmlBufPtr buf, const xmlChar *str)
XML_HIDDEN int	xmlBufCCat (xmlBufPtr buf, const char *str)
XML_HIDDEN int	xmlBufWriteQuotedString (xmlBufPtr buf, const xmlChar *string)
XML_HIDDEN size_t	xmlBufAvail (const xmlBufPtr buf)
XML_HIDDEN size_t	xmlBufLength (const xmlBufPtr buf)
XML_HIDDEN int	xmlBufIsEmpty (const xmlBufPtr buf)
XML_HIDDEN int	xmlBufAddLen (xmlBufPtr buf, size_t len)
XML_HIDDEN xmlChar *	xmlBufDetach (xmlBufPtr buf)
XML_HIDDEN size_t	xmlBufDump (FILE *file, xmlBufPtr buf)
XML_HIDDEN xmlBufPtr	xmlBufFromBuffer (xmlBufferPtr buffer)
XML_HIDDEN xmlBufferPtr	xmlBufBackToBuffer (xmlBufPtr buf)
XML_HIDDEN int	xmlBufMergeBuffer (xmlBufPtr buf, xmlBufferPtr buffer)
XML_HIDDEN int	xmlBufResetInput (xmlBufPtr buf, xmlParserInputPtr input)
XML_HIDDEN int	xmlBufUpdateInput (xmlBufPtr buf, xmlParserInputPtr input, size_t pos)

Function Documentation

xmlBufAdd()

XML_HIDDEN 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 758 of file buf.c.

                                                      {
    size_t needSize;
 
    if ((str == NULL) || (buf == NULL) || (buf->error))
    return -1;
    CHECK_COMPAT(buf)
 
    if (len < -1) {
    return -1;
    }
    if (len == 0) return 0;
 
    if (len < 0)
        len = xmlStrlen(str);
 
    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) {
            xmlBufMemoryError(buf, "growing buffer past SIZE_MAX");
            return(-1);
        }
        needSize = buf->use + len + 1;
    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);
    buf->use += len;
    buf->content[buf->use] = 0;
    UPDATE_COMPAT(buf)
    return 0;
}

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

xmlBufAddLen()

XML_HIDDEN 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 529 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;
    buf->content[buf->use] = 0;
    UPDATE_COMPAT(buf)
    return(0);
}

xmlBufAvail()

XML_HIDDEN 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 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 if an error occurred.

Definition at line 592 of file buf.c.

{
    if ((!buf) || (buf->error))
        return 0;
    CHECK_COMPAT(buf)
 
    return((buf->size > buf->use) ? (buf->size - buf->use - 1) : 0);
}

xmlBufBackToBuffer()

XML_HIDDEN 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 938 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 = buf->use;
        ret->size = INT_MAX;
    } else {
        ret->use = buf->use;
        ret->size = buf->size;
    }
    ret->alloc = buf->alloc;
    ret->content = buf->content;
    ret->contentIO = buf->contentIO;
    xmlFree(buf);
    return(ret);
}

xmlBufCat()

XML_HIDDEN 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 816 of file buf.c.

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

Referenced by xmlBufCCat(), and xmlBufWriteQuotedString().

xmlBufCCat()

XML_HIDDEN 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 835 of file buf.c.

                                           {
    return xmlBufCat(buf, (const xmlChar *) str);
}

Referenced by xmlBufWriteQuotedString().

xmlBufCreate()

XML_HIDDEN 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->use = 0;
    ret->error = 0;
    ret->buffer = NULL;
    ret->size = xmlDefaultBufferSize;
    UPDATE_COMPAT(ret);
    ret->alloc = xmlBufferAllocScheme;
    ret->content = (xmlChar *) xmlMallocAtomic(ret->size);
    if (ret->content == NULL) {
    xmlBufMemoryError(ret, "creating buffer");
    xmlFree(ret);
        return(NULL);
    }
    ret->content[0] = 0;
    ret->contentIO = NULL;
    return(ret);
}

Referenced by xmlSwitchInputEncoding().

xmlBufCreateSize()

XML_HIDDEN xmlBufPtr xmlBufCreateSize

(

size_t

size

)

xmlBufCreateSize: @size: initial size of buffer

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

Definition at line 155 of file buf.c.

                              {
    xmlBufPtr ret;
 
    if (size == SIZE_MAX)
        return(NULL);
    ret = (xmlBufPtr) xmlMalloc(sizeof(xmlBuf));
    if (ret == NULL) {
    xmlBufMemoryError(NULL, "creating buffer");
        return(NULL);
    }
    ret->use = 0;
    ret->error = 0;
    ret->buffer = NULL;
    ret->alloc = xmlBufferAllocScheme;
    ret->size = (size ? size + 1 : 0);         /* +1 for ending null */
    UPDATE_COMPAT(ret);
    if (ret->size){
        ret->content = (xmlChar *) xmlMallocAtomic(ret->size);
        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);
}

xmlBufDetach()

XML_HIDDEN 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->buffer != NULL)
        return(NULL);
    if (buf->error)
        return(NULL);
 
    ret = buf->content;
    buf->content = NULL;
    buf->size = 0;
    buf->use = 0;
    UPDATE_COMPAT(buf);
 
    return ret;
}

Referenced by xmlLoadEntityContent().

xmlBufDump()

XML_HIDDEN size_t xmlBufDump	(	FILE *	file,
		xmlBufPtr	buf
	)

Definition at line 464 of file buf.c.

                                      {
    size_t ret;
 
    if ((buf == NULL) || (buf->error != 0)) {
    return(0);
    }
    if (buf->content == NULL) {
    return(0);
    }
    CHECK_COMPAT(buf)
    if (file == NULL)
    file = stdout;
    ret = fwrite(buf->content, 1, buf->use, file);
    return(ret);
}

xmlBufEmpty()

XML_HIDDEN void xmlBufEmpty

(

xmlBufPtr

buf

)

xmlBufEmpty: @buf: the buffer

empty a buffer.

Definition at line 297 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_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)
}

xmlBufFree()

XML_HIDDEN 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 276 of file buf.c.

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

Referenced by xmlBufBackToBuffer().

xmlBufFromBuffer()

XML_HIDDEN 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 902 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;
    UPDATE_COMPAT(ret);
    ret->error = 0;
    ret->buffer = buffer;
    ret->alloc = buffer->alloc;
    ret->content = buffer->content;
    ret->contentIO = buffer->contentIO;
 
    return(ret);
}

xmlBufGetAllocationScheme()

XML_HIDDEN 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 224 of file buf.c.

                                         {
    if (buf == NULL) {
        return(-1);
    }
    return(buf->alloc);
}

xmlBufGrow()

XML_HIDDEN 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 443 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(ret > INT_MAX ? INT_MAX : ret);
}

xmlBufIsEmpty()

XML_HIDDEN 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 610 of file buf.c.

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

Referenced by xmlParseDocument(), and xmlSwitchInputEncoding().

xmlBufLength()

XML_HIDDEN 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 551 of file buf.c.

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

xmlBufMergeBuffer()

XML_HIDDEN 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 993 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);
}

xmlBufResetInput()

XML_HIDDEN 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 1019 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 = input->cur = buf->content;
    input->end = &buf->content[buf->use];
    return(0);
}

Referenced by xmlCreateDocParserCtxt(), xmlCreateMemoryParserCtxt(), xmlCtxtResetPush(), xmlLoadEntityContent(), xmlNewInputFromFile(), xmlNewIOInputStream(), xmlNewStringInputStream(), and xmlSwitchInputEncoding().

xmlBufResize()

XML_HIDDEN 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 629 of file buf.c.

{
    size_t newSize;
    xmlChar* rebuf = NULL;
    size_t start_buf;
 
    if ((buf == NULL) || (buf->error))
        return(0);
    CHECK_COMPAT(buf)
 
    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*/
            if (buf->size == 0) {
                newSize = (size > SIZE_MAX - 10 ? SIZE_MAX : size + 10);
            } else {
                newSize = buf->size;
            }
        while (size > newSize) {
            if (newSize > SIZE_MAX / 2) {
                xmlBufMemoryError(buf, "growing buffer");
                return 0;
            }
            newSize *= 2;
        }
        break;
    case XML_BUFFER_ALLOC_EXACT:
            newSize = (size > SIZE_MAX - 10 ? SIZE_MAX : size + 10);
        break;
        case XML_BUFFER_ALLOC_HYBRID:
            if (buf->use < BASE_BUFFER_SIZE)
                newSize = size;
            else {
                newSize = buf->size;
                while (size > newSize) {
                    if (newSize > SIZE_MAX / 2) {
                        xmlBufMemoryError(buf, "growing buffer");
                        return 0;
                    }
                    newSize *= 2;
                }
            }
            break;
 
    default:
            newSize = (size > SIZE_MAX - 10 ? SIZE_MAX : 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);
        buf->use = 0;
            if (rebuf != NULL)
            rebuf[buf->use] = 0;
    } 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().

xmlBufSetAllocationScheme()

XML_HIDDEN 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 241 of file buf.c.

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

xmlBufUpdateInput()

XML_HIDDEN int xmlBufUpdateInput	(	xmlBufPtr	buf,
		xmlParserInputPtr	input,
		size_t	pos
	)

xmlBufUpdateInput: @buf: an xmlBufPtr @input: an xmlParserInputPtr @pos: 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 1044 of file buf.c.

                                                                      {
    if (input == NULL)
        return(-1);
    /*
     * TODO: It might be safer to keep using the buffer content if there
     * was an error.
     */
    if ((buf == NULL) || (buf->error)) {
        input->base = input->cur = input->end = BAD_CAST "";
        return(-1);
    }
    CHECK_COMPAT(buf)
    input->base = buf->content;
    input->cur = input->base + pos;
    input->end = &buf->content[buf->use];
    return(0);
}

Referenced by xmlCtxtResetPush(), xmlParserGrow(), and xmlParserShrink().

xmlBufWriteQuotedString()

XML_HIDDEN 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 852 of file buf.c.

                                                              {
    const xmlChar *cur, *base;
    if ((buf == NULL) || (buf->error))
        return(-1);
    CHECK_COMPAT(buf)
    if (xmlStrchr(string, '\"')) {
        if (xmlStrchr(string, '\'')) {
        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);
}