bz2module.c

/*

python-bz2 - python bz2 library interface

Copyright (c) 2002 Gustavo Niemeyer <niemeyer@conectiva.com>
Copyright (c) 2002 Python Software Foundation; All Rights Reserved

*/

#include"Python.h"
#include<stdio.h>
#include<bzlib.h>
#include"structmember.h"

#ifdefWITH_THREAD
#include"pythread.h"
#endif

staticchar__author__[] =
"The bz2 python module was written by:\n\
\n\
 Gustavo Niemeyer <niemeyer@conectiva.com>\n\
";

/* Our very own off_t-like type, 64-bit if possible */
/* copied from Objects/fileobject.c */
#if !defined(HAVE_LARGEFILE_SUPPORT)
typedefoff_tPy_off_t;
#elifSIZEOF_OFF_T >= 8
typedefoff_tPy_off_t;
#elifSIZEOF_FPOS_T >= 8
typedeffpos_tPy_off_t;
#else
#error "Large file support, but neither off_t nor fpos_t is large enough."
#endif

#defineBUF(v) PyString_AS_STRING((PyStringObject *)v)

#defineMODE_CLOSED 0
#defineMODE_READ 1
#defineMODE_READ_EOF 2
#defineMODE_WRITE 3


#ifndefBZ_CONFIG_ERROR

#defineBZ2_bzRead bzRead
#defineBZ2_bzReadOpen bzReadOpen
#defineBZ2_bzReadClose bzReadClose
#defineBZ2_bzWrite bzWrite
#defineBZ2_bzWriteOpen bzWriteOpen
#defineBZ2_bzWriteClose bzWriteClose
#defineBZ2_bzCompress bzCompress
#defineBZ2_bzCompressInit bzCompressInit
#defineBZ2_bzCompressEnd bzCompressEnd
#defineBZ2_bzDecompress bzDecompress
#defineBZ2_bzDecompressInit bzDecompressInit
#defineBZ2_bzDecompressEnd bzDecompressEnd

#endif/* ! BZ_CONFIG_ERROR */


#ifdefWITH_THREAD
#defineACQUIRE_LOCK(obj) do { \
 if (!PyThread_acquire_lock(obj->lock, 0)) { \
 Py_BEGIN_ALLOW_THREADS \
 PyThread_acquire_lock(obj->lock, 1); \
 Py_END_ALLOW_THREADS \
 } } while(0)
#defineRELEASE_LOCK(obj) PyThread_release_lock(obj->lock)
#else
#defineACQUIRE_LOCK(obj)
#defineRELEASE_LOCK(obj)
#endif

#defineMIN(X, Y) (((X) < (Y)) ? (X) : (Y))

/* Bits in f_newlinetypes */
#defineNEWLINE_UNKNOWN 0 /* No newline seen, yet */
#defineNEWLINE_CR 1 /* \r newline seen */
#defineNEWLINE_LF 2 /* \n newline seen */
#defineNEWLINE_CRLF 4 /* \r\n newline seen */

/* ===================================================================== */
/* Structure definitions. */

typedefstruct {
PyObject_HEAD
PyObject*file;

char*f_buf; /* Allocated readahead buffer */
char*f_bufend; /* Points after last occupied position */
char*f_bufptr; /* Current buffer position */

intf_softspace; /* Flag used by 'print' command */

intf_univ_newline; /* Handle any newline convention */
intf_newlinetypes; /* Types of newlines seen */
intf_skipnextlf; /* Skip next \n */

BZFILE*fp;
intmode;
Py_off_tpos;
Py_off_tsize;
#ifdefWITH_THREAD
PyThread_type_locklock;
#endif
} BZ2FileObject;

typedefstruct {
PyObject_HEAD
bz_streambzs;
intrunning;
#ifdefWITH_THREAD
PyThread_type_locklock;
#endif
} BZ2CompObject;

typedefstruct {
PyObject_HEAD
bz_streambzs;
intrunning;
PyObject*unused_data;
#ifdefWITH_THREAD
PyThread_type_locklock;
#endif
} BZ2DecompObject;

