+++ /dev/null
-/*\r
-\r
-python-bz2 - python bz2 library interface\r
-\r
-Copyright (c) 2002 Gustavo Niemeyer <niemeyer@conectiva.com>\r
-Copyright (c) 2002 Python Software Foundation; All Rights Reserved\r
-\r
-*/\r
-\r
-#include "Python.h"\r
-#include <stdio.h>\r
-#include <bzlib.h>\r
-#include "structmember.h"\r
-\r
-#ifdef WITH_THREAD\r
-#include "pythread.h"\r
-#endif\r
-\r
-static char __author__[] =\r
-"The bz2 python module was written by:\n\\r
-\n\\r
- Gustavo Niemeyer <niemeyer@conectiva.com>\n\\r
-";\r
-\r
-/* Our very own off_t-like type, 64-bit if possible */\r
-/* copied from Objects/fileobject.c */\r
-#if !defined(HAVE_LARGEFILE_SUPPORT)\r
-typedef off_t Py_off_t;\r
-#elif SIZEOF_OFF_T >= 8\r
-typedef off_t Py_off_t;\r
-#elif SIZEOF_FPOS_T >= 8\r
-typedef fpos_t Py_off_t;\r
-#else\r
-#error "Large file support, but neither off_t nor fpos_t is large enough."\r
-#endif\r
-\r
-#define BUF(v) PyString_AS_STRING((PyStringObject *)v)\r
-\r
-#define MODE_CLOSED 0\r
-#define MODE_READ 1\r
-#define MODE_READ_EOF 2\r
-#define MODE_WRITE 3\r
-\r
-#define BZ2FileObject_Check(v) (Py_TYPE(v) == &BZ2File_Type)\r
-\r
-\r
-#ifdef BZ_CONFIG_ERROR\r
-\r
-#if SIZEOF_LONG >= 8\r
-#define BZS_TOTAL_OUT(bzs) \\r
- (((long)bzs->total_out_hi32 << 32) + bzs->total_out_lo32)\r
-#elif SIZEOF_LONG_LONG >= 8\r
-#define BZS_TOTAL_OUT(bzs) \\r
- (((PY_LONG_LONG)bzs->total_out_hi32 << 32) + bzs->total_out_lo32)\r
-#else\r
-#define BZS_TOTAL_OUT(bzs) \\r
- bzs->total_out_lo32\r
-#endif\r
-\r
-#else /* ! BZ_CONFIG_ERROR */\r
-\r
-#define BZ2_bzRead bzRead\r
-#define BZ2_bzReadOpen bzReadOpen\r
-#define BZ2_bzReadClose bzReadClose\r
-#define BZ2_bzWrite bzWrite\r
-#define BZ2_bzWriteOpen bzWriteOpen\r
-#define BZ2_bzWriteClose bzWriteClose\r
-#define BZ2_bzCompress bzCompress\r
-#define BZ2_bzCompressInit bzCompressInit\r
-#define BZ2_bzCompressEnd bzCompressEnd\r
-#define BZ2_bzDecompress bzDecompress\r
-#define BZ2_bzDecompressInit bzDecompressInit\r
-#define BZ2_bzDecompressEnd bzDecompressEnd\r
-\r
-#define BZS_TOTAL_OUT(bzs) bzs->total_out\r
-\r
-#endif /* ! BZ_CONFIG_ERROR */\r
-\r
-\r
-#ifdef WITH_THREAD\r
-#define ACQUIRE_LOCK(obj) do { \\r
- if (!PyThread_acquire_lock(obj->lock, 0)) { \\r
- Py_BEGIN_ALLOW_THREADS \\r
- PyThread_acquire_lock(obj->lock, 1); \\r
- Py_END_ALLOW_THREADS \\r
- } } while(0)\r
-#define RELEASE_LOCK(obj) PyThread_release_lock(obj->lock)\r
-#else\r
-#define ACQUIRE_LOCK(obj)\r
-#define RELEASE_LOCK(obj)\r
-#endif\r
-\r
-/* Bits in f_newlinetypes */\r
-#define NEWLINE_UNKNOWN 0 /* No newline seen, yet */\r
-#define NEWLINE_CR 1 /* \r newline seen */\r
-#define NEWLINE_LF 2 /* \n newline seen */\r
-#define NEWLINE_CRLF 4 /* \r\n newline seen */\r
-\r
-/* ===================================================================== */\r
-/* Structure definitions. */\r
-\r
-typedef struct {\r
- PyObject_HEAD\r
- PyObject *file;\r
-\r
- char* f_buf; /* Allocated readahead buffer */\r
- char* f_bufend; /* Points after last occupied position */\r
- char* f_bufptr; /* Current buffer position */\r
-\r
- int f_softspace; /* Flag used by 'print' command */\r
-\r
- int f_univ_newline; /* Handle any newline convention */\r
- int f_newlinetypes; /* Types of newlines seen */\r
- int f_skipnextlf; /* Skip next \n */\r
-\r
- BZFILE *fp;\r
- int mode;\r
- Py_off_t pos;\r
- Py_off_t size;\r
-#ifdef WITH_THREAD\r
- PyThread_type_lock lock;\r
-#endif\r
-} BZ2FileObject;\r
-\r
-typedef struct {\r
- PyObject_HEAD\r
- bz_stream bzs;\r
- int running;\r
-#ifdef WITH_THREAD\r
- PyThread_type_lock lock;\r
-#endif\r
-} BZ2CompObject;\r
-\r
-typedef struct {\r
- PyObject_HEAD\r
- bz_stream bzs;\r
- int running;\r
- PyObject *unused_data;\r
-#ifdef WITH_THREAD\r
- PyThread_type_lock lock;\r
-#endif\r
-} BZ2DecompObject;\r
-\r
-/* ===================================================================== */\r
-/* Utility functions. */\r
-\r
-/* Refuse regular I/O if there's data in the iteration-buffer.\r
- * Mixing them would cause data to arrive out of order, as the read*\r
- * methods don't use the iteration buffer. */\r
-static int\r
-check_iterbuffered(BZ2FileObject *f)\r
-{\r
- if (f->f_buf != NULL &&\r
- (f->f_bufend - f->f_bufptr) > 0 &&\r
- f->f_buf[0] != '\0') {\r
- PyErr_SetString(PyExc_ValueError,\r
- "Mixing iteration and read methods would lose data");\r
- return -1;\r
- }\r
- return 0;\r
-}\r
-\r
-static int\r
-Util_CatchBZ2Error(int bzerror)\r
-{\r
- int ret = 0;\r
- switch(bzerror) {\r
- case BZ_OK:\r
- case BZ_STREAM_END:\r
- break;\r
-\r
-#ifdef BZ_CONFIG_ERROR\r
- case BZ_CONFIG_ERROR:\r
- PyErr_SetString(PyExc_SystemError,\r
- "the bz2 library was not compiled "\r
- "correctly");\r
- ret = 1;\r
- break;\r
-#endif\r
-\r
- case BZ_PARAM_ERROR:\r
- PyErr_SetString(PyExc_ValueError,\r
- "the bz2 library has received wrong "\r
- "parameters");\r
- ret = 1;\r
- break;\r
-\r
- case BZ_MEM_ERROR:\r
- PyErr_NoMemory();\r
- ret = 1;\r
- break;\r
-\r
- case BZ_DATA_ERROR:\r
- case BZ_DATA_ERROR_MAGIC:\r
- PyErr_SetString(PyExc_IOError, "invalid data stream");\r
- ret = 1;\r
- break;\r
-\r
- case BZ_IO_ERROR:\r
- PyErr_SetString(PyExc_IOError, "unknown IO error");\r
- ret = 1;\r
- break;\r
-\r
- case BZ_UNEXPECTED_EOF:\r
- PyErr_SetString(PyExc_EOFError,\r
- "compressed file ended before the "\r
- "logical end-of-stream was detected");\r
- ret = 1;\r
- break;\r
-\r
- case BZ_SEQUENCE_ERROR:\r
- PyErr_SetString(PyExc_RuntimeError,\r
- "wrong sequence of bz2 library "\r
- "commands used");\r
- ret = 1;\r
- break;\r
- }\r
- return ret;\r
-}\r
-\r
-#if BUFSIZ < 8192\r
-#define SMALLCHUNK 8192\r
-#else\r
-#define SMALLCHUNK BUFSIZ\r
-#endif\r
-\r
-#if SIZEOF_INT < 4\r
-#define BIGCHUNK (512 * 32)\r
-#else\r
-#define BIGCHUNK (512 * 1024)\r
-#endif\r
-\r
-/* This is a hacked version of Python's fileobject.c:new_buffersize(). */\r
-static size_t\r
-Util_NewBufferSize(size_t currentsize)\r
-{\r
- if (currentsize > SMALLCHUNK) {\r
- /* Keep doubling until we reach BIGCHUNK;\r
- then keep adding BIGCHUNK. */\r
- if (currentsize <= BIGCHUNK)\r
- return currentsize + currentsize;\r
- else\r
- return currentsize + BIGCHUNK;\r
- }\r
- return currentsize + SMALLCHUNK;\r
-}\r
-\r
-/* This is a hacked version of Python's fileobject.c:get_line(). */\r
-static PyObject *\r
-Util_GetLine(BZ2FileObject *f, int n)\r
-{\r
- char c;\r
- char *buf, *end;\r
- size_t total_v_size; /* total # of slots in buffer */\r
- size_t used_v_size; /* # used slots in buffer */\r
- size_t increment; /* amount to increment the buffer */\r
- PyObject *v;\r
- int bzerror;\r
- int bytes_read;\r
- int newlinetypes = f->f_newlinetypes;\r
- int skipnextlf = f->f_skipnextlf;\r
- int univ_newline = f->f_univ_newline;\r
-\r
- total_v_size = n > 0 ? n : 100;\r
- v = PyString_FromStringAndSize((char *)NULL, total_v_size);\r
- if (v == NULL)\r
- return NULL;\r
-\r
- buf = BUF(v);\r
- end = buf + total_v_size;\r
-\r
- for (;;) {\r
- Py_BEGIN_ALLOW_THREADS\r
- while (buf != end) {\r
- bytes_read = BZ2_bzRead(&bzerror, f->fp, &c, 1);\r
- f->pos++;\r
- if (bytes_read == 0) break;\r
- if (univ_newline) {\r
- if (skipnextlf) {\r
- skipnextlf = 0;\r
- if (c == '\n') {\r
- /* Seeing a \n here with skipnextlf true means we\r
- * saw a \r before.\r
- */\r
- newlinetypes |= NEWLINE_CRLF;\r
- if (bzerror != BZ_OK) break;\r
- bytes_read = BZ2_bzRead(&bzerror, f->fp, &c, 1);\r
- f->pos++;\r
- if (bytes_read == 0) break;\r
- } else {\r
- newlinetypes |= NEWLINE_CR;\r
- }\r
- }\r
- if (c == '\r') {\r
- skipnextlf = 1;\r
- c = '\n';\r
- } else if (c == '\n')\r
- newlinetypes |= NEWLINE_LF;\r
- }\r
- *buf++ = c;\r
- if (bzerror != BZ_OK || c == '\n') break;\r
- }\r
- if (univ_newline && bzerror == BZ_STREAM_END && skipnextlf)\r
- newlinetypes |= NEWLINE_CR;\r
- Py_END_ALLOW_THREADS\r
- f->f_newlinetypes = newlinetypes;\r
- f->f_skipnextlf = skipnextlf;\r
- if (bzerror == BZ_STREAM_END) {\r
- f->size = f->pos;\r
- f->mode = MODE_READ_EOF;\r
- break;\r
- } else if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- Py_DECREF(v);\r
- return NULL;\r
- }\r
- if (c == '\n')\r
- break;\r
- /* Must be because buf == end */\r
- if (n > 0)\r
- break;\r
- used_v_size = total_v_size;\r
- increment = total_v_size >> 2; /* mild exponential growth */\r
- total_v_size += increment;\r
- if (total_v_size > INT_MAX) {\r
- PyErr_SetString(PyExc_OverflowError,\r
- "line is longer than a Python string can hold");\r
- Py_DECREF(v);\r
- return NULL;\r
- }\r
- if (_PyString_Resize(&v, total_v_size) < 0)\r
- return NULL;\r
- buf = BUF(v) + used_v_size;\r
- end = BUF(v) + total_v_size;\r
- }\r
-\r
- used_v_size = buf - BUF(v);\r
- if (used_v_size != total_v_size)\r
- _PyString_Resize(&v, used_v_size);\r
- return v;\r
-}\r
-\r
-/* This is a hacked version of Python's\r
- * fileobject.c:Py_UniversalNewlineFread(). */\r
-size_t\r
-Util_UnivNewlineRead(int *bzerror, BZFILE *stream,\r
- char* buf, size_t n, BZ2FileObject *f)\r
-{\r
- char *dst = buf;\r
- int newlinetypes, skipnextlf;\r
-\r
- assert(buf != NULL);\r
- assert(stream != NULL);\r
-\r
- if (!f->f_univ_newline)\r
- return BZ2_bzRead(bzerror, stream, buf, n);\r
-\r
- newlinetypes = f->f_newlinetypes;\r
- skipnextlf = f->f_skipnextlf;\r
-\r
- /* Invariant: n is the number of bytes remaining to be filled\r
- * in the buffer.\r
- */\r
- while (n) {\r
- size_t nread;\r
- int shortread;\r
- char *src = dst;\r
-\r
- nread = BZ2_bzRead(bzerror, stream, dst, n);\r
- assert(nread <= n);\r
- n -= nread; /* assuming 1 byte out for each in; will adjust */\r
- shortread = n != 0; /* true iff EOF or error */\r
- while (nread--) {\r
- char c = *src++;\r
- if (c == '\r') {\r
- /* Save as LF and set flag to skip next LF. */\r
- *dst++ = '\n';\r
- skipnextlf = 1;\r
- }\r
- else if (skipnextlf && c == '\n') {\r
- /* Skip LF, and remember we saw CR LF. */\r
- skipnextlf = 0;\r
- newlinetypes |= NEWLINE_CRLF;\r
- ++n;\r
- }\r
- else {\r
- /* Normal char to be stored in buffer. Also\r
- * update the newlinetypes flag if either this\r
- * is an LF or the previous char was a CR.\r
- */\r
- if (c == '\n')\r
- newlinetypes |= NEWLINE_LF;\r
- else if (skipnextlf)\r
- newlinetypes |= NEWLINE_CR;\r
- *dst++ = c;\r
- skipnextlf = 0;\r
- }\r
- }\r
- if (shortread) {\r
- /* If this is EOF, update type flags. */\r
- if (skipnextlf && *bzerror == BZ_STREAM_END)\r
- newlinetypes |= NEWLINE_CR;\r
- break;\r
- }\r
- }\r
- f->f_newlinetypes = newlinetypes;\r
- f->f_skipnextlf = skipnextlf;\r
- return dst - buf;\r
-}\r
-\r
-/* This is a hacked version of Python's fileobject.c:drop_readahead(). */\r
-static void\r
-Util_DropReadAhead(BZ2FileObject *f)\r
-{\r
- if (f->f_buf != NULL) {\r
- PyMem_Free(f->f_buf);\r
- f->f_buf = NULL;\r
- }\r
-}\r
-\r
-/* This is a hacked version of Python's fileobject.c:readahead(). */\r
-static int\r
-Util_ReadAhead(BZ2FileObject *f, int bufsize)\r
-{\r
- int chunksize;\r
- int bzerror;\r
-\r
- if (f->f_buf != NULL) {\r
- if((f->f_bufend - f->f_bufptr) >= 1)\r
- return 0;\r
- else\r
- Util_DropReadAhead(f);\r
- }\r
- if (f->mode == MODE_READ_EOF) {\r
- f->f_bufptr = f->f_buf;\r
- f->f_bufend = f->f_buf;\r
- return 0;\r
- }\r
- if ((f->f_buf = PyMem_Malloc(bufsize)) == NULL) {\r
- PyErr_NoMemory();\r
- return -1;\r
- }\r
- Py_BEGIN_ALLOW_THREADS\r
- chunksize = Util_UnivNewlineRead(&bzerror, f->fp, f->f_buf,\r
- bufsize, f);\r
- Py_END_ALLOW_THREADS\r
- f->pos += chunksize;\r
- if (bzerror == BZ_STREAM_END) {\r
- f->size = f->pos;\r
- f->mode = MODE_READ_EOF;\r
- } else if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- Util_DropReadAhead(f);\r
- return -1;\r
- }\r
- f->f_bufptr = f->f_buf;\r
- f->f_bufend = f->f_buf + chunksize;\r
- return 0;\r
-}\r
-\r
-/* This is a hacked version of Python's\r
- * fileobject.c:readahead_get_line_skip(). */\r
-static PyStringObject *\r
-Util_ReadAheadGetLineSkip(BZ2FileObject *f, int skip, int bufsize)\r
-{\r
- PyStringObject* s;\r
- char *bufptr;\r
- char *buf;\r
- int len;\r
-\r
- if (f->f_buf == NULL)\r
- if (Util_ReadAhead(f, bufsize) < 0)\r
- return NULL;\r
-\r
- len = f->f_bufend - f->f_bufptr;\r
- if (len == 0)\r
- return (PyStringObject *)\r
- PyString_FromStringAndSize(NULL, skip);\r
- bufptr = memchr(f->f_bufptr, '\n', len);\r
- if (bufptr != NULL) {\r
- bufptr++; /* Count the '\n' */\r
- len = bufptr - f->f_bufptr;\r
- s = (PyStringObject *)\r
- PyString_FromStringAndSize(NULL, skip+len);\r
- if (s == NULL)\r
- return NULL;\r
- memcpy(PyString_AS_STRING(s)+skip, f->f_bufptr, len);\r
- f->f_bufptr = bufptr;\r
- if (bufptr == f->f_bufend)\r
- Util_DropReadAhead(f);\r
- } else {\r
- bufptr = f->f_bufptr;\r
- buf = f->f_buf;\r
- f->f_buf = NULL; /* Force new readahead buffer */\r
- s = Util_ReadAheadGetLineSkip(f, skip+len,\r
- bufsize + (bufsize>>2));\r
- if (s == NULL) {\r
- PyMem_Free(buf);\r
- return NULL;\r
- }\r
- memcpy(PyString_AS_STRING(s)+skip, bufptr, len);\r
- PyMem_Free(buf);\r
- }\r
- return s;\r
-}\r
-\r
-/* ===================================================================== */\r
-/* Methods of BZ2File. */\r
-\r
-PyDoc_STRVAR(BZ2File_read__doc__,\r
-"read([size]) -> string\n\\r
-\n\\r
-Read at most size uncompressed bytes, returned as a string. If the size\n\\r
-argument is negative or omitted, read until EOF is reached.\n\\r
-");\r
-\r
-/* This is a hacked version of Python's fileobject.c:file_read(). */\r
-static PyObject *\r
-BZ2File_read(BZ2FileObject *self, PyObject *args)\r
-{\r
- long bytesrequested = -1;\r
- size_t bytesread, buffersize, chunksize;\r
- int bzerror;\r
- PyObject *ret = NULL;\r
-\r
- if (!PyArg_ParseTuple(args, "|l:read", &bytesrequested))\r
- return NULL;\r
-\r
- ACQUIRE_LOCK(self);\r
- switch (self->mode) {\r
- case MODE_READ:\r
- break;\r
- case MODE_READ_EOF:\r
- ret = PyString_FromString("");\r
- goto cleanup;\r
- case MODE_CLOSED:\r
- PyErr_SetString(PyExc_ValueError,\r
- "I/O operation on closed file");\r
- goto cleanup;\r
- default:\r
- PyErr_SetString(PyExc_IOError,\r
- "file is not ready for reading");\r
- goto cleanup;\r
- }\r
-\r
- /* refuse to mix with f.next() */\r
- if (check_iterbuffered(self))\r
- goto cleanup;\r
-\r
- if (bytesrequested < 0)\r
- buffersize = Util_NewBufferSize((size_t)0);\r
- else\r
- buffersize = bytesrequested;\r
- if (buffersize > INT_MAX) {\r
- PyErr_SetString(PyExc_OverflowError,\r
- "requested number of bytes is "\r
- "more than a Python string can hold");\r
- goto cleanup;\r
- }\r
- ret = PyString_FromStringAndSize((char *)NULL, buffersize);\r
- if (ret == NULL)\r
- goto cleanup;\r
- bytesread = 0;\r
-\r
- for (;;) {\r
- Py_BEGIN_ALLOW_THREADS\r
- chunksize = Util_UnivNewlineRead(&bzerror, self->fp,\r
- BUF(ret)+bytesread,\r
- buffersize-bytesread,\r
- self);\r
- self->pos += chunksize;\r
- Py_END_ALLOW_THREADS\r
- bytesread += chunksize;\r
- if (bzerror == BZ_STREAM_END) {\r
- self->size = self->pos;\r
- self->mode = MODE_READ_EOF;\r
- break;\r
- } else if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- Py_DECREF(ret);\r
- ret = NULL;\r
- goto cleanup;\r
- }\r
- if (bytesrequested < 0) {\r
- buffersize = Util_NewBufferSize(buffersize);\r
- if (_PyString_Resize(&ret, buffersize) < 0)\r
- goto cleanup;\r
- } else {\r
- break;\r
- }\r
- }\r
- if (bytesread != buffersize)\r
- _PyString_Resize(&ret, bytesread);\r
-\r
-cleanup:\r
- RELEASE_LOCK(self);\r
- return ret;\r
-}\r
-\r
-PyDoc_STRVAR(BZ2File_readline__doc__,\r
-"readline([size]) -> string\n\\r
-\n\\r
-Return the next line from the file, as a string, retaining newline.\n\\r
-A non-negative size argument will limit the maximum number of bytes to\n\\r
-return (an incomplete line may be returned then). Return an empty\n\\r
-string at EOF.\n\\r
-");\r
-\r
-static PyObject *\r
-BZ2File_readline(BZ2FileObject *self, PyObject *args)\r
-{\r
- PyObject *ret = NULL;\r
- int sizehint = -1;\r
-\r
- if (!PyArg_ParseTuple(args, "|i:readline", &sizehint))\r
- return NULL;\r
-\r
- ACQUIRE_LOCK(self);\r
- switch (self->mode) {\r
- case MODE_READ:\r
- break;\r
- case MODE_READ_EOF:\r
- ret = PyString_FromString("");\r
- goto cleanup;\r
- case MODE_CLOSED:\r
- PyErr_SetString(PyExc_ValueError,\r
- "I/O operation on closed file");\r
- goto cleanup;\r
- default:\r
- PyErr_SetString(PyExc_IOError,\r
- "file is not ready for reading");\r
- goto cleanup;\r
- }\r
-\r
- /* refuse to mix with f.next() */\r
- if (check_iterbuffered(self))\r
- goto cleanup;\r
-\r
- if (sizehint == 0)\r
- ret = PyString_FromString("");\r
- else\r
- ret = Util_GetLine(self, (sizehint < 0) ? 0 : sizehint);\r
-\r
-cleanup:\r
- RELEASE_LOCK(self);\r
- return ret;\r
-}\r
-\r
-PyDoc_STRVAR(BZ2File_readlines__doc__,\r
-"readlines([size]) -> list\n\\r
-\n\\r
-Call readline() repeatedly and return a list of lines read.\n\\r
-The optional size argument, if given, is an approximate bound on the\n\\r
-total number of bytes in the lines returned.\n\\r
-");\r
-\r
-/* This is a hacked version of Python's fileobject.c:file_readlines(). */\r
-static PyObject *\r
-BZ2File_readlines(BZ2FileObject *self, PyObject *args)\r
-{\r
- long sizehint = 0;\r
- PyObject *list = NULL;\r
- PyObject *line;\r
- char small_buffer[SMALLCHUNK];\r
- char *buffer = small_buffer;\r
- size_t buffersize = SMALLCHUNK;\r
- PyObject *big_buffer = NULL;\r
- size_t nfilled = 0;\r
- size_t nread;\r
- size_t totalread = 0;\r
- char *p, *q, *end;\r
- int err;\r
- int shortread = 0;\r
- int bzerror;\r
-\r
- if (!PyArg_ParseTuple(args, "|l:readlines", &sizehint))\r
- return NULL;\r
-\r
- ACQUIRE_LOCK(self);\r
- switch (self->mode) {\r
- case MODE_READ:\r
- break;\r
- case MODE_READ_EOF:\r
- list = PyList_New(0);\r
- goto cleanup;\r
- case MODE_CLOSED:\r
- PyErr_SetString(PyExc_ValueError,\r
- "I/O operation on closed file");\r
- goto cleanup;\r
- default:\r
- PyErr_SetString(PyExc_IOError,\r
- "file is not ready for reading");\r
- goto cleanup;\r
- }\r
-\r
- /* refuse to mix with f.next() */\r
- if (check_iterbuffered(self))\r
- goto cleanup;\r
-\r
- if ((list = PyList_New(0)) == NULL)\r
- goto cleanup;\r
-\r
- for (;;) {\r
- Py_BEGIN_ALLOW_THREADS\r
- nread = Util_UnivNewlineRead(&bzerror, self->fp,\r
- buffer+nfilled,\r
- buffersize-nfilled, self);\r
- self->pos += nread;\r
- Py_END_ALLOW_THREADS\r
- if (bzerror == BZ_STREAM_END) {\r
- self->size = self->pos;\r
- self->mode = MODE_READ_EOF;\r
- if (nread == 0) {\r
- sizehint = 0;\r
- break;\r
- }\r
- shortread = 1;\r
- } else if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- error:\r
- Py_DECREF(list);\r
- list = NULL;\r
- goto cleanup;\r
- }\r
- totalread += nread;\r
- p = memchr(buffer+nfilled, '\n', nread);\r
- if (!shortread && p == NULL) {\r
- /* Need a larger buffer to fit this line */\r
- nfilled += nread;\r
- buffersize *= 2;\r
- if (buffersize > INT_MAX) {\r
- PyErr_SetString(PyExc_OverflowError,\r
- "line is longer than a Python string can hold");\r
- goto error;\r
- }\r
- if (big_buffer == NULL) {\r
- /* Create the big buffer */\r
- big_buffer = PyString_FromStringAndSize(\r
- NULL, buffersize);\r
- if (big_buffer == NULL)\r
- goto error;\r
- buffer = PyString_AS_STRING(big_buffer);\r
- memcpy(buffer, small_buffer, nfilled);\r
- }\r
- else {\r
- /* Grow the big buffer */\r
- _PyString_Resize(&big_buffer, buffersize);\r
- buffer = PyString_AS_STRING(big_buffer);\r
- }\r
- continue;\r
- }\r
- end = buffer+nfilled+nread;\r
- q = buffer;\r
- while (p != NULL) {\r
- /* Process complete lines */\r
- p++;\r
- line = PyString_FromStringAndSize(q, p-q);\r
- if (line == NULL)\r
- goto error;\r
- err = PyList_Append(list, line);\r
- Py_DECREF(line);\r
- if (err != 0)\r
- goto error;\r
- q = p;\r
- p = memchr(q, '\n', end-q);\r
- }\r
- /* Move the remaining incomplete line to the start */\r
- nfilled = end-q;\r
- memmove(buffer, q, nfilled);\r
- if (sizehint > 0)\r
- if (totalread >= (size_t)sizehint)\r
- break;\r
- if (shortread) {\r
- sizehint = 0;\r
- break;\r
- }\r
- }\r
- if (nfilled != 0) {\r
- /* Partial last line */\r
- line = PyString_FromStringAndSize(buffer, nfilled);\r
- if (line == NULL)\r
- goto error;\r
- if (sizehint > 0) {\r
- /* Need to complete the last line */\r
- PyObject *rest = Util_GetLine(self, 0);\r
- if (rest == NULL) {\r
- Py_DECREF(line);\r
- goto error;\r
- }\r
- PyString_Concat(&line, rest);\r
- Py_DECREF(rest);\r
- if (line == NULL)\r
- goto error;\r
- }\r
- err = PyList_Append(list, line);\r
- Py_DECREF(line);\r
- if (err != 0)\r
- goto error;\r
- }\r
-\r
- cleanup:\r
- RELEASE_LOCK(self);\r
- if (big_buffer) {\r
- Py_DECREF(big_buffer);\r
- }\r
- return list;\r
-}\r
-\r
-PyDoc_STRVAR(BZ2File_xreadlines__doc__,\r
-"xreadlines() -> self\n\\r
-\n\\r
-For backward compatibility. BZ2File objects now include the performance\n\\r
-optimizations previously implemented in the xreadlines module.\n\\r
-");\r
-\r
-PyDoc_STRVAR(BZ2File_write__doc__,\r
-"write(data) -> None\n\\r
-\n\\r
-Write the 'data' string to file. Note that due to buffering, close() may\n\\r
-be needed before the file on disk reflects the data written.\n\\r
-");\r
-\r
-/* This is a hacked version of Python's fileobject.c:file_write(). */\r
-static PyObject *\r
-BZ2File_write(BZ2FileObject *self, PyObject *args)\r
-{\r
- PyObject *ret = NULL;\r
- Py_buffer pbuf;\r
- char *buf;\r
- int len;\r
- int bzerror;\r
-\r
- if (!PyArg_ParseTuple(args, "s*:write", &pbuf))\r
- return NULL;\r
- buf = pbuf.buf;\r
- len = pbuf.len;\r
-\r
- ACQUIRE_LOCK(self);\r
- switch (self->mode) {\r
- case MODE_WRITE:\r
- break;\r
-\r
- case MODE_CLOSED:\r
- PyErr_SetString(PyExc_ValueError,\r
- "I/O operation on closed file");\r
- goto cleanup;\r
-\r
- default:\r
- PyErr_SetString(PyExc_IOError,\r
- "file is not ready for writing");\r
- goto cleanup;\r
- }\r
-\r
- self->f_softspace = 0;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- BZ2_bzWrite (&bzerror, self->fp, buf, len);\r
- self->pos += len;\r
- Py_END_ALLOW_THREADS\r
-\r
- if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- goto cleanup;\r
- }\r
-\r
- Py_INCREF(Py_None);\r
- ret = Py_None;\r
-\r
-cleanup:\r
- PyBuffer_Release(&pbuf);\r
- RELEASE_LOCK(self);\r
- return ret;\r
-}\r
-\r
-PyDoc_STRVAR(BZ2File_writelines__doc__,\r
-"writelines(sequence_of_strings) -> None\n\\r
-\n\\r
-Write the sequence of strings to the file. Note that newlines are not\n\\r
-added. The sequence can be any iterable object producing strings. This is\n\\r
-equivalent to calling write() for each string.\n\\r
-");\r
-\r
-/* This is a hacked version of Python's fileobject.c:file_writelines(). */\r
-static PyObject *\r
-BZ2File_writelines(BZ2FileObject *self, PyObject *seq)\r
-{\r
-#define CHUNKSIZE 1000\r
- PyObject *list = NULL;\r
- PyObject *iter = NULL;\r
- PyObject *ret = NULL;\r
- PyObject *line;\r
- int i, j, index, len, islist;\r
- int bzerror;\r
-\r
- ACQUIRE_LOCK(self);\r
- switch (self->mode) {\r
- case MODE_WRITE:\r
- break;\r
-\r
- case MODE_CLOSED:\r
- PyErr_SetString(PyExc_ValueError,\r
- "I/O operation on closed file");\r
- goto error;\r
-\r
- default:\r
- PyErr_SetString(PyExc_IOError,\r
- "file is not ready for writing");\r
- goto error;\r
- }\r
-\r
- islist = PyList_Check(seq);\r
- if (!islist) {\r
- iter = PyObject_GetIter(seq);\r
- if (iter == NULL) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "writelines() requires an iterable argument");\r
- goto error;\r
- }\r
- list = PyList_New(CHUNKSIZE);\r
- if (list == NULL)\r
- goto error;\r
- }\r
-\r
- /* Strategy: slurp CHUNKSIZE lines into a private list,\r
- checking that they are all strings, then write that list\r
- without holding the interpreter lock, then come back for more. */\r
- for (index = 0; ; index += CHUNKSIZE) {\r
- if (islist) {\r
- Py_XDECREF(list);\r
- list = PyList_GetSlice(seq, index, index+CHUNKSIZE);\r
- if (list == NULL)\r
- goto error;\r
- j = PyList_GET_SIZE(list);\r
- }\r
- else {\r
- for (j = 0; j < CHUNKSIZE; j++) {\r
- line = PyIter_Next(iter);\r
- if (line == NULL) {\r
- if (PyErr_Occurred())\r
- goto error;\r
- break;\r
- }\r
- PyList_SetItem(list, j, line);\r
- }\r
- }\r
- if (j == 0)\r
- break;\r
-\r
- /* Check that all entries are indeed strings. If not,\r
- apply the same rules as for file.write() and\r
- convert the rets to strings. This is slow, but\r
- seems to be the only way since all conversion APIs\r
- could potentially execute Python code. */\r
- for (i = 0; i < j; i++) {\r
- PyObject *v = PyList_GET_ITEM(list, i);\r
- if (!PyString_Check(v)) {\r
- const char *buffer;\r
- Py_ssize_t len;\r
- if (PyObject_AsCharBuffer(v, &buffer, &len)) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "writelines() "\r
- "argument must be "\r
- "a sequence of "\r
- "strings");\r
- goto error;\r
- }\r
- line = PyString_FromStringAndSize(buffer,\r
- len);\r
- if (line == NULL)\r
- goto error;\r
- Py_DECREF(v);\r
- PyList_SET_ITEM(list, i, line);\r
- }\r
- }\r
-\r
- self->f_softspace = 0;\r
-\r
- /* Since we are releasing the global lock, the\r
- following code may *not* execute Python code. */\r
- Py_BEGIN_ALLOW_THREADS\r
- for (i = 0; i < j; i++) {\r
- line = PyList_GET_ITEM(list, i);\r
- len = PyString_GET_SIZE(line);\r
- BZ2_bzWrite (&bzerror, self->fp,\r
- PyString_AS_STRING(line), len);\r
- if (bzerror != BZ_OK) {\r
- Py_BLOCK_THREADS\r
- Util_CatchBZ2Error(bzerror);\r
- goto error;\r
- }\r
- }\r
- Py_END_ALLOW_THREADS\r
-\r
- if (j < CHUNKSIZE)\r
- break;\r
- }\r
-\r
- Py_INCREF(Py_None);\r
- ret = Py_None;\r
-\r
- error:\r
- RELEASE_LOCK(self);\r
- Py_XDECREF(list);\r
- Py_XDECREF(iter);\r
- return ret;\r
-#undef CHUNKSIZE\r
-}\r
-\r
-PyDoc_STRVAR(BZ2File_seek__doc__,\r
-"seek(offset [, whence]) -> None\n\\r
-\n\\r
-Move to new file position. Argument offset is a byte count. Optional\n\\r
-argument whence defaults to 0 (offset from start of file, offset\n\\r
-should be >= 0); other values are 1 (move relative to current position,\n\\r
-positive or negative), and 2 (move relative to end of file, usually\n\\r
-negative, although many platforms allow seeking beyond the end of a file).\n\\r
-\n\\r
-Note that seeking of bz2 files is emulated, and depending on the parameters\n\\r
-the operation may be extremely slow.\n\\r
-");\r
-\r
-static PyObject *\r
-BZ2File_seek(BZ2FileObject *self, PyObject *args)\r
-{\r
- int where = 0;\r
- PyObject *offobj;\r
- Py_off_t offset;\r
- char small_buffer[SMALLCHUNK];\r
- char *buffer = small_buffer;\r
- size_t buffersize = SMALLCHUNK;\r
- Py_off_t bytesread = 0;\r
- size_t readsize;\r
- int chunksize;\r
- int bzerror;\r
- PyObject *ret = NULL;\r
-\r
- if (!PyArg_ParseTuple(args, "O|i:seek", &offobj, &where))\r
- return NULL;\r
-#if !defined(HAVE_LARGEFILE_SUPPORT)\r
- offset = PyInt_AsLong(offobj);\r
-#else\r
- offset = PyLong_Check(offobj) ?\r
- PyLong_AsLongLong(offobj) : PyInt_AsLong(offobj);\r
-#endif\r
- if (PyErr_Occurred())\r
- return NULL;\r
-\r
- ACQUIRE_LOCK(self);\r
- Util_DropReadAhead(self);\r
- switch (self->mode) {\r
- case MODE_READ:\r
- case MODE_READ_EOF:\r
- break;\r
-\r
- case MODE_CLOSED:\r
- PyErr_SetString(PyExc_ValueError,\r
- "I/O operation on closed file");\r
- goto cleanup;\r
-\r
- default:\r
- PyErr_SetString(PyExc_IOError,\r
- "seek works only while reading");\r
- goto cleanup;\r
- }\r
-\r
- if (where == 2) {\r
- if (self->size == -1) {\r
- assert(self->mode != MODE_READ_EOF);\r
- for (;;) {\r
- Py_BEGIN_ALLOW_THREADS\r
- chunksize = Util_UnivNewlineRead(\r
- &bzerror, self->fp,\r
- buffer, buffersize,\r
- self);\r
- self->pos += chunksize;\r
- Py_END_ALLOW_THREADS\r
-\r
- bytesread += chunksize;\r
- if (bzerror == BZ_STREAM_END) {\r
- break;\r
- } else if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- goto cleanup;\r
- }\r
- }\r
- self->mode = MODE_READ_EOF;\r
- self->size = self->pos;\r
- bytesread = 0;\r
- }\r
- offset = self->size + offset;\r
- } else if (where == 1) {\r
- offset = self->pos + offset;\r
- }\r
-\r
- /* Before getting here, offset must be the absolute position the file\r
- * pointer should be set to. */\r
-\r
- if (offset >= self->pos) {\r
- /* we can move forward */\r
- offset -= self->pos;\r
- } else {\r
- /* we cannot move back, so rewind the stream */\r
- BZ2_bzReadClose(&bzerror, self->fp);\r
- if (self->fp) {\r
- PyFile_DecUseCount((PyFileObject *)self->file);\r
- self->fp = NULL;\r
- }\r
- if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- goto cleanup;\r
- }\r
- ret = PyObject_CallMethod(self->file, "seek", "(i)", 0);\r
- if (!ret)\r
- goto cleanup;\r
- Py_DECREF(ret);\r
- ret = NULL;\r
- self->pos = 0;\r
- self->fp = BZ2_bzReadOpen(&bzerror, PyFile_AsFile(self->file),\r
- 0, 0, NULL, 0);\r
- if (self->fp)\r
- PyFile_IncUseCount((PyFileObject *)self->file);\r
- if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- goto cleanup;\r
- }\r
- self->mode = MODE_READ;\r
- }\r
-\r
- if (offset <= 0 || self->mode == MODE_READ_EOF)\r
- goto exit;\r
-\r
- /* Before getting here, offset must be set to the number of bytes\r
- * to walk forward. */\r
- for (;;) {\r
- if (offset-bytesread > buffersize)\r
- readsize = buffersize;\r
- else\r
- /* offset might be wider that readsize, but the result\r
- * of the subtraction is bound by buffersize (see the\r
- * condition above). buffersize is 8192. */\r
- readsize = (size_t)(offset-bytesread);\r
- Py_BEGIN_ALLOW_THREADS\r
- chunksize = Util_UnivNewlineRead(&bzerror, self->fp,\r
- buffer, readsize, self);\r
- self->pos += chunksize;\r
- Py_END_ALLOW_THREADS\r
- bytesread += chunksize;\r
- if (bzerror == BZ_STREAM_END) {\r
- self->size = self->pos;\r
- self->mode = MODE_READ_EOF;\r
- break;\r
- } else if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- goto cleanup;\r
- }\r
- if (bytesread == offset)\r
- break;\r
- }\r
-\r
-exit:\r
- Py_INCREF(Py_None);\r
- ret = Py_None;\r
-\r
-cleanup:\r
- RELEASE_LOCK(self);\r
- return ret;\r
-}\r
-\r
-PyDoc_STRVAR(BZ2File_tell__doc__,\r
-"tell() -> int\n\\r
-\n\\r
-Return the current file position, an integer (may be a long integer).\n\\r
-");\r
-\r
-static PyObject *\r
-BZ2File_tell(BZ2FileObject *self, PyObject *args)\r
-{\r
- PyObject *ret = NULL;\r
-\r
- if (self->mode == MODE_CLOSED) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "I/O operation on closed file");\r
- goto cleanup;\r
- }\r
-\r
-#if !defined(HAVE_LARGEFILE_SUPPORT)\r
- ret = PyInt_FromLong(self->pos);\r
-#else\r
- ret = PyLong_FromLongLong(self->pos);\r
-#endif\r
-\r
-cleanup:\r
- return ret;\r
-}\r
-\r
-PyDoc_STRVAR(BZ2File_close__doc__,\r
-"close() -> None or (perhaps) an integer\n\\r
-\n\\r
-Close the file. Sets data attribute .closed to true. A closed file\n\\r
-cannot be used for further I/O operations. close() may be called more\n\\r
-than once without error.\n\\r
-");\r
-\r
-static PyObject *\r
-BZ2File_close(BZ2FileObject *self)\r
-{\r
- PyObject *ret = NULL;\r
- int bzerror = BZ_OK;\r
-\r
- ACQUIRE_LOCK(self);\r
- switch (self->mode) {\r
- case MODE_READ:\r
- case MODE_READ_EOF:\r
- BZ2_bzReadClose(&bzerror, self->fp);\r
- break;\r
- case MODE_WRITE:\r
- BZ2_bzWriteClose(&bzerror, self->fp,\r
- 0, NULL, NULL);\r
- break;\r
- }\r
- if (self->fp) {\r
- PyFile_DecUseCount((PyFileObject *)self->file);\r
- self->fp = NULL;\r
- }\r
- self->mode = MODE_CLOSED;\r
- ret = PyObject_CallMethod(self->file, "close", NULL);\r
- if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- Py_XDECREF(ret);\r
- ret = NULL;\r
- }\r
-\r
- RELEASE_LOCK(self);\r
- return ret;\r
-}\r
-\r
-PyDoc_STRVAR(BZ2File_enter_doc,\r
-"__enter__() -> self.");\r
-\r
-static PyObject *\r
-BZ2File_enter(BZ2FileObject *self)\r
-{\r
- if (self->mode == MODE_CLOSED) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "I/O operation on closed file");\r
- return NULL;\r
- }\r
- Py_INCREF(self);\r
- return (PyObject *) self;\r
-}\r
-\r
-PyDoc_STRVAR(BZ2File_exit_doc,\r
-"__exit__(*excinfo) -> None. Closes the file.");\r
-\r
-static PyObject *\r
-BZ2File_exit(BZ2FileObject *self, PyObject *args)\r
-{\r
- PyObject *ret = PyObject_CallMethod((PyObject *) self, "close", NULL);\r
- if (!ret)\r
- /* If error occurred, pass through */\r
- return NULL;\r
- Py_DECREF(ret);\r
- Py_RETURN_NONE;\r
-}\r
-\r
-\r
-static PyObject *BZ2File_getiter(BZ2FileObject *self);\r
-\r
-static PyMethodDef BZ2File_methods[] = {\r
- {"read", (PyCFunction)BZ2File_read, METH_VARARGS, BZ2File_read__doc__},\r
- {"readline", (PyCFunction)BZ2File_readline, METH_VARARGS, BZ2File_readline__doc__},\r
- {"readlines", (PyCFunction)BZ2File_readlines, METH_VARARGS, BZ2File_readlines__doc__},\r
- {"xreadlines", (PyCFunction)BZ2File_getiter, METH_VARARGS, BZ2File_xreadlines__doc__},\r
- {"write", (PyCFunction)BZ2File_write, METH_VARARGS, BZ2File_write__doc__},\r
- {"writelines", (PyCFunction)BZ2File_writelines, METH_O, BZ2File_writelines__doc__},\r
- {"seek", (PyCFunction)BZ2File_seek, METH_VARARGS, BZ2File_seek__doc__},\r
- {"tell", (PyCFunction)BZ2File_tell, METH_NOARGS, BZ2File_tell__doc__},\r
- {"close", (PyCFunction)BZ2File_close, METH_NOARGS, BZ2File_close__doc__},\r
- {"__enter__", (PyCFunction)BZ2File_enter, METH_NOARGS, BZ2File_enter_doc},\r
- {"__exit__", (PyCFunction)BZ2File_exit, METH_VARARGS, BZ2File_exit_doc},\r
- {NULL, NULL} /* sentinel */\r
-};\r
-\r
-\r
-/* ===================================================================== */\r
-/* Getters and setters of BZ2File. */\r
-\r
-/* This is a hacked version of Python's fileobject.c:get_newlines(). */\r
-static PyObject *\r
-BZ2File_get_newlines(BZ2FileObject *self, void *closure)\r
-{\r
- switch (self->f_newlinetypes) {\r
- case NEWLINE_UNKNOWN:\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- case NEWLINE_CR:\r
- return PyString_FromString("\r");\r
- case NEWLINE_LF:\r
- return PyString_FromString("\n");\r
- case NEWLINE_CR|NEWLINE_LF:\r
- return Py_BuildValue("(ss)", "\r", "\n");\r
- case NEWLINE_CRLF:\r
- return PyString_FromString("\r\n");\r
- case NEWLINE_CR|NEWLINE_CRLF:\r
- return Py_BuildValue("(ss)", "\r", "\r\n");\r
- case NEWLINE_LF|NEWLINE_CRLF:\r
- return Py_BuildValue("(ss)", "\n", "\r\n");\r
- case NEWLINE_CR|NEWLINE_LF|NEWLINE_CRLF:\r
- return Py_BuildValue("(sss)", "\r", "\n", "\r\n");\r
- default:\r
- PyErr_Format(PyExc_SystemError,\r
- "Unknown newlines value 0x%x\n",\r
- self->f_newlinetypes);\r
- return NULL;\r
- }\r
-}\r
-\r
-static PyObject *\r
-BZ2File_get_closed(BZ2FileObject *self, void *closure)\r
-{\r
- return PyInt_FromLong(self->mode == MODE_CLOSED);\r
-}\r
-\r
-static PyObject *\r
-BZ2File_get_mode(BZ2FileObject *self, void *closure)\r
-{\r
- return PyObject_GetAttrString(self->file, "mode");\r
-}\r
-\r
-static PyObject *\r
-BZ2File_get_name(BZ2FileObject *self, void *closure)\r
-{\r
- return PyObject_GetAttrString(self->file, "name");\r
-}\r
-\r
-static PyGetSetDef BZ2File_getset[] = {\r
- {"closed", (getter)BZ2File_get_closed, NULL,\r
- "True if the file is closed"},\r
- {"newlines", (getter)BZ2File_get_newlines, NULL,\r
- "end-of-line convention used in this file"},\r
- {"mode", (getter)BZ2File_get_mode, NULL,\r
- "file mode ('r', 'w', or 'U')"},\r
- {"name", (getter)BZ2File_get_name, NULL,\r
- "file name"},\r
- {NULL} /* Sentinel */\r
-};\r
-\r
-\r
-/* ===================================================================== */\r
-/* Members of BZ2File_Type. */\r
-\r
-#undef OFF\r
-#define OFF(x) offsetof(BZ2FileObject, x)\r
-\r
-static PyMemberDef BZ2File_members[] = {\r
- {"softspace", T_INT, OFF(f_softspace), 0,\r
- "flag indicating that a space needs to be printed; used by print"},\r
- {NULL} /* Sentinel */\r
-};\r
-\r
-/* ===================================================================== */\r
-/* Slot definitions for BZ2File_Type. */\r
-\r
-static int\r
-BZ2File_init(BZ2FileObject *self, PyObject *args, PyObject *kwargs)\r
-{\r
- static char *kwlist[] = {"filename", "mode", "buffering",\r
- "compresslevel", 0};\r
- PyObject *name;\r
- char *mode = "r";\r
- int buffering = -1;\r
- int compresslevel = 9;\r
- int bzerror;\r
- int mode_char = 0;\r
-\r
- self->size = -1;\r
-\r
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|sii:BZ2File",\r
- kwlist, &name, &mode, &buffering,\r
- &compresslevel))\r
- return -1;\r
-\r
- if (compresslevel < 1 || compresslevel > 9) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "compresslevel must be between 1 and 9");\r
- return -1;\r
- }\r
-\r
- for (;;) {\r
- int error = 0;\r
- switch (*mode) {\r
- case 'r':\r
- case 'w':\r
- if (mode_char)\r
- error = 1;\r
- mode_char = *mode;\r
- break;\r
-\r
- case 'b':\r
- break;\r
-\r
- case 'U':\r
-#ifdef __VMS\r
- self->f_univ_newline = 0;\r
-#else\r
- self->f_univ_newline = 1;\r
-#endif\r
- break;\r
-\r
- default:\r
- error = 1;\r
- break;\r
- }\r
- if (error) {\r
- PyErr_Format(PyExc_ValueError,\r
- "invalid mode char %c", *mode);\r
- return -1;\r
- }\r
- mode++;\r
- if (*mode == '\0')\r
- break;\r
- }\r
-\r
- if (mode_char == 0) {\r
- mode_char = 'r';\r
- }\r
-\r
- mode = (mode_char == 'r') ? "rb" : "wb";\r
-\r
- self->file = PyObject_CallFunction((PyObject*)&PyFile_Type, "(Osi)",\r
- name, mode, buffering);\r
- if (self->file == NULL)\r
- return -1;\r
-\r
- /* From now on, we have stuff to dealloc, so jump to error label\r
- * instead of returning */\r
-\r
-#ifdef WITH_THREAD\r
- self->lock = PyThread_allocate_lock();\r
- if (!self->lock) {\r
- PyErr_SetString(PyExc_MemoryError, "unable to allocate lock");\r
- goto error;\r
- }\r
-#endif\r
-\r
- if (mode_char == 'r')\r
- self->fp = BZ2_bzReadOpen(&bzerror,\r
- PyFile_AsFile(self->file),\r
- 0, 0, NULL, 0);\r
- else\r
- self->fp = BZ2_bzWriteOpen(&bzerror,\r
- PyFile_AsFile(self->file),\r
- compresslevel, 0, 0);\r
-\r
- if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- goto error;\r
- }\r
- PyFile_IncUseCount((PyFileObject *)self->file);\r
-\r
- self->mode = (mode_char == 'r') ? MODE_READ : MODE_WRITE;\r
-\r
- return 0;\r
-\r
-error:\r
- Py_CLEAR(self->file);\r
-#ifdef WITH_THREAD\r
- if (self->lock) {\r
- PyThread_free_lock(self->lock);\r
- self->lock = NULL;\r
- }\r
-#endif\r
- return -1;\r
-}\r
-\r
-static void\r
-BZ2File_dealloc(BZ2FileObject *self)\r
-{\r
- int bzerror;\r
-#ifdef WITH_THREAD\r
- if (self->lock)\r
- PyThread_free_lock(self->lock);\r
-#endif\r
- switch (self->mode) {\r
- case MODE_READ:\r
- case MODE_READ_EOF:\r
- BZ2_bzReadClose(&bzerror, self->fp);\r
- break;\r
- case MODE_WRITE:\r
- BZ2_bzWriteClose(&bzerror, self->fp,\r
- 0, NULL, NULL);\r
- break;\r
- }\r
- if (self->fp) {\r
- PyFile_DecUseCount((PyFileObject *)self->file);\r
- self->fp = NULL;\r
- }\r
- Util_DropReadAhead(self);\r
- Py_XDECREF(self->file);\r
- Py_TYPE(self)->tp_free((PyObject *)self);\r
-}\r
-\r
-/* This is a hacked version of Python's fileobject.c:file_getiter(). */\r
-static PyObject *\r
-BZ2File_getiter(BZ2FileObject *self)\r
-{\r
- if (self->mode == MODE_CLOSED) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "I/O operation on closed file");\r
- return NULL;\r
- }\r
- Py_INCREF((PyObject*)self);\r
- return (PyObject *)self;\r
-}\r
-\r
-/* This is a hacked version of Python's fileobject.c:file_iternext(). */\r
-#define READAHEAD_BUFSIZE 8192\r
-static PyObject *\r
-BZ2File_iternext(BZ2FileObject *self)\r
-{\r
- PyStringObject* ret;\r
- ACQUIRE_LOCK(self);\r
- if (self->mode == MODE_CLOSED) {\r
- RELEASE_LOCK(self);\r
- PyErr_SetString(PyExc_ValueError,\r
- "I/O operation on closed file");\r
- return NULL;\r
- }\r
- ret = Util_ReadAheadGetLineSkip(self, 0, READAHEAD_BUFSIZE);\r
- RELEASE_LOCK(self);\r
- if (ret == NULL || PyString_GET_SIZE(ret) == 0) {\r
- Py_XDECREF(ret);\r
- return NULL;\r
- }\r
- return (PyObject *)ret;\r
-}\r
-\r
-/* ===================================================================== */\r
-/* BZ2File_Type definition. */\r
-\r
-PyDoc_VAR(BZ2File__doc__) =\r
-PyDoc_STR(\r
-"BZ2File(name [, mode='r', buffering=0, compresslevel=9]) -> file object\n\\r
-\n\\r
-Open a bz2 file. The mode can be 'r' or 'w', for reading (default) or\n\\r
-writing. When opened for writing, the file will be created if it doesn't\n\\r
-exist, and truncated otherwise. If the buffering argument is given, 0 means\n\\r
-unbuffered, and larger numbers specify the buffer size. If compresslevel\n\\r
-is given, must be a number between 1 and 9.\n\\r
-")\r
-PyDoc_STR(\r
-"\n\\r
-Add a 'U' to mode to open the file for input with universal newline\n\\r
-support. Any line ending in the input file will be seen as a '\\n' in\n\\r
-Python. Also, a file so opened gains the attribute 'newlines'; the value\n\\r
-for this attribute is one of None (no newline read yet), '\\r', '\\n',\n\\r
-'\\r\\n' or a tuple containing all the newline types seen. Universal\n\\r
-newlines are available only when reading.\n\\r
-")\r
-;\r
-\r
-static PyTypeObject BZ2File_Type = {\r
- PyVarObject_HEAD_INIT(NULL, 0)\r
- "bz2.BZ2File", /*tp_name*/\r
- sizeof(BZ2FileObject), /*tp_basicsize*/\r
- 0, /*tp_itemsize*/\r
- (destructor)BZ2File_dealloc, /*tp_dealloc*/\r
- 0, /*tp_print*/\r
- 0, /*tp_getattr*/\r
- 0, /*tp_setattr*/\r
- 0, /*tp_compare*/\r
- 0, /*tp_repr*/\r
- 0, /*tp_as_number*/\r
- 0, /*tp_as_sequence*/\r
- 0, /*tp_as_mapping*/\r
- 0, /*tp_hash*/\r
- 0, /*tp_call*/\r
- 0, /*tp_str*/\r
- PyObject_GenericGetAttr,/*tp_getattro*/\r
- PyObject_GenericSetAttr,/*tp_setattro*/\r
- 0, /*tp_as_buffer*/\r
- Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /*tp_flags*/\r
- BZ2File__doc__, /*tp_doc*/\r
- 0, /*tp_traverse*/\r
- 0, /*tp_clear*/\r
- 0, /*tp_richcompare*/\r
- 0, /*tp_weaklistoffset*/\r
- (getiterfunc)BZ2File_getiter, /*tp_iter*/\r
- (iternextfunc)BZ2File_iternext, /*tp_iternext*/\r
- BZ2File_methods, /*tp_methods*/\r
- BZ2File_members, /*tp_members*/\r
- BZ2File_getset, /*tp_getset*/\r
- 0, /*tp_base*/\r
- 0, /*tp_dict*/\r
- 0, /*tp_descr_get*/\r
- 0, /*tp_descr_set*/\r
- 0, /*tp_dictoffset*/\r
- (initproc)BZ2File_init, /*tp_init*/\r
- PyType_GenericAlloc, /*tp_alloc*/\r
- PyType_GenericNew, /*tp_new*/\r
- _PyObject_Del, /*tp_free*/\r
- 0, /*tp_is_gc*/\r
-};\r
-\r
-\r
-/* ===================================================================== */\r
-/* Methods of BZ2Comp. */\r
-\r
-PyDoc_STRVAR(BZ2Comp_compress__doc__,\r
-"compress(data) -> string\n\\r
-\n\\r
-Provide more data to the compressor object. It will return chunks of\n\\r
-compressed data whenever possible. When you've finished providing data\n\\r
-to compress, call the flush() method to finish the compression process,\n\\r
-and return what is left in the internal buffers.\n\\r
-");\r
-\r
-static PyObject *\r
-BZ2Comp_compress(BZ2CompObject *self, PyObject *args)\r
-{\r
- Py_buffer pdata;\r
- char *data;\r
- int datasize;\r
- int bufsize = SMALLCHUNK;\r
- PY_LONG_LONG totalout;\r
- PyObject *ret = NULL;\r
- bz_stream *bzs = &self->bzs;\r
- int bzerror;\r
-\r
- if (!PyArg_ParseTuple(args, "s*:compress", &pdata))\r
- return NULL;\r
- data = pdata.buf;\r
- datasize = pdata.len;\r
-\r
- if (datasize == 0) {\r
- PyBuffer_Release(&pdata);\r
- return PyString_FromString("");\r
- }\r
-\r
- ACQUIRE_LOCK(self);\r
- if (!self->running) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "this object was already flushed");\r
- goto error;\r
- }\r
-\r
- ret = PyString_FromStringAndSize(NULL, bufsize);\r
- if (!ret)\r
- goto error;\r
-\r
- bzs->next_in = data;\r
- bzs->avail_in = datasize;\r
- bzs->next_out = BUF(ret);\r
- bzs->avail_out = bufsize;\r
-\r
- totalout = BZS_TOTAL_OUT(bzs);\r
-\r
- for (;;) {\r
- Py_BEGIN_ALLOW_THREADS\r
- bzerror = BZ2_bzCompress(bzs, BZ_RUN);\r
- Py_END_ALLOW_THREADS\r
- if (bzerror != BZ_RUN_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- goto error;\r
- }\r
- if (bzs->avail_in == 0)\r
- break; /* no more input data */\r
- if (bzs->avail_out == 0) {\r
- bufsize = Util_NewBufferSize(bufsize);\r
- if (_PyString_Resize(&ret, bufsize) < 0) {\r
- BZ2_bzCompressEnd(bzs);\r
- goto error;\r
- }\r
- bzs->next_out = BUF(ret) + (BZS_TOTAL_OUT(bzs)\r
- - totalout);\r
- bzs->avail_out = bufsize - (bzs->next_out - BUF(ret));\r
- }\r
- }\r
-\r
- _PyString_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));\r
-\r
- RELEASE_LOCK(self);\r
- PyBuffer_Release(&pdata);\r
- return ret;\r
-\r
-error:\r
- RELEASE_LOCK(self);\r
- PyBuffer_Release(&pdata);\r
- Py_XDECREF(ret);\r
- return NULL;\r
-}\r
-\r
-PyDoc_STRVAR(BZ2Comp_flush__doc__,\r
-"flush() -> string\n\\r
-\n\\r
-Finish the compression process and return what is left in internal buffers.\n\\r
-You must not use the compressor object after calling this method.\n\\r
-");\r
-\r
-static PyObject *\r
-BZ2Comp_flush(BZ2CompObject *self)\r
-{\r
- int bufsize = SMALLCHUNK;\r
- PyObject *ret = NULL;\r
- bz_stream *bzs = &self->bzs;\r
- PY_LONG_LONG totalout;\r
- int bzerror;\r
-\r
- ACQUIRE_LOCK(self);\r
- if (!self->running) {\r
- PyErr_SetString(PyExc_ValueError, "object was already "\r
- "flushed");\r
- goto error;\r
- }\r
- self->running = 0;\r
-\r
- ret = PyString_FromStringAndSize(NULL, bufsize);\r
- if (!ret)\r
- goto error;\r
-\r
- bzs->next_out = BUF(ret);\r
- bzs->avail_out = bufsize;\r
-\r
- totalout = BZS_TOTAL_OUT(bzs);\r
-\r
- for (;;) {\r
- Py_BEGIN_ALLOW_THREADS\r
- bzerror = BZ2_bzCompress(bzs, BZ_FINISH);\r
- Py_END_ALLOW_THREADS\r
- if (bzerror == BZ_STREAM_END) {\r
- break;\r
- } else if (bzerror != BZ_FINISH_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- goto error;\r
- }\r
- if (bzs->avail_out == 0) {\r
- bufsize = Util_NewBufferSize(bufsize);\r
- if (_PyString_Resize(&ret, bufsize) < 0)\r
- goto error;\r
- bzs->next_out = BUF(ret);\r
- bzs->next_out = BUF(ret) + (BZS_TOTAL_OUT(bzs)\r
- - totalout);\r
- bzs->avail_out = bufsize - (bzs->next_out - BUF(ret));\r
- }\r
- }\r
-\r
- if (bzs->avail_out != 0)\r
- _PyString_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));\r
-\r
- RELEASE_LOCK(self);\r
- return ret;\r
-\r
-error:\r
- RELEASE_LOCK(self);\r
- Py_XDECREF(ret);\r
- return NULL;\r
-}\r
-\r
-static PyMethodDef BZ2Comp_methods[] = {\r
- {"compress", (PyCFunction)BZ2Comp_compress, METH_VARARGS,\r
- BZ2Comp_compress__doc__},\r
- {"flush", (PyCFunction)BZ2Comp_flush, METH_NOARGS,\r
- BZ2Comp_flush__doc__},\r
- {NULL, NULL} /* sentinel */\r
-};\r
-\r
-\r
-/* ===================================================================== */\r
-/* Slot definitions for BZ2Comp_Type. */\r
-\r
-static int\r
-BZ2Comp_init(BZ2CompObject *self, PyObject *args, PyObject *kwargs)\r
-{\r
- int compresslevel = 9;\r
- int bzerror;\r
- static char *kwlist[] = {"compresslevel", 0};\r
-\r
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:BZ2Compressor",\r
- kwlist, &compresslevel))\r
- return -1;\r
-\r
- if (compresslevel < 1 || compresslevel > 9) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "compresslevel must be between 1 and 9");\r
- goto error;\r
- }\r
-\r
-#ifdef WITH_THREAD\r
- self->lock = PyThread_allocate_lock();\r
- if (!self->lock) {\r
- PyErr_SetString(PyExc_MemoryError, "unable to allocate lock");\r
- goto error;\r
- }\r
-#endif\r
-\r
- memset(&self->bzs, 0, sizeof(bz_stream));\r
- bzerror = BZ2_bzCompressInit(&self->bzs, compresslevel, 0, 0);\r
- if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- goto error;\r
- }\r
-\r
- self->running = 1;\r
-\r
- return 0;\r
-error:\r
-#ifdef WITH_THREAD\r
- if (self->lock) {\r
- PyThread_free_lock(self->lock);\r
- self->lock = NULL;\r
- }\r
-#endif\r
- return -1;\r
-}\r
-\r
-static void\r
-BZ2Comp_dealloc(BZ2CompObject *self)\r
-{\r
-#ifdef WITH_THREAD\r
- if (self->lock)\r
- PyThread_free_lock(self->lock);\r
-#endif\r
- BZ2_bzCompressEnd(&self->bzs);\r
- Py_TYPE(self)->tp_free((PyObject *)self);\r
-}\r
-\r
-\r
-/* ===================================================================== */\r
-/* BZ2Comp_Type definition. */\r
-\r
-PyDoc_STRVAR(BZ2Comp__doc__,\r
-"BZ2Compressor([compresslevel=9]) -> compressor object\n\\r
-\n\\r
-Create a new compressor object. This object may be used to compress\n\\r
-data sequentially. If you want to compress data in one shot, use the\n\\r
-compress() function instead. The compresslevel parameter, if given,\n\\r
-must be a number between 1 and 9.\n\\r
-");\r
-\r
-static PyTypeObject BZ2Comp_Type = {\r
- PyVarObject_HEAD_INIT(NULL, 0)\r
- "bz2.BZ2Compressor", /*tp_name*/\r
- sizeof(BZ2CompObject), /*tp_basicsize*/\r
- 0, /*tp_itemsize*/\r
- (destructor)BZ2Comp_dealloc, /*tp_dealloc*/\r
- 0, /*tp_print*/\r
- 0, /*tp_getattr*/\r
- 0, /*tp_setattr*/\r
- 0, /*tp_compare*/\r
- 0, /*tp_repr*/\r
- 0, /*tp_as_number*/\r
- 0, /*tp_as_sequence*/\r
- 0, /*tp_as_mapping*/\r
- 0, /*tp_hash*/\r
- 0, /*tp_call*/\r
- 0, /*tp_str*/\r
- PyObject_GenericGetAttr,/*tp_getattro*/\r
- PyObject_GenericSetAttr,/*tp_setattro*/\r
- 0, /*tp_as_buffer*/\r
- Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /*tp_flags*/\r
- BZ2Comp__doc__, /*tp_doc*/\r
- 0, /*tp_traverse*/\r
- 0, /*tp_clear*/\r
- 0, /*tp_richcompare*/\r
- 0, /*tp_weaklistoffset*/\r
- 0, /*tp_iter*/\r
- 0, /*tp_iternext*/\r
- BZ2Comp_methods, /*tp_methods*/\r
- 0, /*tp_members*/\r
- 0, /*tp_getset*/\r
- 0, /*tp_base*/\r
- 0, /*tp_dict*/\r
- 0, /*tp_descr_get*/\r
- 0, /*tp_descr_set*/\r
- 0, /*tp_dictoffset*/\r
- (initproc)BZ2Comp_init, /*tp_init*/\r
- PyType_GenericAlloc, /*tp_alloc*/\r
- PyType_GenericNew, /*tp_new*/\r
- _PyObject_Del, /*tp_free*/\r
- 0, /*tp_is_gc*/\r
-};\r
-\r
-\r
-/* ===================================================================== */\r
-/* Members of BZ2Decomp. */\r
-\r
-#undef OFF\r
-#define OFF(x) offsetof(BZ2DecompObject, x)\r
-\r
-static PyMemberDef BZ2Decomp_members[] = {\r
- {"unused_data", T_OBJECT, OFF(unused_data), RO},\r
- {NULL} /* Sentinel */\r
-};\r
-\r
-\r
-/* ===================================================================== */\r
-/* Methods of BZ2Decomp. */\r
-\r
-PyDoc_STRVAR(BZ2Decomp_decompress__doc__,\r
-"decompress(data) -> string\n\\r
-\n\\r
-Provide more data to the decompressor object. It will return chunks\n\\r
-of decompressed data whenever possible. If you try to decompress data\n\\r
-after the end of stream is found, EOFError will be raised. If any data\n\\r
-was found after the end of stream, it'll be ignored and saved in\n\\r
-unused_data attribute.\n\\r
-");\r
-\r
-static PyObject *\r
-BZ2Decomp_decompress(BZ2DecompObject *self, PyObject *args)\r
-{\r
- Py_buffer pdata;\r
- char *data;\r
- int datasize;\r
- int bufsize = SMALLCHUNK;\r
- PY_LONG_LONG totalout;\r
- PyObject *ret = NULL;\r
- bz_stream *bzs = &self->bzs;\r
- int bzerror;\r
-\r
- if (!PyArg_ParseTuple(args, "s*:decompress", &pdata))\r
- return NULL;\r
- data = pdata.buf;\r
- datasize = pdata.len;\r
-\r
- ACQUIRE_LOCK(self);\r
- if (!self->running) {\r
- PyErr_SetString(PyExc_EOFError, "end of stream was "\r
- "already found");\r
- goto error;\r
- }\r
-\r
- ret = PyString_FromStringAndSize(NULL, bufsize);\r
- if (!ret)\r
- goto error;\r
-\r
- bzs->next_in = data;\r
- bzs->avail_in = datasize;\r
- bzs->next_out = BUF(ret);\r
- bzs->avail_out = bufsize;\r
-\r
- totalout = BZS_TOTAL_OUT(bzs);\r
-\r
- for (;;) {\r
- Py_BEGIN_ALLOW_THREADS\r
- bzerror = BZ2_bzDecompress(bzs);\r
- Py_END_ALLOW_THREADS\r
- if (bzerror == BZ_STREAM_END) {\r
- if (bzs->avail_in != 0) {\r
- Py_DECREF(self->unused_data);\r
- self->unused_data =\r
- PyString_FromStringAndSize(bzs->next_in,\r
- bzs->avail_in);\r
- }\r
- self->running = 0;\r
- break;\r
- }\r
- if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- goto error;\r
- }\r
- if (bzs->avail_in == 0)\r
- break; /* no more input data */\r
- if (bzs->avail_out == 0) {\r
- bufsize = Util_NewBufferSize(bufsize);\r
- if (_PyString_Resize(&ret, bufsize) < 0) {\r
- BZ2_bzDecompressEnd(bzs);\r
- goto error;\r
- }\r
- bzs->next_out = BUF(ret);\r
- bzs->next_out = BUF(ret) + (BZS_TOTAL_OUT(bzs)\r
- - totalout);\r
- bzs->avail_out = bufsize - (bzs->next_out - BUF(ret));\r
- }\r
- }\r
-\r
- if (bzs->avail_out != 0)\r
- _PyString_Resize(&ret, (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout));\r
-\r
- RELEASE_LOCK(self);\r
- PyBuffer_Release(&pdata);\r
- return ret;\r
-\r
-error:\r
- RELEASE_LOCK(self);\r
- PyBuffer_Release(&pdata);\r
- Py_XDECREF(ret);\r
- return NULL;\r
-}\r
-\r
-static PyMethodDef BZ2Decomp_methods[] = {\r
- {"decompress", (PyCFunction)BZ2Decomp_decompress, METH_VARARGS, BZ2Decomp_decompress__doc__},\r
- {NULL, NULL} /* sentinel */\r
-};\r
-\r
-\r
-/* ===================================================================== */\r
-/* Slot definitions for BZ2Decomp_Type. */\r
-\r
-static int\r
-BZ2Decomp_init(BZ2DecompObject *self, PyObject *args, PyObject *kwargs)\r
-{\r
- int bzerror;\r
-\r
- if (!PyArg_ParseTuple(args, ":BZ2Decompressor"))\r
- return -1;\r
-\r
-#ifdef WITH_THREAD\r
- self->lock = PyThread_allocate_lock();\r
- if (!self->lock) {\r
- PyErr_SetString(PyExc_MemoryError, "unable to allocate lock");\r
- goto error;\r
- }\r
-#endif\r
-\r
- self->unused_data = PyString_FromString("");\r
- if (!self->unused_data)\r
- goto error;\r
-\r
- memset(&self->bzs, 0, sizeof(bz_stream));\r
- bzerror = BZ2_bzDecompressInit(&self->bzs, 0, 0);\r
- if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- goto error;\r
- }\r
-\r
- self->running = 1;\r
-\r
- return 0;\r
-\r
-error:\r
-#ifdef WITH_THREAD\r
- if (self->lock) {\r
- PyThread_free_lock(self->lock);\r
- self->lock = NULL;\r
- }\r
-#endif\r
- Py_CLEAR(self->unused_data);\r
- return -1;\r
-}\r
-\r
-static void\r
-BZ2Decomp_dealloc(BZ2DecompObject *self)\r
-{\r
-#ifdef WITH_THREAD\r
- if (self->lock)\r
- PyThread_free_lock(self->lock);\r
-#endif\r
- Py_XDECREF(self->unused_data);\r
- BZ2_bzDecompressEnd(&self->bzs);\r
- Py_TYPE(self)->tp_free((PyObject *)self);\r
-}\r
-\r
-\r
-/* ===================================================================== */\r
-/* BZ2Decomp_Type definition. */\r
-\r
-PyDoc_STRVAR(BZ2Decomp__doc__,\r
-"BZ2Decompressor() -> decompressor object\n\\r
-\n\\r
-Create a new decompressor object. This object may be used to decompress\n\\r
-data sequentially. If you want to decompress data in one shot, use the\n\\r
-decompress() function instead.\n\\r
-");\r
-\r
-static PyTypeObject BZ2Decomp_Type = {\r
- PyVarObject_HEAD_INIT(NULL, 0)\r
- "bz2.BZ2Decompressor", /*tp_name*/\r
- sizeof(BZ2DecompObject), /*tp_basicsize*/\r
- 0, /*tp_itemsize*/\r
- (destructor)BZ2Decomp_dealloc, /*tp_dealloc*/\r
- 0, /*tp_print*/\r
- 0, /*tp_getattr*/\r
- 0, /*tp_setattr*/\r
- 0, /*tp_compare*/\r
- 0, /*tp_repr*/\r
- 0, /*tp_as_number*/\r
- 0, /*tp_as_sequence*/\r
- 0, /*tp_as_mapping*/\r
- 0, /*tp_hash*/\r
- 0, /*tp_call*/\r
- 0, /*tp_str*/\r
- PyObject_GenericGetAttr,/*tp_getattro*/\r
- PyObject_GenericSetAttr,/*tp_setattro*/\r
- 0, /*tp_as_buffer*/\r
- Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /*tp_flags*/\r
- BZ2Decomp__doc__, /*tp_doc*/\r
- 0, /*tp_traverse*/\r
- 0, /*tp_clear*/\r
- 0, /*tp_richcompare*/\r
- 0, /*tp_weaklistoffset*/\r
- 0, /*tp_iter*/\r
- 0, /*tp_iternext*/\r
- BZ2Decomp_methods, /*tp_methods*/\r
- BZ2Decomp_members, /*tp_members*/\r
- 0, /*tp_getset*/\r
- 0, /*tp_base*/\r
- 0, /*tp_dict*/\r
- 0, /*tp_descr_get*/\r
- 0, /*tp_descr_set*/\r
- 0, /*tp_dictoffset*/\r
- (initproc)BZ2Decomp_init, /*tp_init*/\r
- PyType_GenericAlloc, /*tp_alloc*/\r
- PyType_GenericNew, /*tp_new*/\r
- _PyObject_Del, /*tp_free*/\r
- 0, /*tp_is_gc*/\r
-};\r
-\r
-\r
-/* ===================================================================== */\r
-/* Module functions. */\r
-\r
-PyDoc_STRVAR(bz2_compress__doc__,\r
-"compress(data [, compresslevel=9]) -> string\n\\r
-\n\\r
-Compress data in one shot. If you want to compress data sequentially,\n\\r
-use an instance of BZ2Compressor instead. The compresslevel parameter, if\n\\r
-given, must be a number between 1 and 9.\n\\r
-");\r
-\r
-static PyObject *\r
-bz2_compress(PyObject *self, PyObject *args, PyObject *kwargs)\r
-{\r
- int compresslevel=9;\r
- Py_buffer pdata;\r
- char *data;\r
- int datasize;\r
- int bufsize;\r
- PyObject *ret = NULL;\r
- bz_stream _bzs;\r
- bz_stream *bzs = &_bzs;\r
- int bzerror;\r
- static char *kwlist[] = {"data", "compresslevel", 0};\r
-\r
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s*|i",\r
- kwlist, &pdata,\r
- &compresslevel))\r
- return NULL;\r
- data = pdata.buf;\r
- datasize = pdata.len;\r
-\r
- if (compresslevel < 1 || compresslevel > 9) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "compresslevel must be between 1 and 9");\r
- PyBuffer_Release(&pdata);\r
- return NULL;\r
- }\r
-\r
- /* Conforming to bz2 manual, this is large enough to fit compressed\r
- * data in one shot. We will check it later anyway. */\r
- bufsize = datasize + (datasize/100+1) + 600;\r
-\r
- ret = PyString_FromStringAndSize(NULL, bufsize);\r
- if (!ret) {\r
- PyBuffer_Release(&pdata);\r
- return NULL;\r
- }\r
-\r
- memset(bzs, 0, sizeof(bz_stream));\r
-\r
- bzs->next_in = data;\r
- bzs->avail_in = datasize;\r
- bzs->next_out = BUF(ret);\r
- bzs->avail_out = bufsize;\r
-\r
- bzerror = BZ2_bzCompressInit(bzs, compresslevel, 0, 0);\r
- if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- PyBuffer_Release(&pdata);\r
- Py_DECREF(ret);\r
- return NULL;\r
- }\r
-\r
- for (;;) {\r
- Py_BEGIN_ALLOW_THREADS\r
- bzerror = BZ2_bzCompress(bzs, BZ_FINISH);\r
- Py_END_ALLOW_THREADS\r
- if (bzerror == BZ_STREAM_END) {\r
- break;\r
- } else if (bzerror != BZ_FINISH_OK) {\r
- BZ2_bzCompressEnd(bzs);\r
- Util_CatchBZ2Error(bzerror);\r
- PyBuffer_Release(&pdata);\r
- Py_DECREF(ret);\r
- return NULL;\r
- }\r
- if (bzs->avail_out == 0) {\r
- bufsize = Util_NewBufferSize(bufsize);\r
- if (_PyString_Resize(&ret, bufsize) < 0) {\r
- BZ2_bzCompressEnd(bzs);\r
- PyBuffer_Release(&pdata);\r
- Py_DECREF(ret);\r
- return NULL;\r
- }\r
- bzs->next_out = BUF(ret) + BZS_TOTAL_OUT(bzs);\r
- bzs->avail_out = bufsize - (bzs->next_out - BUF(ret));\r
- }\r
- }\r
-\r
- if (bzs->avail_out != 0)\r
- _PyString_Resize(&ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs));\r
- BZ2_bzCompressEnd(bzs);\r
-\r
- PyBuffer_Release(&pdata);\r
- return ret;\r
-}\r
-\r
-PyDoc_STRVAR(bz2_decompress__doc__,\r
-"decompress(data) -> decompressed data\n\\r
-\n\\r
-Decompress data in one shot. If you want to decompress data sequentially,\n\\r
-use an instance of BZ2Decompressor instead.\n\\r
-");\r
-\r
-static PyObject *\r
-bz2_decompress(PyObject *self, PyObject *args)\r
-{\r
- Py_buffer pdata;\r
- char *data;\r
- int datasize;\r
- int bufsize = SMALLCHUNK;\r
- PyObject *ret;\r
- bz_stream _bzs;\r
- bz_stream *bzs = &_bzs;\r
- int bzerror;\r
-\r
- if (!PyArg_ParseTuple(args, "s*:decompress", &pdata))\r
- return NULL;\r
- data = pdata.buf;\r
- datasize = pdata.len;\r
-\r
- if (datasize == 0) {\r
- PyBuffer_Release(&pdata);\r
- return PyString_FromString("");\r
- }\r
-\r
- ret = PyString_FromStringAndSize(NULL, bufsize);\r
- if (!ret) {\r
- PyBuffer_Release(&pdata);\r
- return NULL;\r
- }\r
-\r
- memset(bzs, 0, sizeof(bz_stream));\r
-\r
- bzs->next_in = data;\r
- bzs->avail_in = datasize;\r
- bzs->next_out = BUF(ret);\r
- bzs->avail_out = bufsize;\r
-\r
- bzerror = BZ2_bzDecompressInit(bzs, 0, 0);\r
- if (bzerror != BZ_OK) {\r
- Util_CatchBZ2Error(bzerror);\r
- Py_DECREF(ret);\r
- PyBuffer_Release(&pdata);\r
- return NULL;\r
- }\r
-\r
- for (;;) {\r
- Py_BEGIN_ALLOW_THREADS\r
- bzerror = BZ2_bzDecompress(bzs);\r
- Py_END_ALLOW_THREADS\r
- if (bzerror == BZ_STREAM_END) {\r
- break;\r
- } else if (bzerror != BZ_OK) {\r
- BZ2_bzDecompressEnd(bzs);\r
- Util_CatchBZ2Error(bzerror);\r
- PyBuffer_Release(&pdata);\r
- Py_DECREF(ret);\r
- return NULL;\r
- }\r
- if (bzs->avail_in == 0) {\r
- BZ2_bzDecompressEnd(bzs);\r
- PyErr_SetString(PyExc_ValueError,\r
- "couldn't find end of stream");\r
- PyBuffer_Release(&pdata);\r
- Py_DECREF(ret);\r
- return NULL;\r
- }\r
- if (bzs->avail_out == 0) {\r
- bufsize = Util_NewBufferSize(bufsize);\r
- if (_PyString_Resize(&ret, bufsize) < 0) {\r
- BZ2_bzDecompressEnd(bzs);\r
- PyBuffer_Release(&pdata);\r
- Py_DECREF(ret);\r
- return NULL;\r
- }\r
- bzs->next_out = BUF(ret) + BZS_TOTAL_OUT(bzs);\r
- bzs->avail_out = bufsize - (bzs->next_out - BUF(ret));\r
- }\r
- }\r
-\r
- if (bzs->avail_out != 0)\r
- _PyString_Resize(&ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs));\r
- BZ2_bzDecompressEnd(bzs);\r
- PyBuffer_Release(&pdata);\r
-\r
- return ret;\r
-}\r
-\r
-static PyMethodDef bz2_methods[] = {\r
- {"compress", (PyCFunction) bz2_compress, METH_VARARGS|METH_KEYWORDS,\r
- bz2_compress__doc__},\r
- {"decompress", (PyCFunction) bz2_decompress, METH_VARARGS,\r
- bz2_decompress__doc__},\r
- {NULL, NULL} /* sentinel */\r
-};\r
-\r
-/* ===================================================================== */\r
-/* Initialization function. */\r
-\r
-PyDoc_STRVAR(bz2__doc__,\r
-"The python bz2 module provides a comprehensive interface for\n\\r
-the bz2 compression library. It implements a complete file\n\\r
-interface, one shot (de)compression functions, and types for\n\\r
-sequential (de)compression.\n\\r
-");\r
-\r
-PyMODINIT_FUNC\r
-initbz2(void)\r
-{\r
- PyObject *m;\r
-\r
- if (PyType_Ready(&BZ2File_Type) < 0)\r
- return;\r
- if (PyType_Ready(&BZ2Comp_Type) < 0)\r
- return;\r
- if (PyType_Ready(&BZ2Decomp_Type) < 0)\r
- return;\r
-\r
- m = Py_InitModule3("bz2", bz2_methods, bz2__doc__);\r
- if (m == NULL)\r
- return;\r
-\r
- PyModule_AddObject(m, "__author__", PyString_FromString(__author__));\r
-\r
- Py_INCREF(&BZ2File_Type);\r
- PyModule_AddObject(m, "BZ2File", (PyObject *)&BZ2File_Type);\r
-\r
- Py_INCREF(&BZ2Comp_Type);\r
- PyModule_AddObject(m, "BZ2Compressor", (PyObject *)&BZ2Comp_Type);\r
-\r
- Py_INCREF(&BZ2Decomp_Type);\r
- PyModule_AddObject(m, "BZ2Decompressor", (PyObject *)&BZ2Decomp_Type);\r
-}\r
projects / mirror_edk2.git / blobdiff