Back to index

python3.2  3.2.2
Classes | Defines | Typedefs | Functions | Variables
bz2module.c File Reference
#include "Python.h"
#include <stdio.h>
#include <bzlib.h>
#include "structmember.h"

Go to the source code of this file.

Classes

struct  BZ2FileObject
struct  BZ2CompObject
struct  BZ2DecompObject

Defines

#define BUF(v)   PyBytes_AS_STRING(v)
#define MODE_CLOSED   0
#define MODE_READ   1
#define MODE_READ_EOF   2
#define MODE_WRITE   3
#define BZ2FileObject_Check(v)   (Py_TYPE(v) == &BZ2File_Type)
#define BZ2_bzRead   bzRead
#define BZ2_bzReadOpen   bzReadOpen
#define BZ2_bzReadClose   bzReadClose
#define BZ2_bzWrite   bzWrite
#define BZ2_bzWriteOpen   bzWriteOpen
#define BZ2_bzWriteClose   bzWriteClose
#define BZ2_bzCompress   bzCompress
#define BZ2_bzCompressInit   bzCompressInit
#define BZ2_bzCompressEnd   bzCompressEnd
#define BZ2_bzDecompress   bzDecompress
#define BZ2_bzDecompressInit   bzDecompressInit
#define BZ2_bzDecompressEnd   bzDecompressEnd
#define BZS_TOTAL_OUT(bzs)   bzs->total_out
#define ACQUIRE_LOCK(obj)
#define RELEASE_LOCK(obj)
#define NEWLINE_UNKNOWN   0 /* No newline seen, yet */
#define NEWLINE_CR   1 /* \r newline seen */
#define NEWLINE_LF   2 /* \n newline seen */
#define NEWLINE_CRLF   4 /* \r\n newline seen */
#define SMALLCHUNK   8192
#define BIGCHUNK   (512 * 32)
#define CHUNKSIZE   1000
#define READAHEAD_BUFSIZE   8192
#define OFF(x)   offsetof(BZ2DecompObject, x)

Typedefs

typedef off_t Py_off_t

Functions

static int check_iterbuffered (BZ2FileObject *f)
static int Util_CatchBZ2Error (int bzerror)
static size_t Util_NewBufferSize (size_t currentsize)
static PyObjectUtil_GetLine (BZ2FileObject *f, int n)
static void Util_DropReadAhead (BZ2FileObject *f)
static int Util_ReadAhead (BZ2FileObject *f, int bufsize)
static PyBytesObjectUtil_ReadAheadGetLineSkip (BZ2FileObject *f, int skip, int bufsize)
 PyDoc_STRVAR (BZ2File_read__doc__,"read([size]) -> string\n\ \n\ Read at most size uncompressed bytes, returned as a string. If the size\n\ argument is negative or omitted, read until EOF is reached.\n\ ")
static PyObjectBZ2File_read (BZ2FileObject *self, PyObject *args)
 PyDoc_STRVAR (BZ2File_readline__doc__,"readline([size]) -> string\n\ \n\ Return the next line from the file, as a string, retaining newline.\n\ A non-negative size argument will limit the maximum number of bytes to\n\ return (an incomplete line may be returned then). Return an empty\n\ string at EOF.\n\ ")
static PyObjectBZ2File_readline (BZ2FileObject *self, PyObject *args)
 PyDoc_STRVAR (BZ2File_readlines__doc__,"readlines([size]) -> list\n\ \n\ Call readline() repeatedly and return a list of lines read.\n\ The optional size argument, if given, is an approximate bound on the\n\ total number of bytes in the lines returned.\n\ ")
static PyObjectBZ2File_readlines (BZ2FileObject *self, PyObject *args)
 PyDoc_STRVAR (BZ2File_write__doc__,"write(data) -> None\n\ \n\ Write the 'data' string to file. Note that due to buffering, close() may\n\ be needed before the file on disk reflects the data written.\n\ ")
static PyObjectBZ2File_write (BZ2FileObject *self, PyObject *args)
 PyDoc_STRVAR (BZ2File_writelines__doc__,"writelines(sequence_of_strings) -> None\n\ \n\ Write the sequence of strings to the file. Note that newlines are not\n\ added. The sequence can be any iterable object producing strings. This is\n\ equivalent to calling write() for each string.\n\ ")
static PyObjectBZ2File_writelines (BZ2FileObject *self, PyObject *seq)
 PyDoc_STRVAR (BZ2File_seek__doc__,"seek(offset [, whence]) -> None\n\ \n\ Move to new file position. Argument offset is a byte count. Optional\n\ argument whence defaults to 0 (offset from start of file, offset\n\ should be >= 0); other values are 1 (move relative to current position,\n\ positive or negative), and 2 (move relative to end of file, usually\n\ negative, although many platforms allow seeking beyond the end of a file).\n\ \n\ Note that seeking of bz2 files is emulated, and depending on the parameters\n\ the operation may be extremely slow.\n\ ")
static PyObjectBZ2File_seek (BZ2FileObject *self, PyObject *args)
 PyDoc_STRVAR (BZ2File_tell__doc__,"tell() -> int\n\ \n\ Return the current file position, an integer (may be a long integer).\n\ ")
static PyObjectBZ2File_tell (BZ2FileObject *self, PyObject *args)
 PyDoc_STRVAR (BZ2File_close__doc__,"close() -> None or (perhaps) an integer\n\ \n\ Close the file. Sets data attribute .closed to true. A closed file\n\ cannot be used for further I/O operations. close() may be called more\n\ than once without error.\n\ ")
static PyObjectBZ2File_close (BZ2FileObject *self)
 PyDoc_STRVAR (BZ2File_enter_doc,"__enter__() -> self.")
static PyObjectBZ2File_enter (BZ2FileObject *self)
 PyDoc_STRVAR (BZ2File_exit_doc,"__exit__(*excinfo) -> None. Closes the file.")
static PyObjectBZ2File_exit (BZ2FileObject *self, PyObject *args)
static PyObjectBZ2File_getiter (BZ2FileObject *self)
static PyObjectBZ2File_get_closed (BZ2FileObject *self, void *closure)
static int BZ2File_init (BZ2FileObject *self, PyObject *args, PyObject *kwargs)
static void BZ2File_dealloc (BZ2FileObject *self)
static PyObjectBZ2File_iternext (BZ2FileObject *self)
 PyDoc_VAR (BZ2File__doc__)
 PyDoc_STRVAR (BZ2Comp_compress__doc__,"compress(data) -> string\n\ \n\ Provide more data to the compressor object. It will return chunks of\n\ compressed data whenever possible. When you've finished providing data\n\ to compress, call the flush() method to finish the compression process,\n\ and return what is left in the internal buffers.\n\ ")
static PyObjectBZ2Comp_compress (BZ2CompObject *self, PyObject *args)
 PyDoc_STRVAR (BZ2Comp_flush__doc__,"flush() -> string\n\ \n\ Finish the compression process and return what is left in internal buffers.\n\ You must not use the compressor object after calling this method.\n\ ")
static PyObjectBZ2Comp_flush (BZ2CompObject *self)
static int BZ2Comp_init (BZ2CompObject *self, PyObject *args, PyObject *kwargs)
static void BZ2Comp_dealloc (BZ2CompObject *self)
 PyDoc_STRVAR (BZ2Comp__doc__,"BZ2Compressor([compresslevel=9]) -> compressor object\n\ \n\ Create a new compressor object. This object may be used to compress\n\ data sequentially. If you want to compress data in one shot, use the\n\ compress() function instead. The compresslevel parameter, if given,\n\ must be a number between 1 and 9.\n\ ")
 PyDoc_STRVAR (BZ2Decomp_decompress__doc__,"decompress(data) -> string\n\ \n\ Provide more data to the decompressor object. It will return chunks\n\ of decompressed data whenever possible. If you try to decompress data\n\ after the end of stream is found, EOFError will be raised. If any data\n\ was found after the end of stream, it'll be ignored and saved in\n\ unused_data attribute.\n\ ")
static PyObjectBZ2Decomp_decompress (BZ2DecompObject *self, PyObject *args)
static int BZ2Decomp_init (BZ2DecompObject *self, PyObject *args, PyObject *kwargs)
static void BZ2Decomp_dealloc (BZ2DecompObject *self)
 PyDoc_STRVAR (BZ2Decomp__doc__,"BZ2Decompressor() -> decompressor object\n\ \n\ Create a new decompressor object. This object may be used to decompress\n\ data sequentially. If you want to decompress data in one shot, use the\n\ decompress() function instead.\n\ ")
 PyDoc_STRVAR (bz2_compress__doc__,"compress(data [, compresslevel=9]) -> string\n\ \n\ Compress data in one shot. If you want to compress data sequentially,\n\ use an instance of BZ2Compressor instead. The compresslevel parameter, if\n\ given, must be a number between 1 and 9.\n\ ")
