Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
6 : : # include "pycore_gc.h" // PyGC_Head
7 : : # include "pycore_runtime.h" // _Py_ID()
8 : : #endif
9 : :
10 : :
11 : : PyDoc_STRVAR(zlib_compress__doc__,
12 : : "compress($module, data, /, level=Z_DEFAULT_COMPRESSION, wbits=MAX_WBITS)\n"
13 : : "--\n"
14 : : "\n"
15 : : "Returns a bytes object containing compressed data.\n"
16 : : "\n"
17 : : " data\n"
18 : : " Binary data to be compressed.\n"
19 : : " level\n"
20 : : " Compression level, in 0-9 or -1.\n"
21 : : " wbits\n"
22 : : " The window buffer size and container format.");
23 : :
24 : : #define ZLIB_COMPRESS_METHODDEF \
25 : : {"compress", _PyCFunction_CAST(zlib_compress), METH_FASTCALL|METH_KEYWORDS, zlib_compress__doc__},
26 : :
27 : : static PyObject *
28 : : zlib_compress_impl(PyObject *module, Py_buffer *data, int level, int wbits);
29 : :
30 : : static PyObject *
31 : 0 : zlib_compress(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
32 : : {
33 : 0 : PyObject *return_value = NULL;
34 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
35 : :
36 : : #define NUM_KEYWORDS 2
37 : : static struct {
38 : : PyGC_Head _this_is_not_used;
39 : : PyObject_VAR_HEAD
40 : : PyObject *ob_item[NUM_KEYWORDS];
41 : : } _kwtuple = {
42 : : .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
43 : : .ob_item = { &_Py_ID(level), &_Py_ID(wbits), },
44 : : };
45 : : #undef NUM_KEYWORDS
46 : : #define KWTUPLE (&_kwtuple.ob_base.ob_base)
47 : :
48 : : #else // !Py_BUILD_CORE
49 : : # define KWTUPLE NULL
50 : : #endif // !Py_BUILD_CORE
51 : :
52 : : static const char * const _keywords[] = {"", "level", "wbits", NULL};
53 : : static _PyArg_Parser _parser = {
54 : : .keywords = _keywords,
55 : : .fname = "compress",
56 : : .kwtuple = KWTUPLE,
57 : : };
58 : : #undef KWTUPLE
59 : : PyObject *argsbuf[3];
60 [ # # ]: 0 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
61 : 0 : Py_buffer data = {NULL, NULL};
62 : 0 : int level = Z_DEFAULT_COMPRESSION;
63 : 0 : int wbits = MAX_WBITS;
64 : :
65 [ # # # # : 0 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
# # # # ]
66 [ # # ]: 0 : if (!args) {
67 : 0 : goto exit;
68 : : }
69 [ # # ]: 0 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
70 : 0 : goto exit;
71 : : }
72 [ # # ]: 0 : if (!PyBuffer_IsContiguous(&data, 'C')) {
73 : 0 : _PyArg_BadArgument("compress", "argument 1", "contiguous buffer", args[0]);
74 : 0 : goto exit;
75 : : }
76 [ # # ]: 0 : if (!noptargs) {
77 : 0 : goto skip_optional_pos;
78 : : }
79 [ # # ]: 0 : if (args[1]) {
80 : 0 : level = _PyLong_AsInt(args[1]);
81 [ # # # # ]: 0 : if (level == -1 && PyErr_Occurred()) {
82 : 0 : goto exit;
83 : : }
84 [ # # ]: 0 : if (!--noptargs) {
85 : 0 : goto skip_optional_pos;
86 : : }
87 : : }
88 : 0 : wbits = _PyLong_AsInt(args[2]);
89 [ # # # # ]: 0 : if (wbits == -1 && PyErr_Occurred()) {
90 : 0 : goto exit;
91 : : }
92 : 0 : skip_optional_pos:
93 : 0 : return_value = zlib_compress_impl(module, &data, level, wbits);
94 : :
95 : 0 : exit:
96 : : /* Cleanup for data */
97 [ # # ]: 0 : if (data.obj) {
98 : 0 : PyBuffer_Release(&data);
99 : : }
100 : :
101 : 0 : return return_value;
102 : : }
103 : :
104 : : PyDoc_STRVAR(zlib_decompress__doc__,
105 : : "decompress($module, data, /, wbits=MAX_WBITS, bufsize=DEF_BUF_SIZE)\n"
106 : : "--\n"
107 : : "\n"
108 : : "Returns a bytes object containing the uncompressed data.\n"
109 : : "\n"
110 : : " data\n"
111 : : " Compressed data.\n"
112 : : " wbits\n"
113 : : " The window buffer size and container format.\n"
114 : : " bufsize\n"
115 : : " The initial output buffer size.");
116 : :
117 : : #define ZLIB_DECOMPRESS_METHODDEF \
118 : : {"decompress", _PyCFunction_CAST(zlib_decompress), METH_FASTCALL|METH_KEYWORDS, zlib_decompress__doc__},
119 : :
120 : : static PyObject *
121 : : zlib_decompress_impl(PyObject *module, Py_buffer *data, int wbits,
122 : : Py_ssize_t bufsize);
123 : :
124 : : static PyObject *
125 : 0 : zlib_decompress(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
126 : : {
127 : 0 : PyObject *return_value = NULL;
128 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
129 : :
130 : : #define NUM_KEYWORDS 2
131 : : static struct {
132 : : PyGC_Head _this_is_not_used;
133 : : PyObject_VAR_HEAD
134 : : PyObject *ob_item[NUM_KEYWORDS];
135 : : } _kwtuple = {
136 : : .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
137 : : .ob_item = { &_Py_ID(wbits), &_Py_ID(bufsize), },
138 : : };
139 : : #undef NUM_KEYWORDS
140 : : #define KWTUPLE (&_kwtuple.ob_base.ob_base)
141 : :
142 : : #else // !Py_BUILD_CORE
143 : : # define KWTUPLE NULL
144 : : #endif // !Py_BUILD_CORE
145 : :
146 : : static const char * const _keywords[] = {"", "wbits", "bufsize", NULL};
147 : : static _PyArg_Parser _parser = {
148 : : .keywords = _keywords,
149 : : .fname = "decompress",
150 : : .kwtuple = KWTUPLE,
151 : : };
152 : : #undef KWTUPLE
153 : : PyObject *argsbuf[3];
154 [ # # ]: 0 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
155 : 0 : Py_buffer data = {NULL, NULL};
156 : 0 : int wbits = MAX_WBITS;
157 : 0 : Py_ssize_t bufsize = DEF_BUF_SIZE;
158 : :
159 [ # # # # : 0 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
# # # # ]
160 [ # # ]: 0 : if (!args) {
161 : 0 : goto exit;
162 : : }
163 [ # # ]: 0 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
164 : 0 : goto exit;
165 : : }
166 [ # # ]: 0 : if (!PyBuffer_IsContiguous(&data, 'C')) {
167 : 0 : _PyArg_BadArgument("decompress", "argument 1", "contiguous buffer", args[0]);
168 : 0 : goto exit;
169 : : }
170 [ # # ]: 0 : if (!noptargs) {
171 : 0 : goto skip_optional_pos;
172 : : }
173 [ # # ]: 0 : if (args[1]) {
174 : 0 : wbits = _PyLong_AsInt(args[1]);
175 [ # # # # ]: 0 : if (wbits == -1 && PyErr_Occurred()) {
176 : 0 : goto exit;
177 : : }
178 [ # # ]: 0 : if (!--noptargs) {
179 : 0 : goto skip_optional_pos;
180 : : }
181 : : }
182 : : {
183 : 0 : Py_ssize_t ival = -1;
184 : 0 : PyObject *iobj = _PyNumber_Index(args[2]);
185 [ # # ]: 0 : if (iobj != NULL) {
186 : 0 : ival = PyLong_AsSsize_t(iobj);
187 : 0 : Py_DECREF(iobj);
188 : : }
189 [ # # # # ]: 0 : if (ival == -1 && PyErr_Occurred()) {
190 : 0 : goto exit;
191 : : }
192 : 0 : bufsize = ival;
193 : : }
194 : 0 : skip_optional_pos:
195 : 0 : return_value = zlib_decompress_impl(module, &data, wbits, bufsize);
196 : :
197 : 0 : exit:
198 : : /* Cleanup for data */
199 [ # # ]: 0 : if (data.obj) {
200 : 0 : PyBuffer_Release(&data);
201 : : }
202 : :
203 : 0 : return return_value;
204 : : }
205 : :
206 : : PyDoc_STRVAR(zlib_compressobj__doc__,
207 : : "compressobj($module, /, level=Z_DEFAULT_COMPRESSION, method=DEFLATED,\n"
208 : : " wbits=MAX_WBITS, memLevel=DEF_MEM_LEVEL,\n"
209 : : " strategy=Z_DEFAULT_STRATEGY, zdict=None)\n"
210 : : "--\n"
211 : : "\n"
212 : : "Return a compressor object.\n"
213 : : "\n"
214 : : " level\n"
215 : : " The compression level (an integer in the range 0-9 or -1; default is\n"
216 : : " currently equivalent to 6). Higher compression levels are slower,\n"
217 : : " but produce smaller results.\n"
218 : : " method\n"
219 : : " The compression algorithm. If given, this must be DEFLATED.\n"
220 : : " wbits\n"
221 : : " +9 to +15: The base-two logarithm of the window size. Include a zlib\n"
222 : : " container.\n"
223 : : " -9 to -15: Generate a raw stream.\n"
224 : : " +25 to +31: Include a gzip container.\n"
225 : : " memLevel\n"
226 : : " Controls the amount of memory used for internal compression state.\n"
227 : : " Valid values range from 1 to 9. Higher values result in higher memory\n"
228 : : " usage, faster compression, and smaller output.\n"
229 : : " strategy\n"
230 : : " Used to tune the compression algorithm. Possible values are\n"
231 : : " Z_DEFAULT_STRATEGY, Z_FILTERED, and Z_HUFFMAN_ONLY.\n"
232 : : " zdict\n"
233 : : " The predefined compression dictionary - a sequence of bytes\n"
234 : : " containing subsequences that are likely to occur in the input data.");
235 : :
236 : : #define ZLIB_COMPRESSOBJ_METHODDEF \
237 : : {"compressobj", _PyCFunction_CAST(zlib_compressobj), METH_FASTCALL|METH_KEYWORDS, zlib_compressobj__doc__},
238 : :
239 : : static PyObject *
240 : : zlib_compressobj_impl(PyObject *module, int level, int method, int wbits,
241 : : int memLevel, int strategy, Py_buffer *zdict);
242 : :
243 : : static PyObject *
244 : 0 : zlib_compressobj(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
245 : : {
246 : 0 : PyObject *return_value = NULL;
247 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
248 : :
249 : : #define NUM_KEYWORDS 6
250 : : static struct {
251 : : PyGC_Head _this_is_not_used;
252 : : PyObject_VAR_HEAD
253 : : PyObject *ob_item[NUM_KEYWORDS];
254 : : } _kwtuple = {
255 : : .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
256 : : .ob_item = { &_Py_ID(level), &_Py_ID(method), &_Py_ID(wbits), &_Py_ID(memLevel), &_Py_ID(strategy), &_Py_ID(zdict), },
257 : : };
258 : : #undef NUM_KEYWORDS
259 : : #define KWTUPLE (&_kwtuple.ob_base.ob_base)
260 : :
261 : : #else // !Py_BUILD_CORE
262 : : # define KWTUPLE NULL
263 : : #endif // !Py_BUILD_CORE
264 : :
265 : : static const char * const _keywords[] = {"level", "method", "wbits", "memLevel", "strategy", "zdict", NULL};
266 : : static _PyArg_Parser _parser = {
267 : : .keywords = _keywords,
268 : : .fname = "compressobj",
269 : : .kwtuple = KWTUPLE,
270 : : };
271 : : #undef KWTUPLE
272 : : PyObject *argsbuf[6];
273 [ # # ]: 0 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
274 : 0 : int level = Z_DEFAULT_COMPRESSION;
275 : 0 : int method = DEFLATED;
276 : 0 : int wbits = MAX_WBITS;
277 : 0 : int memLevel = DEF_MEM_LEVEL;
278 : 0 : int strategy = Z_DEFAULT_STRATEGY;
279 : 0 : Py_buffer zdict = {NULL, NULL};
280 : :
281 [ # # # # : 0 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 6, 0, argsbuf);
# # # # ]
282 [ # # ]: 0 : if (!args) {
283 : 0 : goto exit;
284 : : }
285 [ # # ]: 0 : if (!noptargs) {
286 : 0 : goto skip_optional_pos;
287 : : }
288 [ # # ]: 0 : if (args[0]) {
289 : 0 : level = _PyLong_AsInt(args[0]);
290 [ # # # # ]: 0 : if (level == -1 && PyErr_Occurred()) {
291 : 0 : goto exit;
292 : : }
293 [ # # ]: 0 : if (!--noptargs) {
294 : 0 : goto skip_optional_pos;
295 : : }
296 : : }
297 [ # # ]: 0 : if (args[1]) {
298 : 0 : method = _PyLong_AsInt(args[1]);
299 [ # # # # ]: 0 : if (method == -1 && PyErr_Occurred()) {
300 : 0 : goto exit;
301 : : }
302 [ # # ]: 0 : if (!--noptargs) {
303 : 0 : goto skip_optional_pos;
304 : : }
305 : : }
306 [ # # ]: 0 : if (args[2]) {
307 : 0 : wbits = _PyLong_AsInt(args[2]);
308 [ # # # # ]: 0 : if (wbits == -1 && PyErr_Occurred()) {
309 : 0 : goto exit;
310 : : }
311 [ # # ]: 0 : if (!--noptargs) {
312 : 0 : goto skip_optional_pos;
313 : : }
314 : : }
315 [ # # ]: 0 : if (args[3]) {
316 : 0 : memLevel = _PyLong_AsInt(args[3]);
317 [ # # # # ]: 0 : if (memLevel == -1 && PyErr_Occurred()) {
318 : 0 : goto exit;
319 : : }
320 [ # # ]: 0 : if (!--noptargs) {
321 : 0 : goto skip_optional_pos;
322 : : }
323 : : }
324 [ # # ]: 0 : if (args[4]) {
325 : 0 : strategy = _PyLong_AsInt(args[4]);
326 [ # # # # ]: 0 : if (strategy == -1 && PyErr_Occurred()) {
327 : 0 : goto exit;
328 : : }
329 [ # # ]: 0 : if (!--noptargs) {
330 : 0 : goto skip_optional_pos;
331 : : }
332 : : }
333 [ # # ]: 0 : if (PyObject_GetBuffer(args[5], &zdict, PyBUF_SIMPLE) != 0) {
334 : 0 : goto exit;
335 : : }
336 [ # # ]: 0 : if (!PyBuffer_IsContiguous(&zdict, 'C')) {
337 : 0 : _PyArg_BadArgument("compressobj", "argument 'zdict'", "contiguous buffer", args[5]);
338 : 0 : goto exit;
339 : : }
340 : 0 : skip_optional_pos:
341 : 0 : return_value = zlib_compressobj_impl(module, level, method, wbits, memLevel, strategy, &zdict);
342 : :
343 : 0 : exit:
344 : : /* Cleanup for zdict */
345 [ # # ]: 0 : if (zdict.obj) {
346 : 0 : PyBuffer_Release(&zdict);
347 : : }
348 : :
349 : 0 : return return_value;
350 : : }
351 : :
352 : : PyDoc_STRVAR(zlib_decompressobj__doc__,
353 : : "decompressobj($module, /, wbits=MAX_WBITS, zdict=b\'\')\n"
354 : : "--\n"
355 : : "\n"
356 : : "Return a decompressor object.\n"
357 : : "\n"
358 : : " wbits\n"
359 : : " The window buffer size and container format.\n"
360 : : " zdict\n"
361 : : " The predefined compression dictionary. This must be the same\n"
362 : : " dictionary as used by the compressor that produced the input data.");
363 : :
364 : : #define ZLIB_DECOMPRESSOBJ_METHODDEF \
365 : : {"decompressobj", _PyCFunction_CAST(zlib_decompressobj), METH_FASTCALL|METH_KEYWORDS, zlib_decompressobj__doc__},
366 : :
367 : : static PyObject *
368 : : zlib_decompressobj_impl(PyObject *module, int wbits, PyObject *zdict);
369 : :
370 : : static PyObject *
371 : 0 : zlib_decompressobj(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
372 : : {
373 : 0 : PyObject *return_value = NULL;
374 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
375 : :
376 : : #define NUM_KEYWORDS 2
377 : : static struct {
378 : : PyGC_Head _this_is_not_used;
379 : : PyObject_VAR_HEAD
380 : : PyObject *ob_item[NUM_KEYWORDS];
381 : : } _kwtuple = {
382 : : .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
383 : : .ob_item = { &_Py_ID(wbits), &_Py_ID(zdict), },
384 : : };
385 : : #undef NUM_KEYWORDS
386 : : #define KWTUPLE (&_kwtuple.ob_base.ob_base)
387 : :
388 : : #else // !Py_BUILD_CORE
389 : : # define KWTUPLE NULL
390 : : #endif // !Py_BUILD_CORE
391 : :
392 : : static const char * const _keywords[] = {"wbits", "zdict", NULL};
393 : : static _PyArg_Parser _parser = {
394 : : .keywords = _keywords,
395 : : .fname = "decompressobj",
396 : : .kwtuple = KWTUPLE,
397 : : };
398 : : #undef KWTUPLE
399 : : PyObject *argsbuf[2];
400 [ # # ]: 0 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
401 : 0 : int wbits = MAX_WBITS;
402 : 0 : PyObject *zdict = NULL;
403 : :
404 [ # # # # : 0 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
# # # # ]
405 [ # # ]: 0 : if (!args) {
406 : 0 : goto exit;
407 : : }
408 [ # # ]: 0 : if (!noptargs) {
409 : 0 : goto skip_optional_pos;
410 : : }
411 [ # # ]: 0 : if (args[0]) {
412 : 0 : wbits = _PyLong_AsInt(args[0]);
413 [ # # # # ]: 0 : if (wbits == -1 && PyErr_Occurred()) {
414 : 0 : goto exit;
415 : : }
416 [ # # ]: 0 : if (!--noptargs) {
417 : 0 : goto skip_optional_pos;
418 : : }
419 : : }
420 : 0 : zdict = args[1];
421 : 0 : skip_optional_pos:
422 : 0 : return_value = zlib_decompressobj_impl(module, wbits, zdict);
423 : :
424 : 0 : exit:
425 : 0 : return return_value;
426 : : }
427 : :
428 : : PyDoc_STRVAR(zlib_Compress_compress__doc__,
429 : : "compress($self, data, /)\n"
430 : : "--\n"
431 : : "\n"
432 : : "Returns a bytes object containing compressed data.\n"
433 : : "\n"
434 : : " data\n"
435 : : " Binary data to be compressed.\n"
436 : : "\n"
437 : : "After calling this function, some of the input data may still\n"
438 : : "be stored in internal buffers for later processing.\n"
439 : : "Call the flush() method to clear these buffers.");
440 : :
441 : : #define ZLIB_COMPRESS_COMPRESS_METHODDEF \
442 : : {"compress", _PyCFunction_CAST(zlib_Compress_compress), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Compress_compress__doc__},
443 : :
444 : : static PyObject *
445 : : zlib_Compress_compress_impl(compobject *self, PyTypeObject *cls,
446 : : Py_buffer *data);
447 : :
448 : : static PyObject *
449 : 0 : zlib_Compress_compress(compobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
450 : : {
451 : 0 : PyObject *return_value = NULL;
452 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
453 : : # define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
454 : : #else
455 : : # define KWTUPLE NULL
456 : : #endif
457 : :
458 : : static const char * const _keywords[] = {"", NULL};
459 : : static _PyArg_Parser _parser = {
460 : : .keywords = _keywords,
461 : : .fname = "compress",
462 : : .kwtuple = KWTUPLE,
463 : : };
464 : : #undef KWTUPLE
465 : : PyObject *argsbuf[1];
466 : 0 : Py_buffer data = {NULL, NULL};
467 : :
468 [ # # # # : 0 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
# # # # ]
469 [ # # ]: 0 : if (!args) {
470 : 0 : goto exit;
471 : : }
472 [ # # ]: 0 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
473 : 0 : goto exit;
474 : : }
475 [ # # ]: 0 : if (!PyBuffer_IsContiguous(&data, 'C')) {
476 : 0 : _PyArg_BadArgument("compress", "argument 1", "contiguous buffer", args[0]);
477 : 0 : goto exit;
478 : : }
479 : 0 : return_value = zlib_Compress_compress_impl(self, cls, &data);
480 : :
481 : 0 : exit:
482 : : /* Cleanup for data */
483 [ # # ]: 0 : if (data.obj) {
484 : 0 : PyBuffer_Release(&data);
485 : : }
486 : :
487 : 0 : return return_value;
488 : : }
489 : :
490 : : PyDoc_STRVAR(zlib_Decompress_decompress__doc__,
491 : : "decompress($self, data, /, max_length=0)\n"
492 : : "--\n"
493 : : "\n"
494 : : "Return a bytes object containing the decompressed version of the data.\n"
495 : : "\n"
496 : : " data\n"
497 : : " The binary data to decompress.\n"
498 : : " max_length\n"
499 : : " The maximum allowable length of the decompressed data.\n"
500 : : " Unconsumed input data will be stored in\n"
501 : : " the unconsumed_tail attribute.\n"
502 : : "\n"
503 : : "After calling this function, some of the input data may still be stored in\n"
504 : : "internal buffers for later processing.\n"
505 : : "Call the flush() method to clear these buffers.");
506 : :
507 : : #define ZLIB_DECOMPRESS_DECOMPRESS_METHODDEF \
508 : : {"decompress", _PyCFunction_CAST(zlib_Decompress_decompress), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Decompress_decompress__doc__},
509 : :
510 : : static PyObject *
511 : : zlib_Decompress_decompress_impl(compobject *self, PyTypeObject *cls,
512 : : Py_buffer *data, Py_ssize_t max_length);
513 : :
514 : : static PyObject *
515 : 0 : zlib_Decompress_decompress(compobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
516 : : {
517 : 0 : PyObject *return_value = NULL;
518 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
519 : :
520 : : #define NUM_KEYWORDS 1
521 : : static struct {
522 : : PyGC_Head _this_is_not_used;
523 : : PyObject_VAR_HEAD
524 : : PyObject *ob_item[NUM_KEYWORDS];
525 : : } _kwtuple = {
526 : : .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
527 : : .ob_item = { &_Py_ID(max_length), },
528 : : };
529 : : #undef NUM_KEYWORDS
530 : : #define KWTUPLE (&_kwtuple.ob_base.ob_base)
531 : :
532 : : #else // !Py_BUILD_CORE
533 : : # define KWTUPLE NULL
534 : : #endif // !Py_BUILD_CORE
535 : :
536 : : static const char * const _keywords[] = {"", "max_length", NULL};
537 : : static _PyArg_Parser _parser = {
538 : : .keywords = _keywords,
539 : : .fname = "decompress",
540 : : .kwtuple = KWTUPLE,
541 : : };
542 : : #undef KWTUPLE
543 : : PyObject *argsbuf[2];
544 [ # # ]: 0 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
545 : 0 : Py_buffer data = {NULL, NULL};
546 : 0 : Py_ssize_t max_length = 0;
547 : :
548 [ # # # # : 0 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
# # # # ]
549 [ # # ]: 0 : if (!args) {
550 : 0 : goto exit;
551 : : }
552 [ # # ]: 0 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
553 : 0 : goto exit;
554 : : }
555 [ # # ]: 0 : if (!PyBuffer_IsContiguous(&data, 'C')) {
556 : 0 : _PyArg_BadArgument("decompress", "argument 1", "contiguous buffer", args[0]);
557 : 0 : goto exit;
558 : : }
559 [ # # ]: 0 : if (!noptargs) {
560 : 0 : goto skip_optional_pos;
561 : : }
562 : : {
563 : 0 : Py_ssize_t ival = -1;
564 : 0 : PyObject *iobj = _PyNumber_Index(args[1]);
565 [ # # ]: 0 : if (iobj != NULL) {
566 : 0 : ival = PyLong_AsSsize_t(iobj);
567 : 0 : Py_DECREF(iobj);
568 : : }
569 [ # # # # ]: 0 : if (ival == -1 && PyErr_Occurred()) {
570 : 0 : goto exit;
571 : : }
572 : 0 : max_length = ival;
573 : : }
574 : 0 : skip_optional_pos:
575 : 0 : return_value = zlib_Decompress_decompress_impl(self, cls, &data, max_length);
576 : :
577 : 0 : exit:
578 : : /* Cleanup for data */
579 [ # # ]: 0 : if (data.obj) {
580 : 0 : PyBuffer_Release(&data);
581 : : }
582 : :
583 : 0 : return return_value;
584 : : }
585 : :
586 : : PyDoc_STRVAR(zlib_Compress_flush__doc__,
587 : : "flush($self, mode=zlib.Z_FINISH, /)\n"
588 : : "--\n"
589 : : "\n"
590 : : "Return a bytes object containing any remaining compressed data.\n"
591 : : "\n"
592 : : " mode\n"
593 : : " One of the constants Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH.\n"
594 : : " If mode == Z_FINISH, the compressor object can no longer be\n"
595 : : " used after calling the flush() method. Otherwise, more data\n"
596 : : " can still be compressed.");
597 : :
598 : : #define ZLIB_COMPRESS_FLUSH_METHODDEF \
599 : : {"flush", _PyCFunction_CAST(zlib_Compress_flush), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Compress_flush__doc__},
600 : :
601 : : static PyObject *
602 : : zlib_Compress_flush_impl(compobject *self, PyTypeObject *cls, int mode);
603 : :
604 : : static PyObject *
605 : 0 : zlib_Compress_flush(compobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
606 : : {
607 : 0 : PyObject *return_value = NULL;
608 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
609 : : # define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
610 : : #else
611 : : # define KWTUPLE NULL
612 : : #endif
613 : :
614 : : static const char * const _keywords[] = {"", NULL};
615 : : static _PyArg_Parser _parser = {
616 : : .keywords = _keywords,
617 : : .fname = "flush",
618 : : .kwtuple = KWTUPLE,
619 : : };
620 : : #undef KWTUPLE
621 : : PyObject *argsbuf[1];
622 : 0 : int mode = Z_FINISH;
623 : :
624 [ # # # # : 0 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
# # # # ]
625 [ # # ]: 0 : if (!args) {
626 : 0 : goto exit;
627 : : }
628 [ # # ]: 0 : if (nargs < 1) {
629 : 0 : goto skip_optional_posonly;
630 : : }
631 : 0 : mode = _PyLong_AsInt(args[0]);
632 [ # # # # ]: 0 : if (mode == -1 && PyErr_Occurred()) {
633 : 0 : goto exit;
634 : : }
635 : 0 : skip_optional_posonly:
636 : 0 : return_value = zlib_Compress_flush_impl(self, cls, mode);
637 : :
638 : 0 : exit:
639 : 0 : return return_value;
640 : : }
641 : :
642 : : #if defined(HAVE_ZLIB_COPY)
643 : :
644 : : PyDoc_STRVAR(zlib_Compress_copy__doc__,
645 : : "copy($self, /)\n"
646 : : "--\n"
647 : : "\n"
648 : : "Return a copy of the compression object.");
649 : :
650 : : #define ZLIB_COMPRESS_COPY_METHODDEF \
651 : : {"copy", _PyCFunction_CAST(zlib_Compress_copy), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Compress_copy__doc__},
652 : :
653 : : static PyObject *
654 : : zlib_Compress_copy_impl(compobject *self, PyTypeObject *cls);
655 : :
656 : : static PyObject *
657 : 0 : zlib_Compress_copy(compobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
658 : : {
659 [ # # ]: 0 : if (nargs) {
660 : 0 : PyErr_SetString(PyExc_TypeError, "copy() takes no arguments");
661 : 0 : return NULL;
662 : : }
663 : 0 : return zlib_Compress_copy_impl(self, cls);
664 : : }
665 : :
666 : : #endif /* defined(HAVE_ZLIB_COPY) */
667 : :
668 : : #if defined(HAVE_ZLIB_COPY)
669 : :
670 : : PyDoc_STRVAR(zlib_Compress___copy____doc__,
671 : : "__copy__($self, /)\n"
672 : : "--\n"
673 : : "\n");
674 : :
675 : : #define ZLIB_COMPRESS___COPY___METHODDEF \
676 : : {"__copy__", _PyCFunction_CAST(zlib_Compress___copy__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Compress___copy____doc__},
677 : :
678 : : static PyObject *
679 : : zlib_Compress___copy___impl(compobject *self, PyTypeObject *cls);
680 : :
681 : : static PyObject *
682 : 0 : zlib_Compress___copy__(compobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
683 : : {
684 [ # # ]: 0 : if (nargs) {
685 : 0 : PyErr_SetString(PyExc_TypeError, "__copy__() takes no arguments");
686 : 0 : return NULL;
687 : : }
688 : 0 : return zlib_Compress___copy___impl(self, cls);
689 : : }
690 : :
691 : : #endif /* defined(HAVE_ZLIB_COPY) */
692 : :
693 : : #if defined(HAVE_ZLIB_COPY)
694 : :
695 : : PyDoc_STRVAR(zlib_Compress___deepcopy____doc__,
696 : : "__deepcopy__($self, memo, /)\n"
697 : : "--\n"
698 : : "\n");
699 : :
700 : : #define ZLIB_COMPRESS___DEEPCOPY___METHODDEF \
701 : : {"__deepcopy__", _PyCFunction_CAST(zlib_Compress___deepcopy__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Compress___deepcopy____doc__},
702 : :
703 : : static PyObject *
704 : : zlib_Compress___deepcopy___impl(compobject *self, PyTypeObject *cls,
705 : : PyObject *memo);
706 : :
707 : : static PyObject *
708 : 0 : zlib_Compress___deepcopy__(compobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
709 : : {
710 : 0 : PyObject *return_value = NULL;
711 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
712 : : # define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
713 : : #else
714 : : # define KWTUPLE NULL
715 : : #endif
716 : :
717 : : static const char * const _keywords[] = {"", NULL};
718 : : static _PyArg_Parser _parser = {
719 : : .keywords = _keywords,
720 : : .fname = "__deepcopy__",
721 : : .kwtuple = KWTUPLE,
722 : : };
723 : : #undef KWTUPLE
724 : : PyObject *argsbuf[1];
725 : : PyObject *memo;
726 : :
727 [ # # # # : 0 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
# # # # ]
728 [ # # ]: 0 : if (!args) {
729 : 0 : goto exit;
730 : : }
731 : 0 : memo = args[0];
732 : 0 : return_value = zlib_Compress___deepcopy___impl(self, cls, memo);
733 : :
734 : 0 : exit:
735 : 0 : return return_value;
736 : : }
737 : :
738 : : #endif /* defined(HAVE_ZLIB_COPY) */
739 : :
740 : : #if defined(HAVE_ZLIB_COPY)
741 : :
742 : : PyDoc_STRVAR(zlib_Decompress_copy__doc__,
743 : : "copy($self, /)\n"
744 : : "--\n"
745 : : "\n"
746 : : "Return a copy of the decompression object.");
747 : :
748 : : #define ZLIB_DECOMPRESS_COPY_METHODDEF \
749 : : {"copy", _PyCFunction_CAST(zlib_Decompress_copy), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Decompress_copy__doc__},
750 : :
751 : : static PyObject *
752 : : zlib_Decompress_copy_impl(compobject *self, PyTypeObject *cls);
753 : :
754 : : static PyObject *
755 : 0 : zlib_Decompress_copy(compobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
756 : : {
757 [ # # ]: 0 : if (nargs) {
758 : 0 : PyErr_SetString(PyExc_TypeError, "copy() takes no arguments");
759 : 0 : return NULL;
760 : : }
761 : 0 : return zlib_Decompress_copy_impl(self, cls);
762 : : }
763 : :
764 : : #endif /* defined(HAVE_ZLIB_COPY) */
765 : :
766 : : #if defined(HAVE_ZLIB_COPY)
767 : :
768 : : PyDoc_STRVAR(zlib_Decompress___copy____doc__,
769 : : "__copy__($self, /)\n"
770 : : "--\n"
771 : : "\n");
772 : :
773 : : #define ZLIB_DECOMPRESS___COPY___METHODDEF \
774 : : {"__copy__", _PyCFunction_CAST(zlib_Decompress___copy__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Decompress___copy____doc__},
775 : :
776 : : static PyObject *
777 : : zlib_Decompress___copy___impl(compobject *self, PyTypeObject *cls);
778 : :
779 : : static PyObject *
780 : 0 : zlib_Decompress___copy__(compobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
781 : : {
782 [ # # ]: 0 : if (nargs) {
783 : 0 : PyErr_SetString(PyExc_TypeError, "__copy__() takes no arguments");
784 : 0 : return NULL;
785 : : }
786 : 0 : return zlib_Decompress___copy___impl(self, cls);
787 : : }
788 : :
789 : : #endif /* defined(HAVE_ZLIB_COPY) */
790 : :
791 : : #if defined(HAVE_ZLIB_COPY)
792 : :
793 : : PyDoc_STRVAR(zlib_Decompress___deepcopy____doc__,
794 : : "__deepcopy__($self, memo, /)\n"
795 : : "--\n"
796 : : "\n");
797 : :
798 : : #define ZLIB_DECOMPRESS___DEEPCOPY___METHODDEF \
799 : : {"__deepcopy__", _PyCFunction_CAST(zlib_Decompress___deepcopy__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Decompress___deepcopy____doc__},
800 : :
801 : : static PyObject *
802 : : zlib_Decompress___deepcopy___impl(compobject *self, PyTypeObject *cls,
803 : : PyObject *memo);
804 : :
805 : : static PyObject *
806 : 0 : zlib_Decompress___deepcopy__(compobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
807 : : {
808 : 0 : PyObject *return_value = NULL;
809 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
810 : : # define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
811 : : #else
812 : : # define KWTUPLE NULL
813 : : #endif
814 : :
815 : : static const char * const _keywords[] = {"", NULL};
816 : : static _PyArg_Parser _parser = {
817 : : .keywords = _keywords,
818 : : .fname = "__deepcopy__",
819 : : .kwtuple = KWTUPLE,
820 : : };
821 : : #undef KWTUPLE
822 : : PyObject *argsbuf[1];
823 : : PyObject *memo;
824 : :
825 [ # # # # : 0 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
# # # # ]
826 [ # # ]: 0 : if (!args) {
827 : 0 : goto exit;
828 : : }
829 : 0 : memo = args[0];
830 : 0 : return_value = zlib_Decompress___deepcopy___impl(self, cls, memo);
831 : :
832 : 0 : exit:
833 : 0 : return return_value;
834 : : }
835 : :
836 : : #endif /* defined(HAVE_ZLIB_COPY) */
837 : :
838 : : PyDoc_STRVAR(zlib_Decompress_flush__doc__,
839 : : "flush($self, length=zlib.DEF_BUF_SIZE, /)\n"
840 : : "--\n"
841 : : "\n"
842 : : "Return a bytes object containing any remaining decompressed data.\n"
843 : : "\n"
844 : : " length\n"
845 : : " the initial size of the output buffer.");
846 : :
847 : : #define ZLIB_DECOMPRESS_FLUSH_METHODDEF \
848 : : {"flush", _PyCFunction_CAST(zlib_Decompress_flush), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Decompress_flush__doc__},
849 : :
850 : : static PyObject *
851 : : zlib_Decompress_flush_impl(compobject *self, PyTypeObject *cls,
852 : : Py_ssize_t length);
853 : :
854 : : static PyObject *
855 : 0 : zlib_Decompress_flush(compobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
856 : : {
857 : 0 : PyObject *return_value = NULL;
858 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
859 : : # define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
860 : : #else
861 : : # define KWTUPLE NULL
862 : : #endif
863 : :
864 : : static const char * const _keywords[] = {"", NULL};
865 : : static _PyArg_Parser _parser = {
866 : : .keywords = _keywords,
867 : : .fname = "flush",
868 : : .kwtuple = KWTUPLE,
869 : : };
870 : : #undef KWTUPLE
871 : : PyObject *argsbuf[1];
872 : 0 : Py_ssize_t length = DEF_BUF_SIZE;
873 : :
874 [ # # # # : 0 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
# # # # ]
875 [ # # ]: 0 : if (!args) {
876 : 0 : goto exit;
877 : : }
878 [ # # ]: 0 : if (nargs < 1) {
879 : 0 : goto skip_optional_posonly;
880 : : }
881 : : {
882 : 0 : Py_ssize_t ival = -1;
883 : 0 : PyObject *iobj = _PyNumber_Index(args[0]);
884 [ # # ]: 0 : if (iobj != NULL) {
885 : 0 : ival = PyLong_AsSsize_t(iobj);
886 : 0 : Py_DECREF(iobj);
887 : : }
888 [ # # # # ]: 0 : if (ival == -1 && PyErr_Occurred()) {
889 : 0 : goto exit;
890 : : }
891 : 0 : length = ival;
892 : : }
893 : 0 : skip_optional_posonly:
894 : 0 : return_value = zlib_Decompress_flush_impl(self, cls, length);
895 : :
896 : 0 : exit:
897 : 0 : return return_value;
898 : : }
899 : :
900 : : PyDoc_STRVAR(zlib_ZlibDecompressor_decompress__doc__,
901 : : "decompress($self, /, data, max_length=-1)\n"
902 : : "--\n"
903 : : "\n"
904 : : "Decompress *data*, returning uncompressed data as bytes.\n"
905 : : "\n"
906 : : "If *max_length* is nonnegative, returns at most *max_length* bytes of\n"
907 : : "decompressed data. If this limit is reached and further output can be\n"
908 : : "produced, *self.needs_input* will be set to ``False``. In this case, the next\n"
909 : : "call to *decompress()* may provide *data* as b\'\' to obtain more of the output.\n"
910 : : "\n"
911 : : "If all of the input data was decompressed and returned (either because this\n"
912 : : "was less than *max_length* bytes, or because *max_length* was negative),\n"
913 : : "*self.needs_input* will be set to True.\n"
914 : : "\n"
915 : : "Attempting to decompress data after the end of stream is reached raises an\n"
916 : : "EOFError. Any data found after the end of the stream is ignored and saved in\n"
917 : : "the unused_data attribute.");
918 : :
919 : : #define ZLIB_ZLIBDECOMPRESSOR_DECOMPRESS_METHODDEF \
920 : : {"decompress", _PyCFunction_CAST(zlib_ZlibDecompressor_decompress), METH_FASTCALL|METH_KEYWORDS, zlib_ZlibDecompressor_decompress__doc__},
921 : :
922 : : static PyObject *
923 : : zlib_ZlibDecompressor_decompress_impl(ZlibDecompressor *self,
924 : : Py_buffer *data, Py_ssize_t max_length);
925 : :
926 : : static PyObject *
927 : 0 : zlib_ZlibDecompressor_decompress(ZlibDecompressor *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
928 : : {
929 : 0 : PyObject *return_value = NULL;
930 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
931 : :
932 : : #define NUM_KEYWORDS 2
933 : : static struct {
934 : : PyGC_Head _this_is_not_used;
935 : : PyObject_VAR_HEAD
936 : : PyObject *ob_item[NUM_KEYWORDS];
937 : : } _kwtuple = {
938 : : .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
939 : : .ob_item = { &_Py_ID(data), &_Py_ID(max_length), },
940 : : };
941 : : #undef NUM_KEYWORDS
942 : : #define KWTUPLE (&_kwtuple.ob_base.ob_base)
943 : :
944 : : #else // !Py_BUILD_CORE
945 : : # define KWTUPLE NULL
946 : : #endif // !Py_BUILD_CORE
947 : :
948 : : static const char * const _keywords[] = {"data", "max_length", NULL};
949 : : static _PyArg_Parser _parser = {
950 : : .keywords = _keywords,
951 : : .fname = "decompress",
952 : : .kwtuple = KWTUPLE,
953 : : };
954 : : #undef KWTUPLE
955 : : PyObject *argsbuf[2];
956 [ # # ]: 0 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
957 : 0 : Py_buffer data = {NULL, NULL};
958 : 0 : Py_ssize_t max_length = -1;
959 : :
960 [ # # # # : 0 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
# # # # ]
961 [ # # ]: 0 : if (!args) {
962 : 0 : goto exit;
963 : : }
964 [ # # ]: 0 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
965 : 0 : goto exit;
966 : : }
967 [ # # ]: 0 : if (!PyBuffer_IsContiguous(&data, 'C')) {
968 : 0 : _PyArg_BadArgument("decompress", "argument 'data'", "contiguous buffer", args[0]);
969 : 0 : goto exit;
970 : : }
971 [ # # ]: 0 : if (!noptargs) {
972 : 0 : goto skip_optional_pos;
973 : : }
974 : : {
975 : 0 : Py_ssize_t ival = -1;
976 : 0 : PyObject *iobj = _PyNumber_Index(args[1]);
977 [ # # ]: 0 : if (iobj != NULL) {
978 : 0 : ival = PyLong_AsSsize_t(iobj);
979 : 0 : Py_DECREF(iobj);
980 : : }
981 [ # # # # ]: 0 : if (ival == -1 && PyErr_Occurred()) {
982 : 0 : goto exit;
983 : : }
984 : 0 : max_length = ival;
985 : : }
986 : 0 : skip_optional_pos:
987 : 0 : return_value = zlib_ZlibDecompressor_decompress_impl(self, &data, max_length);
988 : :
989 : 0 : exit:
990 : : /* Cleanup for data */
991 [ # # ]: 0 : if (data.obj) {
992 : 0 : PyBuffer_Release(&data);
993 : : }
994 : :
995 : 0 : return return_value;
996 : : }
997 : :
998 : : PyDoc_STRVAR(zlib_adler32__doc__,
999 : : "adler32($module, data, value=1, /)\n"
1000 : : "--\n"
1001 : : "\n"
1002 : : "Compute an Adler-32 checksum of data.\n"
1003 : : "\n"
1004 : : " value\n"
1005 : : " Starting value of the checksum.\n"
1006 : : "\n"
1007 : : "The returned checksum is an integer.");
1008 : :
1009 : : #define ZLIB_ADLER32_METHODDEF \
1010 : : {"adler32", _PyCFunction_CAST(zlib_adler32), METH_FASTCALL, zlib_adler32__doc__},
1011 : :
1012 : : static PyObject *
1013 : : zlib_adler32_impl(PyObject *module, Py_buffer *data, unsigned int value);
1014 : :
1015 : : static PyObject *
1016 : 0 : zlib_adler32(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1017 : : {
1018 : 0 : PyObject *return_value = NULL;
1019 : 0 : Py_buffer data = {NULL, NULL};
1020 : 0 : unsigned int value = 1;
1021 : :
1022 [ # # # # : 0 : if (!_PyArg_CheckPositional("adler32", nargs, 1, 2)) {
# # ]
1023 : 0 : goto exit;
1024 : : }
1025 [ # # ]: 0 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
1026 : 0 : goto exit;
1027 : : }
1028 [ # # ]: 0 : if (!PyBuffer_IsContiguous(&data, 'C')) {
1029 : 0 : _PyArg_BadArgument("adler32", "argument 1", "contiguous buffer", args[0]);
1030 : 0 : goto exit;
1031 : : }
1032 [ # # ]: 0 : if (nargs < 2) {
1033 : 0 : goto skip_optional;
1034 : : }
1035 : 0 : value = (unsigned int)PyLong_AsUnsignedLongMask(args[1]);
1036 [ # # # # ]: 0 : if (value == (unsigned int)-1 && PyErr_Occurred()) {
1037 : 0 : goto exit;
1038 : : }
1039 : 0 : skip_optional:
1040 : 0 : return_value = zlib_adler32_impl(module, &data, value);
1041 : :
1042 : 0 : exit:
1043 : : /* Cleanup for data */
1044 [ # # ]: 0 : if (data.obj) {
1045 : 0 : PyBuffer_Release(&data);
1046 : : }
1047 : :
1048 : 0 : return return_value;
1049 : : }
1050 : :
1051 : : PyDoc_STRVAR(zlib_crc32__doc__,
1052 : : "crc32($module, data, value=0, /)\n"
1053 : : "--\n"
1054 : : "\n"
1055 : : "Compute a CRC-32 checksum of data.\n"
1056 : : "\n"
1057 : : " value\n"
1058 : : " Starting value of the checksum.\n"
1059 : : "\n"
1060 : : "The returned checksum is an integer.");
1061 : :
1062 : : #define ZLIB_CRC32_METHODDEF \
1063 : : {"crc32", _PyCFunction_CAST(zlib_crc32), METH_FASTCALL, zlib_crc32__doc__},
1064 : :
1065 : : static unsigned int
1066 : : zlib_crc32_impl(PyObject *module, Py_buffer *data, unsigned int value);
1067 : :
1068 : : static PyObject *
1069 : 0 : zlib_crc32(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1070 : : {
1071 : 0 : PyObject *return_value = NULL;
1072 : 0 : Py_buffer data = {NULL, NULL};
1073 : 0 : unsigned int value = 0;
1074 : : unsigned int _return_value;
1075 : :
1076 [ # # # # : 0 : if (!_PyArg_CheckPositional("crc32", nargs, 1, 2)) {
# # ]
1077 : 0 : goto exit;
1078 : : }
1079 [ # # ]: 0 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
1080 : 0 : goto exit;
1081 : : }
1082 [ # # ]: 0 : if (!PyBuffer_IsContiguous(&data, 'C')) {
1083 : 0 : _PyArg_BadArgument("crc32", "argument 1", "contiguous buffer", args[0]);
1084 : 0 : goto exit;
1085 : : }
1086 [ # # ]: 0 : if (nargs < 2) {
1087 : 0 : goto skip_optional;
1088 : : }
1089 : 0 : value = (unsigned int)PyLong_AsUnsignedLongMask(args[1]);
1090 [ # # # # ]: 0 : if (value == (unsigned int)-1 && PyErr_Occurred()) {
1091 : 0 : goto exit;
1092 : : }
1093 : 0 : skip_optional:
1094 : 0 : _return_value = zlib_crc32_impl(module, &data, value);
1095 [ # # # # ]: 0 : if ((_return_value == (unsigned int)-1) && PyErr_Occurred()) {
1096 : 0 : goto exit;
1097 : : }
1098 : 0 : return_value = PyLong_FromUnsignedLong((unsigned long)_return_value);
1099 : :
1100 : 0 : exit:
1101 : : /* Cleanup for data */
1102 [ # # ]: 0 : if (data.obj) {
1103 : 0 : PyBuffer_Release(&data);
1104 : : }
1105 : :
1106 : 0 : return return_value;
1107 : : }
1108 : :
1109 : : #ifndef ZLIB_COMPRESS_COPY_METHODDEF
1110 : : #define ZLIB_COMPRESS_COPY_METHODDEF
1111 : : #endif /* !defined(ZLIB_COMPRESS_COPY_METHODDEF) */
1112 : :
1113 : : #ifndef ZLIB_COMPRESS___COPY___METHODDEF
1114 : : #define ZLIB_COMPRESS___COPY___METHODDEF
1115 : : #endif /* !defined(ZLIB_COMPRESS___COPY___METHODDEF) */
1116 : :
1117 : : #ifndef ZLIB_COMPRESS___DEEPCOPY___METHODDEF
1118 : : #define ZLIB_COMPRESS___DEEPCOPY___METHODDEF
1119 : : #endif /* !defined(ZLIB_COMPRESS___DEEPCOPY___METHODDEF) */
1120 : :
1121 : : #ifndef ZLIB_DECOMPRESS_COPY_METHODDEF
1122 : : #define ZLIB_DECOMPRESS_COPY_METHODDEF
1123 : : #endif /* !defined(ZLIB_DECOMPRESS_COPY_METHODDEF) */
1124 : :
1125 : : #ifndef ZLIB_DECOMPRESS___COPY___METHODDEF
1126 : : #define ZLIB_DECOMPRESS___COPY___METHODDEF
1127 : : #endif /* !defined(ZLIB_DECOMPRESS___COPY___METHODDEF) */
1128 : :
1129 : : #ifndef ZLIB_DECOMPRESS___DEEPCOPY___METHODDEF
1130 : : #define ZLIB_DECOMPRESS___DEEPCOPY___METHODDEF
1131 : : #endif /* !defined(ZLIB_DECOMPRESS___DEEPCOPY___METHODDEF) */
1132 : : /*[clinic end generated code: output=57ff7b511ab23132 input=a9049054013a1b77]*/
|