/* ===================================================================== */
/* Utility functions. */

/* Refuse regular I/O if there's data in the iteration-buffer.
 * Mixing them would cause data to arrive out of order, as the read*
 * methods don't use the iteration buffer. */
staticint
check_iterbuffered(BZ2FileObject*f)
{
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;
 }
return0;
}

staticint
Util_CatchBZ2Error(intbzerror)
{
intret=0;
switch(bzerror) {
caseBZ_OK:
caseBZ_STREAM_END:
break;

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

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

caseBZ_MEM_ERROR:
PyErr_NoMemory();
ret=1;
break;

caseBZ_DATA_ERROR:
caseBZ_DATA_ERROR_MAGIC:
PyErr_SetString(PyExc_IOError, "invalid data stream");
ret=1;
break;

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

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

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

#ifBUFSIZ<8192
#defineSMALLCHUNK 8192
#else
#defineSMALLCHUNK BUFSIZ
#endif

/* This is a hacked version of Python's fileobject.c:new_buffersize(). */
staticsize_t
Util_NewBufferSize(size_tcurrentsize)
{
/* Expand the buffer by an amount proportional to the current size,
 giving us amortized linear-time behavior. Use a less-than-double
 growth factor to avoid excessive allocation. */
returncurrentsize+ (currentsize >> 3) +6;
}

staticint
Util_GrowBuffer(PyObject**buf)
{
size_tsize=PyString_GET_SIZE(*buf);
size_tnew_size=Util_NewBufferSize(size);
if (new_size>size) {
return_PyString_Resize(buf, new_size);
 } else { /* overflow */
PyErr_SetString(PyExc_OverflowError,
"Unable to allocate buffer - output too large");
return-1;
 }
}

/* This is a hacked version of Python's fileobject.c:get_line(). */
staticPyObject*
Util_GetLine(BZ2FileObject*f, intn)
{
charc;
char*buf, *end;
size_ttotal_v_size; /* total # of slots in buffer */
size_tused_v_size; /* # used slots in buffer */
size_tincrement; /* amount to increment the buffer */
PyObject*v;
intbzerror;
intbytes_read;
intnewlinetypes=f->f_newlinetypes;
intskipnextlf=f->f_skipnextlf;
intuniv_newline=f->f_univ_newline;

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

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

for (;;) {
Py_BEGIN_ALLOW_THREADS
while (buf!=end) {
bytes_read=BZ2_bzRead(&bzerror, f->fp, &c, 1);
f->pos++;
if (bytes_read==0) break;
if (univ_newline) {
if (skipnextlf) {
skipnextlf=0;
if (c=='\n') {
/* Seeing a \n here with skipnextlf true means we
 * saw a \r before.
 */
newlinetypes |= NEWLINE_CRLF;
if (bzerror!=BZ_OK) break;
bytes_read=BZ2_bzRead(&bzerror, f->fp, &c, 1);
f->pos++;
if (bytes_read==0) break;
 } else {
newlinetypes |= NEWLINE_CR;
 }
 }
if (c=='\r') {
skipnextlf=1;
c='\n';
 } elseif (c=='\n')
newlinetypes |= NEWLINE_LF;
 }
*buf++=c;
if (bzerror!=BZ_OK||c=='\n') break;
 }
if (univ_newline&&bzerror==BZ_STREAM_END&&skipnextlf)
newlinetypes |= NEWLINE_CR;
Py_END_ALLOW_THREADS
f->f_newlinetypes=newlinetypes;
f->f_skipnextlf=skipnextlf;
if (bzerror==BZ_STREAM_END) {
f->size=f->pos;
f->mode=MODE_READ_EOF;
break;
 } elseif (bzerror!=BZ_OK) {
Util_CatchBZ2Error(bzerror);
Py_DECREF(v);
returnNULL;
 }
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);
returnNULL;
 }
if (_PyString_Resize(&v, total_v_size) <0)
returnNULL;
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)
_PyString_Resize(&v, used_v_size);
returnv;
}

/* This is a hacked version of Python's
 * fileobject.c:Py_UniversalNewlineFread(). */