static PyObjectbz2_compress (PyObject *self, PyObject *args, PyObject *kwargs)
 PyDoc_STRVAR (bz2_decompress__doc__,"decompress(data) -> decompressed data\n\ \n\ Decompress data in one shot. If you want to decompress data sequentially,\n\ use an instance of BZ2Decompressor instead.\n\ ")
static PyObjectbz2_decompress (PyObject *self, PyObject *args)
 PyDoc_STRVAR (bz2__doc__,"The python bz2 module provides a comprehensive interface for\n\ the bz2 compression library. It implements a complete file\n\ interface, one shot (de)compression functions, and types for\n\ sequential (de)compression.\n\ ")
PyMODINIT_FUNC PyInit_bz2 (void)

Variables

static char __author__ []
static PyMethodDef BZ2File_methods []
static PyGetSetDef BZ2File_getset []
static PyTypeObject BZ2File_Type
static PyMethodDef BZ2Comp_methods []
static PyTypeObject BZ2Comp_Type
static PyMemberDef BZ2Decomp_members []
static PyMethodDef BZ2Decomp_methods []
static PyTypeObject BZ2Decomp_Type
static PyMethodDef bz2_methods []
static struct PyModuleDef

Class Documentation

struct BZ2FileObject

Definition at line 102 of file bz2module.c.

Class Members
char * f_buf
char * f_bufend
char * f_bufptr
BZFILE * fp
int mode
Py_off_t pos
PyObject_HEAD FILE * rawfp
Py_off_t size
struct BZ2CompObject

Definition at line 119 of file bz2module.c.

Class Members
PyObject_HEAD bz_stream bzs
int running
struct BZ2DecompObject

Definition at line 128 of file bz2module.c.

Collaboration diagram for BZ2DecompObject:
Class Members
PyObject_HEAD bz_stream bzs
int running
PyObject * unused_data

Define Documentation

#define ACQUIRE_LOCK (   obj)

Definition at line 89 of file bz2module.c.

#define BIGCHUNK   (512 * 32)

Definition at line 222 of file bz2module.c.

#define BUF (   v)    PyBytes_AS_STRING(v)

Definition at line 37 of file bz2module.c.

#define BZ2_bzCompress   bzCompress

Definition at line 68 of file bz2module.c.

#define BZ2_bzCompressEnd   bzCompressEnd

Definition at line 70 of file bz2module.c.

#define BZ2_bzCompressInit   bzCompressInit

Definition at line 69 of file bz2module.c.

#define BZ2_bzDecompress   bzDecompress

Definition at line 71 of file bz2module.c.

#define BZ2_bzDecompressEnd   bzDecompressEnd

Definition at line 73 of file bz2module.c.

#define BZ2_bzDecompressInit   bzDecompressInit

Definition at line 72 of file bz2module.c.

#define BZ2_bzRead   bzRead

Definition at line 62 of file bz2module.c.

#define BZ2_bzReadClose   bzReadClose

Definition at line 64 of file bz2module.c.

#define BZ2_bzReadOpen   bzReadOpen

Definition at line 63 of file bz2module.c.

#define BZ2_bzWrite   bzWrite

Definition at line 65 of file bz2module.c.

#define BZ2_bzWriteClose   bzWriteClose

Definition at line 67 of file bz2module.c.

#define BZ2_bzWriteOpen   bzWriteOpen

Definition at line 66 of file bz2module.c.

#define BZ2FileObject_Check (   v)    (Py_TYPE(v) == &BZ2File_Type)

Definition at line 44 of file bz2module.c.

#define BZS_TOTAL_OUT (   bzs)    bzs->total_out

Definition at line 75 of file bz2module.c.

#define CHUNKSIZE   1000
#define MODE_CLOSED   0

Definition at line 39 of file bz2module.c.

#define MODE_READ   1

Definition at line 40 of file bz2module.c.

#define MODE_READ_EOF   2

Definition at line 41 of file bz2module.c.

#define MODE_WRITE   3

Definition at line 42 of file bz2module.c.

#define NEWLINE_CR   1 /* \r newline seen */

Definition at line 95 of file bz2module.c.

#define NEWLINE_CRLF   4 /* \r\n newline seen */

Definition at line 97 of file bz2module.c.

#define NEWLINE_LF   2 /* \n newline seen */

Definition at line 96 of file bz2module.c.

#define NEWLINE_UNKNOWN   0 /* No newline seen, yet */

Definition at line 94 of file bz2module.c.

#define OFF (   x)    offsetof(BZ2DecompObject, x)

Definition at line 1703 of file bz2module.c.

#define READAHEAD_BUFSIZE   8192

Definition at line 1336 of file bz2module.c.

#define RELEASE_LOCK (   obj)

Definition at line 90 of file bz2module.c.

#define SMALLCHUNK   8192

Definition at line 216 of file bz2module.c.


Typedef Documentation

typedef off_t Py_off_t

Definition at line 28 of file bz2module.c.


Function Documentation

static PyObject* bz2_compress ( PyObject self,
PyObject args,
PyObject kwargs 
) [static]

Definition at line 1940 of file bz2module.c.

{
    int compresslevel=9;
    Py_buffer pdata;
    char *data;
    int datasize;
    int bufsize;
    PyObject *ret = NULL;
    bz_stream _bzs;
    bz_stream *bzs = &_bzs;
    int bzerror;
    static char *kwlist[] = {"data", "compresslevel", 0};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|i",
                                     kwlist, &pdata,
                                     &compresslevel))
        return NULL;
    data = pdata.buf;
    datasize = pdata.len;

    if (compresslevel < 1 || compresslevel > 9) {
        PyErr_SetString(PyExc_ValueError,
                        "compresslevel must be between 1 and 9");
        PyBuffer_Release(&pdata);
        return NULL;
    }

    /* Conforming to bz2 manual, this is large enough to fit compressed
     * data in one shot. We will check it later anyway. */
    bufsize = datasize + (datasize/100+1) + 600;

    ret = PyBytes_FromStringAndSize(NULL, bufsize);
    if (!ret) {
        PyBuffer_Release(&pdata);
        return NULL;
    }

    memset(bzs, 0, sizeof(bz_stream));

    bzs->next_in = data;
    bzs->avail_in = datasize;
    bzs->next_out = BUF(ret);
    bzs->avail_out = bufsize;

    bzerror = BZ2_bzCompressInit(bzs, compresslevel, 0, 0);
    if (bzerror != BZ_OK) {
        Util_CatchBZ2Error(bzerror);
        PyBuffer_Release(&pdata);
        Py_DECREF(ret);
        return NULL;
    }

    for (;;) {
        Py_BEGIN_ALLOW_THREADS
        bzerror = BZ2_bzCompress(bzs, BZ_FINISH);
        Py_END_ALLOW_THREADS
        if (bzerror == BZ_STREAM_END) {
            break;
        } else if (bzerror != BZ_FINISH_OK) {
            BZ2_bzCompressEnd(bzs);
            Util_CatchBZ2Error(bzerror);
            PyBuffer_Release(&pdata);
            Py_DECREF(ret);
            return NULL;
        }
        if (bzs->avail_out == 0) {
            bufsize = Util_NewBufferSize(bufsize);
            if (_PyBytes_Resize(&ret, bufsize) < 0) {
                BZ2_bzCompressEnd(bzs);
                PyBuffer_Release(&pdata);
                return NULL;
            }
            bzs->next_out = BUF(ret) + BZS_TOTAL_OUT(bzs);
            bzs->avail_out = bufsize - (bzs->next_out - BUF(ret));
        }
    }

    if (bzs->avail_out != 0) {
        if (_PyBytes_Resize(&ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs)) < 0) {
            ret = NULL;
        }
    }
    BZ2_bzCompressEnd(bzs);

    PyBuffer_Release(&pdata);
    return ret;
}

Here is the call graph for this function:

static PyObject* bz2_decompress ( PyObject self,
PyObject args 
) [static]

Definition at line 2036 of file bz2module.c.

