typedef struct {
PyObject_HEAD
- PyObject *file;
+ FILE *rawfp;
char* f_buf; /* Allocated readahead buffer */
char* f_bufend; /* Points after last occupied position */
char* f_bufptr; /* Current buffer position */
- int f_univ_newline; /* Handle any newline convention */
- int f_newlinetypes; /* Types of newlines seen */
- int f_skipnextlf; /* Skip next \n */
-
BZFILE *fp;
int mode;
Py_off_t pos;
size_t increment; /* amount to increment the buffer */
PyObject *v;
int bzerror;
- int newlinetypes = f->f_newlinetypes;
- int skipnextlf = f->f_skipnextlf;
- int univ_newline = f->f_univ_newline;
total_v_size = n > 0 ? n : 100;
v = PyBytes_FromStringAndSize((char *)NULL, total_v_size);
for (;;) {
Py_BEGIN_ALLOW_THREADS
- if (univ_newline) {
- while (1) {
- BZ2_bzRead(&bzerror, f->fp, &c, 1);
- f->pos++;
- if (bzerror != BZ_OK || buf == end)
- break;
- if (skipnextlf) {
- skipnextlf = 0;
- if (c == '\n') {
- /* Seeing a \n here with
- * skipnextlf true means we
- * saw a \r before.
- */
- newlinetypes |= NEWLINE_CRLF;
- BZ2_bzRead(&bzerror, f->fp,
- &c, 1);
- if (bzerror != BZ_OK)
- break;
- } else {
- newlinetypes |= NEWLINE_CR;
- }
- }
- if (c == '\r') {
- skipnextlf = 1;
- c = '\n';
- } else if ( c == '\n')
- newlinetypes |= NEWLINE_LF;
- *buf++ = c;
- if (c == '\n') break;
- }
- if (bzerror == BZ_STREAM_END && skipnextlf)
- newlinetypes |= NEWLINE_CR;
- } else /* If not universal newlines use the normal loop */
- do {
- BZ2_bzRead(&bzerror, f->fp, &c, 1);
- f->pos++;
- *buf++ = c;
- } while (bzerror == BZ_OK && c != '\n' && buf != end);
+ do {
+ BZ2_bzRead(&bzerror, f->fp, &c, 1);
+ f->pos++;
+ *buf++ = c;
+ } while (bzerror == BZ_OK && c != '\n' && buf != end);
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;
return v;
}
-/* This is a hacked version of Python's
- * fileobject.c:Py_UniversalNewlineFread(). */
-size_t
-Util_UnivNewlineRead(int *bzerror, BZFILE *stream,
- char* buf, size_t n, BZ2FileObject *f)
-{
- char *dst = buf;
- int newlinetypes, skipnextlf;
-
- assert(buf != NULL);
- assert(stream != NULL);
-
- if (!f->f_univ_newline)
- return BZ2_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_t nread;
- int shortread;
- 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--) {
- char c = *src++;
- if (c == '\r') {
- /* Save as LF and set flag to skip next LF. */
- *dst++ = '\n';
- skipnextlf = 1;
- }
- else if (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;
- else if (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;
- return dst - buf;
-}
-
/* This is a hacked version of Python's fileobject.c:drop_readahead(). */
static void
Util_DropReadAhead(BZ2FileObject *f)
return -1;
}
Py_BEGIN_ALLOW_THREADS
- chunksize = Util_UnivNewlineRead(&bzerror, f->fp, f->f_buf,
- bufsize, f);
+ chunksize = BZ2_bzRead(&bzerror, f->fp, f->f_buf, bufsize);
Py_END_ALLOW_THREADS
f->pos += chunksize;
if (bzerror == BZ_STREAM_END) {
for (;;) {
Py_BEGIN_ALLOW_THREADS
- chunksize = Util_UnivNewlineRead(&bzerror, self->fp,
- BUF(ret)+bytesread,
- buffersize-bytesread,
- self);
+ chunksize = BZ2_bzRead(&bzerror, self->fp,
+ BUF(ret)+bytesread,
+ buffersize-bytesread);
self->pos += chunksize;
Py_END_ALLOW_THREADS
bytesread += chunksize;
for (;;) {
Py_BEGIN_ALLOW_THREADS
- nread = Util_UnivNewlineRead(&bzerror, self->fp,
- buffer+nfilled,
- buffersize-nfilled, self);
+ nread = BZ2_bzRead(&bzerror, self->fp,
+ buffer+nfilled, buffersize-nfilled);
self->pos += nread;
Py_END_ALLOW_THREADS
if (bzerror == BZ_STREAM_END) {
assert(self->mode != MODE_READ_EOF);
for (;;) {
Py_BEGIN_ALLOW_THREADS
- chunksize = Util_UnivNewlineRead(
- &bzerror, self->fp,
- buffer, buffersize,
- self);
+ chunksize = BZ2_bzRead(&bzerror, self->fp,
+ buffer, buffersize);
self->pos += chunksize;
Py_END_ALLOW_THREADS
offset -= self->pos;
} else {
/* we cannot move back, so rewind the stream */
- FILE *fp = NULL; /* XXX temporary!!! */
BZ2_bzReadClose(&bzerror, self->fp);
if (bzerror != BZ_OK) {
Util_CatchBZ2Error(bzerror);
goto cleanup;
}
- ret = PyObject_CallMethod(self->file, "seek", "(i)", 0);
- if (!ret)
- goto cleanup;
- Py_DECREF(ret);
- ret = NULL;
+ rewind(self->rawfp);
self->pos = 0;
- self->fp = BZ2_bzReadOpen(&bzerror, fp,
+ self->fp = BZ2_bzReadOpen(&bzerror, self->rawfp,
0, 0, NULL, 0);
if (bzerror != BZ_OK) {
Util_CatchBZ2Error(bzerror);
* condition above). buffersize is 8192. */
readsize = (size_t)(offset-bytesread);
Py_BEGIN_ALLOW_THREADS
- chunksize = Util_UnivNewlineRead(&bzerror, self->fp,
- buffer, readsize, self);
+ chunksize = BZ2_bzRead(&bzerror, self->fp, buffer, readsize);
self->pos += chunksize;
Py_END_ALLOW_THREADS
bytesread += chunksize;
PyObject *ret = NULL;
int bzerror = BZ_OK;
+ if (self->mode == MODE_CLOSED) {
+ Py_RETURN_NONE;
+ }
+
ACQUIRE_LOCK(self);
switch (self->mode) {
case MODE_READ:
break;
}
self->mode = MODE_CLOSED;
- ret = PyObject_CallMethod(self->file, "close", NULL);
- if (bzerror != BZ_OK) {
+ fclose(self->rawfp);
+ self->rawfp = NULL;
+ if (bzerror == BZ_OK) {
+ Py_INCREF(Py_None);
+ ret = Py_None;
+ }
+ else {
Util_CatchBZ2Error(bzerror);
- Py_XDECREF(ret);
- ret = NULL;
}
RELEASE_LOCK(self);
/* ===================================================================== */
/* Getters and setters of BZ2File. */
-/* This is a hacked version of Python's fileobject.c:get_newlines(). */
-static PyObject *
-BZ2File_get_newlines(BZ2FileObject *self, void *closure)
-{
- switch (self->f_newlinetypes) {
- case NEWLINE_UNKNOWN:
- Py_INCREF(Py_None);
- return Py_None;
- case NEWLINE_CR:
- return PyBytes_FromStringAndSize("\r", 1);
- case NEWLINE_LF:
- return PyBytes_FromStringAndSize("\n", 1);
- case NEWLINE_CR|NEWLINE_LF:
- return Py_BuildValue("(ss)", "\r", "\n");
- case NEWLINE_CRLF:
- return PyBytes_FromStringAndSize("\r\n", 2);
- case NEWLINE_CR|NEWLINE_CRLF:
- return Py_BuildValue("(ss)", "\r", "\r\n");
- case NEWLINE_LF|NEWLINE_CRLF:
- return Py_BuildValue("(ss)", "\n", "\r\n");
- case NEWLINE_CR|NEWLINE_LF|NEWLINE_CRLF:
- return Py_BuildValue("(sss)", "\r", "\n", "\r\n");
- default:
- PyErr_Format(PyExc_SystemError,
- "Unknown newlines value 0x%x\n",
- self->f_newlinetypes);
- return NULL;
- }
-}
-
static PyObject *
BZ2File_get_closed(BZ2FileObject *self, void *closure)
{
return PyInt_FromLong(self->mode == MODE_CLOSED);
}
-static PyObject *
-BZ2File_get_mode(BZ2FileObject *self, void *closure)
-{
- return PyObject_GetAttrString(self->file, "mode");
-}
-
-static PyObject *
-BZ2File_get_name(BZ2FileObject *self, void *closure)
-{
- return PyObject_GetAttrString(self->file, "name");
-}
-
static PyGetSetDef BZ2File_getset[] = {
{"closed", (getter)BZ2File_get_closed, NULL,
"True if the file is closed"},
- {"newlines", (getter)BZ2File_get_newlines, NULL,
- "end-of-line convention used in this file"},
- {"mode", (getter)BZ2File_get_mode, NULL,
- "file mode ('r', 'w', or 'U')"},
- {"name", (getter)BZ2File_get_name, NULL,
- "file name"},
{NULL} /* Sentinel */
};
BZ2File_init(BZ2FileObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = {"filename", "mode", "buffering",
- "compresslevel", 0};
- FILE *fp = NULL; /* XXX temporary!!! */
- PyObject *name;
+ "compresslevel", 0};
+ char *name;
char *mode = "r";
int buffering = -1;
int compresslevel = 9;
self->size = -1;
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|sii:BZ2File",
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|sii:BZ2File",
kwlist, &name, &mode, &buffering,
&compresslevel))
return -1;
case 'b':
break;
- case 'U':
-#ifdef __VMS
- self->f_univ_newline = 0;
-#else
- self->f_univ_newline = 1;
-#endif
- break;
-
default:
error = 1;
break;
mode = (mode_char == 'r') ? "rb" : "wb";
- self->file = NULL; /* XXX io.open(name, mode, buffering); */
- PyErr_SetString(PyExc_RuntimeError, "can't open bz2 files yet");
- if (self->file == NULL)
+ self->rawfp = fopen(name, mode);
+ 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 */
#endif
if (mode_char == 'r')
- self->fp = BZ2_bzReadOpen(&bzerror,
- fp,
+ self->fp = BZ2_bzReadOpen(&bzerror, self->rawfp,
0, 0, NULL, 0);
else
- self->fp = BZ2_bzWriteOpen(&bzerror,
- fp,
+ self->fp = BZ2_bzWriteOpen(&bzerror, self->rawfp,
compresslevel, 0, 0);
if (bzerror != BZ_OK) {
return 0;
error:
- Py_CLEAR(self->file);
+ fclose(self->rawfp);
+ self->rawfp = NULL;
#ifdef WITH_THREAD
if (self->lock) {
PyThread_free_lock(self->lock);
break;
}
Util_DropReadAhead(self);
- Py_XDECREF(self->file);
+ if (self->rawfp != NULL)
+ fclose(self->rawfp);
self->ob_type->tp_free((PyObject *)self);
}
projects / python / commitdiff