size_t
Util_UnivNewlineRead(int*bzerror, BZFILE*stream,
char*buf, size_tn, BZ2FileObject*f)
{
char*dst=buf;
intnewlinetypes, skipnextlf;

assert(buf!=NULL);
assert(stream!=NULL);

if (!f->f_univ_newline)
returnBZ2_bzRead(bzerror, stream, buf, n);

newlinetypes=f->f_newlinetypes;
skipnextlf=f->f_skipnextlf;

/* Invariant: n is the number of bytes remaining to be filled
 * in the buffer.
 */
while (n) {
size_tnread;
intshortread;
char*src=dst;

nread=BZ2_bzRead(bzerror, stream, dst, n);
assert(nread <= n);
n-=nread; /* assuming 1 byte out for each in; will adjust */
shortread=n!=0; /* true iff EOF or error */
while (nread--) {
charc=*src++;
if (c=='\r') {
/* Save as LF and set flag to skip next LF. */
*dst++='\n';
skipnextlf=1;
 }
elseif (skipnextlf&&c=='\n') {
/* Skip LF, and remember we saw CR LF. */
skipnextlf=0;
newlinetypes |= NEWLINE_CRLF;
++n;
 }
else {
/* Normal char to be stored in buffer. Also
 * update the newlinetypes flag if either this
 * is an LF or the previous char was a CR.
 */
if (c=='\n')
newlinetypes |= NEWLINE_LF;
elseif (skipnextlf)
newlinetypes |= NEWLINE_CR;
*dst++=c;
skipnextlf=0;
 }
 }
if (shortread) {
/* If this is EOF, update type flags. */
if (skipnextlf&&*bzerror==BZ_STREAM_END)
newlinetypes |= NEWLINE_CR;
break;
 }
 }
f->f_newlinetypes=newlinetypes;
f->f_skipnextlf=skipnextlf;
returndst-buf;
}

/* This is a hacked version of Python's fileobject.c:drop_readahead(). */
staticvoid
Util_DropReadAhead(BZ2FileObject*f)
{
if (f->f_buf!=NULL) {
PyMem_Free(f->f_buf);
f->f_buf=NULL;
 }
}

/* This is a hacked version of Python's fileobject.c:readahead(). */
staticint
Util_ReadAhead(BZ2FileObject*f, intbufsize)
{
intchunksize;
intbzerror;

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

/* This is a hacked version of Python's
 * fileobject.c:readahead_get_line_skip(). */
staticPyStringObject*
Util_ReadAheadGetLineSkip(BZ2FileObject*f, intskip, intbufsize)
{
PyStringObject*s;
char*bufptr;
char*buf;
intlen;

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

len=f->f_bufend-f->f_bufptr;
if (len==0)
return (PyStringObject*)
PyString_FromStringAndSize(NULL, skip);
bufptr=memchr(f->f_bufptr, '\n', len);
if (bufptr!=NULL) {
bufptr++; /* Count the '\n' */
len=bufptr-f->f_bufptr;
s= (PyStringObject*)
PyString_FromStringAndSize(NULL, skip+len);
if (s==NULL)
returnNULL;
memcpy(PyString_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);
returnNULL;
 }
memcpy(PyString_AS_STRING(s)+skip, bufptr, len);
PyMem_Free(buf);
 }
returns;
}

/* ===================================================================== */
/* Methods of BZ2File. */

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\
");