{
    Py_buffer pdata;
    char *data;
    int datasize;
    int bufsize = SMALLCHUNK;
    PyObject *ret;
    bz_stream _bzs;
    bz_stream *bzs = &_bzs;
    int bzerror;

    if (!PyArg_ParseTuple(args, "y*:decompress", &pdata))
        return NULL;
    data = pdata.buf;
    datasize = pdata.len;

    if (datasize == 0) {
        PyBuffer_Release(&pdata);
        return PyBytes_FromStringAndSize("", 0);
    }

    ret = PyBytes_FromStringAndSize(NULL, bufsize);
    if (!ret) {
        PyBuffer_Release(&pdata);
        return NULL;
    }

    memset(bzs, 0, sizeof(bz_stream));

    bzs->next_in = data;
    bzs->avail_in = datasize;
    bzs->next_out = BUF(ret);
    bzs->avail_out = bufsize;

    bzerror = BZ2_bzDecompressInit(bzs, 0, 0);
    if (bzerror != BZ_OK) {
        Util_CatchBZ2Error(bzerror);
        Py_DECREF(ret);
        PyBuffer_Release(&pdata);
        return NULL;
    }

    for (;;) {
        Py_BEGIN_ALLOW_THREADS
        bzerror = BZ2_bzDecompress(bzs);
        Py_END_ALLOW_THREADS
        if (bzerror == BZ_STREAM_END) {
            break;
        } else if (bzerror != BZ_OK) {
            BZ2_bzDecompressEnd(bzs);
            Util_CatchBZ2Error(bzerror);
            PyBuffer_Release(&pdata);
            Py_DECREF(ret);
            return NULL;
        }
        if (bzs->avail_in == 0) {
            BZ2_bzDecompressEnd(bzs);
            PyErr_SetString(PyExc_ValueError,
                            "couldn't find end of stream");
            PyBuffer_Release(&pdata);
            Py_DECREF(ret);
            return NULL;
        }
        if (bzs->avail_out == 0) {
            bufsize = Util_NewBufferSize(bufsize);
            if (_PyBytes_Resize(&ret, bufsize) < 0) {
                BZ2_bzDecompressEnd(bzs);
                PyBuffer_Release(&pdata);
                return NULL;
            }
            bzs->next_out = BUF(ret) + BZS_TOTAL_OUT(bzs);
            bzs->avail_out = bufsize - (bzs->next_out - BUF(ret));
        }
    }

    if (bzs->avail_out != 0) {
        if (_PyBytes_Resize(&ret, (Py_ssize_t)BZS_TOTAL_OUT(bzs)) < 0) {
            ret = NULL;
        }
    }
    BZ2_bzDecompressEnd(bzs);
    PyBuffer_Release(&pdata);

    return ret;
}

Here is the call graph for this function:

static PyObject* BZ2Comp_compress ( BZ2CompObject self,
PyObject args 
) [static]

Definition at line 1429 of file bz2module.c.

{
    Py_buffer pdata;
    char *data;
    int datasize;
    int bufsize = SMALLCHUNK;
    PY_LONG_LONG totalout;
    PyObject *ret = NULL;
    bz_stream *bzs = &self->bzs;
    int bzerror;

    if (!PyArg_ParseTuple(args, "y*:compress", &pdata))
        return NULL;
    data = pdata.buf;
    datasize = pdata.len;

    if (datasize == 0) {
        PyBuffer_Release(&pdata);
        return PyBytes_FromStringAndSize("", 0);
    }

    ACQUIRE_LOCK(self);
    if (!self->running) {
        PyErr_SetString(PyExc_ValueError,
                        "this object was already flushed");
        goto error;
    }

    ret = PyBytes_FromStringAndSize(NULL, bufsize);
    if (!ret)
        goto error;

    bzs->next_in = data;
    bzs->avail_in = datasize;
    bzs->next_out = BUF(ret);
    bzs->avail_out = bufsize;

    totalout = BZS_TOTAL_OUT(bzs);

    for (;;) {
        Py_BEGIN_ALLOW_THREADS
        bzerror = BZ2_bzCompress(bzs, BZ_RUN);
        Py_END_ALLOW_THREADS
        if (bzerror != BZ_RUN_OK) {
            Util_CatchBZ2Error(bzerror);
            goto error;
        }
        if (bzs->avail_in == 0)
            break; /* no more input data */
        if (bzs->avail_out == 0) {
            bufsize = Util_NewBufferSize(bufsize);
            if (_PyBytes_Resize(&ret, bufsize) < 0) {
                BZ2_bzCompressEnd(bzs);
                goto error;
            }
            bzs->next_out = BUF(ret) + (BZS_TOTAL_OUT(bzs)
                                        - totalout);
            bzs->avail_out = bufsize - (bzs->next_out - BUF(ret));
        }
    }

    if (_PyBytes_Resize(&ret,
                       (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout)) < 0)
        goto error;

    RELEASE_LOCK(self);
    PyBuffer_Release(&pdata);
    return ret;

error:
    RELEASE_LOCK(self);
    PyBuffer_Release(&pdata);
    Py_XDECREF(ret);
    return NULL;
}

Here is the call graph for this function:

static void BZ2Comp_dealloc ( BZ2CompObject self) [static]

Definition at line 1632 of file bz2module.c.

{
#ifdef WITH_THREAD
    if (self->lock)
        PyThread_free_lock(self->lock);
#endif
    BZ2_bzCompressEnd(&self->bzs);
    Py_TYPE(self)->tp_free((PyObject *)self);
}

Here is the call graph for this function:

static PyObject* BZ2Comp_flush ( BZ2CompObject self) [static]

Definition at line 1513 of file bz2module.c.

{
    int bufsize = SMALLCHUNK;
    PyObject *ret = NULL;
    bz_stream *bzs = &self->bzs;
    PY_LONG_LONG totalout;
    int bzerror;

    ACQUIRE_LOCK(self);
    if (!self->running) {
        PyErr_SetString(PyExc_ValueError, "object was already "
                                          "flushed");
        goto error;
    }
    self->running = 0;

    ret = PyBytes_FromStringAndSize(NULL, bufsize);
    if (!ret)
        goto error;

    bzs->next_out = BUF(ret);
    bzs->avail_out = bufsize;

    totalout = BZS_TOTAL_OUT(bzs);

    for (;;) {
        Py_BEGIN_ALLOW_THREADS
        bzerror = BZ2_bzCompress(bzs, BZ_FINISH);
        Py_END_ALLOW_THREADS
        if (bzerror == BZ_STREAM_END) {
            break;
        } else if (bzerror != BZ_FINISH_OK) {
            Util_CatchBZ2Error(bzerror);
            goto error;
        }
        if (bzs->avail_out == 0) {
            bufsize = Util_NewBufferSize(bufsize);
            if (_PyBytes_Resize(&ret, bufsize) < 0)
                goto error;
            bzs->next_out = BUF(ret);
            bzs->next_out = BUF(ret) + (BZS_TOTAL_OUT(bzs)
                                        - totalout);
            bzs->avail_out = bufsize - (bzs->next_out - BUF(ret));
        }
    }

    if (bzs->avail_out != 0) {
        if (_PyBytes_Resize(&ret,
                    (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout)) < 0)
            goto error;
    }

    RELEASE_LOCK(self);
    return ret;

error:
    RELEASE_LOCK(self);
    Py_XDECREF(ret);
    return NULL;
}

Here is the call graph for this function:

static int BZ2Comp_init ( BZ2CompObject self,
PyObject args,
PyObject kwargs 
) [static]

Definition at line 1587 of file bz2module.c.

{
    int compresslevel = 9;
    int bzerror;
    static char *kwlist[] = {"compresslevel", 0};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:BZ2Compressor",
                                     kwlist, &compresslevel))
        return -1;

    if (compresslevel < 1 || compresslevel > 9) {
        PyErr_SetString(PyExc_ValueError,
                        "compresslevel must be between 1 and 9");
        goto error;
    }

#ifdef WITH_THREAD
    self->lock = PyThread_allocate_lock();
    if (!self->lock) {
        PyErr_SetString(PyExc_MemoryError, "unable to allocate lock");
        goto error;
    }
#endif

    memset(&self->bzs, 0, sizeof(bz_stream));
    bzerror = BZ2_bzCompressInit(&self->bzs, compresslevel, 0, 0);
    if (bzerror != BZ_OK) {
        Util_CatchBZ2Error(bzerror);
        goto error;
    }

    self->running = 1;

    return 0;
error:
#ifdef WITH_THREAD
    if (self->lock) {
        PyThread_free_lock(self->lock);
        self->lock = NULL;
    }
#endif
    return -1;
}

Here is the call graph for this function:

static void BZ2Decomp_dealloc ( BZ2DecompObject self) [static]

Definition at line 1861 of file bz2module.c.

{
#ifdef WITH_THREAD
    if (self->lock)
        PyThread_free_lock(self->lock);
#endif
    Py_XDECREF(self->unused_data);
    BZ2_bzDecompressEnd(&self->bzs);
    Py_TYPE(self)->tp_free((PyObject *)self);
}

Here is the call graph for this function:

static PyObject* BZ2Decomp_decompress ( BZ2DecompObject self,
PyObject args 
) [static]

Definition at line 1725 of file bz2module.c.

