Skip to content
Projeler
Gruplar
Parçacıklar
Yardım
Yükleniyor...
Oturum aç / Kaydol
Gezinmeyi değiştir
C
cpython
Proje
Proje
Ayrıntılar
Etkinlik
Cycle Analytics
Depo (repository)
Depo (repository)
Dosyalar
Kayıtlar (commit)
Dallar (branch)
Etiketler
Katkıda bulunanlar
Grafik
Karşılaştır
Grafikler
Konular (issue)
0
Konular (issue)
0
Liste
Pano
Etiketler
Kilometre Taşları
Birleştirme (merge) Talepleri
0
Birleştirme (merge) Talepleri
0
CI / CD
CI / CD
İş akışları (pipeline)
İşler
Zamanlamalar
Grafikler
Paketler
Paketler
Wiki
Wiki
Parçacıklar
Parçacıklar
Üyeler
Üyeler
Collapse sidebar
Close sidebar
Etkinlik
Grafik
Grafikler
Yeni bir konu (issue) oluştur
İşler
Kayıtlar (commit)
Konu (issue) Panoları
Kenar çubuğunu aç
Batuhan Osman TASKAYA
cpython
Commits
fb221562
Kaydet (Commit)
fb221562
authored
Nis 29, 1997
tarafından
Guido van Rossum
Dosyalara gözat
Seçenekler
Dosyalara Gözat
İndir
Eposta Yamaları
Sade Fark
Added Andrew Kuchling's zlib module.
üst
1818b770
Hide whitespace changes
Inline
Side-by-side
Showing
1 changed file
with
670 additions
and
0 deletions
+670
-0
zlibmodule.c
Modules/zlibmodule.c
+670
-0
No files found.
Modules/zlibmodule.c
0 → 100644
Dosyayı görüntüle @
fb221562
/* zlibmodule.c -- gzip-compatible data compression */
#include <Python.h>
#include <zlib.h>
/* The following parameters are copied from zutil.h, version 0.95 */
#define DEFLATED 8
#if MAX_MEM_LEVEL >= 8
# define DEF_MEM_LEVEL 8
#else
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
#endif
#define DEF_WBITS MAX_WBITS
/* The output buffer will be increased in chunks of ADDCHUNK bytes. */
#define ADDCHUNK 2048
#define PyInit_zlib initzlib
staticforward
PyTypeObject
Comptype
;
staticforward
PyTypeObject
Decomptype
;
static
PyObject
*
ZlibError
;
typedef
struct
{
PyObject_HEAD
z_stream
zst
;
}
compobject
;
static
compobject
*
newcompobject
(
type
)
PyTypeObject
*
type
;
{
compobject
*
self
;
self
=
PyObject_NEW
(
compobject
,
type
);
if
(
self
==
NULL
)
return
NULL
;
return
self
;
}
static
PyObject
*
PyZlib_compress
(
self
,
args
)
PyObject
*
self
;
PyObject
*
args
;
{
PyObject
*
ReturnVal
;
Byte
*
input
,
*
output
;
int
length
,
level
=
Z_DEFAULT_COMPRESSION
,
err
;
z_stream
zst
;
if
(
!
PyArg_ParseTuple
(
args
,
"s#|i"
,
&
input
,
&
length
,
&
level
))
return
NULL
;
zst
.
avail_out
=
length
+
length
/
1000
+
12
+
1
;
output
=
(
Byte
*
)
malloc
(
zst
.
avail_out
);
if
(
output
==
NULL
)
{
PyErr_SetString
(
PyExc_MemoryError
,
"Can't allocate memory to compress data"
);
return
NULL
;
}
zst
.
zalloc
=
(
alloc_func
)
zst
.
zfree
=
(
free_func
)
Z_NULL
;
zst
.
next_out
=
(
Byte
*
)
output
;
zst
.
next_in
=
(
Byte
*
)
input
;
zst
.
avail_in
=
length
;
err
=
deflateInit
(
&
zst
,
level
);
switch
(
err
)
{
case
(
Z_OK
):
break
;
case
(
Z_MEM_ERROR
):
PyErr_SetString
(
PyExc_MemoryError
,
"Out of memory while compressing data"
);
free
(
output
);
return
NULL
;
break
;
case
(
Z_STREAM_ERROR
):
PyErr_SetString
(
ZlibError
,
"Bad compression level"
);
free
(
output
);
return
NULL
;
break
;
default
:
{
char
temp
[
500
];
if
(
zst
.
msg
==
Z_NULL
)
zst
.
msg
=
""
;
sprintf
(
temp
,
"Error %i while compressing data [%s]"
,
err
,
zst
.
msg
);
PyErr_SetString
(
ZlibError
,
temp
);
deflateEnd
(
&
zst
);
free
(
output
);
return
NULL
;
}
break
;
}
err
=
deflate
(
&
zst
,
Z_FINISH
);
switch
(
err
)
{
case
(
Z_STREAM_END
):
break
;
/* Are there other errors to be trapped here? */
default
:
{
char
temp
[
500
];
if
(
zst
.
msg
==
Z_NULL
)
zst
.
msg
=
""
;
sprintf
(
temp
,
"Error %i while compressing data [%s]"
,
err
,
zst
.
msg
);
PyErr_SetString
(
ZlibError
,
temp
);
deflateEnd
(
&
zst
);
free
(
output
);
return
NULL
;
}
}
err
=
deflateEnd
(
&
zst
);
if
(
err
!=
Z_OK
)
{
char
temp
[
500
];
if
(
zst
.
msg
==
Z_NULL
)
zst
.
msg
=
""
;
sprintf
(
temp
,
"Error %i while finishing data compression [%s]"
,
err
,
zst
.
msg
);
PyErr_SetString
(
ZlibError
,
temp
);
free
(
output
);
return
NULL
;
}
ReturnVal
=
PyString_FromStringAndSize
(
output
,
zst
.
total_out
);
free
(
output
);
return
ReturnVal
;
}
static
PyObject
*
PyZlib_decompress
(
self
,
args
)
PyObject
*
self
;
PyObject
*
args
;
{
PyObject
*
ReturnVal
;
Byte
*
input
,
*
output
;
int
length
,
err
;
z_stream
zst
;
if
(
!
PyArg_ParseTuple
(
args
,
"s#"
,
&
input
,
&
length
))
return
NULL
;
zst
.
avail_in
=
length
;
zst
.
avail_out
=
length
=
length
*
2
;
output
=
(
Byte
*
)
malloc
(
zst
.
avail_out
);
if
(
output
==
NULL
)
{
PyErr_SetString
(
PyExc_MemoryError
,
"Can't allocate memory to decompress data"
);
return
NULL
;
}
zst
.
zalloc
=
(
alloc_func
)
zst
.
zfree
=
(
free_func
)
Z_NULL
;
zst
.
next_out
=
(
Byte
*
)
output
;
zst
.
next_in
=
(
Byte
*
)
input
;
err
=
inflateInit
(
&
zst
);
switch
(
err
)
{
case
(
Z_OK
):
break
;
case
(
Z_MEM_ERROR
):
PyErr_SetString
(
PyExc_MemoryError
,
"Out of memory while decompressing data"
);
free
(
output
);
return
NULL
;
default
:
{
char
temp
[
500
];
if
(
zst
.
msg
==
Z_NULL
)
zst
.
msg
=
""
;
sprintf
(
temp
,
"Error %i while preparing to decompress data [%s]"
,
err
,
zst
.
msg
);
PyErr_SetString
(
ZlibError
,
temp
);
inflateEnd
(
&
zst
);
free
(
output
);
return
NULL
;
}
}
do
{
err
=
inflate
(
&
zst
,
Z_FINISH
);
switch
(
err
)
{
case
(
Z_OK
):
case
(
Z_STREAM_END
):
output
=
(
Byte
*
)
realloc
(
output
,
length
+
ADDCHUNK
);
if
(
output
==
NULL
)
{
PyErr_SetString
(
PyExc_MemoryError
,
"Out of memory while decompressing data"
);
inflateEnd
(
&
zst
);
return
NULL
;
}
zst
.
next_out
=
output
+
length
;
zst
.
avail_out
=
ADDCHUNK
;
length
+=
ADDCHUNK
;
break
;
default
:
{
char
temp
[
500
];
if
(
zst
.
msg
==
Z_NULL
)
zst
.
msg
=
""
;
sprintf
(
temp
,
"Error %i while decompressing data: [%s]"
,
err
,
zst
.
msg
);
PyErr_SetString
(
ZlibError
,
temp
);
inflateEnd
(
&
zst
);
return
NULL
;
}
}
}
while
(
err
!=
Z_STREAM_END
);
err
=
inflateEnd
(
&
zst
);
if
(
err
!=
Z_OK
)
{
char
temp
[
500
];
if
(
zst
.
msg
==
Z_NULL
)
zst
.
msg
=
""
;
sprintf
(
temp
,
"Error %i while finishing data decompression [%s]"
,
err
,
zst
.
msg
);
PyErr_SetString
(
ZlibError
,
temp
);
free
(
output
);
return
NULL
;
}
ReturnVal
=
PyString_FromStringAndSize
(
output
,
zst
.
total_out
);
free
(
output
);
return
ReturnVal
;
}
static
PyObject
*
PyZlib_compressobj
(
selfptr
,
args
)
PyObject
*
selfptr
;
PyObject
*
args
;
{
compobject
*
self
;
int
level
=
Z_DEFAULT_COMPRESSION
,
method
=
DEFLATED
;
int
wbits
=
MAX_WBITS
,
memLevel
=
DEF_MEM_LEVEL
,
strategy
=
0
,
err
;
/* XXX Argh! Is there a better way to have multiple levels of */
/* optional arguments? */
if
(
!
PyArg_ParseTuple
(
args
,
"iiiii"
,
&
level
,
&
method
,
&
wbits
,
&
memLevel
,
&
strategy
))
{
PyErr_Clear
();
if
(
!
PyArg_ParseTuple
(
args
,
"iiii"
,
&
level
,
&
method
,
&
wbits
,
&
memLevel
))
{
PyErr_Clear
();
if
(
!
PyArg_ParseTuple
(
args
,
"iii"
,
&
level
,
&
method
,
&
wbits
))
{
PyErr_Clear
();
if
(
!
PyArg_ParseTuple
(
args
,
"ii"
,
&
level
,
&
method
))
{
PyErr_Clear
();
if
(
!
PyArg_ParseTuple
(
args
,
"i"
,
&
level
))
{
PyErr_Clear
();
if
(
!
PyArg_ParseTuple
(
args
,
""
))
return
(
NULL
);
}
}
}
}
}
self
=
newcompobject
(
&
Comptype
);
if
(
self
==
NULL
)
return
(
NULL
);
self
->
zst
.
zalloc
=
(
alloc_func
)
self
->
zst
.
zfree
=
(
free_func
)
Z_NULL
;
err
=
deflateInit2
(
&
self
->
zst
,
level
,
method
,
wbits
,
memLevel
,
strategy
);
switch
(
err
)
{
case
(
Z_OK
):
return
(
PyObject
*
)
self
;
break
;
case
(
Z_MEM_ERROR
):
PyErr_SetString
(
PyExc_MemoryError
,
"Can't allocate memory for compression object"
);
return
NULL
;
break
;
case
(
Z_STREAM_ERROR
):
PyErr_SetString
(
PyExc_ValueError
,
"Invalid compression level"
);
return
NULL
;
break
;
default
:
{
char
temp
[
500
];
if
(
self
->
zst
.
msg
==
Z_NULL
)
self
->
zst
.
msg
=
""
;
sprintf
(
temp
,
"Error %i while creating compression object [%s]"
,
err
,
self
->
zst
.
msg
);
PyErr_SetString
(
ZlibError
,
temp
);
return
NULL
;
break
;
}
}
}
static
PyObject
*
PyZlib_decompressobj
(
selfptr
,
args
)
PyObject
*
selfptr
;
PyObject
*
args
;
{
int
wbits
=
DEF_WBITS
,
err
;
compobject
*
self
;
if
(
!
PyArg_ParseTuple
(
args
,
"|i"
,
&
wbits
))
{
return
NULL
;
}
self
=
newcompobject
(
&
Decomptype
);
if
(
self
==
NULL
)
return
(
NULL
);
self
->
zst
.
zalloc
=
(
alloc_func
)
self
->
zst
.
zfree
=
(
free_func
)
Z_NULL
;
/* XXX If illegal values of wbits are allowed to get here, Python
coredumps, instead of raising an exception as it should.
This is a bug in zlib 0.95; I have reported it. */
err
=
inflateInit2
(
&
self
->
zst
,
wbits
);
switch
(
err
)
{
case
(
Z_OK
):
return
(
PyObject
*
)
self
;
break
;
case
(
Z_MEM_ERROR
):
PyErr_SetString
(
PyExc_MemoryError
,
"Can't allocate memory for decompression object"
);
return
NULL
;
break
;
default
:
{
char
temp
[
500
];
if
(
self
->
zst
.
msg
==
Z_NULL
)
self
->
zst
.
msg
=
""
;
sprintf
(
temp
,
"Error %i while creating decompression object [%s]"
,
err
,
self
->
zst
.
msg
);
PyErr_SetString
(
ZlibError
,
temp
);
return
NULL
;
break
;
}
}
}
static
void
Comp_dealloc
(
self
)
compobject
*
self
;
{
int
err
;
err
=
deflateEnd
(
&
self
->
zst
);
/* Deallocate zstream structure */
}
static
void
Decomp_dealloc
(
self
)
compobject
*
self
;
{
int
err
;
err
=
inflateEnd
(
&
self
->
zst
);
/* Deallocate zstream structure */
}
static
PyObject
*
PyZlib_objcompress
(
self
,
args
)
compobject
*
self
;
PyObject
*
args
;
{
int
length
=
0
,
err
,
inplen
;
Byte
*
buf
=
NULL
;
PyObject
*
RetVal
;
Byte
*
input
;
if
(
!
PyArg_ParseTuple
(
args
,
"s#"
,
&
input
,
&
inplen
))
return
NULL
;
self
->
zst
.
avail_in
=
inplen
;
self
->
zst
.
next_in
=
input
;
do
{
buf
=
(
Byte
*
)
realloc
(
buf
,
length
+
ADDCHUNK
);
if
(
buf
==
NULL
)
{
PyErr_SetString
(
PyExc_MemoryError
,
"Can't allocate memory to compress data"
);
return
NULL
;
}
self
->
zst
.
next_out
=
buf
+
length
;
self
->
zst
.
avail_out
=
ADDCHUNK
;
length
+=
ADDCHUNK
;
err
=
deflate
(
&
(
self
->
zst
),
Z_NO_FLUSH
);
}
while
(
self
->
zst
.
avail_in
!=
0
&&
err
==
Z_OK
);
if
(
err
!=
Z_OK
)
{
char
temp
[
500
];
if
(
self
->
zst
.
msg
==
Z_NULL
)
self
->
zst
.
msg
=
""
;
sprintf
(
temp
,
"Error %i while compressing [%s]"
,
err
,
self
->
zst
.
msg
);
PyErr_SetString
(
ZlibError
,
temp
);
return
NULL
;
}
RetVal
=
PyString_FromStringAndSize
(
buf
,
self
->
zst
.
next_out
-
buf
);
free
(
buf
);
return
RetVal
;
}
static
PyObject
*
PyZlib_objdecompress
(
self
,
args
)
compobject
*
self
;
PyObject
*
args
;
{
int
length
=
0
,
err
,
inplen
;
Byte
*
buf
=
NULL
;
PyObject
*
RetVal
;
Byte
*
input
;
if
(
!
PyArg_ParseTuple
(
args
,
"s#"
,
&
input
,
&
inplen
))
return
NULL
;
self
->
zst
.
avail_in
=
inplen
;
self
->
zst
.
next_in
=
input
;
do
{
buf
=
(
Byte
*
)
realloc
(
buf
,
length
+
ADDCHUNK
);
if
(
buf
==
NULL
)
{
PyErr_SetString
(
PyExc_MemoryError
,
"Can't allocate memory to decompress data"
);
return
NULL
;
}
self
->
zst
.
next_out
=
buf
+
length
;
self
->
zst
.
avail_out
=
ADDCHUNK
;
length
+=
ADDCHUNK
;
err
=
inflate
(
&
(
self
->
zst
),
Z_NO_FLUSH
);
}
while
(
self
->
zst
.
avail_in
!=
0
&&
err
==
Z_OK
);
if
(
err
!=
Z_OK
&&
err
!=
Z_STREAM_END
)
{
char
temp
[
500
];
if
(
self
->
zst
.
msg
==
Z_NULL
)
self
->
zst
.
msg
=
""
;
sprintf
(
temp
,
"Error %i while decompressing [%s]"
,
err
,
self
->
zst
.
msg
);
PyErr_SetString
(
ZlibError
,
temp
);
return
NULL
;
}
RetVal
=
PyString_FromStringAndSize
(
buf
,
self
->
zst
.
next_out
-
buf
);
free
(
buf
);
return
RetVal
;
}
static
PyObject
*
PyZlib_flush
(
self
,
args
)
compobject
*
self
;
PyObject
*
args
;
{
int
length
=
0
,
err
;
Byte
*
buf
=
NULL
;
PyObject
*
RetVal
;
if
(
!
PyArg_NoArgs
(
args
))
return
NULL
;
self
->
zst
.
avail_in
=
0
;
do
{
buf
=
(
Byte
*
)
realloc
(
buf
,
length
+
ADDCHUNK
);
if
(
buf
==
NULL
)
{
PyErr_SetString
(
PyExc_MemoryError
,
"Can't allocate memory to compress data"
);
return
NULL
;
}
self
->
zst
.
next_out
=
buf
+
length
;
self
->
zst
.
avail_out
=
ADDCHUNK
;
length
+=
ADDCHUNK
;
err
=
deflate
(
&
(
self
->
zst
),
Z_FINISH
);
}
while
(
err
==
Z_OK
);
if
(
err
!=
Z_STREAM_END
)
{
char
temp
[
500
];
if
(
self
->
zst
.
msg
==
Z_NULL
)
self
->
zst
.
msg
=
""
;
sprintf
(
temp
,
"Error %i while compressing [%s]"
,
err
,
self
->
zst
.
msg
);
PyErr_SetString
(
ZlibError
,
temp
);
return
NULL
;
}
RetVal
=
PyString_FromStringAndSize
(
buf
,
self
->
zst
.
next_out
-
buf
);
free
(
buf
);
err
=
deflateEnd
(
&
(
self
->
zst
));
if
(
err
!=
Z_OK
)
{
char
temp
[
500
];
if
(
self
->
zst
.
msg
==
Z_NULL
)
self
->
zst
.
msg
=
""
;
sprintf
(
temp
,
"Error %i while flushing compression object [%s]"
,
err
,
self
->
zst
.
msg
);
PyErr_SetString
(
ZlibError
,
temp
);
return
NULL
;
}
return
RetVal
;
}
static
PyObject
*
PyZlib_unflush
(
self
,
args
)
compobject
*
self
;
PyObject
*
args
;
{
int
length
=
0
,
err
;
Byte
*
buf
=
NULL
;
PyObject
*
RetVal
;
if
(
!
PyArg_NoArgs
(
args
))
return
NULL
;
self
->
zst
.
avail_in
=
0
;
do
{
buf
=
(
Byte
*
)
realloc
(
buf
,
length
+
ADDCHUNK
);
if
(
buf
==
NULL
)
{
PyErr_SetString
(
PyExc_MemoryError
,
"Can't allocate memory to decompress data"
);
return
NULL
;
}
self
->
zst
.
next_out
=
buf
+
length
;
length
+=
ADDCHUNK
;
err
=
inflate
(
&
(
self
->
zst
),
Z_FINISH
);
}
while
(
err
==
Z_OK
);
if
(
err
!=
Z_STREAM_END
)
{
char
temp
[
500
];
if
(
self
->
zst
.
msg
==
Z_NULL
)
self
->
zst
.
msg
=
""
;
sprintf
(
temp
,
"Error %i while decompressing [%s]"
,
err
,
self
->
zst
.
msg
);
PyErr_SetString
(
ZlibError
,
temp
);
return
NULL
;
}
RetVal
=
PyString_FromStringAndSize
(
buf
,
self
->
zst
.
next_out
-
buf
);
free
(
buf
);
err
=
inflateEnd
(
&
(
self
->
zst
));
if
(
err
!=
Z_OK
)
{
char
temp
[
500
];
if
(
self
->
zst
.
msg
==
Z_NULL
)
self
->
zst
.
msg
=
""
;
sprintf
(
temp
,
"Error %i while flushing decompression object [%s]"
,
err
,
self
->
zst
.
msg
);
PyErr_SetString
(
ZlibError
,
temp
);
return
NULL
;
}
return
RetVal
;
}
static
PyMethodDef
comp_methods
[]
=
{
{
"compress"
,
PyZlib_objcompress
,
1
},
{
"flush"
,
PyZlib_flush
,
0
},
{
NULL
,
NULL
}
};
static
PyMethodDef
Decomp_methods
[]
=
{
{
"decompress"
,
PyZlib_objdecompress
,
1
},
{
"flush"
,
PyZlib_unflush
,
0
},
{
NULL
,
NULL
}
};
static
PyObject
*
Comp_getattr
(
self
,
name
)
compobject
*
self
;
char
*
name
;
{
return
Py_FindMethod
(
comp_methods
,
(
PyObject
*
)
self
,
name
);
}
static
PyObject
*
Decomp_getattr
(
self
,
name
)
compobject
*
self
;
char
*
name
;
{
return
Py_FindMethod
(
Decomp_methods
,
(
PyObject
*
)
self
,
name
);
}
static
PyObject
*
PyZlib_adler32
(
self
,
args
)
PyObject
*
self
,
*
args
;
{
uLong
adler32val
=
adler32
(
0L
,
Z_NULL
,
0
);
Byte
*
buf
;
int
len
;
if
(
!
PyArg_ParseTuple
(
args
,
"s#|l"
,
&
buf
,
&
len
,
&
adler32val
))
{
return
NULL
;
}
adler32val
=
adler32
(
adler32val
,
buf
,
len
);
return
Py_BuildValue
(
"l"
,
adler32val
);
}
static
PyObject
*
PyZlib_crc32
(
self
,
args
)
PyObject
*
self
,
*
args
;
{
uLong
crc32val
=
crc32
(
0L
,
Z_NULL
,
0
);
Byte
*
buf
;
int
len
;
if
(
!
PyArg_ParseTuple
(
args
,
"s#|l"
,
&
buf
,
&
len
,
&
crc32val
))
{
return
NULL
;
}
crc32val
=
crc32
(
crc32val
,
buf
,
len
);
return
Py_BuildValue
(
"l"
,
crc32val
);
}
static
PyMethodDef
zlib_methods
[]
=
{
{
"adler32"
,
PyZlib_adler32
,
1
},
{
"compress"
,
PyZlib_compress
,
1
},
{
"compressobj"
,
PyZlib_compressobj
,
1
},
{
"crc32"
,
PyZlib_crc32
,
1
},
{
"decompress"
,
PyZlib_decompress
,
1
},
{
"decompressobj"
,
PyZlib_decompressobj
,
1
},
{
NULL
,
NULL
}
};
statichere
PyTypeObject
Comptype
=
{
PyObject_HEAD_INIT
(
&
PyType_Type
)
0
,
"Compress"
,
sizeof
(
compobject
),
0
,
(
destructor
)
Comp_dealloc
,
/*tp_dealloc*/
0
,
/*tp_print*/
(
getattrfunc
)
Comp_getattr
,
/*tp_getattr*/
0
,
/*tp_setattr*/
0
,
/*tp_compare*/
0
,
/*tp_repr*/
0
,
/*tp_as_number*/
0
,
/*tp_as_sequence*/
0
,
/*tp_as_mapping*/
};
statichere
PyTypeObject
Decomptype
=
{
PyObject_HEAD_INIT
(
&
PyType_Type
)
0
,
"Decompress"
,
sizeof
(
compobject
),
0
,
(
destructor
)
Decomp_dealloc
,
/*tp_dealloc*/
0
,
/*tp_print*/
(
getattrfunc
)
Decomp_getattr
,
/*tp_getattr*/
0
,
/*tp_setattr*/
0
,
/*tp_compare*/
0
,
/*tp_repr*/
0
,
/*tp_as_number*/
0
,
/*tp_as_sequence*/
0
,
/*tp_as_mapping*/
};
/* The following insint() routine was blatantly ripped off from
socketmodule.c */
/* Convenience routine to export an integer value.
For simplicity, errors (which are unlikely anyway) are ignored. */
static
void
insint
(
d
,
name
,
value
)
PyObject
*
d
;
char
*
name
;
int
value
;
{
PyObject
*
v
=
PyInt_FromLong
((
long
)
value
);
if
(
v
==
NULL
)
{
/* Don't bother reporting this error */
PyErr_Clear
();
}
else
{
PyDict_SetItemString
(
d
,
name
,
v
);
Py_DECREF
(
v
);
}
}
void
PyInit_zlib
()
{
PyObject
*
m
,
*
d
;
m
=
Py_InitModule
(
"zlib"
,
zlib_methods
);
d
=
PyModule_GetDict
(
m
);
ZlibError
=
Py_BuildValue
(
"s"
,
"zlib.error"
);
PyDict_SetItemString
(
d
,
"error"
,
ZlibError
);
insint
(
d
,
"MAX_WBITS"
,
MAX_WBITS
);
insint
(
d
,
"DEFLATED"
,
DEFLATED
);
insint
(
d
,
"DEF_MEM_LEVEL"
,
DEF_MEM_LEVEL
);
if
(
PyErr_Occurred
())
Py_FatalError
(
"can't initialize module zlib"
);
}
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment