3 python-bz2 - python bz2 library interface
5 Copyright (c) 2002 Gustavo Niemeyer <niemeyer@conectiva.com>
6 Copyright (c) 2002 Python Software Foundation; All Rights Reserved
13 #include "structmember.h"
19 static char __author__
[] =
20 "The bz2 python module was written by:\n\
22 Gustavo Niemeyer <niemeyer@conectiva.com>\n\
25 /* Our very own off_t-like type, 64-bit if possible */
26 /* copied from Objects/fileobject.c */
27 #if !defined(HAVE_LARGEFILE_SUPPORT)
28 typedef off_t Py_off_t
;
29 #elif SIZEOF_OFF_T >= 8
30 typedef off_t Py_off_t
;
31 #elif SIZEOF_FPOS_T >= 8
32 typedef fpos_t Py_off_t
;
34 #error "Large file support, but neither off_t nor fpos_t is large enough."
37 #define BUF(v) PyString_AS_STRING((PyStringObject *)v)
41 #define MODE_READ_EOF 2
44 #define BZ2FileObject_Check(v) ((v)->ob_type == &BZ2File_Type)
47 #ifdef BZ_CONFIG_ERROR
50 #define BZS_TOTAL_OUT(bzs) \
51 (((long)bzs->total_out_hi32 << 32) + bzs->total_out_lo32)
52 #elif SIZEOF_LONG_LONG >= 8
53 #define BZS_TOTAL_OUT(bzs) \
54 (((PY_LONG_LONG)bzs->total_out_hi32 << 32) + bzs->total_out_lo32)
56 #define BZS_TOTAL_OUT(bzs) \
60 #else /* ! BZ_CONFIG_ERROR */
62 #define BZ2_bzRead bzRead
63 #define BZ2_bzReadOpen bzReadOpen
64 #define BZ2_bzReadClose bzReadClose
65 #define BZ2_bzWrite bzWrite
66 #define BZ2_bzWriteOpen bzWriteOpen
67 #define BZ2_bzWriteClose bzWriteClose
68 #define BZ2_bzCompress bzCompress
69 #define BZ2_bzCompressInit bzCompressInit
70 #define BZ2_bzCompressEnd bzCompressEnd
71 #define BZ2_bzDecompress bzDecompress
72 #define BZ2_bzDecompressInit bzDecompressInit
73 #define BZ2_bzDecompressEnd bzDecompressEnd
75 #define BZS_TOTAL_OUT(bzs) bzs->total_out
77 #endif /* ! BZ_CONFIG_ERROR */
81 #define ACQUIRE_LOCK(obj) PyThread_acquire_lock(obj->lock, 1)
82 #define RELEASE_LOCK(obj) PyThread_release_lock(obj->lock)
84 #define ACQUIRE_LOCK(obj)
85 #define RELEASE_LOCK(obj)
88 /* Bits in f_newlinetypes */
89 #define NEWLINE_UNKNOWN 0 /* No newline seen, yet */
90 #define NEWLINE_CR 1 /* \r newline seen */
91 #define NEWLINE_LF 2 /* \n newline seen */
92 #define NEWLINE_CRLF 4 /* \r\n newline seen */
94 /* ===================================================================== */
95 /* Structure definitions. */
101 char* f_buf
; /* Allocated readahead buffer */
102 char* f_bufend
; /* Points after last occupied position */
103 char* f_bufptr
; /* Current buffer position */
105 int f_softspace
; /* Flag used by 'print' command */
107 int f_univ_newline
; /* Handle any newline convention */
108 int f_newlinetypes
; /* Types of newlines seen */
109 int f_skipnextlf
; /* Skip next \n */
116 PyThread_type_lock lock
;
125 PyThread_type_lock lock
;
133 PyObject
*unused_data
;
135 PyThread_type_lock lock
;
139 /* ===================================================================== */
140 /* Utility functions. */
143 Util_CatchBZ2Error(int bzerror
)
151 #ifdef BZ_CONFIG_ERROR
152 case BZ_CONFIG_ERROR
:
153 PyErr_SetString(PyExc_SystemError
,
154 "the bz2 library was not compiled "
161 PyErr_SetString(PyExc_ValueError
,
162 "the bz2 library has received wrong "
173 case BZ_DATA_ERROR_MAGIC
:
174 PyErr_SetString(PyExc_IOError
, "invalid data stream");
179 PyErr_SetString(PyExc_IOError
, "unknown IO error");
183 case BZ_UNEXPECTED_EOF
:
184 PyErr_SetString(PyExc_EOFError
,
185 "compressed file ended before the "
186 "logical end-of-stream was detected");
190 case BZ_SEQUENCE_ERROR
:
191 PyErr_SetString(PyExc_RuntimeError
,
192 "wrong sequence of bz2 library "
201 #define SMALLCHUNK 8192
203 #define SMALLCHUNK BUFSIZ
207 #define BIGCHUNK (512 * 32)
209 #define BIGCHUNK (512 * 1024)
212 /* This is a hacked version of Python's fileobject.c:new_buffersize(). */
214 Util_NewBufferSize(size_t currentsize
)
216 if (currentsize
> SMALLCHUNK
) {
217 /* Keep doubling until we reach BIGCHUNK;
218 then keep adding BIGCHUNK. */
219 if (currentsize
<= BIGCHUNK
)
220 return currentsize
+ currentsize
;
222 return currentsize
+ BIGCHUNK
;
224 return currentsize
+ SMALLCHUNK
;
227 /* This is a hacked version of Python's fileobject.c:get_line(). */
229 Util_GetLine(BZ2FileObject
*f
, int n
)
233 size_t total_v_size
; /* total # of slots in buffer */
234 size_t used_v_size
; /* # used slots in buffer */
235 size_t increment
; /* amount to increment the buffer */
238 int newlinetypes
= f
->f_newlinetypes
;
239 int skipnextlf
= f
->f_skipnextlf
;
240 int univ_newline
= f
->f_univ_newline
;
242 total_v_size
= n
> 0 ? n
: 100;
243 v
= PyString_FromStringAndSize((char *)NULL
, total_v_size
);
248 end
= buf
+ total_v_size
;
251 Py_BEGIN_ALLOW_THREADS
254 BZ2_bzRead(&bzerror
, f
->fp
, &c
, 1);
256 if (bzerror
!= BZ_OK
|| buf
== end
)
261 /* Seeing a \n here with
262 * skipnextlf true means we
265 newlinetypes
|= NEWLINE_CRLF
;
266 BZ2_bzRead(&bzerror
, f
->fp
,
268 if (bzerror
!= BZ_OK
)
271 newlinetypes
|= NEWLINE_CR
;
277 } else if ( c
== '\n')
278 newlinetypes
|= NEWLINE_LF
;
280 if (c
== '\n') break;
282 if (bzerror
== BZ_STREAM_END
&& skipnextlf
)
283 newlinetypes
|= NEWLINE_CR
;
284 } else /* If not universal newlines use the normal loop */
286 BZ2_bzRead(&bzerror
, f
->fp
, &c
, 1);
289 } while (bzerror
== BZ_OK
&& c
!= '\n' && buf
!= end
);
291 f
->f_newlinetypes
= newlinetypes
;
292 f
->f_skipnextlf
= skipnextlf
;
293 if (bzerror
== BZ_STREAM_END
) {
295 f
->mode
= MODE_READ_EOF
;
297 } else if (bzerror
!= BZ_OK
) {
298 Util_CatchBZ2Error(bzerror
);
304 /* Must be because buf == end */
307 used_v_size
= total_v_size
;
308 increment
= total_v_size
>> 2; /* mild exponential growth */
309 total_v_size
+= increment
;
310 if (total_v_size
> INT_MAX
) {
311 PyErr_SetString(PyExc_OverflowError
,
312 "line is longer than a Python string can hold");
316 if (_PyString_Resize(&v
, total_v_size
) < 0)
318 buf
= BUF(v
) + used_v_size
;
319 end
= BUF(v
) + total_v_size
;
322 used_v_size
= buf
- BUF(v
);
323 if (used_v_size
!= total_v_size
)
324 _PyString_Resize(&v
, used_v_size
);
328 /* This is a hacked version of Python's
329 * fileobject.c:Py_UniversalNewlineFread(). */
331 Util_UnivNewlineRead(int *bzerror
, BZFILE
*stream
,
332 char* buf
, size_t n
, BZ2FileObject
*f
)
335 int newlinetypes
, skipnextlf
;
338 assert(stream
!= NULL
);
340 if (!f
->f_univ_newline
)
341 return BZ2_bzRead(bzerror
, stream
, buf
, n
);
343 newlinetypes
= f
->f_newlinetypes
;
344 skipnextlf
= f
->f_skipnextlf
;
346 /* Invariant: n is the number of bytes remaining to be filled
354 nread
= BZ2_bzRead(bzerror
, stream
, dst
, n
);
356 n
-= nread
; /* assuming 1 byte out for each in; will adjust */
357 shortread
= n
!= 0; /* true iff EOF or error */
361 /* Save as LF and set flag to skip next LF. */
365 else if (skipnextlf
&& c
== '\n') {
366 /* Skip LF, and remember we saw CR LF. */
368 newlinetypes
|= NEWLINE_CRLF
;
372 /* Normal char to be stored in buffer. Also
373 * update the newlinetypes flag if either this
374 * is an LF or the previous char was a CR.
377 newlinetypes
|= NEWLINE_LF
;
379 newlinetypes
|= NEWLINE_CR
;
385 /* If this is EOF, update type flags. */
386 if (skipnextlf
&& *bzerror
== BZ_STREAM_END
)
387 newlinetypes
|= NEWLINE_CR
;
391 f
->f_newlinetypes
= newlinetypes
;
392 f
->f_skipnextlf
= skipnextlf
;
396 /* This is a hacked version of Python's fileobject.c:drop_readahead(). */
398 Util_DropReadAhead(BZ2FileObject
*f
)
400 if (f
->f_buf
!= NULL
) {
401 PyMem_Free(f
->f_buf
);
406 /* This is a hacked version of Python's fileobject.c:readahead(). */
408 Util_ReadAhead(BZ2FileObject
*f
, int bufsize
)
413 if (f
->f_buf
!= NULL
) {
414 if((f
->f_bufend
- f
->f_bufptr
) >= 1)
417 Util_DropReadAhead(f
);
419 if (f
->mode
== MODE_READ_EOF
) {
420 f
->f_bufptr
= f
->f_buf
;
421 f
->f_bufend
= f
->f_buf
;
424 if ((f
->f_buf
= PyMem_Malloc(bufsize
)) == NULL
) {
427 Py_BEGIN_ALLOW_THREADS
428 chunksize
= Util_UnivNewlineRead(&bzerror
, f
->fp
, f
->f_buf
,
432 if (bzerror
== BZ_STREAM_END
) {
434 f
->mode
= MODE_READ_EOF
;
435 } else if (bzerror
!= BZ_OK
) {
436 Util_CatchBZ2Error(bzerror
);
437 Util_DropReadAhead(f
);
440 f
->f_bufptr
= f
->f_buf
;
441 f
->f_bufend
= f
->f_buf
+ chunksize
;
445 /* This is a hacked version of Python's
446 * fileobject.c:readahead_get_line_skip(). */
447 static PyStringObject
*
448 Util_ReadAheadGetLineSkip(BZ2FileObject
*f
, int skip
, int bufsize
)
455 if (f
->f_buf
== NULL
)
456 if (Util_ReadAhead(f
, bufsize
) < 0)
459 len
= f
->f_bufend
- f
->f_bufptr
;
461 return (PyStringObject
*)
462 PyString_FromStringAndSize(NULL
, skip
);
463 bufptr
= memchr(f
->f_bufptr
, '\n', len
);
464 if (bufptr
!= NULL
) {
465 bufptr
++; /* Count the '\n' */
466 len
= bufptr
- f
->f_bufptr
;
467 s
= (PyStringObject
*)
468 PyString_FromStringAndSize(NULL
, skip
+len
);
471 memcpy(PyString_AS_STRING(s
)+skip
, f
->f_bufptr
, len
);
472 f
->f_bufptr
= bufptr
;
473 if (bufptr
== f
->f_bufend
)
474 Util_DropReadAhead(f
);
476 bufptr
= f
->f_bufptr
;
478 f
->f_buf
= NULL
; /* Force new readahead buffer */
479 s
= Util_ReadAheadGetLineSkip(f
, skip
+len
,
480 bufsize
+ (bufsize
>>2));
485 memcpy(PyString_AS_STRING(s
)+skip
, bufptr
, len
);
491 /* ===================================================================== */
492 /* Methods of BZ2File. */
494 PyDoc_STRVAR(BZ2File_read__doc__
,
495 "read([size]) -> string\n\
497 Read at most size uncompressed bytes, returned as a string. If the size\n\
498 argument is negative or omitted, read until EOF is reached.\n\
501 /* This is a hacked version of Python's fileobject.c:file_read(). */
503 BZ2File_read(BZ2FileObject
*self
, PyObject
*args
)
505 long bytesrequested
= -1;
506 size_t bytesread
, buffersize
, chunksize
;
508 PyObject
*ret
= NULL
;
510 if (!PyArg_ParseTuple(args
, "|l:read", &bytesrequested
))
514 switch (self
->mode
) {
518 ret
= PyString_FromString("");
521 PyErr_SetString(PyExc_ValueError
,
522 "I/O operation on closed file");
525 PyErr_SetString(PyExc_IOError
,
526 "file is not ready for reading");
530 if (bytesrequested
< 0)
531 buffersize
= Util_NewBufferSize((size_t)0);
533 buffersize
= bytesrequested
;
534 if (buffersize
> INT_MAX
) {
535 PyErr_SetString(PyExc_OverflowError
,
536 "requested number of bytes is "
537 "more than a Python string can hold");
540 ret
= PyString_FromStringAndSize((char *)NULL
, buffersize
);
546 Py_BEGIN_ALLOW_THREADS
547 chunksize
= Util_UnivNewlineRead(&bzerror
, self
->fp
,
549 buffersize
-bytesread
,
551 self
->pos
+= chunksize
;
553 bytesread
+= chunksize
;
554 if (bzerror
== BZ_STREAM_END
) {
555 self
->size
= self
->pos
;
556 self
->mode
= MODE_READ_EOF
;
558 } else if (bzerror
!= BZ_OK
) {
559 Util_CatchBZ2Error(bzerror
);
564 if (bytesrequested
< 0) {
565 buffersize
= Util_NewBufferSize(buffersize
);
566 if (_PyString_Resize(&ret
, buffersize
) < 0)
572 if (bytesread
!= buffersize
)
573 _PyString_Resize(&ret
, bytesread
);
580 PyDoc_STRVAR(BZ2File_readline__doc__
,
581 "readline([size]) -> string\n\
583 Return the next line from the file, as a string, retaining newline.\n\
584 A non-negative size argument will limit the maximum number of bytes to\n\
585 return (an incomplete line may be returned then). Return an empty\n\
590 BZ2File_readline(BZ2FileObject
*self
, PyObject
*args
)
592 PyObject
*ret
= NULL
;
595 if (!PyArg_ParseTuple(args
, "|i:readline", &sizehint
))
599 switch (self
->mode
) {
603 ret
= PyString_FromString("");
606 PyErr_SetString(PyExc_ValueError
,
607 "I/O operation on closed file");
610 PyErr_SetString(PyExc_IOError
,
611 "file is not ready for reading");
616 ret
= PyString_FromString("");
618 ret
= Util_GetLine(self
, (sizehint
< 0) ? 0 : sizehint
);
625 PyDoc_STRVAR(BZ2File_readlines__doc__
,
626 "readlines([size]) -> list\n\
628 Call readline() repeatedly and return a list of lines read.\n\
629 The optional size argument, if given, is an approximate bound on the\n\
630 total number of bytes in the lines returned.\n\
633 /* This is a hacked version of Python's fileobject.c:file_readlines(). */
635 BZ2File_readlines(BZ2FileObject
*self
, PyObject
*args
)
638 PyObject
*list
= NULL
;
640 char small_buffer
[SMALLCHUNK
];
641 char *buffer
= small_buffer
;
642 size_t buffersize
= SMALLCHUNK
;
643 PyObject
*big_buffer
= NULL
;
646 size_t totalread
= 0;
652 if (!PyArg_ParseTuple(args
, "|l:readlines", &sizehint
))
656 switch (self
->mode
) {
660 list
= PyList_New(0);
663 PyErr_SetString(PyExc_ValueError
,
664 "I/O operation on closed file");
667 PyErr_SetString(PyExc_IOError
,
668 "file is not ready for reading");
672 if ((list
= PyList_New(0)) == NULL
)
676 Py_BEGIN_ALLOW_THREADS
677 nread
= Util_UnivNewlineRead(&bzerror
, self
->fp
,
679 buffersize
-nfilled
, self
);
682 if (bzerror
== BZ_STREAM_END
) {
683 self
->size
= self
->pos
;
684 self
->mode
= MODE_READ_EOF
;
690 } else if (bzerror
!= BZ_OK
) {
691 Util_CatchBZ2Error(bzerror
);
698 p
= memchr(buffer
+nfilled
, '\n', nread
);
699 if (!shortread
&& p
== NULL
) {
700 /* Need a larger buffer to fit this line */
703 if (buffersize
> INT_MAX
) {
704 PyErr_SetString(PyExc_OverflowError
,
705 "line is longer than a Python string can hold");
708 if (big_buffer
== NULL
) {
709 /* Create the big buffer */
710 big_buffer
= PyString_FromStringAndSize(
712 if (big_buffer
== NULL
)
714 buffer
= PyString_AS_STRING(big_buffer
);
715 memcpy(buffer
, small_buffer
, nfilled
);
718 /* Grow the big buffer */
719 _PyString_Resize(&big_buffer
, buffersize
);
720 buffer
= PyString_AS_STRING(big_buffer
);
724 end
= buffer
+nfilled
+nread
;
727 /* Process complete lines */
729 line
= PyString_FromStringAndSize(q
, p
-q
);
732 err
= PyList_Append(list
, line
);
737 p
= memchr(q
, '\n', end
-q
);
739 /* Move the remaining incomplete line to the start */
741 memmove(buffer
, q
, nfilled
);
743 if (totalread
>= (size_t)sizehint
)
751 /* Partial last line */
752 line
= PyString_FromStringAndSize(buffer
, nfilled
);
756 /* Need to complete the last line */
757 PyObject
*rest
= Util_GetLine(self
, 0);
762 PyString_Concat(&line
, rest
);
767 err
= PyList_Append(list
, line
);
776 Py_DECREF(big_buffer
);
781 PyDoc_STRVAR(BZ2File_xreadlines__doc__
,
782 "xreadlines() -> self\n\
784 For backward compatibility. BZ2File objects now include the performance\n\
785 optimizations previously implemented in the xreadlines module.\n\
788 PyDoc_STRVAR(BZ2File_write__doc__
,
789 "write(data) -> None\n\
791 Write the 'data' string to file. Note that due to buffering, close() may\n\
792 be needed before the file on disk reflects the data written.\n\
795 /* This is a hacked version of Python's fileobject.c:file_write(). */
797 BZ2File_write(BZ2FileObject
*self
, PyObject
*args
)
799 PyObject
*ret
= NULL
;
804 if (!PyArg_ParseTuple(args
, "s#:write", &buf
, &len
))
808 switch (self
->mode
) {
813 PyErr_SetString(PyExc_ValueError
,
814 "I/O operation on closed file");
818 PyErr_SetString(PyExc_IOError
,
819 "file is not ready for writing");
823 self
->f_softspace
= 0;
825 Py_BEGIN_ALLOW_THREADS
826 BZ2_bzWrite (&bzerror
, self
->fp
, buf
, len
);
830 if (bzerror
!= BZ_OK
) {
831 Util_CatchBZ2Error(bzerror
);
843 PyDoc_STRVAR(BZ2File_writelines__doc__
,
844 "writelines(sequence_of_strings) -> None\n\
846 Write the sequence of strings to the file. Note that newlines are not\n\
847 added. The sequence can be any iterable object producing strings. This is\n\
848 equivalent to calling write() for each string.\n\
851 /* This is a hacked version of Python's fileobject.c:file_writelines(). */
853 BZ2File_writelines(BZ2FileObject
*self
, PyObject
*seq
)
855 #define CHUNKSIZE 1000
856 PyObject
*list
= NULL
;
857 PyObject
*iter
= NULL
;
858 PyObject
*ret
= NULL
;
860 int i
, j
, index
, len
, islist
;
864 islist
= PyList_Check(seq
);
866 iter
= PyObject_GetIter(seq
);
868 PyErr_SetString(PyExc_TypeError
,
869 "writelines() requires an iterable argument");
872 list
= PyList_New(CHUNKSIZE
);
877 /* Strategy: slurp CHUNKSIZE lines into a private list,
878 checking that they are all strings, then write that list
879 without holding the interpreter lock, then come back for more. */
880 for (index
= 0; ; index
+= CHUNKSIZE
) {
883 list
= PyList_GetSlice(seq
, index
, index
+CHUNKSIZE
);
886 j
= PyList_GET_SIZE(list
);
889 for (j
= 0; j
< CHUNKSIZE
; j
++) {
890 line
= PyIter_Next(iter
);
892 if (PyErr_Occurred())
896 PyList_SetItem(list
, j
, line
);
902 /* Check that all entries are indeed strings. If not,
903 apply the same rules as for file.write() and
904 convert the rets to strings. This is slow, but
905 seems to be the only way since all conversion APIs
906 could potentially execute Python code. */
907 for (i
= 0; i
< j
; i
++) {
908 PyObject
*v
= PyList_GET_ITEM(list
, i
);
909 if (!PyString_Check(v
)) {
912 if (PyObject_AsCharBuffer(v
, &buffer
, &len
)) {
913 PyErr_SetString(PyExc_TypeError
,
920 line
= PyString_FromStringAndSize(buffer
,
925 PyList_SET_ITEM(list
, i
, line
);
929 self
->f_softspace
= 0;
931 /* Since we are releasing the global lock, the
932 following code may *not* execute Python code. */
933 Py_BEGIN_ALLOW_THREADS
934 for (i
= 0; i
< j
; i
++) {
935 line
= PyList_GET_ITEM(list
, i
);
936 len
= PyString_GET_SIZE(line
);
937 BZ2_bzWrite (&bzerror
, self
->fp
,
938 PyString_AS_STRING(line
), len
);
939 if (bzerror
!= BZ_OK
) {
941 Util_CatchBZ2Error(bzerror
);
962 PyDoc_STRVAR(BZ2File_seek__doc__
,
963 "seek(offset [, whence]) -> None\n\
965 Move to new file position. Argument offset is a byte count. Optional\n\
966 argument whence defaults to 0 (offset from start of file, offset\n\
967 should be >= 0); other values are 1 (move relative to current position,\n\
968 positive or negative), and 2 (move relative to end of file, usually\n\
969 negative, although many platforms allow seeking beyond the end of a file).\n\
971 Note that seeking of bz2 files is emulated, and depending on the parameters\n\
972 the operation may be extremely slow.\n\
976 BZ2File_seek(BZ2FileObject
*self
, PyObject
*args
)
981 char small_buffer
[SMALLCHUNK
];
982 char *buffer
= small_buffer
;
983 size_t buffersize
= SMALLCHUNK
;
988 PyObject
*ret
= NULL
;
990 if (!PyArg_ParseTuple(args
, "O|i:seek", &offobj
, &where
))
992 #if !defined(HAVE_LARGEFILE_SUPPORT)
993 offset
= PyInt_AsLong(offobj
);
995 offset
= PyLong_Check(offobj
) ?
996 PyLong_AsLongLong(offobj
) : PyInt_AsLong(offobj
);
998 if (PyErr_Occurred())
1002 Util_DropReadAhead(self
);
1003 switch (self
->mode
) {
1009 PyErr_SetString(PyExc_ValueError
,
1010 "I/O operation on closed file");
1014 PyErr_SetString(PyExc_IOError
,
1015 "seek works only while reading");
1020 if (self
->size
== -1) {
1021 assert(self
->mode
!= MODE_READ_EOF
);
1023 Py_BEGIN_ALLOW_THREADS
1024 chunksize
= Util_UnivNewlineRead(
1028 self
->pos
+= chunksize
;
1029 Py_END_ALLOW_THREADS
1031 bytesread
+= chunksize
;
1032 if (bzerror
== BZ_STREAM_END
) {
1034 } else if (bzerror
!= BZ_OK
) {
1035 Util_CatchBZ2Error(bzerror
);
1039 self
->mode
= MODE_READ_EOF
;
1040 self
->size
= self
->pos
;
1043 offset
= self
->size
+ offset
;
1044 } else if (where
== 1) {
1045 offset
= self
->pos
+ offset
;
1048 /* Before getting here, offset must be the absolute position the file
1049 * pointer should be set to. */
1051 if (offset
>= self
->pos
) {
1052 /* we can move forward */
1053 offset
-= self
->pos
;
1055 /* we cannot move back, so rewind the stream */
1056 BZ2_bzReadClose(&bzerror
, self
->fp
);
1057 if (bzerror
!= BZ_OK
) {
1058 Util_CatchBZ2Error(bzerror
);
1061 ret
= PyObject_CallMethod(self
->file
, "seek", "(i)", 0);
1067 self
->fp
= BZ2_bzReadOpen(&bzerror
, PyFile_AsFile(self
->file
),
1069 if (bzerror
!= BZ_OK
) {
1070 Util_CatchBZ2Error(bzerror
);
1073 self
->mode
= MODE_READ
;
1076 if (offset
<= 0 || self
->mode
== MODE_READ_EOF
)
1079 /* Before getting here, offset must be set to the number of bytes
1080 * to walk forward. */
1082 if (offset
-bytesread
> buffersize
)
1083 readsize
= buffersize
;
1085 /* offset might be wider that readsize, but the result
1086 * of the subtraction is bound by buffersize (see the
1087 * condition above). buffersize is 8192. */
1088 readsize
= (size_t)(offset
-bytesread
);
1089 Py_BEGIN_ALLOW_THREADS
1090 chunksize
= Util_UnivNewlineRead(&bzerror
, self
->fp
,
1091 buffer
, readsize
, self
);
1092 self
->pos
+= chunksize
;
1093 Py_END_ALLOW_THREADS
1094 bytesread
+= chunksize
;
1095 if (bzerror
== BZ_STREAM_END
) {
1096 self
->size
= self
->pos
;
1097 self
->mode
= MODE_READ_EOF
;
1099 } else if (bzerror
!= BZ_OK
) {
1100 Util_CatchBZ2Error(bzerror
);
1103 if (bytesread
== offset
)
1116 PyDoc_STRVAR(BZ2File_tell__doc__
,
1119 Return the current file position, an integer (may be a long integer).\n\
1123 BZ2File_tell(BZ2FileObject
*self
, PyObject
*args
)
1125 PyObject
*ret
= NULL
;
1127 if (self
->mode
== MODE_CLOSED
) {
1128 PyErr_SetString(PyExc_ValueError
,
1129 "I/O operation on closed file");
1133 #if !defined(HAVE_LARGEFILE_SUPPORT)
1134 ret
= PyInt_FromLong(self
->pos
);
1136 ret
= PyLong_FromLongLong(self
->pos
);
1143 PyDoc_STRVAR(BZ2File_close__doc__
,
1144 "close() -> None or (perhaps) an integer\n\
1146 Close the file. Sets data attribute .closed to true. A closed file\n\
1147 cannot be used for further I/O operations. close() may be called more\n\
1148 than once without error.\n\
1152 BZ2File_close(BZ2FileObject
*self
)
1154 PyObject
*ret
= NULL
;
1155 int bzerror
= BZ_OK
;
1158 switch (self
->mode
) {
1161 BZ2_bzReadClose(&bzerror
, self
->fp
);
1164 BZ2_bzWriteClose(&bzerror
, self
->fp
,
1168 self
->mode
= MODE_CLOSED
;
1169 ret
= PyObject_CallMethod(self
->file
, "close", NULL
);
1170 if (bzerror
!= BZ_OK
) {
1171 Util_CatchBZ2Error(bzerror
);
1180 static PyObject
*BZ2File_getiter(BZ2FileObject
*self
);
1182 static PyMethodDef BZ2File_methods
[] = {
1183 {"read", (PyCFunction
)BZ2File_read
, METH_VARARGS
, BZ2File_read__doc__
},
1184 {"readline", (PyCFunction
)BZ2File_readline
, METH_VARARGS
, BZ2File_readline__doc__
},
1185 {"readlines", (PyCFunction
)BZ2File_readlines
, METH_VARARGS
, BZ2File_readlines__doc__
},
1186 {"xreadlines", (PyCFunction
)BZ2File_getiter
, METH_VARARGS
, BZ2File_xreadlines__doc__
},
1187 {"write", (PyCFunction
)BZ2File_write
, METH_VARARGS
, BZ2File_write__doc__
},
1188 {"writelines", (PyCFunction
)BZ2File_writelines
, METH_O
, BZ2File_writelines__doc__
},
1189 {"seek", (PyCFunction
)BZ2File_seek
, METH_VARARGS
, BZ2File_seek__doc__
},
1190 {"tell", (PyCFunction
)BZ2File_tell
, METH_NOARGS
, BZ2File_tell__doc__
},
1191 {"close", (PyCFunction
)BZ2File_close
, METH_NOARGS
, BZ2File_close__doc__
},
1192 {NULL
, NULL
} /* sentinel */
1196 /* ===================================================================== */
1197 /* Getters and setters of BZ2File. */
1199 /* This is a hacked version of Python's fileobject.c:get_newlines(). */
1201 BZ2File_get_newlines(BZ2FileObject
*self
, void *closure
)
1203 switch (self
->f_newlinetypes
) {
1204 case NEWLINE_UNKNOWN
:
1208 return PyString_FromString("\r");
1210 return PyString_FromString("\n");
1211 case NEWLINE_CR
|NEWLINE_LF
:
1212 return Py_BuildValue("(ss)", "\r", "\n");
1214 return PyString_FromString("\r\n");
1215 case NEWLINE_CR
|NEWLINE_CRLF
:
1216 return Py_BuildValue("(ss)", "\r", "\r\n");
1217 case NEWLINE_LF
|NEWLINE_CRLF
:
1218 return Py_BuildValue("(ss)", "\n", "\r\n");
1219 case NEWLINE_CR
|NEWLINE_LF
|NEWLINE_CRLF
:
1220 return Py_BuildValue("(sss)", "\r", "\n", "\r\n");
1222 PyErr_Format(PyExc_SystemError
,
1223 "Unknown newlines value 0x%x\n",
1224 self
->f_newlinetypes
);
1230 BZ2File_get_closed(BZ2FileObject
*self
, void *closure
)
1232 return PyInt_FromLong(self
->mode
== MODE_CLOSED
);
1236 BZ2File_get_mode(BZ2FileObject
*self
, void *closure
)
1238 return PyObject_GetAttrString(self
->file
, "mode");
1242 BZ2File_get_name(BZ2FileObject
*self
, void *closure
)
1244 return PyObject_GetAttrString(self
->file
, "name");
1247 static PyGetSetDef BZ2File_getset
[] = {
1248 {"closed", (getter
)BZ2File_get_closed
, NULL
,
1249 "True if the file is closed"},
1250 {"newlines", (getter
)BZ2File_get_newlines
, NULL
,
1251 "end-of-line convention used in this file"},
1252 {"mode", (getter
)BZ2File_get_mode
, NULL
,
1253 "file mode ('r', 'w', or 'U')"},
1254 {"name", (getter
)BZ2File_get_name
, NULL
,
1256 {NULL
} /* Sentinel */
1260 /* ===================================================================== */
1261 /* Members of BZ2File_Type. */
1264 #define OFF(x) offsetof(BZ2FileObject, x)
1266 static PyMemberDef BZ2File_members
[] = {
1267 {"softspace", T_INT
, OFF(f_softspace
), 0,
1268 "flag indicating that a space needs to be printed; used by print"},
1269 {NULL
} /* Sentinel */
1272 /* ===================================================================== */
1273 /* Slot definitions for BZ2File_Type. */
1276 BZ2File_init(BZ2FileObject
*self
, PyObject
*args
, PyObject
*kwargs
)
1278 static char *kwlist
[] = {"filename", "mode", "buffering",
1279 "compresslevel", 0};
1283 int compresslevel
= 9;
1289 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "O|sii:BZ2File",
1290 kwlist
, &name
, &mode
, &buffering
,
1294 if (compresslevel
< 1 || compresslevel
> 9) {
1295 PyErr_SetString(PyExc_ValueError
,
1296 "compresslevel must be between 1 and 9");
1314 self
->f_univ_newline
= 1;
1322 PyErr_Format(PyExc_ValueError
,
1323 "invalid mode char %c", *mode
);
1331 if (mode_char
== 0) {
1335 mode
= (mode_char
== 'r') ? "rb" : "wb";
1337 self
->file
= PyObject_CallFunction((PyObject
*)&PyFile_Type
, "(Osi)",
1338 name
, mode
, buffering
);
1339 if (self
->file
== NULL
)
1342 /* From now on, we have stuff to dealloc, so jump to error label
1343 * instead of returning */
1346 self
->lock
= PyThread_allocate_lock();
1351 if (mode_char
== 'r')
1352 self
->fp
= BZ2_bzReadOpen(&bzerror
,
1353 PyFile_AsFile(self
->file
),
1356 self
->fp
= BZ2_bzWriteOpen(&bzerror
,
1357 PyFile_AsFile(self
->file
),
1358 compresslevel
, 0, 0);
1360 if (bzerror
!= BZ_OK
) {
1361 Util_CatchBZ2Error(bzerror
);
1365 self
->mode
= (mode_char
== 'r') ? MODE_READ
: MODE_WRITE
;
1370 Py_DECREF(self
->file
);
1373 PyThread_free_lock(self
->lock
);
1379 BZ2File_dealloc(BZ2FileObject
*self
)
1384 PyThread_free_lock(self
->lock
);
1386 switch (self
->mode
) {
1389 BZ2_bzReadClose(&bzerror
, self
->fp
);
1392 BZ2_bzWriteClose(&bzerror
, self
->fp
,
1396 Util_DropReadAhead(self
);
1397 Py_XDECREF(self
->file
);
1398 self
->ob_type
->tp_free((PyObject
*)self
);
1401 /* This is a hacked version of Python's fileobject.c:file_getiter(). */
1403 BZ2File_getiter(BZ2FileObject
*self
)
1405 if (self
->mode
== MODE_CLOSED
) {
1406 PyErr_SetString(PyExc_ValueError
,
1407 "I/O operation on closed file");
1410 Py_INCREF((PyObject
*)self
);
1411 return (PyObject
*)self
;
1414 /* This is a hacked version of Python's fileobject.c:file_iternext(). */
1415 #define READAHEAD_BUFSIZE 8192
1417 BZ2File_iternext(BZ2FileObject
*self
)
1419 PyStringObject
* ret
;
1421 if (self
->mode
== MODE_CLOSED
) {
1422 PyErr_SetString(PyExc_ValueError
,
1423 "I/O operation on closed file");
1426 ret
= Util_ReadAheadGetLineSkip(self
, 0, READAHEAD_BUFSIZE
);
1428 if (ret
== NULL
|| PyString_GET_SIZE(ret
) == 0) {
1432 return (PyObject
*)ret
;
1435 /* ===================================================================== */
1436 /* BZ2File_Type definition. */
1438 PyDoc_VAR(BZ2File__doc__
) =
1440 "BZ2File(name [, mode='r', buffering=0, compresslevel=9]) -> file object\n\
1442 Open a bz2 file. The mode can be 'r' or 'w', for reading (default) or\n\
1443 writing. When opened for writing, the file will be created if it doesn't\n\
1444 exist, and truncated otherwise. If the buffering argument is given, 0 means\n\
1445 unbuffered, and larger numbers specify the buffer size. If compresslevel\n\
1446 is given, must be a number between 1 and 9.\n\
1450 Add a 'U' to mode to open the file for input with universal newline\n\
1451 support. Any line ending in the input file will be seen as a '\\n' in\n\
1452 Python. Also, a file so opened gains the attribute 'newlines'; the value\n\
1453 for this attribute is one of None (no newline read yet), '\\r', '\\n',\n\
1454 '\\r\\n' or a tuple containing all the newline types seen. Universal\n\
1455 newlines are available only when reading.\n\
1459 static PyTypeObject BZ2File_Type
= {
1460 PyObject_HEAD_INIT(NULL
)
1462 "bz2.BZ2File", /*tp_name*/
1463 sizeof(BZ2FileObject
), /*tp_basicsize*/
1465 (destructor
)BZ2File_dealloc
, /*tp_dealloc*/
1472 0, /*tp_as_sequence*/
1473 0, /*tp_as_mapping*/
1477 PyObject_GenericGetAttr
,/*tp_getattro*/
1478 PyObject_GenericSetAttr
,/*tp_setattro*/
1480 Py_TPFLAGS_DEFAULT
|Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1481 BZ2File__doc__
, /*tp_doc*/
1484 0, /*tp_richcompare*/
1485 0, /*tp_weaklistoffset*/
1486 (getiterfunc
)BZ2File_getiter
, /*tp_iter*/
1487 (iternextfunc
)BZ2File_iternext
, /*tp_iternext*/
1488 BZ2File_methods
, /*tp_methods*/
1489 BZ2File_members
, /*tp_members*/
1490 BZ2File_getset
, /*tp_getset*/
1495 0, /*tp_dictoffset*/
1496 (initproc
)BZ2File_init
, /*tp_init*/
1497 PyType_GenericAlloc
, /*tp_alloc*/
1498 PyType_GenericNew
, /*tp_new*/
1499 _PyObject_Del
, /*tp_free*/
1504 /* ===================================================================== */
1505 /* Methods of BZ2Comp. */
1507 PyDoc_STRVAR(BZ2Comp_compress__doc__
,
1508 "compress(data) -> string\n\
1510 Provide more data to the compressor object. It will return chunks of\n\
1511 compressed data whenever possible. When you've finished providing data\n\
1512 to compress, call the flush() method to finish the compression process,\n\
1513 and return what is left in the internal buffers.\n\
1517 BZ2Comp_compress(BZ2CompObject
*self
, PyObject
*args
)
1521 int bufsize
= SMALLCHUNK
;
1522 PY_LONG_LONG totalout
;
1523 PyObject
*ret
= NULL
;
1524 bz_stream
*bzs
= &self
->bzs
;
1527 if (!PyArg_ParseTuple(args
, "s#:compress", &data
, &datasize
))
1531 return PyString_FromString("");
1534 if (!self
->running
) {
1535 PyErr_SetString(PyExc_ValueError
,
1536 "this object was already flushed");
1540 ret
= PyString_FromStringAndSize(NULL
, bufsize
);
1544 bzs
->next_in
= data
;
1545 bzs
->avail_in
= datasize
;
1546 bzs
->next_out
= BUF(ret
);
1547 bzs
->avail_out
= bufsize
;
1549 totalout
= BZS_TOTAL_OUT(bzs
);
1552 Py_BEGIN_ALLOW_THREADS
1553 bzerror
= BZ2_bzCompress(bzs
, BZ_RUN
);
1554 Py_END_ALLOW_THREADS
1555 if (bzerror
!= BZ_RUN_OK
) {
1556 Util_CatchBZ2Error(bzerror
);
1559 if (bzs
->avail_out
== 0) {
1560 bufsize
= Util_NewBufferSize(bufsize
);
1561 if (_PyString_Resize(&ret
, bufsize
) < 0) {
1562 BZ2_bzCompressEnd(bzs
);
1565 bzs
->next_out
= BUF(ret
) + (BZS_TOTAL_OUT(bzs
)
1567 bzs
->avail_out
= bufsize
- (bzs
->next_out
- BUF(ret
));
1568 } else if (bzs
->avail_in
== 0) {
1573 _PyString_Resize(&ret
, (int)(BZS_TOTAL_OUT(bzs
) - totalout
));
1584 PyDoc_STRVAR(BZ2Comp_flush__doc__
,
1585 "flush() -> string\n\
1587 Finish the compression process and return what is left in internal buffers.\n\
1588 You must not use the compressor object after calling this method.\n\
1592 BZ2Comp_flush(BZ2CompObject
*self
)
1594 int bufsize
= SMALLCHUNK
;
1595 PyObject
*ret
= NULL
;
1596 bz_stream
*bzs
= &self
->bzs
;
1597 PY_LONG_LONG totalout
;
1601 if (!self
->running
) {
1602 PyErr_SetString(PyExc_ValueError
, "object was already "
1608 ret
= PyString_FromStringAndSize(NULL
, bufsize
);
1612 bzs
->next_out
= BUF(ret
);
1613 bzs
->avail_out
= bufsize
;
1615 totalout
= BZS_TOTAL_OUT(bzs
);
1618 Py_BEGIN_ALLOW_THREADS
1619 bzerror
= BZ2_bzCompress(bzs
, BZ_FINISH
);
1620 Py_END_ALLOW_THREADS
1621 if (bzerror
== BZ_STREAM_END
) {
1623 } else if (bzerror
!= BZ_FINISH_OK
) {
1624 Util_CatchBZ2Error(bzerror
);
1627 if (bzs
->avail_out
== 0) {
1628 bufsize
= Util_NewBufferSize(bufsize
);
1629 if (_PyString_Resize(&ret
, bufsize
) < 0)
1631 bzs
->next_out
= BUF(ret
);
1632 bzs
->next_out
= BUF(ret
) + (BZS_TOTAL_OUT(bzs
)
1634 bzs
->avail_out
= bufsize
- (bzs
->next_out
- BUF(ret
));
1638 if (bzs
->avail_out
!= 0)
1639 _PyString_Resize(&ret
, (int)(BZS_TOTAL_OUT(bzs
) - totalout
));
1650 static PyMethodDef BZ2Comp_methods
[] = {
1651 {"compress", (PyCFunction
)BZ2Comp_compress
, METH_VARARGS
,
1652 BZ2Comp_compress__doc__
},
1653 {"flush", (PyCFunction
)BZ2Comp_flush
, METH_NOARGS
,
1654 BZ2Comp_flush__doc__
},
1655 {NULL
, NULL
} /* sentinel */
1659 /* ===================================================================== */
1660 /* Slot definitions for BZ2Comp_Type. */
1663 BZ2Comp_init(BZ2CompObject
*self
, PyObject
*args
, PyObject
*kwargs
)
1665 int compresslevel
= 9;
1667 static char *kwlist
[] = {"compresslevel", 0};
1669 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "|i:BZ2Compressor",
1670 kwlist
, &compresslevel
))
1673 if (compresslevel
< 1 || compresslevel
> 9) {
1674 PyErr_SetString(PyExc_ValueError
,
1675 "compresslevel must be between 1 and 9");
1680 self
->lock
= PyThread_allocate_lock();
1685 memset(&self
->bzs
, 0, sizeof(bz_stream
));
1686 bzerror
= BZ2_bzCompressInit(&self
->bzs
, compresslevel
, 0, 0);
1687 if (bzerror
!= BZ_OK
) {
1688 Util_CatchBZ2Error(bzerror
);
1698 PyThread_free_lock(self
->lock
);
1704 BZ2Comp_dealloc(BZ2CompObject
*self
)
1708 PyThread_free_lock(self
->lock
);
1710 BZ2_bzCompressEnd(&self
->bzs
);
1711 self
->ob_type
->tp_free((PyObject
*)self
);
1715 /* ===================================================================== */
1716 /* BZ2Comp_Type definition. */
1718 PyDoc_STRVAR(BZ2Comp__doc__
,
1719 "BZ2Compressor([compresslevel=9]) -> compressor object\n\
1721 Create a new compressor object. This object may be used to compress\n\
1722 data sequentially. If you want to compress data in one shot, use the\n\
1723 compress() function instead. The compresslevel parameter, if given,\n\
1724 must be a number between 1 and 9.\n\
1727 static PyTypeObject BZ2Comp_Type
= {
1728 PyObject_HEAD_INIT(NULL
)
1730 "bz2.BZ2Compressor", /*tp_name*/
1731 sizeof(BZ2CompObject
), /*tp_basicsize*/
1733 (destructor
)BZ2Comp_dealloc
, /*tp_dealloc*/
1740 0, /*tp_as_sequence*/
1741 0, /*tp_as_mapping*/
1745 PyObject_GenericGetAttr
,/*tp_getattro*/
1746 PyObject_GenericSetAttr
,/*tp_setattro*/
1748 Py_TPFLAGS_DEFAULT
|Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1749 BZ2Comp__doc__
, /*tp_doc*/
1752 0, /*tp_richcompare*/
1753 0, /*tp_weaklistoffset*/
1756 BZ2Comp_methods
, /*tp_methods*/
1763 0, /*tp_dictoffset*/
1764 (initproc
)BZ2Comp_init
, /*tp_init*/
1765 PyType_GenericAlloc
, /*tp_alloc*/
1766 PyType_GenericNew
, /*tp_new*/
1767 _PyObject_Del
, /*tp_free*/
1772 /* ===================================================================== */
1773 /* Members of BZ2Decomp. */
1776 #define OFF(x) offsetof(BZ2DecompObject, x)
1778 static PyMemberDef BZ2Decomp_members
[] = {
1779 {"unused_data", T_OBJECT
, OFF(unused_data
), RO
},
1780 {NULL
} /* Sentinel */
1784 /* ===================================================================== */
1785 /* Methods of BZ2Decomp. */
1787 PyDoc_STRVAR(BZ2Decomp_decompress__doc__
,
1788 "decompress(data) -> string\n\
1790 Provide more data to the decompressor object. It will return chunks\n\
1791 of decompressed data whenever possible. If you try to decompress data\n\
1792 after the end of stream is found, EOFError will be raised. If any data\n\
1793 was found after the end of stream, it'll be ignored and saved in\n\
1794 unused_data attribute.\n\
1798 BZ2Decomp_decompress(BZ2DecompObject
*self
, PyObject
*args
)
1802 int bufsize
= SMALLCHUNK
;
1803 PY_LONG_LONG totalout
;
1804 PyObject
*ret
= NULL
;
1805 bz_stream
*bzs
= &self
->bzs
;
1808 if (!PyArg_ParseTuple(args
, "s#:decompress", &data
, &datasize
))
1812 if (!self
->running
) {
1813 PyErr_SetString(PyExc_EOFError
, "end of stream was "
1818 ret
= PyString_FromStringAndSize(NULL
, bufsize
);
1822 bzs
->next_in
= data
;
1823 bzs
->avail_in
= datasize
;
1824 bzs
->next_out
= BUF(ret
);
1825 bzs
->avail_out
= bufsize
;
1827 totalout
= BZS_TOTAL_OUT(bzs
);
1830 Py_BEGIN_ALLOW_THREADS
1831 bzerror
= BZ2_bzDecompress(bzs
);
1832 Py_END_ALLOW_THREADS
1833 if (bzerror
== BZ_STREAM_END
) {
1834 if (bzs
->avail_in
!= 0) {
1835 Py_DECREF(self
->unused_data
);
1837 PyString_FromStringAndSize(bzs
->next_in
,
1843 if (bzerror
!= BZ_OK
) {
1844 Util_CatchBZ2Error(bzerror
);
1847 if (bzs
->avail_out
== 0) {
1848 bufsize
= Util_NewBufferSize(bufsize
);
1849 if (_PyString_Resize(&ret
, bufsize
) < 0) {
1850 BZ2_bzDecompressEnd(bzs
);
1853 bzs
->next_out
= BUF(ret
);
1854 bzs
->next_out
= BUF(ret
) + (BZS_TOTAL_OUT(bzs
)
1856 bzs
->avail_out
= bufsize
- (bzs
->next_out
- BUF(ret
));
1857 } else if (bzs
->avail_in
== 0) {
1862 if (bzs
->avail_out
!= 0)
1863 _PyString_Resize(&ret
, (int)(BZS_TOTAL_OUT(bzs
) - totalout
));
1874 static PyMethodDef BZ2Decomp_methods
[] = {
1875 {"decompress", (PyCFunction
)BZ2Decomp_decompress
, METH_VARARGS
, BZ2Decomp_decompress__doc__
},
1876 {NULL
, NULL
} /* sentinel */
1880 /* ===================================================================== */
1881 /* Slot definitions for BZ2Decomp_Type. */
1884 BZ2Decomp_init(BZ2DecompObject
*self
, PyObject
*args
, PyObject
*kwargs
)
1888 if (!PyArg_ParseTuple(args
, ":BZ2Decompressor"))
1892 self
->lock
= PyThread_allocate_lock();
1897 self
->unused_data
= PyString_FromString("");
1898 if (!self
->unused_data
)
1901 memset(&self
->bzs
, 0, sizeof(bz_stream
));
1902 bzerror
= BZ2_bzDecompressInit(&self
->bzs
, 0, 0);
1903 if (bzerror
!= BZ_OK
) {
1904 Util_CatchBZ2Error(bzerror
);
1915 PyThread_free_lock(self
->lock
);
1917 Py_XDECREF(self
->unused_data
);
1922 BZ2Decomp_dealloc(BZ2DecompObject
*self
)
1926 PyThread_free_lock(self
->lock
);
1928 Py_XDECREF(self
->unused_data
);
1929 BZ2_bzDecompressEnd(&self
->bzs
);
1930 self
->ob_type
->tp_free((PyObject
*)self
);
1934 /* ===================================================================== */
1935 /* BZ2Decomp_Type definition. */
1937 PyDoc_STRVAR(BZ2Decomp__doc__
,
1938 "BZ2Decompressor() -> decompressor object\n\
1940 Create a new decompressor object. This object may be used to decompress\n\
1941 data sequentially. If you want to decompress data in one shot, use the\n\
1942 decompress() function instead.\n\
1945 static PyTypeObject BZ2Decomp_Type
= {
1946 PyObject_HEAD_INIT(NULL
)
1948 "bz2.BZ2Decompressor", /*tp_name*/
1949 sizeof(BZ2DecompObject
), /*tp_basicsize*/
1951 (destructor
)BZ2Decomp_dealloc
, /*tp_dealloc*/
1958 0, /*tp_as_sequence*/
1959 0, /*tp_as_mapping*/
1963 PyObject_GenericGetAttr
,/*tp_getattro*/
1964 PyObject_GenericSetAttr
,/*tp_setattro*/
1966 Py_TPFLAGS_DEFAULT
|Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1967 BZ2Decomp__doc__
, /*tp_doc*/
1970 0, /*tp_richcompare*/
1971 0, /*tp_weaklistoffset*/
1974 BZ2Decomp_methods
, /*tp_methods*/
1975 BZ2Decomp_members
, /*tp_members*/
1981 0, /*tp_dictoffset*/
1982 (initproc
)BZ2Decomp_init
, /*tp_init*/
1983 PyType_GenericAlloc
, /*tp_alloc*/
1984 PyType_GenericNew
, /*tp_new*/
1985 _PyObject_Del
, /*tp_free*/
1990 /* ===================================================================== */
1991 /* Module functions. */
1993 PyDoc_STRVAR(bz2_compress__doc__
,
1994 "compress(data [, compresslevel=9]) -> string\n\
1996 Compress data in one shot. If you want to compress data sequentially,\n\
1997 use an instance of BZ2Compressor instead. The compresslevel parameter, if\n\
1998 given, must be a number between 1 and 9.\n\
2002 bz2_compress(PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
2004 int compresslevel
=9;
2008 PyObject
*ret
= NULL
;
2010 bz_stream
*bzs
= &_bzs
;
2012 static char *kwlist
[] = {"data", "compresslevel", 0};
2014 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "s#|i",
2015 kwlist
, &data
, &datasize
,
2019 if (compresslevel
< 1 || compresslevel
> 9) {
2020 PyErr_SetString(PyExc_ValueError
,
2021 "compresslevel must be between 1 and 9");
2025 /* Conforming to bz2 manual, this is large enough to fit compressed
2026 * data in one shot. We will check it later anyway. */
2027 bufsize
= datasize
+ (datasize
/100+1) + 600;
2029 ret
= PyString_FromStringAndSize(NULL
, bufsize
);
2033 memset(bzs
, 0, sizeof(bz_stream
));
2035 bzs
->next_in
= data
;
2036 bzs
->avail_in
= datasize
;
2037 bzs
->next_out
= BUF(ret
);
2038 bzs
->avail_out
= bufsize
;
2040 bzerror
= BZ2_bzCompressInit(bzs
, compresslevel
, 0, 0);
2041 if (bzerror
!= BZ_OK
) {
2042 Util_CatchBZ2Error(bzerror
);
2048 Py_BEGIN_ALLOW_THREADS
2049 bzerror
= BZ2_bzCompress(bzs
, BZ_FINISH
);
2050 Py_END_ALLOW_THREADS
2051 if (bzerror
== BZ_STREAM_END
) {
2053 } else if (bzerror
!= BZ_FINISH_OK
) {
2054 BZ2_bzCompressEnd(bzs
);
2055 Util_CatchBZ2Error(bzerror
);
2059 if (bzs
->avail_out
== 0) {
2060 bufsize
= Util_NewBufferSize(bufsize
);
2061 if (_PyString_Resize(&ret
, bufsize
) < 0) {
2062 BZ2_bzCompressEnd(bzs
);
2066 bzs
->next_out
= BUF(ret
) + BZS_TOTAL_OUT(bzs
);
2067 bzs
->avail_out
= bufsize
- (bzs
->next_out
- BUF(ret
));
2071 if (bzs
->avail_out
!= 0)
2072 _PyString_Resize(&ret
, (int)BZS_TOTAL_OUT(bzs
));
2073 BZ2_bzCompressEnd(bzs
);
2078 PyDoc_STRVAR(bz2_decompress__doc__
,
2079 "decompress(data) -> decompressed data\n\
2081 Decompress data in one shot. If you want to decompress data sequentially,\n\
2082 use an instance of BZ2Decompressor instead.\n\
2086 bz2_decompress(PyObject
*self
, PyObject
*args
)
2090 int bufsize
= SMALLCHUNK
;
2093 bz_stream
*bzs
= &_bzs
;
2096 if (!PyArg_ParseTuple(args
, "s#:decompress", &data
, &datasize
))
2100 return PyString_FromString("");
2102 ret
= PyString_FromStringAndSize(NULL
, bufsize
);
2106 memset(bzs
, 0, sizeof(bz_stream
));
2108 bzs
->next_in
= data
;
2109 bzs
->avail_in
= datasize
;
2110 bzs
->next_out
= BUF(ret
);
2111 bzs
->avail_out
= bufsize
;
2113 bzerror
= BZ2_bzDecompressInit(bzs
, 0, 0);
2114 if (bzerror
!= BZ_OK
) {
2115 Util_CatchBZ2Error(bzerror
);
2121 Py_BEGIN_ALLOW_THREADS
2122 bzerror
= BZ2_bzDecompress(bzs
);
2123 Py_END_ALLOW_THREADS
2124 if (bzerror
== BZ_STREAM_END
) {
2126 } else if (bzerror
!= BZ_OK
) {
2127 BZ2_bzDecompressEnd(bzs
);
2128 Util_CatchBZ2Error(bzerror
);
2132 if (bzs
->avail_out
== 0) {
2133 bufsize
= Util_NewBufferSize(bufsize
);
2134 if (_PyString_Resize(&ret
, bufsize
) < 0) {
2135 BZ2_bzDecompressEnd(bzs
);
2139 bzs
->next_out
= BUF(ret
) + BZS_TOTAL_OUT(bzs
);
2140 bzs
->avail_out
= bufsize
- (bzs
->next_out
- BUF(ret
));
2141 } else if (bzs
->avail_in
== 0) {
2142 BZ2_bzDecompressEnd(bzs
);
2143 PyErr_SetString(PyExc_ValueError
,
2144 "couldn't find end of stream");
2150 if (bzs
->avail_out
!= 0)
2151 _PyString_Resize(&ret
, (int)BZS_TOTAL_OUT(bzs
));
2152 BZ2_bzDecompressEnd(bzs
);
2157 static PyMethodDef bz2_methods
[] = {
2158 {"compress", (PyCFunction
) bz2_compress
, METH_VARARGS
|METH_KEYWORDS
,
2159 bz2_compress__doc__
},
2160 {"decompress", (PyCFunction
) bz2_decompress
, METH_VARARGS
,
2161 bz2_decompress__doc__
},
2162 {NULL
, NULL
} /* sentinel */
2165 /* ===================================================================== */
2166 /* Initialization function. */
2168 PyDoc_STRVAR(bz2__doc__
,
2169 "The python bz2 module provides a comprehensive interface for\n\
2170 the bz2 compression library. It implements a complete file\n\
2171 interface, one shot (de)compression functions, and types for\n\
2172 sequential (de)compression.\n\
2180 BZ2File_Type
.ob_type
= &PyType_Type
;
2181 BZ2Comp_Type
.ob_type
= &PyType_Type
;
2182 BZ2Decomp_Type
.ob_type
= &PyType_Type
;
2184 m
= Py_InitModule3("bz2", bz2_methods
, bz2__doc__
);
2188 PyModule_AddObject(m
, "__author__", PyString_FromString(__author__
));
2190 Py_INCREF(&BZ2File_Type
);
2191 PyModule_AddObject(m
, "BZ2File", (PyObject
*)&BZ2File_Type
);
2193 Py_INCREF(&BZ2Comp_Type
);
2194 PyModule_AddObject(m
, "BZ2Compressor", (PyObject
*)&BZ2Comp_Type
);
2196 Py_INCREF(&BZ2Decomp_Type
);
2197 PyModule_AddObject(m
, "BZ2Decompressor", (PyObject
*)&BZ2Decomp_Type
);