#endif
#include <libxml/globals.h>
+#include "buf.h"
+#include "enc.h"
+
/* #define VERBOSE_FAILURE */
/* #define DEBUG_EXTERNAL_ENTITIES */
/* #define DEBUG_INPUT */
xmlCheckFilename (const char *path)
{
#ifdef HAVE_STAT
- struct stat stat_buffer;
+ struct stat stat_buffer;
#endif
- if (path == NULL)
- return(0);
+ if (path == NULL)
+ return(0);
#ifdef HAVE_STAT
#if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
+ /*
+ * On Windows stat and wstat do not work with long pathname,
+ * which start with '\\?\'
+ */
+ if ((path[0] == '\\') && (path[1] == '\\') && (path[2] == '?') &&
+ (path[3] == '\\') )
+ return 1;
+
if (xmlWrapStat(path, &stat_buffer) == -1)
return 0;
#else
return 1;
}
-static int
+/**
+ * xmlNop:
+ *
+ * No Operation function, does nothing, no input
+ *
+ * Returns zero
+ */
+int
xmlNop(void) {
return(0);
}
*/
static void *
xmlFileOpen_real (const char *filename) {
- const char *path = NULL;
+ const char *path = filename;
FILE *fd;
if (filename == NULL)
#else
path = &filename[5];
#endif
- } else
- path = filename;
+ }
- if (path == NULL)
- return(NULL);
if (!xmlCheckFilename(path))
return(NULL);
#if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
fd = xmlWrapOpen(path, 1);
#else
- fd = fopen(path, "wb");
+ fd = fopen(path, "wb");
#endif /* WIN32 */
if (fd == NULL) xmlIOErr(0, path);
gzFile fd;
if (!strcmp(filename, "-")) {
- fd = gzdopen(dup(0), "rb");
+ int duped_fd = dup(fileno(stdin));
+ fd = gzdopen(duped_fd, "rb");
+ if (fd == Z_NULL && duped_fd >= 0) {
+ close(duped_fd); /* gzdOpen() does not close on failure */
+ }
+
return((void *) fd);
}
snprintf(mode, sizeof(mode), "wb%d", compression);
if (!strcmp(filename, "-")) {
- fd = gzdopen(dup(1), mode);
+ int duped_fd = dup(fileno(stdout));
+ fd = gzdopen(duped_fd, "rb");
+ if (fd == Z_NULL && duped_fd >= 0) {
+ close(duped_fd); /* gzdOpen() does not close on failure */
+ }
+
return((void *) fd);
}
xzFile fd;
if (!strcmp(filename, "-")) {
- fd = __libxml2_xzdopen(dup(0), "rb");
+ fd = __libxml2_xzdopen(dup(fileno(stdin)), "rb");
return((void *) fd);
}
/* Pull the data out of the memory output buffer */
xmlOutputBufferPtr dctxt = ctxt->doc_buff;
- http_content = (char *)dctxt->buffer->content;
- content_lgth = dctxt->buffer->use;
+ http_content = (char *) xmlBufContent(dctxt->buffer);
+ content_lgth = xmlBufUse(dctxt->buffer);
}
if ( http_content == NULL ) {
return(NULL);
}
memset(ret, 0, (size_t) sizeof(xmlParserInputBuffer));
- ret->buffer = xmlBufferCreateSize(2 * xmlDefaultBufferSize);
+ ret->buffer = xmlBufCreateSize(2 * xmlDefaultBufferSize);
if (ret->buffer == NULL) {
xmlFree(ret);
return(NULL);
}
- ret->buffer->alloc = XML_BUFFER_ALLOC_DOUBLEIT;
+ xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_DOUBLEIT);
ret->encoder = xmlGetCharEncodingHandler(enc);
if (ret->encoder != NULL)
- ret->raw = xmlBufferCreateSize(2 * xmlDefaultBufferSize);
+ ret->raw = xmlBufCreateSize(2 * xmlDefaultBufferSize);
else
ret->raw = NULL;
ret->readcallback = NULL;
return(NULL);
}
memset(ret, 0, (size_t) sizeof(xmlOutputBuffer));
- ret->buffer = xmlBufferCreate();
+ ret->buffer = xmlBufCreate();
if (ret->buffer == NULL) {
xmlFree(ret);
return(NULL);
}
/* try to avoid a performance problem with Windows realloc() */
- if (ret->buffer->alloc == XML_BUFFER_ALLOC_EXACT)
- ret->buffer->alloc = XML_BUFFER_ALLOC_DOUBLEIT;
+ if (xmlBufGetAllocationScheme(ret->buffer) == XML_BUFFER_ALLOC_EXACT)
+ xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_DOUBLEIT);
ret->encoder = encoder;
if (encoder != NULL) {
- ret->conv = xmlBufferCreateSize(4000);
+ ret->conv = xmlBufCreateSize(4000);
if (ret->conv == NULL) {
xmlFree(ret);
return(NULL);
/*
* This call is designed to initiate the encoder state
*/
- xmlCharEncOutFunc(encoder, ret->conv, NULL);
+ xmlCharEncOutput(ret, 1);
} else
ret->conv = NULL;
ret->writecallback = NULL;
return(NULL);
}
memset(ret, 0, (size_t) sizeof(xmlOutputBuffer));
- ret->buffer = xmlBufferCreate();
+ ret->buffer = xmlBufCreate();
if (ret->buffer == NULL) {
xmlFree(ret);
return(NULL);
/*
* For conversion buffers we use the special IO handling
- * We don't do that from the exported API to avoid confusing
- * user's code.
*/
- ret->buffer->alloc = XML_BUFFER_ALLOC_IO;
- ret->buffer->contentIO = ret->buffer->content;
+ xmlBufSetAllocationScheme(ret->buffer, XML_BUFFER_ALLOC_IO);
ret->encoder = encoder;
if (encoder != NULL) {
- ret->conv = xmlBufferCreateSize(4000);
+ ret->conv = xmlBufCreateSize(4000);
if (ret->conv == NULL) {
xmlFree(ret);
return(NULL);
/*
* This call is designed to initiate the encoder state
*/
- xmlCharEncOutFunc(encoder, ret->conv, NULL);
+ xmlCharEncOutput(ret, 1);
} else
ret->conv = NULL;
ret->writecallback = NULL;
if (in == NULL) return;
if (in->raw) {
- xmlBufferFree(in->raw);
+ xmlBufFree(in->raw);
in->raw = NULL;
}
if (in->encoder != NULL) {
in->closecallback(in->context);
}
if (in->buffer != NULL) {
- xmlBufferFree(in->buffer);
+ xmlBufFree(in->buffer);
in->buffer = NULL;
}
}
written = out->written;
if (out->conv) {
- xmlBufferFree(out->conv);
+ xmlBufFree(out->conv);
out->conv = NULL;
}
if (out->encoder != NULL) {
xmlCharEncCloseFunc(out->encoder);
}
if (out->buffer != NULL) {
- xmlBufferFree(out->buffer);
+ xmlBufFree(out->buffer);
out->buffer = NULL;
}
#endif
}
#endif
+#ifdef HAVE_LZMA_H
+ if ((xmlInputCallbackTable[i].opencallback == xmlXzfileOpen) &&
+ (strcmp(URI, "-") != 0)) {
+ ret->compressed = __libxml2_xzcompressed(context);
+ }
+#endif
}
else
xmlInputCallbackTable[i].closecallback (context);
return(ret);
}
+/**
+ * xmlOutputBufferGetContent:
+ * @out: an xmlOutputBufferPtr
+ *
+ * Gives a pointer to the data currently held in the output buffer
+ *
+ * Returns a pointer to the data or NULL in case of error
+ */
+const xmlChar *
+xmlOutputBufferGetContent(xmlOutputBufferPtr out) {
+ if ((out == NULL) || (out->buffer == NULL))
+ return(NULL);
+
+ return(xmlBufContent(out->buffer));
+}
+
+/**
+ * xmlOutputBufferGetSize:
+ * @out: an xmlOutputBufferPtr
+ *
+ * Gives the length of the data currently held in the output buffer
+ *
+ * Returns 0 in case or error or no data is held, the size otherwise
+ */
+size_t
+xmlOutputBufferGetSize(xmlOutputBufferPtr out) {
+ if ((out == NULL) || (out->buffer == NULL))
+ return(0);
+
+ return(xmlBufUse(out->buffer));
+}
+
+
#endif /* LIBXML_OUTPUT_ENABLED */
/**
ret->context = (void *) mem;
ret->readcallback = (xmlInputReadCallback) xmlNop;
ret->closecallback = NULL;
- errcode = xmlBufferAdd(ret->buffer, (const xmlChar *) mem, size);
+ errcode = xmlBufAdd(ret->buffer, (const xmlChar *) mem, size);
if (errcode != 0) {
xmlFree(ret);
return(NULL);
return(NULL);
}
memset(ret, 0, (size_t) sizeof(xmlParserInputBuffer));
- ret->buffer = xmlBufferCreateStatic((void *)mem, (size_t) size);
+ ret->buffer = xmlBufCreateStatic((void *)mem, (size_t) size);
if (ret->buffer == NULL) {
xmlFree(ret);
return(NULL);
}
ret->encoder = xmlGetCharEncodingHandler(enc);
if (ret->encoder != NULL)
- ret->raw = xmlBufferCreateSize(2 * xmlDefaultBufferSize);
+ ret->raw = xmlBufCreateSize(2 * xmlDefaultBufferSize);
else
ret->raw = NULL;
ret->compressed = -1;
* Store the data in the incoming raw buffer
*/
if (in->raw == NULL) {
- in->raw = xmlBufferCreate();
+ in->raw = xmlBufCreate();
}
- ret = xmlBufferAdd(in->raw, (const xmlChar *) buf, len);
+ ret = xmlBufAdd(in->raw, (const xmlChar *) buf, len);
if (ret != 0)
return(-1);
/*
* convert as much as possible to the parser reading buffer.
*/
- use = in->raw->use;
- nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
+ use = xmlBufUse(in->raw);
+ nbchars = xmlCharEncInput(in, 1);
if (nbchars < 0) {
xmlIOErr(XML_IO_ENCODER, NULL);
in->error = XML_IO_ENCODER;
return(-1);
}
- in->rawconsumed += (use - in->raw->use);
+ in->rawconsumed += (use - xmlBufUse(in->raw));
} else {
nbchars = len;
- ret = xmlBufferAdd(in->buffer, (xmlChar *) buf, nbchars);
+ ret = xmlBufAdd(in->buffer, (xmlChar *) buf, nbchars);
if (ret != 0)
return(-1);
}
#ifdef DEBUG_INPUT
xmlGenericError(xmlGenericErrorContext,
"I/O: pushed %d chars, buffer %d/%d\n",
- nbchars, in->buffer->use, in->buffer->size);
+ nbchars, xmlBufUse(in->buffer), xmlBufLength(in->buffer));
#endif
return(nbchars);
}
char *buffer = NULL;
int res = 0;
int nbchars = 0;
- int buffree;
- unsigned int needSize;
if ((in == NULL) || (in->error)) return(-1);
if ((len <= MINLEN) && (len != 4))
len = MINLEN;
- buffree = in->buffer->size - in->buffer->use;
- if (buffree <= 0) {
+ if (xmlBufAvail(in->buffer) <= 0) {
xmlIOErr(XML_IO_BUFFER_FULL, NULL);
in->error = XML_IO_BUFFER_FULL;
return(-1);
}
- needSize = in->buffer->use + len + 1;
- if (needSize > in->buffer->size){
- if (!xmlBufferResize(in->buffer, needSize)){
- xmlIOErrMemory("growing input buffer");
- in->error = XML_ERR_NO_MEMORY;
- return(-1);
- }
+ if (xmlBufGrow(in->buffer, len + 1) < 0) {
+ xmlIOErrMemory("growing input buffer");
+ in->error = XML_ERR_NO_MEMORY;
+ return(-1);
}
- buffer = (char *)&in->buffer->content[in->buffer->use];
+ buffer = (char *)xmlBufEnd(in->buffer);
/*
* Call the read method for this I/O type.
if (res < 0) {
return(-1);
}
+
+ /*
+ * try to establish compressed status of input if not done already
+ */
+ if (in->compressed == -1) {
+#ifdef HAVE_LZMA_H
+ if (in->readcallback == xmlXzfileRead)
+ in->compressed = __libxml2_xzcompressed(in->context);
+#endif
+ }
+
len = res;
if (in->encoder != NULL) {
unsigned int use;
* Store the data in the incoming raw buffer
*/
if (in->raw == NULL) {
- in->raw = xmlBufferCreate();
+ in->raw = xmlBufCreate();
}
- res = xmlBufferAdd(in->raw, (const xmlChar *) buffer, len);
+ res = xmlBufAdd(in->raw, (const xmlChar *) buffer, len);
if (res != 0)
return(-1);
/*
* convert as much as possible to the parser reading buffer.
*/
- use = in->raw->use;
- nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
+ use = xmlBufUse(in->raw);
+ nbchars = xmlCharEncInput(in, 1);
if (nbchars < 0) {
xmlIOErr(XML_IO_ENCODER, NULL);
in->error = XML_IO_ENCODER;
return(-1);
}
- in->rawconsumed += (use - in->raw->use);
+ in->rawconsumed += (use - xmlBufUse(in->raw));
} else {
nbchars = len;
- in->buffer->use += nbchars;
- buffer[nbchars] = 0;
+ xmlBufAddLen(in->buffer, nbchars);
}
#ifdef DEBUG_INPUT
xmlGenericError(xmlGenericErrorContext,
- "I/O: read %d chars, buffer %d/%d\n",
- nbchars, in->buffer->use, in->buffer->size);
+ "I/O: read %d chars, buffer %d\n",
+ nbchars, xmlBufUse(in->buffer));
#endif
return(nbchars);
}
if ((in == NULL) || (in->error)) return(-1);
if (in->readcallback != NULL)
return(xmlParserInputBufferGrow(in, len));
- else if ((in->buffer != NULL) &&
- (in->buffer->alloc == XML_BUFFER_ALLOC_IMMUTABLE))
+ else if (xmlBufGetAllocationScheme(in->buffer) == XML_BUFFER_ALLOC_IMMUTABLE)
return(0);
else
return(-1);
* Store the data in the incoming raw buffer
*/
if (out->conv == NULL) {
- out->conv = xmlBufferCreate();
+ out->conv = xmlBufCreate();
}
- ret = xmlBufferAdd(out->buffer, (const xmlChar *) buf, chunk);
+ ret = xmlBufAdd(out->buffer, (const xmlChar *) buf, chunk);
if (ret != 0)
return(-1);
- if ((out->buffer->use < MINLEN) && (chunk == len))
+ if ((xmlBufUse(out->buffer) < MINLEN) && (chunk == len))
goto done;
/*
* convert as much as possible to the parser reading buffer.
*/
- ret = xmlCharEncOutFunc(out->encoder, out->conv, out->buffer);
+ ret = xmlCharEncOutput(out, 0);
if ((ret < 0) && (ret != -3)) {
xmlIOErr(XML_IO_ENCODER, NULL);
out->error = XML_IO_ENCODER;
return(-1);
}
- nbchars = out->conv->use;
+ nbchars = xmlBufUse(out->conv);
} else {
- ret = xmlBufferAdd(out->buffer, (const xmlChar *) buf, chunk);
+ ret = xmlBufAdd(out->buffer, (const xmlChar *) buf, chunk);
if (ret != 0)
return(-1);
- nbchars = out->buffer->use;
+ nbchars = xmlBufUse(out->buffer);
}
buf += chunk;
len -= chunk;
*/
if (out->encoder != NULL) {
ret = out->writecallback(out->context,
- (const char *)out->conv->content, nbchars);
+ (const char *)xmlBufContent(out->conv), nbchars);
if (ret >= 0)
- xmlBufferShrink(out->conv, ret);
+ xmlBufShrink(out->conv, ret);
} else {
ret = out->writecallback(out->context,
- (const char *)out->buffer->content, nbchars);
+ (const char *)xmlBufContent(out->buffer), nbchars);
if (ret >= 0)
- xmlBufferShrink(out->buffer, ret);
+ xmlBufShrink(out->buffer, ret);
}
if (ret < 0) {
xmlIOErr(XML_IO_WRITE, NULL);
inend = in + (*inlen);
while ((in < inend) && (out < outend)) {
- if (*in == '<') {
+ if (*in == '<') {
if (outend - out < 4) break;
*out++ = '&';
*out++ = 'l';
if ((out == NULL) || (out->error) || (str == NULL) ||
(out->buffer == NULL) ||
- (out->buffer->alloc == XML_BUFFER_ALLOC_IMMUTABLE)) return(-1);
+ (xmlBufGetAllocationScheme(out->buffer) == XML_BUFFER_ALLOC_IMMUTABLE))
+ return(-1);
len = strlen((const char *)str);
if (len < 0) return(0);
if (out->error) return(-1);
* how many bytes to consume and how many bytes to store.
*/
cons = len;
- chunk = (out->buffer->size - out->buffer->use) - 1;
+ chunk = xmlBufAvail(out->buffer) - 1;
/*
* make sure we have enough room to save first, if this is
* not the case force a flush, but make sure we stay in the loop
*/
if (chunk < 40) {
- if (xmlBufferGrow(out->buffer, out->buffer->size + 100) < 0)
+ if (xmlBufGrow(out->buffer, 100) < 0)
return(-1);
oldwritten = -1;
continue;
* Store the data in the incoming raw buffer
*/
if (out->conv == NULL) {
- out->conv = xmlBufferCreate();
+ out->conv = xmlBufCreate();
}
- ret = escaping(out->buffer->content + out->buffer->use ,
+ ret = escaping(xmlBufEnd(out->buffer) ,
&chunk, str, &cons);
if ((ret < 0) || (chunk == 0)) /* chunk==0 => nothing done */
return(-1);
- out->buffer->use += chunk;
- out->buffer->content[out->buffer->use] = 0;
+ xmlBufAddLen(out->buffer, chunk);
- if ((out->buffer->use < MINLEN) && (cons == len))
+ if ((xmlBufUse(out->buffer) < MINLEN) && (cons == len))
goto done;
/*
* convert as much as possible to the output buffer.
*/
- ret = xmlCharEncOutFunc(out->encoder, out->conv, out->buffer);
+ ret = xmlCharEncOutput(out, 0);
if ((ret < 0) && (ret != -3)) {
xmlIOErr(XML_IO_ENCODER, NULL);
out->error = XML_IO_ENCODER;
return(-1);
}
- nbchars = out->conv->use;
+ nbchars = xmlBufUse(out->conv);
} else {
- ret = escaping(out->buffer->content + out->buffer->use ,
- &chunk, str, &cons);
+ ret = escaping(xmlBufEnd(out->buffer), &chunk, str, &cons);
if ((ret < 0) || (chunk == 0)) /* chunk==0 => nothing done */
return(-1);
- out->buffer->use += chunk;
- out->buffer->content[out->buffer->use] = 0;
- nbchars = out->buffer->use;
+ xmlBufAddLen(out->buffer, chunk);
+ nbchars = xmlBufUse(out->buffer);
}
str += cons;
len -= cons;
*/
if (out->encoder != NULL) {
ret = out->writecallback(out->context,
- (const char *)out->conv->content, nbchars);
+ (const char *)xmlBufContent(out->conv), nbchars);
if (ret >= 0)
- xmlBufferShrink(out->conv, ret);
+ xmlBufShrink(out->conv, ret);
} else {
ret = out->writecallback(out->context,
- (const char *)out->buffer->content, nbchars);
+ (const char *)xmlBufContent(out->buffer), nbchars);
if (ret >= 0)
- xmlBufferShrink(out->buffer, ret);
+ xmlBufShrink(out->buffer, ret);
}
if (ret < 0) {
xmlIOErr(XML_IO_WRITE, NULL);
return(ret);
}
out->written += ret;
- } else if (out->buffer->size - out->buffer->use < MINLEN) {
- xmlBufferResize(out->buffer, out->buffer->size + MINLEN);
+ } else if (xmlBufAvail(out->buffer) < MINLEN) {
+ xmlBufGrow(out->buffer, MINLEN);
}
written += nbchars;
} while ((len > 0) && (oldwritten != written));
*/
if ((out->conv != NULL) && (out->encoder != NULL)) {
/*
- * convert as much as possible to the parser reading buffer.
+ * convert as much as possible to the parser output buffer.
*/
- nbchars = xmlCharEncOutFunc(out->encoder, out->conv, out->buffer);
- if (nbchars < 0) {
- xmlIOErr(XML_IO_ENCODER, NULL);
- out->error = XML_IO_ENCODER;
- return(-1);
- }
+ do {
+ nbchars = xmlCharEncOutput(out, 0);
+ if (nbchars < 0) {
+ xmlIOErr(XML_IO_ENCODER, NULL);
+ out->error = XML_IO_ENCODER;
+ return(-1);
+ }
+ } while (nbchars);
}
/*
if ((out->conv != NULL) && (out->encoder != NULL) &&
(out->writecallback != NULL)) {
ret = out->writecallback(out->context,
- (const char *)out->conv->content, out->conv->use);
+ (const char *)xmlBufContent(out->conv),
+ xmlBufUse(out->conv));
if (ret >= 0)
- xmlBufferShrink(out->conv, ret);
+ xmlBufShrink(out->conv, ret);
} else if (out->writecallback != NULL) {
ret = out->writecallback(out->context,
- (const char *)out->buffer->content, out->buffer->use);
+ (const char *)xmlBufContent(out->buffer),
+ xmlBufUse(out->buffer));
if (ret >= 0)
- xmlBufferShrink(out->buffer, ret);
+ xmlBufShrink(out->buffer, ret);
}
if (ret < 0) {
xmlIOErr(XML_IO_FLUSH, NULL);
projects / platform / upstream / libxml2.git / blobdiff