typedef struct
{
- PyObject_HEAD
- z_stream zst;
- PyObject *unused_data;
- PyObject *unconsumed_tail;
- int is_initialised;
+ PyObject_HEAD
+ z_stream zst;
+ PyObject *unused_data;
+ PyObject *unconsumed_tail;
+ int is_initialised;
} compobject;
static char compressobj__doc__[] =
static compobject *
newcompobject(PyTypeObject *type)
{
- compobject *self;
- self = PyObject_New(compobject, type);
- if (self == NULL)
- return NULL;
- self->is_initialised = 0;
- self->unused_data = PyString_FromString("");
- if (self->unused_data == NULL) {
- Py_DECREF(self);
- return NULL;
- }
- self->unconsumed_tail = PyString_FromString("");
- if (self->unconsumed_tail == NULL) {
- Py_DECREF(self);
- return NULL;
- }
- return self;
+ compobject *self;
+ self = PyObject_New(compobject, type);
+ if (self == NULL)
+ return NULL;
+ self->is_initialised = 0;
+ self->unused_data = PyString_FromString("");
+ if (self->unused_data == NULL) {
+ Py_DECREF(self);
+ return NULL;
+ }
+ self->unconsumed_tail = PyString_FromString("");
+ if (self->unconsumed_tail == NULL) {
+ Py_DECREF(self);
+ return NULL;
+ }
+ return self;
}
static char compress__doc__[] =
static PyObject *
PyZlib_compress(PyObject *self, PyObject *args)
{
- PyObject *ReturnVal = NULL;
- Byte *input, *output;
- int length, level=Z_DEFAULT_COMPRESSION, err;
- z_stream zst;
- int return_error;
- PyObject * inputString;
+ PyObject *ReturnVal = NULL;
+ Byte *input, *output;
+ int length, level=Z_DEFAULT_COMPRESSION, err;
+ z_stream zst;
+ int return_error;
+ PyObject * inputString;
- /* require Python string object, optional 'level' arg */
- if (!PyArg_ParseTuple(args, "S|i:compress", &inputString, &level))
- return NULL;
+ /* require Python string object, optional 'level' arg */
+ if (!PyArg_ParseTuple(args, "S|i:compress", &inputString, &level))
+ return NULL;
- /* now get a pointer to the internal string */
- if (PyString_AsStringAndSize(inputString, (char**)&input, &length) == -1)
- return NULL;
+ /* now get a pointer to the internal string */
+ if (PyString_AsStringAndSize(inputString, (char**)&input, &length) == -1)
+ return NULL;
- zst.avail_out = length + length/1000 + 12 + 1;
+ zst.avail_out = length + length/1000 + 12 + 1;
- output=(Byte*)malloc(zst.avail_out);
- if (output==NULL)
+ output=(Byte*)malloc(zst.avail_out);
+ if (output==NULL)
{
- PyErr_SetString(PyExc_MemoryError,
- "Can't allocate memory to compress data");
- free(output);
+ PyErr_SetString(PyExc_MemoryError,
+ "Can't allocate memory to compress data");
+ free(output);
- return NULL;
+ return NULL;
}
- /* Past the point of no return. From here on out, we need to make sure
- we clean up mallocs & INCREFs. */
+ /* Past the point of no return. From here on out, we need to make sure
+ we clean up mallocs & INCREFs. */
- Py_INCREF(inputString); /* increment so that we hold ref */
+ Py_INCREF(inputString); /* increment so that we hold ref */
- zst.zalloc=(alloc_func)NULL;
- zst.zfree=(free_func)Z_NULL;
- zst.next_out=(Byte *)output;
- zst.next_in =(Byte *)input;
- zst.avail_in=length;
- err=deflateInit(&zst, level);
+ zst.zalloc=(alloc_func)NULL;
+ zst.zfree=(free_func)Z_NULL;
+ zst.next_out=(Byte *)output;
+ zst.next_in =(Byte *)input;
+ zst.avail_in=length;
+ err=deflateInit(&zst, level);
- return_error = 0;
- switch(err)
+ return_error = 0;
+ switch(err)
{
case(Z_OK):
- break;
+ break;
case(Z_MEM_ERROR):
- PyErr_SetString(PyExc_MemoryError,
- "Out of memory while compressing data");
- return_error = 1;
- break;
+ PyErr_SetString(PyExc_MemoryError,
+ "Out of memory while compressing data");
+ return_error = 1;
+ break;
case(Z_STREAM_ERROR):
- PyErr_SetString(ZlibError,
- "Bad compression level");
- return_error = 1;
- break;
- default:
- {
+ PyErr_SetString(ZlibError,
+ "Bad compression level");
+ return_error = 1;
+ break;
+ default: {
if (zst.msg == Z_NULL)
PyErr_Format(ZlibError, "Error %i while compressing data",
err);
err, zst.msg);
deflateEnd(&zst);
return_error = 1;
- }
+ }
}
- if (!return_error) {
- Py_BEGIN_ALLOW_THREADS
- err=deflate(&zst, Z_FINISH);
- Py_END_ALLOW_THREADS
+ if (!return_error) {
+ Py_BEGIN_ALLOW_THREADS;
+ err=deflate(&zst, Z_FINISH);
+ Py_END_ALLOW_THREADS;
- switch(err)
- {
- case(Z_STREAM_END):
- break;
- /* Are there other errors to be trapped here? */
- default:
+ switch(err)
{
- if (zst.msg == Z_NULL)
- PyErr_Format(ZlibError, "Error %i while compressing data",
- err);
- else
- PyErr_Format(ZlibError, "Error %i while compressing data: %.200s",
- err, zst.msg);
+ case(Z_STREAM_END):
+ break;
+ /* Are there other errors to be trapped here? */
+ default: {
+ if (zst.msg == Z_NULL)
+ PyErr_Format(ZlibError, "Error %i while compressing data",
+ err);
+ else
+ PyErr_Format(ZlibError, "Error %i while compressing data: %.200s",
+ err, zst.msg);
- deflateEnd(&zst);
+ deflateEnd(&zst);
- return_error = 1;
+ return_error = 1;
+ }
}
- }
- if (!return_error) {
- err=deflateEnd(&zst);
- if (err == Z_OK)
- ReturnVal = PyString_FromStringAndSize((char *)output, zst.total_out);
- else {
- {
- if (zst.msg == Z_NULL)
- PyErr_Format(ZlibError, "Error %i while finishing compression",
- err);
- else
- PyErr_Format(ZlibError,
- "Error %i while finishing compression: %.200s",
- err, zst.msg);
+ if (!return_error) {
+ err=deflateEnd(&zst);
+ if (err == Z_OK)
+ ReturnVal = PyString_FromStringAndSize((char *)output,
+ zst.total_out);
+ else {
+ if (zst.msg == Z_NULL)
+ PyErr_Format(ZlibError,
+ "Error %i while finishing compression",
+ err);
+ else
+ PyErr_Format(ZlibError,
+ "Error %i while finishing compression: %.200s",
+ err, zst.msg);
+ }
}
- }
-
}
- }
- free(output);
- Py_DECREF(inputString);
+ free(output);
+ Py_DECREF(inputString);
- return ReturnVal;
+ return ReturnVal;
}
static char decompress__doc__[] =
static PyObject *
PyZlib_decompress(PyObject *self, PyObject *args)
{
- PyObject *result_str;
- Byte *input;
- int length, err;
- int wsize=DEF_WBITS, r_strlen=DEFAULTALLOC;
- z_stream zst;
- int return_error;
- PyObject * inputString;
-
- if (!PyArg_ParseTuple(args, "S|ii:decompress", &inputString, &wsize, &r_strlen))
- return NULL;
- if (PyString_AsStringAndSize(inputString, (char**)&input, &length) == -1)
- return NULL;
-
- if (r_strlen <= 0)
- r_strlen = 1;
-
- zst.avail_in=length;
- zst.avail_out=r_strlen;
-
- if (!(result_str = PyString_FromStringAndSize(NULL, r_strlen)))
- {
- PyErr_SetString(PyExc_MemoryError,
- "Can't allocate memory to decompress data");
- return NULL;
- }
+ PyObject *result_str;
+ Byte *input;
+ int length, err;
+ int wsize=DEF_WBITS, r_strlen=DEFAULTALLOC;
+ z_stream zst;
+ int return_error;
+ PyObject * inputString;
+
+ if (!PyArg_ParseTuple(args, "S|ii:decompress",
+ &inputString, &wsize, &r_strlen))
+ return NULL;
+ if (PyString_AsStringAndSize(inputString, (char**)&input, &length) == -1)
+ return NULL;
- /* Past the point of no return. From here on out, we need to make sure
- we clean up mallocs & INCREFs. */
+ if (r_strlen <= 0)
+ r_strlen = 1;
- Py_INCREF(inputString); /* increment so that we hold ref */
+ zst.avail_in = length;
+ zst.avail_out = r_strlen;
- zst.zalloc=(alloc_func)NULL;
- zst.zfree=(free_func)Z_NULL;
- zst.next_out=(Byte *)PyString_AsString(result_str);
- zst.next_in =(Byte *)input;
- err=inflateInit2(&zst, wsize);
+ if (!(result_str = PyString_FromStringAndSize(NULL, r_strlen))) {
+ PyErr_SetString(PyExc_MemoryError,
+ "Can't allocate memory to decompress data");
+ return NULL;
+ }
- return_error = 0;
- switch(err)
- {
+ /* Past the point of no return. From here on out, we need to make sure
+ we clean up mallocs & INCREFs. */
+
+ Py_INCREF(inputString); /* increment so that we hold ref */
+
+ zst.zalloc = (alloc_func)NULL;
+ zst.zfree = (free_func)Z_NULL;
+ zst.next_out = (Byte *)PyString_AsString(result_str);
+ zst.next_in = (Byte *)input;
+ err = inflateInit2(&zst, wsize);
+
+ return_error = 0;
+ switch(err) {
case(Z_OK):
- break;
+ break;
case(Z_MEM_ERROR):
- PyErr_SetString(PyExc_MemoryError,
- "Out of memory while decompressing data");
- return_error = 1;
- default:
- {
+ PyErr_SetString(PyExc_MemoryError,
+ "Out of memory while decompressing data");
+ return_error = 1;
+ default: {
if (zst.msg == Z_NULL)
PyErr_Format(ZlibError, "Error %i preparing to decompress data",
err);
inflateEnd(&zst);
return_error = 1;
- }
+ }
}
- do
- {
- if (return_error)
- break;
+ do {
+ if (return_error)
+ break;
- Py_BEGIN_ALLOW_THREADS
- err=inflate(&zst, Z_FINISH);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ err=inflate(&zst, Z_FINISH);
+ Py_END_ALLOW_THREADS
- switch(err)
- {
- case(Z_STREAM_END):
+ switch(err) {
+ case(Z_STREAM_END):
break;
case(Z_BUF_ERROR):
/*
* process the inflate call() due to an error in the data.
*/
if (zst.avail_out > 0)
- {
- PyErr_Format(ZlibError, "Error %i while decompressing data",
- err);
- inflateEnd(&zst);
- return_error = 1;
- break;
- }
+ {
+ PyErr_Format(ZlibError, "Error %i while decompressing data",
+ err);
+ inflateEnd(&zst);
+ return_error = 1;
+ break;
+ }
/* fall through */
case(Z_OK):
/* need more memory */
- if (_PyString_Resize(&result_str, r_strlen << 1) == -1)
- {
- PyErr_SetString(PyExc_MemoryError,
- "Out of memory while decompressing data");
- inflateEnd(&zst);
- result_str = NULL;
- return_error = 1;
- }
- zst.next_out = (unsigned char *)PyString_AsString(result_str) + r_strlen;
- zst.avail_out=r_strlen;
+ if (_PyString_Resize(&result_str, r_strlen << 1) == -1) {
+ PyErr_SetString(PyExc_MemoryError,
+ "Out of memory while decompressing data");
+ inflateEnd(&zst);
+ result_str = NULL;
+ return_error = 1;
+ }
+ zst.next_out = (unsigned char *)PyString_AsString(result_str) \
+ + r_strlen;
+ zst.avail_out = r_strlen;
r_strlen = r_strlen << 1;
break;
- default:
- {
- if (zst.msg == Z_NULL)
- PyErr_Format(ZlibError, "Error %i while decompressing data",
- err);
- else
- PyErr_Format(ZlibError,
- "Error %i while decompressing data: %.200s",
- err, zst.msg);
- inflateEnd(&zst);
+ default: {
+ if (zst.msg == Z_NULL)
+ PyErr_Format(ZlibError, "Error %i while decompressing data",
+ err);
+ else
+ PyErr_Format(ZlibError,
+ "Error %i while decompressing data: %.200s",
+ err, zst.msg);
+ inflateEnd(&zst);
return_error = 1;
- }
- }
- } while(err!=Z_STREAM_END);
+ }
+ }
+ } while (err != Z_STREAM_END);
- if (!return_error) {
- err=inflateEnd(&zst);
- if (err!=Z_OK)
- {
- if (zst.msg == Z_NULL)
- PyErr_Format(ZlibError,
- "Error %i while finishing data decompression",
- err);
- else
- PyErr_Format(ZlibError,
- "Error %i while finishing data decompression: %.200s",
- err, zst.msg);
+ if (!return_error) {
+ err = inflateEnd(&zst);
+ if (err != Z_OK) {
+ if (zst.msg == Z_NULL)
+ PyErr_Format(ZlibError,
+ "Error %i while finishing data decompression",
+ err);
+ else
+ PyErr_Format(ZlibError,
+ "Error %i while finishing data decompression: %.200s",
+ err, zst.msg);
- return_error = 1;
- return NULL;
+ return_error = 1;
+ return NULL;
+ }
}
- }
- if (!return_error)
- _PyString_Resize(&result_str, zst.total_out);
- else {
- Py_XDECREF(result_str); /* sets result_str == NULL, if not already */
- }
- Py_DECREF(inputString);
+ if (!return_error)
+ _PyString_Resize(&result_str, zst.total_out);
+ else
+ Py_XDECREF(result_str); /* sets result_str == NULL, if not already */
+ Py_DECREF(inputString);
- return result_str;
+ return result_str;
}
static PyObject *
static PyObject *
PyZlib_objcompress(compobject *self, PyObject *args)
{
- int err, inplen, length = DEFAULTALLOC;
- PyObject *RetVal;
- Byte *input;
- unsigned long start_total_out;
- int return_error;
- PyObject * inputString;
+ int err, inplen, length = DEFAULTALLOC;
+ PyObject *RetVal;
+ Byte *input;
+ unsigned long start_total_out;
+ int return_error;
+ PyObject * inputString;
- if (!PyArg_ParseTuple(args, "S:compress", &inputString))
- return NULL;
- if (PyString_AsStringAndSize(inputString, (char**)&input, &inplen) == -1)
- return NULL;
-
- if (!(RetVal = PyString_FromStringAndSize(NULL, length))) {
- PyErr_SetString(PyExc_MemoryError,
- "Can't allocate memory to compress data");
- return NULL;
- }
+ if (!PyArg_ParseTuple(args, "S:compress", &inputString))
+ return NULL;
+ if (PyString_AsStringAndSize(inputString, (char**)&input, &inplen) == -1)
+ return NULL;
+
+ if (!(RetVal = PyString_FromStringAndSize(NULL, length))) {
+ PyErr_SetString(PyExc_MemoryError,
+ "Can't allocate memory to compress data");
+ return NULL;
+ }
- ENTER_ZLIB
+ ENTER_ZLIB
- Py_INCREF(inputString);
+ Py_INCREF(inputString);
- start_total_out = self->zst.total_out;
- self->zst.avail_in = inplen;
- self->zst.next_in = input;
- self->zst.avail_out = length;
- self->zst.next_out = (unsigned char *)PyString_AsString(RetVal);
-
- Py_BEGIN_ALLOW_THREADS
- err = deflate(&(self->zst), Z_NO_FLUSH);
- Py_END_ALLOW_THREADS
-
- return_error = 0;
-
- /* while Z_OK and the output buffer is full, there might be more output,
- so extend the output buffer and try again */
- while (err == Z_OK && self->zst.avail_out == 0) {
- if (_PyString_Resize(&RetVal, length << 1) == -1) {
- PyErr_SetString(PyExc_MemoryError,
- "Can't allocate memory to compress data");
- return_error = 1;
- break;
- }
- self->zst.next_out = (unsigned char *)PyString_AsString(RetVal) + length;
+ start_total_out = self->zst.total_out;
+ self->zst.avail_in = inplen;
+ self->zst.next_in = input;
self->zst.avail_out = length;
- length = length << 1;
-
+ self->zst.next_out = (unsigned char *)PyString_AsString(RetVal);
+
Py_BEGIN_ALLOW_THREADS
err = deflate(&(self->zst), Z_NO_FLUSH);
Py_END_ALLOW_THREADS
- }
- /* We will only get Z_BUF_ERROR if the output buffer was full but there
- wasn't more output when we tried again, so it is not an error condition */
-
- if (!return_error) {
- if (err != Z_OK && err != Z_BUF_ERROR) {
- if (self->zst.msg == Z_NULL)
- PyErr_Format(ZlibError, "Error %i while compressing",
- err);
- else
- PyErr_Format(ZlibError, "Error %i while compressing: %.200s",
- err, self->zst.msg);
-
- return_error = 1;
- Py_DECREF(RetVal);
+
+ return_error = 0;
+
+ /* while Z_OK and the output buffer is full, there might be more output,
+ so extend the output buffer and try again */
+ while (err == Z_OK && self->zst.avail_out == 0) {
+ if (_PyString_Resize(&RetVal, length << 1) == -1) {
+ PyErr_SetString(PyExc_MemoryError,
+ "Can't allocate memory to compress data");
+ return_error = 1;
+ break;
+ }
+ self->zst.next_out = (unsigned char *)PyString_AsString(RetVal) \
+ + length;
+ self->zst.avail_out = length;
+ length = length << 1;
+
+ Py_BEGIN_ALLOW_THREADS
+ err = deflate(&(self->zst), Z_NO_FLUSH);
+ Py_END_ALLOW_THREADS
}
- }
+ /* We will only get Z_BUF_ERROR if the output buffer was full but
+ there wasn't more output when we tried again, so it is not an error
+ condition.
+ */
- if (return_error)
- RetVal = NULL; /* should have been handled by DECREF */
- else
- _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
+ if (!return_error) {
+ if (err != Z_OK && err != Z_BUF_ERROR) {
+ if (self->zst.msg == Z_NULL)
+ PyErr_Format(ZlibError, "Error %i while compressing",
+ err);
+ else
+ PyErr_Format(ZlibError, "Error %i while compressing: %.200s",
+ err, self->zst.msg);
+
+ return_error = 1;
+ Py_DECREF(RetVal);
+ }
+ }
+
+ if (return_error)
+ RetVal = NULL; /* should have been handled by DECREF */
+ else
+ _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
- Py_DECREF(inputString);
+ Py_DECREF(inputString);
- LEAVE_ZLIB
+ LEAVE_ZLIB
- return RetVal;
+ return RetVal;
}
static char decomp_decompress__doc__[] =
static PyObject *
PyZlib_objdecompress(compobject *self, PyObject *args)
{
- int err, inplen, old_length, length = DEFAULTALLOC;
- int max_length = 0;
- PyObject *RetVal;
- Byte *input;
- unsigned long start_total_out;
- int return_error;
- PyObject * inputString;
-
- if (!PyArg_ParseTuple(args, "S|i:decompress", &inputString, &max_length))
- return NULL;
- if (max_length < 0) {
- PyErr_SetString(PyExc_ValueError,
- "max_length must be greater than zero");
- return NULL;
- }
+ int err, inplen, old_length, length = DEFAULTALLOC;
+ int max_length = 0;
+ PyObject *RetVal;
+ Byte *input;
+ unsigned long start_total_out;
+ int return_error;
+ PyObject * inputString;
+
+ if (!PyArg_ParseTuple(args, "S|i:decompress", &inputString, &max_length))
+ return NULL;
+ if (max_length < 0) {
+ PyErr_SetString(PyExc_ValueError,
+ "max_length must be greater than zero");
+ return NULL;
+ }
- if (PyString_AsStringAndSize(inputString, (char**)&input, &inplen) == -1)
- return NULL;
+ if (PyString_AsStringAndSize(inputString, (char**)&input, &inplen) == -1)
+ return NULL;
- /* limit amount of data allocated to max_length */
- if (max_length && length > max_length)
- length = max_length;
- if (!(RetVal = PyString_FromStringAndSize(NULL, length))) {
- PyErr_SetString(PyExc_MemoryError,
- "Can't allocate memory to compress data");
- return NULL;
- }
+ /* limit amount of data allocated to max_length */
+ if (max_length && length > max_length)
+ length = max_length;
+ if (!(RetVal = PyString_FromStringAndSize(NULL, length))) {
+ PyErr_SetString(PyExc_MemoryError,
+ "Can't allocate memory to compress data");
+ return NULL;
+ }
- ENTER_ZLIB
- return_error = 0;
+ ENTER_ZLIB
+ return_error = 0;
- Py_INCREF(inputString);
+ Py_INCREF(inputString);
- start_total_out = self->zst.total_out;
- self->zst.avail_in = inplen;
- self->zst.next_in = input;
- self->zst.avail_out = length;
- self->zst.next_out = (unsigned char *)PyString_AsString(RetVal);
+ start_total_out = self->zst.total_out;
+ self->zst.avail_in = inplen;
+ self->zst.next_in = input;
+ self->zst.avail_out = length;
+ self->zst.next_out = (unsigned char *)PyString_AsString(RetVal);
- Py_BEGIN_ALLOW_THREADS
- err = inflate(&(self->zst), Z_SYNC_FLUSH);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ err = inflate(&(self->zst), Z_SYNC_FLUSH);
+ Py_END_ALLOW_THREADS
- /* While Z_OK and the output buffer is full, there might be more output.
- So extend the output buffer and try again.
- */
- while (err == Z_OK && self->zst.avail_out == 0) {
- /* If max_length set, don't continue decompressing if we've already
- reached the limit.
+ /* While Z_OK and the output buffer is full, there might be more output.
+ So extend the output buffer and try again.
*/
- if (max_length && length >= max_length)
- break;
+ while (err == Z_OK && self->zst.avail_out == 0) {
+ /* If max_length set, don't continue decompressing if we've already
+ reached the limit.
+ */
+ if (max_length && length >= max_length)
+ break;
- /* otherwise, ... */
- old_length = length;
- length = length << 1;
- if (max_length && length > max_length)
- length = max_length;
+ /* otherwise, ... */
+ old_length = length;
+ length = length << 1;
+ if (max_length && length > max_length)
+ length = max_length;
- if (_PyString_Resize(&RetVal, length) == -1) {
- PyErr_SetString(PyExc_MemoryError,
- "Can't allocate memory to compress data");
- return_error = 1;
- break;
- }
- self->zst.next_out = (unsigned char *)PyString_AsString(RetVal)+old_length;
- self->zst.avail_out = length - old_length;
-
- Py_BEGIN_ALLOW_THREADS
- err = inflate(&(self->zst), Z_SYNC_FLUSH);
- Py_END_ALLOW_THREADS
- }
+ if (_PyString_Resize(&RetVal, length) == -1) {
+ PyErr_SetString(PyExc_MemoryError,
+ "Can't allocate memory to compress data");
+ return_error = 1;
+ break;
+ }
+ self->zst.next_out = (unsigned char *)PyString_AsString(RetVal) \
+ + old_length;
+ self->zst.avail_out = length - old_length;
- /* Not all of the compressed data could be accomodated in the output buffer
- of specified size. Return the unconsumed tail in an attribute.*/
- if(max_length) {
- Py_DECREF(self->unconsumed_tail);
- self->unconsumed_tail = PyString_FromStringAndSize(self->zst.next_in,
- self->zst.avail_in);
- if(!self->unconsumed_tail)
- return_error = 1;
- }
+ Py_BEGIN_ALLOW_THREADS
+ err = inflate(&(self->zst), Z_SYNC_FLUSH);
+ Py_END_ALLOW_THREADS
+ }
- /* The end of the compressed data has been reached, so set the unused_data
- attribute to a string containing the remainder of the data in the string.
- Note that this is also a logical place to call inflateEnd, but the old
- behaviour of only calling it on flush() is preserved.*/
- if (!return_error) {
- if (err == Z_STREAM_END) {
- Py_XDECREF(self->unused_data); /* Free the original, empty string */
- self->unused_data = PyString_FromStringAndSize((char *)self->zst.next_in,
- self->zst.avail_in);
- if (self->unused_data == NULL) {
- PyErr_SetString(PyExc_MemoryError,
- "Can't allocate memory to unused_data");
- Py_DECREF(RetVal);
- return_error = 1;
+ /* Not all of the compressed data could be accomodated in the output buffer
+ of specified size. Return the unconsumed tail in an attribute.*/
+ if(max_length) {
+ Py_DECREF(self->unconsumed_tail);
+ self->unconsumed_tail = PyString_FromStringAndSize(self->zst.next_in,
+ self->zst.avail_in);
+ if(!self->unconsumed_tail)
+ return_error = 1;
}
- /* We will only get Z_BUF_ERROR if the output buffer was full but there
- wasn't more output when we tried again, so it is not an error
- condition */
- } else if (err != Z_OK && err != Z_BUF_ERROR) {
- if (self->zst.msg == Z_NULL)
- PyErr_Format(ZlibError, "Error %i while decompressing",
- err);
- else
- PyErr_Format(ZlibError, "Error %i while decompressing: %.200s",
- err, self->zst.msg);
- Py_DECREF(RetVal);
- return_error = 1;
+
+ /* The end of the compressed data has been reached, so set the
+ unused_data attribute to a string containing the remainder of the
+ data in the string. Note that this is also a logical place to call
+ inflateEnd, but the old behaviour of only calling it on flush() is
+ preserved.
+ */
+ if (!return_error) {
+ if (err == Z_STREAM_END) {
+ Py_XDECREF(self->unused_data); /* Free original empty string */
+ self->unused_data = PyString_FromStringAndSize(
+ (char *)self->zst.next_in, self->zst.avail_in);
+ if (self->unused_data == NULL) {
+ PyErr_SetString(PyExc_MemoryError,
+ "Can't allocate memory to unused_data");
+ Py_DECREF(RetVal);
+ return_error = 1;
+ }
+ /* We will only get Z_BUF_ERROR if the output buffer was full
+ but there wasn't more output when we tried again, so it is
+ not an error condition.
+ */
+ } else if (err != Z_OK && err != Z_BUF_ERROR) {
+ if (self->zst.msg == Z_NULL)
+ PyErr_Format(ZlibError, "Error %i while decompressing",
+ err);
+ else
+ PyErr_Format(ZlibError, "Error %i while decompressing: %.200s",
+ err, self->zst.msg);
+ Py_DECREF(RetVal);
+ return_error = 1;
+ }
}
- }
- if (!return_error) {
- _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
- }
- else
- RetVal = NULL; /* should be handled by DECREF */
+ if (!return_error) {
+ _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
+ }
+ else
+ RetVal = NULL; /* should be handled by DECREF */
- Py_DECREF(inputString);
+ Py_DECREF(inputString);
- LEAVE_ZLIB
+ LEAVE_ZLIB
- return RetVal;
+ return RetVal;
}
static char comp_flush__doc__[] =
static PyObject *
PyZlib_flush(compobject *self, PyObject *args)
{
- int err, length=DEFAULTALLOC;
- PyObject *RetVal;
- int flushmode = Z_FINISH;
- unsigned long start_total_out;
- int return_error;
-
- if (!PyArg_ParseTuple(args, "|i:flush", &flushmode))
- return NULL;
-
- /* Flushing with Z_NO_FLUSH is a no-op, so there's no point in
- doing any work at all; just return an empty string. */
- if (flushmode == Z_NO_FLUSH) {
- return PyString_FromStringAndSize(NULL, 0);
- }
-
- if (!(RetVal = PyString_FromStringAndSize(NULL, length))) {
- PyErr_SetString(PyExc_MemoryError,
- "Can't allocate memory to compress data");
- return NULL;
- }
-
- ENTER_ZLIB
-
- start_total_out = self->zst.total_out;
- self->zst.avail_in = 0;
- self->zst.avail_out = length;
- self->zst.next_out = (unsigned char *)PyString_AsString(RetVal);
+ int err, length = DEFAULTALLOC;
+ PyObject *RetVal;
+ int flushmode = Z_FINISH;
+ unsigned long start_total_out;
+ int return_error;
- Py_BEGIN_ALLOW_THREADS
- err = deflate(&(self->zst), flushmode);
- Py_END_ALLOW_THREADS
+ if (!PyArg_ParseTuple(args, "|i:flush", &flushmode))
+ return NULL;
- return_error = 0;
+ /* Flushing with Z_NO_FLUSH is a no-op, so there's no point in
+ doing any work at all; just return an empty string. */
+ if (flushmode == Z_NO_FLUSH) {
+ return PyString_FromStringAndSize(NULL, 0);
+ }
- /* while Z_OK and the output buffer is full, there might be more output,
- so extend the output buffer and try again */
- while (err == Z_OK && self->zst.avail_out == 0) {
- if (_PyString_Resize(&RetVal, length << 1) == -1) {
- PyErr_SetString(PyExc_MemoryError,
- "Can't allocate memory to compress data");
- return_error = 1;
- break;
+ if (!(RetVal = PyString_FromStringAndSize(NULL, length))) {
+ PyErr_SetString(PyExc_MemoryError,
+ "Can't allocate memory to compress data");
+ return NULL;
}
- self->zst.next_out = (unsigned char *)PyString_AsString(RetVal) + length;
+
+ ENTER_ZLIB
+
+ start_total_out = self->zst.total_out;
+ self->zst.avail_in = 0;
self->zst.avail_out = length;
- length = length << 1;
+ self->zst.next_out = (unsigned char *)PyString_AsString(RetVal);
Py_BEGIN_ALLOW_THREADS
err = deflate(&(self->zst), flushmode);
Py_END_ALLOW_THREADS
- }
- /* If flushmode is Z_FINISH, we also have to call deflateEnd() to free
- various data structures. Note we should only get Z_STREAM_END when
- flushmode is Z_FINISH, but checking both for safety*/
- if (!return_error) {
- if (err == Z_STREAM_END && flushmode == Z_FINISH) {
- err=deflateEnd(&(self->zst));
- if (err!=Z_OK) {
- if (self->zst.msg == Z_NULL)
- PyErr_Format(ZlibError, "Error %i from deflateEnd()",
- err);
- else
- PyErr_Format(ZlibError,"Error %i from deflateEnd(): %.200s",
- err, self->zst.msg);
+ return_error = 0;
- Py_DECREF(RetVal);
- return_error = 1;
- }
- else
- self->is_initialised = 0;
+ /* while Z_OK and the output buffer is full, there might be more output,
+ so extend the output buffer and try again */
+ while (err == Z_OK && self->zst.avail_out == 0) {
+ if (_PyString_Resize(&RetVal, length << 1) == -1) {
+ PyErr_SetString(PyExc_MemoryError,
+ "Can't allocate memory to compress data");
+ return_error = 1;
+ break;
+ }
+ self->zst.next_out = (unsigned char *)PyString_AsString(RetVal) \
+ + length;
+ self->zst.avail_out = length;
+ length = length << 1;
+
+ Py_BEGIN_ALLOW_THREADS
+ err = deflate(&(self->zst), flushmode);
+ Py_END_ALLOW_THREADS
+ }
- /* We will only get Z_BUF_ERROR if the output buffer was full but there
- wasn't more output when we tried again, so it is not an error
- condition */
- } else if (err!=Z_OK && err!=Z_BUF_ERROR) {
- if (self->zst.msg == Z_NULL)
- PyErr_Format(ZlibError, "Error %i while flushing",
- err);
- else
- PyErr_Format(ZlibError, "Error %i while flushing: %.200s",
- err, self->zst.msg);
- Py_DECREF(RetVal);
- return_error = 1;
+ /* If flushmode is Z_FINISH, we also have to call deflateEnd() to free
+ various data structures. Note we should only get Z_STREAM_END when
+ flushmode is Z_FINISH, but checking both for safety*/
+ if (!return_error) {
+ if (err == Z_STREAM_END && flushmode == Z_FINISH) {
+ err = deflateEnd(&(self->zst));
+ if (err != Z_OK) {
+ if (self->zst.msg == Z_NULL)
+ PyErr_Format(ZlibError, "Error %i from deflateEnd()",
+ err);
+ else
+ PyErr_Format(ZlibError,
+ "Error %i from deflateEnd(): %.200s",
+ err, self->zst.msg);
+
+ Py_DECREF(RetVal);
+ return_error = 1;
+ } else
+ self->is_initialised = 0;
+
+ /* We will only get Z_BUF_ERROR if the output buffer was full
+ but there wasn't more output when we tried again, so it is
+ not an error condition.
+ */
+ } else if (err!=Z_OK && err!=Z_BUF_ERROR) {
+ if (self->zst.msg == Z_NULL)
+ PyErr_Format(ZlibError, "Error %i while flushing",
+ err);
+ else
+ PyErr_Format(ZlibError, "Error %i while flushing: %.200s",
+ err, self->zst.msg);
+ Py_DECREF(RetVal);
+ return_error = 1;
+ }
}
- }
- if (!return_error)
- _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
- else
- RetVal = NULL; /* should have been handled by DECREF */
+ if (!return_error)
+ _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
+ else
+ RetVal = NULL; /* should have been handled by DECREF */
- LEAVE_ZLIB
+ LEAVE_ZLIB
- return RetVal;
+ return RetVal;
}
static char decomp_flush__doc__[] =
inflateEnd, causing any further decompress or flush calls to raise
exceptions. This behaviour has been preserved.*/
{
- int err;
- PyObject * retval;
+ int err;
+ PyObject * retval;
- if (!PyArg_ParseTuple(args, ""))
- return NULL;
-
- ENTER_ZLIB
+ if (!PyArg_ParseTuple(args, ""))
+ return NULL;
- err=inflateEnd(&(self->zst));
- if (err!=Z_OK) {
- if (self->zst.msg == Z_NULL)
- PyErr_Format(ZlibError, "Error %i from inflateEnd()",
- err);
- else
- PyErr_Format(ZlibError, "Error %i from inflateEnd(): %.200s",
- err, self->zst.msg);
+ ENTER_ZLIB
- retval = NULL;
+ err = inflateEnd(&(self->zst));
+ if (err != Z_OK) {
+ if (self->zst.msg == Z_NULL)
+ PyErr_Format(ZlibError, "Error %i from inflateEnd()",
+ err);
+ else
+ PyErr_Format(ZlibError, "Error %i from inflateEnd(): %.200s",
+ err, self->zst.msg);
- } else {
- self->is_initialised = 0;
- retval = PyString_FromStringAndSize(NULL, 0);
- }
+ retval = NULL;
+ } else {
+ self->is_initialised = 0;
+ retval = PyString_FromStringAndSize(NULL, 0);
+ }
- LEAVE_ZLIB
+ LEAVE_ZLIB
- return retval;
+ return retval;
}
static PyMethodDef comp_methods[] =
{
- {"compress", (binaryfunc)PyZlib_objcompress,
- METH_VARARGS, comp_compress__doc__},
- {"flush", (binaryfunc)PyZlib_flush,
- METH_VARARGS, comp_flush__doc__},
- {NULL, NULL}
+ {"compress", (binaryfunc)PyZlib_objcompress, METH_VARARGS,
+ comp_compress__doc__},
+ {"flush", (binaryfunc)PyZlib_flush, METH_VARARGS,
+ comp_flush__doc__},
+ {NULL, NULL}
};
static PyMethodDef Decomp_methods[] =
{
- {"decompress", (binaryfunc)PyZlib_objdecompress,
- METH_VARARGS, decomp_decompress__doc__},
- {"flush", (binaryfunc)PyZlib_unflush,
- METH_VARARGS, decomp_flush__doc__},
- {NULL, NULL}
+ {"decompress", (binaryfunc)PyZlib_objdecompress, METH_VARARGS,
+ decomp_decompress__doc__},
+ {"flush", (binaryfunc)PyZlib_unflush, METH_VARARGS,
+ decomp_flush__doc__},
+ {NULL, NULL}
};
static PyObject *
static PyObject *
Decomp_getattr(compobject *self, char *name)
{
- PyObject * retval;
-
- ENTER_ZLIB
-
- if (strcmp(name, "unused_data") == 0)
- {
- Py_INCREF(self->unused_data);
- retval = self->unused_data;
- }
- else if (strcmp(name, "unconsumed_tail") == 0)
- {
- Py_INCREF(self->unconsumed_tail);
- retval = self->unconsumed_tail;
- }
- else
- retval = Py_FindMethod(Decomp_methods, (PyObject *)self, name);
-
- LEAVE_ZLIB
-
- return retval;
+ PyObject * retval;
+
+ ENTER_ZLIB
+
+ if (strcmp(name, "unused_data") == 0) {
+ Py_INCREF(self->unused_data);
+ retval = self->unused_data;
+ } else if (strcmp(name, "unconsumed_tail") == 0) {
+ Py_INCREF(self->unconsumed_tail);
+ retval = self->unconsumed_tail;
+ } else
+ retval = Py_FindMethod(Decomp_methods, (PyObject *)self, name);
+
+ LEAVE_ZLIB
+
+ return retval;
}
static char adler32__doc__[] =
static PyObject *
PyZlib_adler32(PyObject *self, PyObject *args)
{
- uLong adler32val=adler32(0L, Z_NULL, 0);
+ uLong adler32val = adler32(0L, Z_NULL, 0);
Byte *buf;
int len;
if (!PyArg_ParseTuple(args, "s#|l:adler32", &buf, &len, &adler32val))
- {
return NULL;
- }
adler32val = adler32(adler32val, buf, len);
return PyInt_FromLong(adler32val);
}
static PyObject *
PyZlib_crc32(PyObject *self, PyObject *args)
{
- uLong crc32val=crc32(0L, Z_NULL, 0);
+ uLong crc32val = crc32(0L, Z_NULL, 0);
Byte *buf;
int len;
if (!PyArg_ParseTuple(args, "s#|l:crc32", &buf, &len, &crc32val))
- {
return NULL;
- }
crc32val = crc32(crc32val, buf, len);
return PyInt_FromLong(crc32val);
}
static PyMethodDef zlib_methods[] =
{
- {"adler32", (PyCFunction)PyZlib_adler32,
- METH_VARARGS, adler32__doc__},
- {"compress", (PyCFunction)PyZlib_compress,
- METH_VARARGS, compress__doc__},
- {"compressobj", (PyCFunction)PyZlib_compressobj,
- METH_VARARGS, compressobj__doc__},
- {"crc32", (PyCFunction)PyZlib_crc32,
- METH_VARARGS, crc32__doc__},
- {"decompress", (PyCFunction)PyZlib_decompress,
- METH_VARARGS, decompress__doc__},
- {"decompressobj", (PyCFunction)PyZlib_decompressobj,
- METH_VARARGS, decompressobj__doc__},
- {NULL, NULL}
+ {"adler32", (PyCFunction)PyZlib_adler32, METH_VARARGS,
+ adler32__doc__},
+ {"compress", (PyCFunction)PyZlib_compress, METH_VARARGS,
+ compress__doc__},
+ {"compressobj", (PyCFunction)PyZlib_compressobj, METH_VARARGS,
+ compressobj__doc__},
+ {"crc32", (PyCFunction)PyZlib_crc32, METH_VARARGS,
+ crc32__doc__},
+ {"decompress", (PyCFunction)PyZlib_decompress, METH_VARARGS,
+ decompress__doc__},
+ {"decompressobj", (PyCFunction)PyZlib_decompressobj, METH_VARARGS,
+ decompressobj__doc__},
+ {NULL, NULL}
};
statichere PyTypeObject Comptype = {
- PyObject_HEAD_INIT(0)
- 0,
- "Compress",
- sizeof(compobject),
- 0,
- (destructor)Comp_dealloc, /*tp_dealloc*/
- 0, /*tp_print*/
- (getattrfunc)Comp_getattr, /*tp_getattr*/
- 0, /*tp_setattr*/
- 0, /*tp_compare*/
- 0, /*tp_repr*/
- 0, /*tp_as_number*/
- 0, /*tp_as_sequence*/
- 0, /*tp_as_mapping*/
+ PyObject_HEAD_INIT(0)
+ 0,
+ "Compress",
+ sizeof(compobject),
+ 0,
+ (destructor)Comp_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc)Comp_getattr, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
};
statichere PyTypeObject Decomptype = {
- PyObject_HEAD_INIT(0)
- 0,
- "Decompress",
- sizeof(compobject),
- 0,
- (destructor)Decomp_dealloc, /*tp_dealloc*/
- 0, /*tp_print*/
- (getattrfunc)Decomp_getattr, /*tp_getattr*/
- 0, /*tp_setattr*/
- 0, /*tp_compare*/
- 0, /*tp_repr*/
- 0, /*tp_as_number*/
- 0, /*tp_as_sequence*/
- 0, /*tp_as_mapping*/
+ PyObject_HEAD_INIT(0)
+ 0,
+ "Decompress",
+ sizeof(compobject),
+ 0,
+ (destructor)Decomp_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc)Decomp_getattr, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
};
/* The following insint() routine was blatantly ripped off from
DL_EXPORT(void)
PyInit_zlib(void)
{
- PyObject *m, *d, *ver;
- Comptype.ob_type = &PyType_Type;
- Decomptype.ob_type = &PyType_Type;
- m = Py_InitModule4("zlib", zlib_methods,
- zlib_module_documentation,
- (PyObject*)NULL,PYTHON_API_VERSION);
- d = PyModule_GetDict(m);
- ZlibError = PyErr_NewException("zlib.error", NULL, NULL);
- if (ZlibError != NULL)
- PyDict_SetItemString(d, "error", ZlibError);
-
- insint(d, "MAX_WBITS", MAX_WBITS);
- insint(d, "DEFLATED", DEFLATED);
- insint(d, "DEF_MEM_LEVEL", DEF_MEM_LEVEL);
- insint(d, "Z_BEST_SPEED", Z_BEST_SPEED);
- insint(d, "Z_BEST_COMPRESSION", Z_BEST_COMPRESSION);
- insint(d, "Z_DEFAULT_COMPRESSION", Z_DEFAULT_COMPRESSION);
- insint(d, "Z_FILTERED", Z_FILTERED);
- insint(d, "Z_HUFFMAN_ONLY", Z_HUFFMAN_ONLY);
- insint(d, "Z_DEFAULT_STRATEGY", Z_DEFAULT_STRATEGY);
-
- insint(d, "Z_FINISH", Z_FINISH);
- insint(d, "Z_NO_FLUSH", Z_NO_FLUSH);
- insint(d, "Z_SYNC_FLUSH", Z_SYNC_FLUSH);
- insint(d, "Z_FULL_FLUSH", Z_FULL_FLUSH);
-
- ver = PyString_FromString(ZLIB_VERSION);
- if (ver != NULL) {
- PyDict_SetItemString(d, "ZLIB_VERSION", ver);
- Py_DECREF(ver);
- }
+ PyObject *m, *d, *ver;
+ Comptype.ob_type = &PyType_Type;
+ Decomptype.ob_type = &PyType_Type;
+ m = Py_InitModule4("zlib", zlib_methods,
+ zlib_module_documentation,
+ (PyObject*)NULL,PYTHON_API_VERSION);
+ d = PyModule_GetDict(m);
+ ZlibError = PyErr_NewException("zlib.error", NULL, NULL);
+ if (ZlibError != NULL)
+ PyDict_SetItemString(d, "error", ZlibError);
+
+ PyModule_AddIntConstant(m, "MAX_WBITS", MAX_WBITS);
+ PyModule_AddIntConstant(m, "DEFLATED", DEFLATED);
+ PyModule_AddIntConstant(m, "DEF_MEM_LEVEL", DEF_MEM_LEVEL);
+ PyModule_AddIntConstant(m, "Z_BEST_SPEED", Z_BEST_SPEED);
+ PyModule_AddIntConstant(m, "Z_BEST_COMPRESSION", Z_BEST_COMPRESSION);
+ PyModule_AddIntConstant(m, "Z_DEFAULT_COMPRESSION", Z_DEFAULT_COMPRESSION);
+ PyModule_AddIntConstant(m, "Z_FILTERED", Z_FILTERED);
+ PyModule_AddIntConstant(m, "Z_HUFFMAN_ONLY", Z_HUFFMAN_ONLY);
+ PyModule_AddIntConstant(m, "Z_DEFAULT_STRATEGY", Z_DEFAULT_STRATEGY);
+
+ PyModule_AddIntConstant(m, "Z_FINISH", Z_FINISH);
+ PyModule_AddIntConstant(m, "Z_NO_FLUSH", Z_NO_FLUSH);
+ PyModule_AddIntConstant(m, "Z_SYNC_FLUSH", Z_SYNC_FLUSH);
+ PyModule_AddIntConstant(m, "Z_FULL_FLUSH", Z_FULL_FLUSH);
+
+ ver = PyString_FromString(ZLIB_VERSION);
+ if (ver != NULL) {
+ PyDict_SetItemString(d, "ZLIB_VERSION", ver);
+ Py_DECREF(ver);
+ }
#ifdef WITH_THREAD
- zlib_lock = PyThread_allocate_lock();
+ zlib_lock = PyThread_allocate_lock();
#endif // WITH_THREAD
}
projects / python / commitdiff