{
    Py_buffer pdata;
    char *data;
    int datasize;
    int bufsize = SMALLCHUNK;
    PY_LONG_LONG totalout;
    PyObject *ret = NULL;
    bz_stream *bzs = &self->bzs;
    int bzerror;

    if (!PyArg_ParseTuple(args, "y*:decompress", &pdata))
        return NULL;
    data = pdata.buf;
    datasize = pdata.len;

    ACQUIRE_LOCK(self);
    if (!self->running) {
        PyErr_SetString(PyExc_EOFError, "end of stream was "
                                        "already found");
        goto error;
    }

    ret = PyBytes_FromStringAndSize(NULL, bufsize);
    if (!ret)
        goto error;

    bzs->next_in = data;
    bzs->avail_in = datasize;
    bzs->next_out = BUF(ret);
    bzs->avail_out = bufsize;

    totalout = BZS_TOTAL_OUT(bzs);

    for (;;) {
        Py_BEGIN_ALLOW_THREADS
        bzerror = BZ2_bzDecompress(bzs);
        Py_END_ALLOW_THREADS
        if (bzerror == BZ_STREAM_END) {
            if (bzs->avail_in != 0) {
                Py_DECREF(self->unused_data);
                self->unused_data =
                    PyBytes_FromStringAndSize(bzs->next_in,
                                               bzs->avail_in);
            }
            self->running = 0;
            break;
        }
        if (bzerror != BZ_OK) {
            Util_CatchBZ2Error(bzerror);
            goto error;
        }
        if (bzs->avail_in == 0)
            break; /* no more input data */
        if (bzs->avail_out == 0) {
            bufsize = Util_NewBufferSize(bufsize);
            if (_PyBytes_Resize(&ret, bufsize) < 0) {
                BZ2_bzDecompressEnd(bzs);
                goto error;
            }
            bzs->next_out = BUF(ret);
            bzs->next_out = BUF(ret) + (BZS_TOTAL_OUT(bzs)
                                        - totalout);
            bzs->avail_out = bufsize - (bzs->next_out - BUF(ret));
        }
    }

    if (bzs->avail_out != 0) {
        if (_PyBytes_Resize(&ret,
                    (Py_ssize_t)(BZS_TOTAL_OUT(bzs) - totalout)) < 0)
            goto error;
    }

    RELEASE_LOCK(self);
    PyBuffer_Release(&pdata);
    return ret;

error:
    RELEASE_LOCK(self);
    PyBuffer_Release(&pdata);
    Py_XDECREF(ret);
    return NULL;
}

Here is the call graph for this function:

static int BZ2Decomp_init ( BZ2DecompObject self,
PyObject args,
PyObject kwargs 
) [static]

Definition at line 1819 of file bz2module.c.

{
    int bzerror;

    if (!PyArg_ParseTuple(args, ":BZ2Decompressor"))
        return -1;

#ifdef WITH_THREAD
    self->lock = PyThread_allocate_lock();
    if (!self->lock) {
        PyErr_SetString(PyExc_MemoryError, "unable to allocate lock");
        goto error;
    }
#endif

    self->unused_data = PyBytes_FromStringAndSize("", 0);
    if (!self->unused_data)
        goto error;

    memset(&self->bzs, 0, sizeof(bz_stream));
    bzerror = BZ2_bzDecompressInit(&self->bzs, 0, 0);
    if (bzerror != BZ_OK) {
        Util_CatchBZ2Error(bzerror);
        goto error;
    }

    self->running = 1;

    return 0;

error:
#ifdef WITH_THREAD
    if (self->lock) {
        PyThread_free_lock(self->lock);
        self->lock = NULL;
    }
#endif
    Py_CLEAR(self->unused_data);
    return -1;
}

Here is the call graph for this function:

static PyObject* BZ2File_close ( BZ2FileObject self) [static]

Definition at line 1087 of file bz2module.c.

{
    PyObject *ret = NULL;
    int bzerror = BZ_OK;

    if (self->mode == MODE_CLOSED) {
        Py_RETURN_NONE;
    }

    ACQUIRE_LOCK(self);
    switch (self->mode) {
        case MODE_READ:
        case MODE_READ_EOF:
            BZ2_bzReadClose(&bzerror, self->fp);
            break;
        case MODE_WRITE:
            BZ2_bzWriteClose(&bzerror, self->fp,
                             0, NULL, NULL);
            break;
    }
    self->mode = MODE_CLOSED;
    fclose(self->rawfp);
    self->rawfp = NULL;
    if (bzerror == BZ_OK) {
        Py_INCREF(Py_None);
        ret = Py_None;
    }
    else {
        Util_CatchBZ2Error(bzerror);
    }

    RELEASE_LOCK(self);
    return ret;
}

Here is the call graph for this function:

static void BZ2File_dealloc ( BZ2FileObject self) [static]

Definition at line 1299 of file bz2module.c.

{
    int bzerror;
#ifdef WITH_THREAD
    if (self->lock)
        PyThread_free_lock(self->lock);
#endif
    switch (self->mode) {
        case MODE_READ:
        case MODE_READ_EOF:
            BZ2_bzReadClose(&bzerror, self->fp);
            break;
        case MODE_WRITE:
            BZ2_bzWriteClose(&bzerror, self->fp,
                             0, NULL, NULL);
            break;
    }
    Util_DropReadAhead(self);
    if (self->rawfp != NULL)
        fclose(self->rawfp);
    Py_TYPE(self)->tp_free((PyObject *)self);
}

Here is the call graph for this function:

static PyObject* BZ2File_enter ( BZ2FileObject self) [static]

Definition at line 1126 of file bz2module.c.

{
    if (self->mode == MODE_CLOSED) {
        PyErr_SetString(PyExc_ValueError,
            "I/O operation on closed file");
        return NULL;
    }
    Py_INCREF(self);
    return (PyObject *) self;
}

Here is the call graph for this function:

static PyObject* BZ2File_exit ( BZ2FileObject self,
PyObject args 
) [static]

Definition at line 1141 of file bz2module.c.

{
    PyObject *ret = PyObject_CallMethod((PyObject *) self, "close", NULL);
    if (!ret)
        /* If error occurred, pass through */
        return NULL;
    Py_DECREF(ret);
    Py_RETURN_NONE;
}

Here is the call graph for this function:

static PyObject* BZ2File_get_closed ( BZ2FileObject self,
void closure 
) [static]

Definition at line 1173 of file bz2module.c.

{
    return PyLong_FromLong(self->mode == MODE_CLOSED);
}

Here is the call graph for this function:

static PyObject * BZ2File_getiter ( BZ2FileObject self) [static]

Definition at line 1324 of file bz2module.c.

{
    if (self->mode == MODE_CLOSED) {
        PyErr_SetString(PyExc_ValueError,
                        "I/O operation on closed file");
        return NULL;
    }
    Py_INCREF((PyObject*)self);
    return (PyObject *)self;
}

Here is the call graph for this function:

static int BZ2File_init ( BZ2FileObject self,
PyObject args,
PyObject kwargs 
) [static]

Definition at line 1189 of file bz2module.c.

{
    static char *kwlist[] = {"filename", "mode", "buffering",
                             "compresslevel", 0};
    PyObject *name_obj = NULL;
    char *name;
    char *mode = "r";
    int buffering = -1;
    int compresslevel = 9;
    int bzerror;
    int mode_char = 0;

    self->size = -1;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&|sii:BZ2File",
                                     kwlist, PyUnicode_FSConverter, &name_obj,
                                     &mode, &buffering,
                                     &compresslevel))
        return -1;

    name = PyBytes_AsString(name_obj);
    if (compresslevel < 1 || compresslevel > 9) {
        PyErr_SetString(PyExc_ValueError,
                        "compresslevel must be between 1 and 9");
        Py_DECREF(name_obj);
        return -1;
    }

    for (;;) {
        int error = 0;
        switch (*mode) {
            case 'r':
            case 'w':
                if (mode_char)
                    error = 1;
                mode_char = *mode;
                break;

            case 'b':
                break;

            default:
                error = 1;
                break;
        }
        if (error) {
            PyErr_Format(PyExc_ValueError,
                         "invalid mode char %c", *mode);
            Py_DECREF(name_obj);
            return -1;
        }
        mode++;
        if (*mode == '\0')
            break;
    }

    if (mode_char == 0) {
        mode_char = 'r';
    }

    mode = (mode_char == 'r') ? "rb" : "wb";

    self->rawfp = fopen(name, mode);
    Py_DECREF(name_obj);
    if (self->rawfp == NULL) {
        PyErr_SetFromErrno(PyExc_IOError);
        return -1;
    }
    /* XXX Ignore buffering */

    /* From now on, we have stuff to dealloc, so jump to error label
     * instead of returning */

#ifdef WITH_THREAD
    self->lock = PyThread_allocate_lock();
    if (!self->lock) {
        PyErr_SetString(PyExc_MemoryError, "unable to allocate lock");
        goto error;
    }
#endif

    if (mode_char == 'r')
        self->fp = BZ2_bzReadOpen(&bzerror, self->rawfp,
                                  0, 0, NULL, 0);
    else
        self->fp = BZ2_bzWriteOpen(&bzerror, self->rawfp,
                                   compresslevel, 0, 0);

    if (bzerror != BZ_OK) {
        Util_CatchBZ2Error(bzerror);
        goto error;
    }

    self->mode = (mode_char == 'r') ? MODE_READ : MODE_WRITE;

    return 0;