/* This is a hacked version of Python's fileobject.c:file_read(). */
staticPyObject*
BZ2File_read(BZ2FileObject*self, PyObject*args)
{
longbytesrequested=-1;
size_tbytesread, buffersize, chunksize;
intbzerror;
PyObject*ret=NULL;

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

ACQUIRE_LOCK(self);
switch (self->mode) {
caseMODE_READ:
break;
caseMODE_READ_EOF:
ret=PyString_FromString("");
 goto cleanup;
caseMODE_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=PyString_FromStringAndSize((char*)NULL, buffersize);
if (ret==NULL)
 goto cleanup;
bytesread=0;

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

cleanup:
RELEASE_LOCK(self);
returnret;
}

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\
");

staticPyObject*
BZ2File_readline(BZ2FileObject*self, PyObject*args)
{
PyObject*ret=NULL;
intsizehint=-1;

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

ACQUIRE_LOCK(self);
switch (self->mode) {
caseMODE_READ:
break;
caseMODE_READ_EOF:
ret=PyString_FromString("");
 goto cleanup;
caseMODE_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=PyString_FromString("");
else
ret=Util_GetLine(self, (sizehint<0) ? 0 : sizehint);

cleanup:
RELEASE_LOCK(self);
returnret;
}

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\
");

/* This is a hacked version of Python's fileobject.c:file_readlines(). */
staticPyObject*
BZ2File_readlines(BZ2FileObject*self, PyObject*args)
{
longsizehint=0;
PyObject*list=NULL;
PyObject*line;
charsmall_buffer[SMALLCHUNK];
char*buffer=small_buffer;
size_tbuffersize=SMALLCHUNK;
PyObject*big_buffer=NULL;
size_tnfilled=0;
size_tnread;
size_ttotalread=0;
char*p, *q, *end;
interr;
intshortread=0;
intbzerror;

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

ACQUIRE_LOCK(self);
switch (self->mode) {
caseMODE_READ:
break;
caseMODE_READ_EOF:
list=PyList_New(0);
 goto cleanup;
caseMODE_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=Util_UnivNewlineRead(&bzerror, self->fp,
buffer+nfilled,
buffersize-nfilled, self);
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;
 } elseif (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=PyString_FromStringAndSize(
NULL, buffersize);
if (big_buffer==NULL)
 goto error;
buffer=PyString_AS_STRING(big_buffer);
memcpy(buffer, small_buffer, nfilled);
 }
else {
/* Grow the big buffer */
if (_PyString_Resize(&big_buffer, buffersize))
 goto error;
buffer=PyString_AS_STRING(big_buffer);
 }
continue;
 }
end=buffer+nfilled+nread;
q=buffer;
while (p!=NULL) {
/* Process complete lines */
p++;
line=PyString_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=PyString_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;
 }
PyString_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);
 }
returnlist;
}

PyDoc_STRVAR(BZ2File_xreadlines__doc__,
"xreadlines() -> self\n\
\n\
For backward compatibility. BZ2File objects now include the performance\n\
optimizations previously implemented in the xreadlines module.\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\
");

/* This is a hacked version of Python's fileobject.c:file_write(). */
staticPyObject*
BZ2File_write(BZ2FileObject*self, PyObject*args)
{
PyObject*ret=NULL;
Py_bufferpbuf;
char*buf;
intlen;
intbzerror;

if (!PyArg_ParseTuple(args, "s*:write", &pbuf))
returnNULL;
buf=pbuf.buf;
len=pbuf.len;

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

caseMODE_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;
 }

self->f_softspace=0;

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);
returnret;
}

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\
");

/* This is a hacked version of Python's fileobject.c:file_writelines(). */
staticPyObject*
BZ2File_writelines(BZ2FileObject*self, PyObject*seq)
{
#defineCHUNKSIZE 1000
PyObject*list=NULL;
PyObject*iter=NULL;
PyObject*ret=NULL;
PyObject*line;
inti, j, index, len, islist;
intbzerror;

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

caseMODE_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 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 (!PyString_Check(v)) {
constchar*buffer;
Py_ssize_tlen;
if (PyObject_AsCharBuffer(v, &buffer, &len)) {
PyErr_SetString(PyExc_TypeError,
"writelines() "
"argument must be "
"a sequence of "
"strings");
 goto error;
 }
line=PyString_FromStringAndSize(buffer,
len);
if (line==NULL)
 goto error;
Py_DECREF(v);
PyList_SET_ITEM(list, i, line);
 }
 }

self->f_softspace=0;

/* 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=PyString_GET_SIZE(line);
BZ2_bzWrite (&bzerror, self->fp,
PyString_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);
returnret;
#undef CHUNKSIZE
}

PyDoc_STRVAR(BZ2File_seek__doc__,
"seek(offset [, whence]) -> None\n\
\n\