error:
    fclose(self->rawfp);
    self->rawfp = NULL;
#ifdef WITH_THREAD
    if (self->lock) {
        PyThread_free_lock(self->lock);
        self->lock = NULL;
    }
#endif
    return -1;
}

Here is the call graph for this function:

static PyObject* BZ2File_iternext ( BZ2FileObject self) [static]

Definition at line 1338 of file bz2module.c.

{
    PyBytesObject* ret;
    ACQUIRE_LOCK(self);
    if (self->mode == MODE_CLOSED) {
        RELEASE_LOCK(self);
        PyErr_SetString(PyExc_ValueError,
                        "I/O operation on closed file");
        return NULL;
    }
    ret = Util_ReadAheadGetLineSkip(self, 0, READAHEAD_BUFSIZE);
    RELEASE_LOCK(self);
    if (ret == NULL || PyBytes_GET_SIZE(ret) == 0) {
        Py_XDECREF(ret);
        return NULL;
    }
    return (PyObject *)ret;
}

Here is the call graph for this function:

static PyObject* BZ2File_read ( BZ2FileObject self,
PyObject args 
) [static]

Definition at line 419 of file bz2module.c.

{
    long bytesrequested = -1;
    size_t bytesread, buffersize, chunksize;
    int bzerror;
    PyObject *ret = NULL;

    if (!PyArg_ParseTuple(args, "|l:read", &bytesrequested))
        return NULL;

    ACQUIRE_LOCK(self);
    switch (self->mode) {
        case MODE_READ:
            break;
        case MODE_READ_EOF:
            ret = PyBytes_FromStringAndSize("", 0);
            goto cleanup;
        case MODE_CLOSED:
            PyErr_SetString(PyExc_ValueError,
                            "I/O operation on closed file");
            goto cleanup;
        default:
            PyErr_SetString(PyExc_IOError,
                            "file is not ready for reading");
            goto cleanup;
    }

    /* refuse to mix with f.next() */
    if (check_iterbuffered(self))
        goto cleanup;

    if (bytesrequested < 0)
        buffersize = Util_NewBufferSize((size_t)0);
    else
        buffersize = bytesrequested;
    if (buffersize > INT_MAX) {
        PyErr_SetString(PyExc_OverflowError,
                        "requested number of bytes is "
                        "more than a Python string can hold");
        goto cleanup;
    }
    ret = PyBytes_FromStringAndSize((char *)NULL, buffersize);
    if (ret == NULL || buffersize == 0)
        goto cleanup;
    bytesread = 0;

    for (;;) {
        Py_BEGIN_ALLOW_THREADS
        chunksize = BZ2_bzRead(&bzerror, self->fp,
                               BUF(ret)+bytesread,
                               buffersize-bytesread);
        self->pos += chunksize;
        Py_END_ALLOW_THREADS
        bytesread += chunksize;
        if (bzerror == BZ_STREAM_END) {
            self->size = self->pos;
            self->mode = MODE_READ_EOF;
            break;
        } else if (bzerror != BZ_OK) {
            Util_CatchBZ2Error(bzerror);
            Py_DECREF(ret);
            ret = NULL;
            goto cleanup;
        }
        if (bytesrequested < 0) {
            buffersize = Util_NewBufferSize(buffersize);
            if (_PyBytes_Resize(&ret, buffersize) < 0) {
                ret = NULL;
                goto cleanup;
            }
        } else {
            break;
        }
    }
    if (bytesread != buffersize) {
        if (_PyBytes_Resize(&ret, bytesread) < 0) {
            ret = NULL;
        }
    }

cleanup:
    RELEASE_LOCK(self);
    return ret;
}

Here is the call graph for this function:

static PyObject* BZ2File_readline ( BZ2FileObject self,
PyObject args 
) [static]

Definition at line 514 of file bz2module.c.

{
    PyObject *ret = NULL;
    int sizehint = -1;

    if (!PyArg_ParseTuple(args, "|i:readline", &sizehint))
        return NULL;

    ACQUIRE_LOCK(self);
    switch (self->mode) {
        case MODE_READ:
            break;
        case MODE_READ_EOF:
            ret = PyBytes_FromStringAndSize("", 0);
            goto cleanup;
        case MODE_CLOSED:
            PyErr_SetString(PyExc_ValueError,
                            "I/O operation on closed file");
            goto cleanup;
        default:
            PyErr_SetString(PyExc_IOError,
                            "file is not ready for reading");
            goto cleanup;
    }

    /* refuse to mix with f.next() */
    if (check_iterbuffered(self))
        goto cleanup;

    if (sizehint == 0)
        ret = PyBytes_FromStringAndSize("", 0);
    else
        ret = Util_GetLine(self, (sizehint < 0) ? 0 : sizehint);

cleanup:
    RELEASE_LOCK(self);
    return ret;
}

Here is the call graph for this function:

static PyObject* BZ2File_readlines ( BZ2FileObject self,
PyObject args 
) [static]

Definition at line 563 of file bz2module.c.

{
    long sizehint = 0;
    PyObject *list = NULL;
    PyObject *line;
    char small_buffer[SMALLCHUNK];
    char *buffer = small_buffer;
    size_t buffersize = SMALLCHUNK;
    PyObject *big_buffer = NULL;
    size_t nfilled = 0;
    size_t nread;
    size_t totalread = 0;
    char *p, *q, *end;
    int err;
    int shortread = 0;
    int bzerror;

    if (!PyArg_ParseTuple(args, "|l:readlines", &sizehint))
        return NULL;

    ACQUIRE_LOCK(self);
    switch (self->mode) {
        case MODE_READ:
            break;
        case MODE_READ_EOF:
            list = PyList_New(0);
            goto cleanup;
        case MODE_CLOSED:
            PyErr_SetString(PyExc_ValueError,
                            "I/O operation on closed file");
            goto cleanup;
        default:
            PyErr_SetString(PyExc_IOError,
                            "file is not ready for reading");
            goto cleanup;
    }

    /* refuse to mix with f.next() */
    if (check_iterbuffered(self))
        goto cleanup;

    if ((list = PyList_New(0)) == NULL)
        goto cleanup;

    for (;;) {
        Py_BEGIN_ALLOW_THREADS
        nread = BZ2_bzRead(&bzerror, self->fp,
                           buffer+nfilled, buffersize-nfilled);
        self->pos += nread;
        Py_END_ALLOW_THREADS
        if (bzerror == BZ_STREAM_END) {
            self->size = self->pos;
            self->mode = MODE_READ_EOF;
            if (nread == 0) {
                sizehint = 0;
                break;
            }
            shortread = 1;
        } else if (bzerror != BZ_OK) {
            Util_CatchBZ2Error(bzerror);
          error:
            Py_DECREF(list);
            list = NULL;
            goto cleanup;
        }
        totalread += nread;
        p = memchr(buffer+nfilled, '\n', nread);
        if (!shortread && p == NULL) {
            /* Need a larger buffer to fit this line */
            nfilled += nread;
            buffersize *= 2;
            if (buffersize > INT_MAX) {
                PyErr_SetString(PyExc_OverflowError,
                "line is longer than a Python string can hold");
                goto error;
            }
            if (big_buffer == NULL) {
                /* Create the big buffer */
                big_buffer = PyBytes_FromStringAndSize(
                    NULL, buffersize);
                if (big_buffer == NULL)
                    goto error;
                buffer = PyBytes_AS_STRING(big_buffer);
                memcpy(buffer, small_buffer, nfilled);
            }
            else {
                /* Grow the big buffer */
                if (_PyBytes_Resize(&big_buffer, buffersize) < 0){
                    big_buffer = NULL;
                    goto error;
                }
                buffer = PyBytes_AS_STRING(big_buffer);
            }
            continue;
        }
        end = buffer+nfilled+nread;
        q = buffer;
        while (p != NULL) {
            /* Process complete lines */
            p++;
            line = PyBytes_FromStringAndSize(q, p-q);
            if (line == NULL)
                goto error;
            err = PyList_Append(list, line);
            Py_DECREF(line);
            if (err != 0)
                goto error;
            q = p;
            p = memchr(q, '\n', end-q);
        }
        /* Move the remaining incomplete line to the start */
        nfilled = end-q;
        memmove(buffer, q, nfilled);
        if (sizehint > 0)
            if (totalread >= (size_t)sizehint)
                break;
        if (shortread) {
            sizehint = 0;
            break;
        }
    }
    if (nfilled != 0) {
        /* Partial last line */
        line = PyBytes_FromStringAndSize(buffer, nfilled);
        if (line == NULL)
            goto error;
        if (sizehint > 0) {
            /* Need to complete the last line */
            PyObject *rest = Util_GetLine(self, 0);
            if (rest == NULL) {
                Py_DECREF(line);
                goto error;
            }
            PyBytes_Concat(&line, rest);
            Py_DECREF(rest);
            if (line == NULL)
                goto error;
        }
        err = PyList_Append(list, line);
        Py_DECREF(line);
        if (err != 0)
            goto error;
    }

  cleanup:
    RELEASE_LOCK(self);
    if (big_buffer) {
        Py_DECREF(big_buffer);
    }
    return list;
}

Here is the call graph for this function:

static PyObject* BZ2File_seek ( BZ2FileObject self,
PyObject args 
) [static]

Definition at line 918 of file bz2module.c.

{
    int where = 0;
    PyObject *offobj;
    Py_off_t offset;
    char small_buffer[SMALLCHUNK];
    char *buffer = small_buffer;
    size_t buffersize = SMALLCHUNK;
    Py_off_t bytesread = 0;
    size_t readsize;
    int chunksize;
    int bzerror;
    PyObject *ret = NULL;

    if (!PyArg_ParseTuple(args, "O|i:seek", &offobj, &where))
        return NULL;
#if !defined(HAVE_LARGEFILE_SUPPORT)
    offset = PyLong_AsLong(offobj);
#else
    offset = PyLong_Check(offobj) ?
        PyLong_AsLongLong(offobj) : PyLong_AsLong(offobj);
#endif
    if (PyErr_Occurred())
        return NULL;

    ACQUIRE_LOCK(self);
    Util_DropReadAhead(self);
    switch (self->mode) {
        case MODE_READ:
        case MODE_READ_EOF:
            break;

        case MODE_CLOSED:
            PyErr_SetString(PyExc_ValueError,
                            "I/O operation on closed file");
            goto cleanup;

        default:
            PyErr_SetString(PyExc_IOError,
                            "seek works only while reading");
            goto cleanup;
    }

    if (where == 2) {
        if (self->size == -1) {
            assert(self->mode != MODE_READ_EOF);
            for (;;) {
                Py_BEGIN_ALLOW_THREADS
                chunksize = BZ2_bzRead(&bzerror, self->fp,
                                       buffer, buffersize);
                self->pos += chunksize;
                Py_END_ALLOW_THREADS

                bytesread += chunksize;
                if (bzerror == BZ_STREAM_END) {
                    break;
                } else if (bzerror != BZ_OK) {
                    Util_CatchBZ2Error(bzerror);
                    goto cleanup;
                }
            }
            self->mode = MODE_READ_EOF;
            self->size = self->pos;
            bytesread = 0;
        }
        offset = self->size + offset;
    } else if (where == 1) {
        offset = self->pos + offset;
    }

    /* Before getting here, offset must be the absolute position the file
     * pointer should be set to. */

    if (offset >= self->pos) {
        /* we can move forward */
        offset -= self->pos;
    } else {
        /* we cannot move back, so rewind the stream */
        BZ2_bzReadClose(&bzerror, self->fp);
        if (bzerror != BZ_OK) {
            Util_CatchBZ2Error(bzerror);
            goto cleanup;
        }
        rewind(self->rawfp);
        self->pos = 0;
        self->fp = BZ2_bzReadOpen(&bzerror, self->rawfp,
                                  0, 0, NULL, 0);
        if (bzerror != BZ_OK) {
            Util_CatchBZ2Error(bzerror);
            goto cleanup;
        }
        self->mode = MODE_READ;
    }

    if (offset <= 0 || self->mode == MODE_READ_EOF)
        goto exit;

    /* Before getting here, offset must be set to the number of bytes
     * to walk forward. */
    for (;;) {
        if (offset-bytesread > buffersize)
            readsize = buffersize;
        else
            /* offset might be wider that readsize, but the result
             * of the subtraction is bound by buffersize (see the
             * condition above). buffersize is 8192. */
            readsize = (size_t)(offset-bytesread);
        Py_BEGIN_ALLOW_THREADS
        chunksize = BZ2_bzRead(&bzerror, self->fp, buffer, readsize);
        self->pos += chunksize;
        Py_END_ALLOW_THREADS
        bytesread += chunksize;
        if (bzerror == BZ_STREAM_END) {
            self->size = self->pos;
            self->mode = MODE_READ_EOF;
            break;
        } else if (bzerror != BZ_OK) {
            Util_CatchBZ2Error(bzerror);
            goto cleanup;
        }
        if (bytesread == offset)
            break;
    }

exit:
    Py_INCREF(Py_None);
    ret = Py_None;

cleanup:
    RELEASE_LOCK(self);
    return ret;
}

Here is the call graph for this function:

static PyObject* BZ2File_tell ( BZ2FileObject self,
PyObject args 
) [static]

Definition at line 1058 of file bz2module.c.

{
    PyObject *ret = NULL;

    if (self->mode == MODE_CLOSED) {
        PyErr_SetString(PyExc_ValueError,
                        "I/O operation on closed file");
        goto cleanup;
    }

#if !defined(HAVE_LARGEFILE_SUPPORT)
    ret = PyLong_FromLong(self->pos);
#else
    ret = PyLong_FromLongLong(self->pos);
#endif

cleanup:
    return ret;
}

Here is the call graph for this function:

static PyObject* BZ2File_write ( BZ2FileObject self,
PyObject args 
) [static]

Definition at line 724 of file bz2module.c.

{
    PyObject *ret = NULL;
    Py_buffer pbuf;
    char *buf;
    int len;
    int bzerror;

    if (!PyArg_ParseTuple(args, "y*:write", &pbuf))
        return NULL;
    buf = pbuf.buf;
    len = pbuf.len;

    ACQUIRE_LOCK(self);
    switch (self->mode) {
        case MODE_WRITE:
            break;

        case MODE_CLOSED:
            PyErr_SetString(PyExc_ValueError,
                            "I/O operation on closed file");
            goto cleanup;

        default:
            PyErr_SetString(PyExc_IOError,
                            "file is not ready for writing");
            goto cleanup;
    }

    Py_BEGIN_ALLOW_THREADS
    BZ2_bzWrite (&bzerror, self->fp, buf, len);
    self->pos += len;
    Py_END_ALLOW_THREADS

    if (bzerror != BZ_OK) {
        Util_CatchBZ2Error(bzerror);
        goto cleanup;
    }

    Py_INCREF(Py_None);
    ret = Py_None;

cleanup:
    PyBuffer_Release(&pbuf);
    RELEASE_LOCK(self);
    return ret;
}

Here is the call graph for this function:

static PyObject* BZ2File_writelines ( BZ2FileObject self,
PyObject seq 
) [static]

Definition at line 782 of file bz2module.c.

{
#define CHUNKSIZE 1000
    PyObject *list = NULL;
    PyObject *iter = NULL;
    PyObject *ret = NULL;
    PyObject *line;
    int i, j, index, len, islist;
    int bzerror;

    ACQUIRE_LOCK(self);
    switch (self->mode) {
        case MODE_WRITE:
            break;

        case MODE_CLOSED:
            PyErr_SetString(PyExc_ValueError,
                            "I/O operation on closed file");
            goto error;

        default:
            PyErr_SetString(PyExc_IOError,
                            "file is not ready for writing");
            goto error;
    }

    islist = PyList_Check(seq);
    if  (!islist) {
        iter = PyObject_GetIter(seq);
        if (iter == NULL) {
            PyErr_SetString(PyExc_TypeError,
                "writelines() requires an iterable argument");
            goto error;
        }
        list = PyList_New(CHUNKSIZE);
        if (list == NULL)
            goto error;
    }

    /* Strategy: slurp CHUNKSIZE lines into a private list,
       checking that they are all strings, then write that list
       without holding the interpreter lock, then come back for more. */
    for (index = 0; ; index += CHUNKSIZE) {
        if (islist) {
            Py_XDECREF(list);
            list = PyList_GetSlice(seq, index, index+CHUNKSIZE);
            if (list == NULL)
                goto error;
            j = PyList_GET_SIZE(list);
        }
        else {
            for (j = 0; j < CHUNKSIZE; j++) {
                line = PyIter_Next(iter);
                if (line == NULL) {
                    if (PyErr_Occurred())
                        goto error;
                    break;
                }
                PyList_SetItem(list, j, line);
            }
        }
        if (j == 0)
            break;

        /* Check that all entries are indeed byte strings. If not,
           apply the same rules as for file.write() and
           convert the rets to strings. This is slow, but
           seems to be the only way since all conversion APIs
           could potentially execute Python code. */
        for (i = 0; i < j; i++) {
            PyObject *v = PyList_GET_ITEM(list, i);
            if (!PyBytes_Check(v)) {
                const char *buffer;
                Py_ssize_t len;
                if (PyObject_AsCharBuffer(v, &buffer, &len)) {
                    PyErr_SetString(PyExc_TypeError,
                                    "writelines() "
                                    "argument must be "
                                    "a sequence of "
                                    "bytes objects");
                    goto error;
                }
                line = PyBytes_FromStringAndSize(buffer,
                                                  len);
                if (line == NULL)
                    goto error;
                Py_DECREF(v);
                PyList_SET_ITEM(list, i, line);
            }
        }

        /* Since we are releasing the global lock, the
           following code may *not* execute Python code. */
        Py_BEGIN_ALLOW_THREADS
        for (i = 0; i < j; i++) {
            line = PyList_GET_ITEM(list, i);
            len = PyBytes_GET_SIZE(line);
            BZ2_bzWrite (&bzerror, self->fp,
                         PyBytes_AS_STRING(line), len);
            if (bzerror != BZ_OK) {
                Py_BLOCK_THREADS
                Util_CatchBZ2Error(bzerror);
                goto error;
            }
        }
        Py_END_ALLOW_THREADS

        if (j < CHUNKSIZE)
            break;
    }

    Py_INCREF(Py_None);
    ret = Py_None;

  error:
    RELEASE_LOCK(self);
    Py_XDECREF(list);
    Py_XDECREF(iter);
    return ret;
#undef CHUNKSIZE
}

Here is the call graph for this function:

static int check_iterbuffered ( BZ2FileObject f) [static]

Definition at line 145 of file bz2module.c.

{
    if (f->f_buf != NULL &&
        (f->f_bufend - f->f_bufptr) > 0 &&
        f->f_buf[0] != '\0') {
        PyErr_SetString(PyExc_ValueError,
            "Mixing iteration and read methods would lose data");
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyDoc_STRVAR ( BZ2File_read__doc__  ,
"read([size]) -> string\n\\n\Read at most size uncompressed  bytes,
returned as a string.If the size\n\argument is negative or  omitted,
read until EOF is reached.\n\"   
)
PyDoc_STRVAR ( BZ2File_readline__doc__  ,
"readline([size]) -> string\n\\n\Return the next line from the  file,
as a  string,
retaining newline.\n\A non-negative size argument will limit the maximum number of bytes to\n\return(an incomplete line may be returned then).Return an empty\n\string at EOF.\n\"   
)
PyDoc_STRVAR ( BZ2File_readlines__doc__  ,
"readlines([size]) -> list\n\\n\Call readline() repeatedly and return a list of lines read.\n\The optional size  argument,
if  given,
is an approximate bound on the\n\total number of bytes in the lines returned.\n\"   
)
PyDoc_STRVAR ( BZ2File_write__doc__  ,
"write(data) -> None\n\\n\Write the 'data' string to file. Note that due to  buffering,
close() may\n\be needed before the file on disk reflects the data written.\n\"   
)
PyDoc_STRVAR ( BZ2File_writelines__doc__  ,
"writelines(sequence_of_strings) -> None\n\\n\Write the sequence of strings to the file. Note that newlines are not\n\added. The sequence can be any iterable object producing strings. This is\n\equivalent to calling write() for each string.\n\"   
)
PyDoc_STRVAR ( BZ2File_seek__doc__  ,
seekoffset [, whence]) -> None\n\\n\Move to new file position. Argument offset is a byte count. Optional\n\argument whence defaults to 0 (offset from start of file, offset\n\should be >= 0); other values are 1 (move relative to current position,\n\positive or negative,
and 2(move relative to end of file, usually\n\negative, although many platforms allow seeking beyond the end of a file).\n\\n\Note that seeking of bz2 files is  emulated,
and depending on the parameters\n\the operation may be extremely slow.\n\"   
)
PyDoc_STRVAR ( BZ2File_tell__doc__  ,
"tell() -> int\n\\n\Return the current file  position,
an integer(may be a long integer).\n\"   
)
PyDoc_STRVAR ( BZ2File_close__doc__  ,
"close() -> None or (perhaps) an integer\n\\n\Close the file. Sets data attribute .closed to true. A closed file\n\cannot be used for further I/O operations. close() may be called more\n\than once without error.\n\"   
)
PyDoc_STRVAR ( BZ2File_enter_doc  ,
"__enter__() -> self."   
)
PyDoc_STRVAR ( BZ2File_exit_doc  ,
"__exit__*excinfo -> None. Closes the file."   
)
PyDoc_STRVAR ( BZ2Comp_compress__doc__  ,
"compress(data) -> string\n\\n\Provide more data to the compressor object. It will return chunks of\n\compressed data whenever possible. When you've finished providing data\n\to  compress,
call the flush() method to finish the compression  process,
\n\and return what is left in the internal buffers.\n\"   
)
PyDoc_STRVAR ( BZ2Comp_flush__doc__  ,
"flush() -> string\n\\n\Finish the compression process and return what is left in internal buffers.\n\You must not use the compressor object after calling this method.\n\"   
)
PyDoc_STRVAR ( BZ2Comp__doc__  ,
"BZ2Compressor([compresslevel=9]) -> compressor object\n\\n\Create a new compressor object. This object may be used to compress\n\data sequentially. If you want to compress data in one  shot,
use the\n\compress() function instead.The compresslevel  parameter,
if  given,
\n\must be a number between 1 and 9.\n\"   
)
PyDoc_STRVAR ( BZ2Decomp_decompress__doc__  ,
"decompress(data) -> string\n\\n\Provide more data to the decompressor object. It will return chunks\n\of decompressed data whenever possible. If you try to decompress data\n\after the end of stream is  found,
EOFError will be raised.If any data\n\was found after the end of  stream,
it'll be ignored and saved in\n\unused_data attribute.\n\"   
)
PyDoc_STRVAR ( BZ2Decomp__doc__  ,
"BZ2Decompressor() -> decompressor object\n\\n\Create a new decompressor object. This object may be used to decompress\n\data sequentially. If you want to decompress data in one  shot,
use the\n\decompress() function instead.\n\"   
)
PyDoc_STRVAR ( bz2_compress__doc__  ,
"compress(data [, compresslevel=9]) -> string\n\\n\Compress data in one shot. If you want to compress data  sequentially,
\n\use an instance of BZ2Compressor instead.The compresslevel  parameter,
if\n\  given,
must be a number between 1 and 9.\n\"   
)
PyDoc_STRVAR ( bz2_decompress__doc__  ,
"decompress(data) -> decompressed data\n\\n\Decompress data in one shot. If you want to decompress data  sequentially,
\n\use an instance of BZ2Decompressor instead.\n\"   
)
PyDoc_STRVAR ( bz2__doc__  ,
"The python bz2 module provides a comprehensive interface for\n\the bz2 compression library. It implements a complete file\n\  interface,
one shot(de) compression  functions,
and types for\n\sequential(de) compression.\n\"   
)
PyDoc_VAR ( BZ2File__doc__  )

Definition at line 2154 of file bz2module.c.

{
    PyObject *m;

    if (PyType_Ready(&BZ2File_Type) < 0)
        return NULL;
    if (PyType_Ready(&BZ2Comp_Type) < 0)
        return NULL;
    if (PyType_Ready(&BZ2Decomp_Type) < 0)
        return NULL;

    m = PyModule_Create(&bz2module);
    if (m == NULL)
        return NULL;

    PyModule_AddObject(m, "__author__", PyUnicode_FromString(__author__));

    Py_INCREF(&BZ2File_Type);
    PyModule_AddObject(m, "BZ2File", (PyObject *)&BZ2File_Type);

    Py_INCREF(&BZ2Comp_Type);
    PyModule_AddObject(m, "BZ2Compressor", (PyObject *)&BZ2Comp_Type);

    Py_INCREF(&BZ2Decomp_Type);
    PyModule_AddObject(m, "BZ2Decompressor", (PyObject *)&BZ2Decomp_Type);
    return m;
}

Here is the call graph for this function:

static int Util_CatchBZ2Error ( int  bzerror) [static]

Definition at line 158 of file bz2module.c.

{
    int ret = 0;
    switch(bzerror) {
        case BZ_OK:
        case BZ_STREAM_END:
            break;

#ifdef BZ_CONFIG_ERROR
        case BZ_CONFIG_ERROR:
            PyErr_SetString(PyExc_SystemError,
                            "the bz2 library was not compiled "
                            "correctly");
            ret = 1;
            break;
#endif

        case BZ_PARAM_ERROR:
            PyErr_SetString(PyExc_ValueError,
                            "the bz2 library has received wrong "
                            "parameters");
            ret = 1;
            break;

        case BZ_MEM_ERROR:
            PyErr_NoMemory();
            ret = 1;
            break;

        case BZ_DATA_ERROR:
        case BZ_DATA_ERROR_MAGIC:
            PyErr_SetString(PyExc_IOError, "invalid data stream");
            ret = 1;
            break;

        case BZ_IO_ERROR:
            PyErr_SetString(PyExc_IOError, "unknown IO error");
            ret = 1;
            break;

        case BZ_UNEXPECTED_EOF:
            PyErr_SetString(PyExc_EOFError,
                            "compressed file ended before the "
                            "logical end-of-stream was detected");
            ret = 1;
            break;

        case BZ_SEQUENCE_ERROR:
            PyErr_SetString(PyExc_RuntimeError,
                            "wrong sequence of bz2 library "
                            "commands used");
            ret = 1;
            break;
    }
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void Util_DropReadAhead ( BZ2FileObject f) [static]

Definition at line 314 of file bz2module.c.

{
    if (f->f_buf != NULL) {
        PyMem_Free(f->f_buf);
        f->f_buf = NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* Util_GetLine ( BZ2FileObject f,
int  n 
) [static]

Definition at line 244 of file bz2module.c.

{
    char c;
    char *buf, *end;
    size_t total_v_size;        /* total # of slots in buffer */
    size_t used_v_size;         /* # used slots in buffer */
    size_t increment;       /* amount to increment the buffer */
    PyObject *v;
    int bzerror;
    int bytes_read;

    total_v_size = n > 0 ? n : 100;
    v = PyBytes_FromStringAndSize((char *)NULL, total_v_size);
    if (v == NULL)
        return NULL;

    buf = BUF(v);
    end = buf + total_v_size;

    for (;;) {
        Py_BEGIN_ALLOW_THREADS
        do {
            bytes_read = BZ2_bzRead(&bzerror, f->fp, &c, 1);
            f->pos++;
            if (bytes_read == 0)
                break;
            *buf++ = c;
        } while (bzerror == BZ_OK && c != '\n' && buf != end);
        Py_END_ALLOW_THREADS
        if (bzerror == BZ_STREAM_END) {
            f->size = f->pos;
            f->mode = MODE_READ_EOF;
            break;
        } else if (bzerror != BZ_OK) {
            Util_CatchBZ2Error(bzerror);
            Py_DECREF(v);
            return NULL;
        }
        if (c == '\n')
            break;
        /* Must be because buf == end */
        if (n > 0)
            break;
        used_v_size = total_v_size;
        increment = total_v_size >> 2; /* mild exponential growth */
        total_v_size += increment;
        if (total_v_size > INT_MAX) {
            PyErr_SetString(PyExc_OverflowError,
                "line is longer than a Python string can hold");
            Py_DECREF(v);
            return NULL;
        }
        if (_PyBytes_Resize(&v, total_v_size) < 0) {
            return NULL;
        }
        buf = BUF(v) + used_v_size;
        end = BUF(v) + total_v_size;
    }

    used_v_size = buf - BUF(v);
    if (used_v_size != total_v_size) {
        if (_PyBytes_Resize(&v, used_v_size) < 0) {
            v = NULL;
        }
    }
    return v;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static size_t Util_NewBufferSize ( size_t  currentsize) [static]

Definition at line 229 of file bz2module.c.

{
    if (currentsize > SMALLCHUNK) {
        /* Keep doubling until we reach BIGCHUNK;
           then keep adding BIGCHUNK. */
        if (currentsize <= BIGCHUNK)
            return currentsize + currentsize;
        else
            return currentsize + BIGCHUNK;
    }
    return currentsize + SMALLCHUNK;
}

Here is the caller graph for this function:

static int Util_ReadAhead ( BZ2FileObject f,
int  bufsize 
) [static]

Definition at line 324 of file bz2module.c.

{
    int chunksize;
    int bzerror;

    if (f->f_buf != NULL) {
        if((f->f_bufend - f->f_bufptr) >= 1)
            return 0;
        else
            Util_DropReadAhead(f);
    }
    if (f->mode == MODE_READ_EOF) {
        f->f_bufptr = f->f_buf;
        f->f_bufend = f->f_buf;
        return 0;
    }
    if ((f->f_buf = PyMem_Malloc(bufsize)) == NULL) {
        PyErr_NoMemory();
        return -1;
    }
    Py_BEGIN_ALLOW_THREADS
    chunksize = BZ2_bzRead(&bzerror, f->fp, f->f_buf, bufsize);
    Py_END_ALLOW_THREADS
    f->pos += chunksize;
    if (bzerror == BZ_STREAM_END) {
        f->size = f->pos;
        f->mode = MODE_READ_EOF;
    } else if (bzerror != BZ_OK) {
        Util_CatchBZ2Error(bzerror);
        Util_DropReadAhead(f);
        return -1;
    }
    f->f_bufptr = f->f_buf;
    f->f_bufend = f->f_buf + chunksize;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyBytesObject* Util_ReadAheadGetLineSkip ( BZ2FileObject f,
int  skip,
int  bufsize 
) [static]

Definition at line 364 of file bz2module.c.

{
    PyBytesObject* s;
    char *bufptr;
    char *buf;
    int len;

    if (f->f_buf == NULL)
        if (Util_ReadAhead(f, bufsize) < 0)
            return NULL;

    len = f->f_bufend - f->f_bufptr;
    if (len == 0)
        return (PyBytesObject *)
            PyBytes_FromStringAndSize(NULL, skip);
    bufptr = memchr(f->f_bufptr, '\n', len);
    if (bufptr != NULL) {
        bufptr++;                               /* Count the '\n' */
        len = bufptr - f->f_bufptr;
        s = (PyBytesObject *)
            PyBytes_FromStringAndSize(NULL, skip+len);
        if (s == NULL)
            return NULL;
        memcpy(PyBytes_AS_STRING(s)+skip, f->f_bufptr, len);
        f->f_bufptr = bufptr;
        if (bufptr == f->f_bufend)
            Util_DropReadAhead(f);
    } else {
        bufptr = f->f_bufptr;
        buf = f->f_buf;
        f->f_buf = NULL;                /* Force new readahead buffer */
        s = Util_ReadAheadGetLineSkip(f, skip+len,
                                      bufsize + (bufsize>>2));
        if (s == NULL) {
            PyMem_Free(buf);
            return NULL;
        }
        memcpy(PyBytes_AS_STRING(s)+skip, bufptr, len);
        PyMem_Free(buf);
    }
    return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

char __author__[] [static]
Initial value:
"The bz2 python module was written by:\n\
\n\
    Gustavo Niemeyer <niemeyer@conectiva.com>\n\
"

Definition at line 19 of file bz2module.c.

Initial value:
 {
    {"compress", (PyCFunction) bz2_compress, METH_VARARGS|METH_KEYWORDS,
        bz2_compress__doc__},
    {"decompress", (PyCFunction) bz2_decompress, METH_VARARGS,
        bz2_decompress__doc__},
    {NULL,              NULL}           
}

Definition at line 2122 of file bz2module.c.

Initial value:
 {
    {"compress", (PyCFunction)BZ2Comp_compress, METH_VARARGS,
     BZ2Comp_compress__doc__},
    {"flush", (PyCFunction)BZ2Comp_flush, METH_NOARGS,
     BZ2Comp_flush__doc__},
    {NULL,              NULL}           
}

Definition at line 1574 of file bz2module.c.

Definition at line 1655 of file bz2module.c.

Initial value:
 {
    {"unused_data", T_OBJECT, OFF(unused_data), READONLY},
    {NULL}      
}

Definition at line 1705 of file bz2module.c.

Initial value:
 {
    {"decompress", (PyCFunction)BZ2Decomp_decompress, METH_VARARGS, BZ2Decomp_decompress__doc__},
    {NULL,              NULL}           
}

Definition at line 1809 of file bz2module.c.

Definition at line 1884 of file bz2module.c.

Initial value:
 {
    {"closed", (getter)BZ2File_get_closed, NULL,
                    "True if the file is closed"},
    {NULL}      
}

Definition at line 1178 of file bz2module.c.

Initial value:
 {
    {"read", (PyCFunction)BZ2File_read, METH_VARARGS, BZ2File_read__doc__},
    {"readline", (PyCFunction)BZ2File_readline, METH_VARARGS, BZ2File_readline__doc__},
    {"readlines", (PyCFunction)BZ2File_readlines, METH_VARARGS, BZ2File_readlines__doc__},
    {"write", (PyCFunction)BZ2File_write, METH_VARARGS, BZ2File_write__doc__},
    {"writelines", (PyCFunction)BZ2File_writelines, METH_O, BZ2File_writelines__doc__},
    {"seek", (PyCFunction)BZ2File_seek, METH_VARARGS, BZ2File_seek__doc__},
    {"tell", (PyCFunction)BZ2File_tell, METH_NOARGS, BZ2File_tell__doc__},
    {"close", (PyCFunction)BZ2File_close, METH_NOARGS, BZ2File_close__doc__},
    {"__enter__", (PyCFunction)BZ2File_enter, METH_NOARGS, BZ2File_enter_doc},
    {"__exit__", (PyCFunction)BZ2File_exit, METH_VARARGS, BZ2File_exit_doc},
    {NULL,              NULL}           
}

Definition at line 1154 of file bz2module.c.

Definition at line 1372 of file bz2module.c.

struct PyModuleDef [static]
Initial value:
 {
    PyModuleDef_HEAD_INIT,
    "bz2",
    bz2__doc__,
    -1,
    bz2_methods,
    NULL,
    NULL,
    NULL,
    NULL
}

Definition at line 2141 of file bz2module.c.