Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : PyDoc_STRVAR(binascii_a2b_uu__doc__,
6 : : "a2b_uu($module, data, /)\n"
7 : : "--\n"
8 : : "\n"
9 : : "Decode a line of uuencoded data.");
10 : :
11 : : #define BINASCII_A2B_UU_METHODDEF \
12 : : {"a2b_uu", (PyCFunction)binascii_a2b_uu, METH_O, binascii_a2b_uu__doc__},
13 : :
14 : : static PyObject *
15 : : binascii_a2b_uu_impl(PyObject *module, Py_buffer *data);
16 : :
17 : : static PyObject *
18 : 200 : binascii_a2b_uu(PyObject *module, PyObject *arg)
19 : : {
20 : 200 : PyObject *return_value = NULL;
21 : 200 : Py_buffer data = {NULL, NULL};
22 : :
23 [ + + ]: 200 : if (!ascii_buffer_converter(arg, &data)) {
24 : 4 : goto exit;
25 : : }
26 : 196 : return_value = binascii_a2b_uu_impl(module, &data);
27 : :
28 : 200 : exit:
29 : : /* Cleanup for data */
30 [ + + ]: 200 : if (data.obj)
31 : 192 : PyBuffer_Release(&data);
32 : :
33 : 200 : return return_value;
34 : : }
35 : :
36 : : PyDoc_STRVAR(binascii_b2a_uu__doc__,
37 : : "b2a_uu($module, data, /, *, backtick=False)\n"
38 : : "--\n"
39 : : "\n"
40 : : "Uuencode line of data.");
41 : :
42 : : #define BINASCII_B2A_UU_METHODDEF \
43 : : {"b2a_uu", _PyCFunction_CAST(binascii_b2a_uu), METH_FASTCALL|METH_KEYWORDS, binascii_b2a_uu__doc__},
44 : :
45 : : static PyObject *
46 : : binascii_b2a_uu_impl(PyObject *module, Py_buffer *data, int backtick);
47 : :
48 : : static PyObject *
49 : 138 : binascii_b2a_uu(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
50 : : {
51 : 138 : PyObject *return_value = NULL;
52 : : static const char * const _keywords[] = {"", "backtick", NULL};
53 : : static _PyArg_Parser _parser = {NULL, _keywords, "b2a_uu", 0};
54 : : PyObject *argsbuf[2];
55 [ + + ]: 138 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
56 : 138 : Py_buffer data = {NULL, NULL};
57 : 138 : int backtick = 0;
58 : :
59 [ + + + + : 138 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ + - + ]
60 [ + + ]: 138 : if (!args) {
61 : 8 : goto exit;
62 : : }
63 [ + + ]: 130 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
64 : 4 : goto exit;
65 : : }
66 [ - + ]: 126 : if (!PyBuffer_IsContiguous(&data, 'C')) {
67 : 0 : _PyArg_BadArgument("b2a_uu", "argument 1", "contiguous buffer", args[0]);
68 : 0 : goto exit;
69 : : }
70 [ + + ]: 126 : if (!noptargs) {
71 : 40 : goto skip_optional_kwonly;
72 : : }
73 : 86 : backtick = _PyLong_AsInt(args[1]);
74 [ - + - - ]: 86 : if (backtick == -1 && PyErr_Occurred()) {
75 : 0 : goto exit;
76 : : }
77 : 86 : skip_optional_kwonly:
78 : 126 : return_value = binascii_b2a_uu_impl(module, &data, backtick);
79 : :
80 : 138 : exit:
81 : : /* Cleanup for data */
82 [ + + ]: 138 : if (data.obj) {
83 : 126 : PyBuffer_Release(&data);
84 : : }
85 : :
86 : 138 : return return_value;
87 : : }
88 : :
89 : : PyDoc_STRVAR(binascii_a2b_base64__doc__,
90 : : "a2b_base64($module, data, /, *, strict_mode=False)\n"
91 : : "--\n"
92 : : "\n"
93 : : "Decode a line of base64 data.\n"
94 : : "\n"
95 : : " strict_mode\n"
96 : : " When set to True, bytes that are not part of the base64 standard are not allowed.\n"
97 : : " The same applies to excess data after padding (= / ==).");
98 : :
99 : : #define BINASCII_A2B_BASE64_METHODDEF \
100 : : {"a2b_base64", _PyCFunction_CAST(binascii_a2b_base64), METH_FASTCALL|METH_KEYWORDS, binascii_a2b_base64__doc__},
101 : :
102 : : static PyObject *
103 : : binascii_a2b_base64_impl(PyObject *module, Py_buffer *data, int strict_mode);
104 : :
105 : : static PyObject *
106 : 1011 : binascii_a2b_base64(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
107 : : {
108 : 1011 : PyObject *return_value = NULL;
109 : : static const char * const _keywords[] = {"", "strict_mode", NULL};
110 : : static _PyArg_Parser _parser = {NULL, _keywords, "a2b_base64", 0};
111 : : PyObject *argsbuf[2];
112 [ + + ]: 1011 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
113 : 1011 : Py_buffer data = {NULL, NULL};
114 : 1011 : int strict_mode = 0;
115 : :
116 [ + + + + : 1011 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ - - + ]
117 [ + + ]: 1011 : if (!args) {
118 : 4 : goto exit;
119 : : }
120 [ + + ]: 1007 : if (!ascii_buffer_converter(args[0], &data)) {
121 : 4 : goto exit;
122 : : }
123 [ + + ]: 1003 : if (!noptargs) {
124 : 669 : goto skip_optional_kwonly;
125 : : }
126 : 334 : strict_mode = _PyLong_AsInt(args[1]);
127 [ - + - - ]: 334 : if (strict_mode == -1 && PyErr_Occurred()) {
128 : 0 : goto exit;
129 : : }
130 : 334 : skip_optional_kwonly:
131 : 1003 : return_value = binascii_a2b_base64_impl(module, &data, strict_mode);
132 : :
133 : 1011 : exit:
134 : : /* Cleanup for data */
135 [ + + ]: 1011 : if (data.obj)
136 : 999 : PyBuffer_Release(&data);
137 : :
138 : 1011 : return return_value;
139 : : }
140 : :
141 : : PyDoc_STRVAR(binascii_b2a_base64__doc__,
142 : : "b2a_base64($module, data, /, *, newline=True)\n"
143 : : "--\n"
144 : : "\n"
145 : : "Base64-code line of data.");
146 : :
147 : : #define BINASCII_B2A_BASE64_METHODDEF \
148 : : {"b2a_base64", _PyCFunction_CAST(binascii_b2a_base64), METH_FASTCALL|METH_KEYWORDS, binascii_b2a_base64__doc__},
149 : :
150 : : static PyObject *
151 : : binascii_b2a_base64_impl(PyObject *module, Py_buffer *data, int newline);
152 : :
153 : : static PyObject *
154 : 4537 : binascii_b2a_base64(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
155 : : {
156 : 4537 : PyObject *return_value = NULL;
157 : : static const char * const _keywords[] = {"", "newline", NULL};
158 : : static _PyArg_Parser _parser = {NULL, _keywords, "b2a_base64", 0};
159 : : PyObject *argsbuf[2];
160 [ + + ]: 4537 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
161 : 4537 : Py_buffer data = {NULL, NULL};
162 : 4537 : int newline = 1;
163 : :
164 [ + + + + : 4537 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ - - + ]
165 [ + + ]: 4537 : if (!args) {
166 : 4 : goto exit;
167 : : }
168 [ + + ]: 4533 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
169 : 14 : goto exit;
170 : : }
171 [ - + ]: 4519 : if (!PyBuffer_IsContiguous(&data, 'C')) {
172 : 0 : _PyArg_BadArgument("b2a_base64", "argument 1", "contiguous buffer", args[0]);
173 : 0 : goto exit;
174 : : }
175 [ + + ]: 4519 : if (!noptargs) {
176 : 4203 : goto skip_optional_kwonly;
177 : : }
178 : 316 : newline = _PyLong_AsInt(args[1]);
179 [ - + - - ]: 316 : if (newline == -1 && PyErr_Occurred()) {
180 : 0 : goto exit;
181 : : }
182 : 316 : skip_optional_kwonly:
183 : 4519 : return_value = binascii_b2a_base64_impl(module, &data, newline);
184 : :
185 : 4537 : exit:
186 : : /* Cleanup for data */
187 [ + + ]: 4537 : if (data.obj) {
188 : 4519 : PyBuffer_Release(&data);
189 : : }
190 : :
191 : 4537 : return return_value;
192 : : }
193 : :
194 : : PyDoc_STRVAR(binascii_crc_hqx__doc__,
195 : : "crc_hqx($module, data, crc, /)\n"
196 : : "--\n"
197 : : "\n"
198 : : "Compute CRC-CCITT incrementally.");
199 : :
200 : : #define BINASCII_CRC_HQX_METHODDEF \
201 : : {"crc_hqx", _PyCFunction_CAST(binascii_crc_hqx), METH_FASTCALL, binascii_crc_hqx__doc__},
202 : :
203 : : static PyObject *
204 : : binascii_crc_hqx_impl(PyObject *module, Py_buffer *data, unsigned int crc);
205 : :
206 : : static PyObject *
207 : 60 : binascii_crc_hqx(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
208 : : {
209 : 60 : PyObject *return_value = NULL;
210 : 60 : Py_buffer data = {NULL, NULL};
211 : : unsigned int crc;
212 : :
213 [ + + - + : 60 : if (!_PyArg_CheckPositional("crc_hqx", nargs, 2, 2)) {
+ - ]
214 : 16 : goto exit;
215 : : }
216 [ + + ]: 44 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
217 : 4 : goto exit;
218 : : }
219 [ - + ]: 40 : if (!PyBuffer_IsContiguous(&data, 'C')) {
220 : 0 : _PyArg_BadArgument("crc_hqx", "argument 1", "contiguous buffer", args[0]);
221 : 0 : goto exit;
222 : : }
223 : 40 : crc = (unsigned int)PyLong_AsUnsignedLongMask(args[1]);
224 [ + + - + ]: 40 : if (crc == (unsigned int)-1 && PyErr_Occurred()) {
225 : 0 : goto exit;
226 : : }
227 : 40 : return_value = binascii_crc_hqx_impl(module, &data, crc);
228 : :
229 : 60 : exit:
230 : : /* Cleanup for data */
231 [ + + ]: 60 : if (data.obj) {
232 : 40 : PyBuffer_Release(&data);
233 : : }
234 : :
235 : 60 : return return_value;
236 : : }
237 : :
238 : : PyDoc_STRVAR(binascii_crc32__doc__,
239 : : "crc32($module, data, crc=0, /)\n"
240 : : "--\n"
241 : : "\n"
242 : : "Compute CRC-32 incrementally.");
243 : :
244 : : #define BINASCII_CRC32_METHODDEF \
245 : : {"crc32", _PyCFunction_CAST(binascii_crc32), METH_FASTCALL, binascii_crc32__doc__},
246 : :
247 : : static unsigned int
248 : : binascii_crc32_impl(PyObject *module, Py_buffer *data, unsigned int crc);
249 : :
250 : : static PyObject *
251 : 30 : binascii_crc32(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
252 : : {
253 : 30 : PyObject *return_value = NULL;
254 : 30 : Py_buffer data = {NULL, NULL};
255 : 30 : unsigned int crc = 0;
256 : : unsigned int _return_value;
257 : :
258 [ + + - + : 30 : if (!_PyArg_CheckPositional("crc32", nargs, 1, 2)) {
+ - ]
259 : 8 : goto exit;
260 : : }
261 [ + + ]: 22 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
262 : 4 : goto exit;
263 : : }
264 [ - + ]: 18 : if (!PyBuffer_IsContiguous(&data, 'C')) {
265 : 0 : _PyArg_BadArgument("crc32", "argument 1", "contiguous buffer", args[0]);
266 : 0 : goto exit;
267 : : }
268 [ + + ]: 18 : if (nargs < 2) {
269 : 14 : goto skip_optional;
270 : : }
271 : 4 : crc = (unsigned int)PyLong_AsUnsignedLongMask(args[1]);
272 [ - + - - ]: 4 : if (crc == (unsigned int)-1 && PyErr_Occurred()) {
273 : 0 : goto exit;
274 : : }
275 : 4 : skip_optional:
276 : 18 : _return_value = binascii_crc32_impl(module, &data, crc);
277 [ - + - - ]: 18 : if ((_return_value == (unsigned int)-1) && PyErr_Occurred()) {
278 : 0 : goto exit;
279 : : }
280 : 18 : return_value = PyLong_FromUnsignedLong((unsigned long)_return_value);
281 : :
282 : 30 : exit:
283 : : /* Cleanup for data */
284 [ + + ]: 30 : if (data.obj) {
285 : 18 : PyBuffer_Release(&data);
286 : : }
287 : :
288 : 30 : return return_value;
289 : : }
290 : :
291 : : PyDoc_STRVAR(binascii_b2a_hex__doc__,
292 : : "b2a_hex($module, /, data, sep=<unrepresentable>, bytes_per_sep=1)\n"
293 : : "--\n"
294 : : "\n"
295 : : "Hexadecimal representation of binary data.\n"
296 : : "\n"
297 : : " sep\n"
298 : : " An optional single character or byte to separate hex bytes.\n"
299 : : " bytes_per_sep\n"
300 : : " How many bytes between separators. Positive values count from the\n"
301 : : " right, negative values count from the left.\n"
302 : : "\n"
303 : : "The return value is a bytes object. This function is also\n"
304 : : "available as \"hexlify()\".\n"
305 : : "\n"
306 : : "Example:\n"
307 : : ">>> binascii.b2a_hex(b\'\\xb9\\x01\\xef\')\n"
308 : : "b\'b901ef\'\n"
309 : : ">>> binascii.hexlify(b\'\\xb9\\x01\\xef\', \':\')\n"
310 : : "b\'b9:01:ef\'\n"
311 : : ">>> binascii.b2a_hex(b\'\\xb9\\x01\\xef\', b\'_\', 2)\n"
312 : : "b\'b9_01ef\'");
313 : :
314 : : #define BINASCII_B2A_HEX_METHODDEF \
315 : : {"b2a_hex", _PyCFunction_CAST(binascii_b2a_hex), METH_FASTCALL|METH_KEYWORDS, binascii_b2a_hex__doc__},
316 : :
317 : : static PyObject *
318 : : binascii_b2a_hex_impl(PyObject *module, Py_buffer *data, PyObject *sep,
319 : : int bytes_per_sep);
320 : :
321 : : static PyObject *
322 : 40 : binascii_b2a_hex(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
323 : : {
324 : 40 : PyObject *return_value = NULL;
325 : : static const char * const _keywords[] = {"data", "sep", "bytes_per_sep", NULL};
326 : : static _PyArg_Parser _parser = {NULL, _keywords, "b2a_hex", 0};
327 : : PyObject *argsbuf[3];
328 [ - + ]: 40 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
329 : 40 : Py_buffer data = {NULL, NULL};
330 : 40 : PyObject *sep = NULL;
331 : 40 : int bytes_per_sep = 1;
332 : :
333 [ + - + + : 40 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
+ - - + ]
334 [ + + ]: 40 : if (!args) {
335 : 4 : goto exit;
336 : : }
337 [ + + ]: 36 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
338 : 5 : goto exit;
339 : : }
340 [ - + ]: 31 : if (!PyBuffer_IsContiguous(&data, 'C')) {
341 : 0 : _PyArg_BadArgument("b2a_hex", "argument 'data'", "contiguous buffer", args[0]);
342 : 0 : goto exit;
343 : : }
344 [ + + ]: 31 : if (!noptargs) {
345 : 27 : goto skip_optional_pos;
346 : : }
347 [ + - ]: 4 : if (args[1]) {
348 : 4 : sep = args[1];
349 [ + - ]: 4 : if (!--noptargs) {
350 : 4 : goto skip_optional_pos;
351 : : }
352 : : }
353 : 0 : bytes_per_sep = _PyLong_AsInt(args[2]);
354 [ # # # # ]: 0 : if (bytes_per_sep == -1 && PyErr_Occurred()) {
355 : 0 : goto exit;
356 : : }
357 : 0 : skip_optional_pos:
358 : 31 : return_value = binascii_b2a_hex_impl(module, &data, sep, bytes_per_sep);
359 : :
360 : 40 : exit:
361 : : /* Cleanup for data */
362 [ + + ]: 40 : if (data.obj) {
363 : 31 : PyBuffer_Release(&data);
364 : : }
365 : :
366 : 40 : return return_value;
367 : : }
368 : :
369 : : PyDoc_STRVAR(binascii_hexlify__doc__,
370 : : "hexlify($module, /, data, sep=<unrepresentable>, bytes_per_sep=1)\n"
371 : : "--\n"
372 : : "\n"
373 : : "Hexadecimal representation of binary data.\n"
374 : : "\n"
375 : : " sep\n"
376 : : " An optional single character or byte to separate hex bytes.\n"
377 : : " bytes_per_sep\n"
378 : : " How many bytes between separators. Positive values count from the\n"
379 : : " right, negative values count from the left.\n"
380 : : "\n"
381 : : "The return value is a bytes object. This function is also\n"
382 : : "available as \"b2a_hex()\".");
383 : :
384 : : #define BINASCII_HEXLIFY_METHODDEF \
385 : : {"hexlify", _PyCFunction_CAST(binascii_hexlify), METH_FASTCALL|METH_KEYWORDS, binascii_hexlify__doc__},
386 : :
387 : : static PyObject *
388 : : binascii_hexlify_impl(PyObject *module, Py_buffer *data, PyObject *sep,
389 : : int bytes_per_sep);
390 : :
391 : : static PyObject *
392 : 246 : binascii_hexlify(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
393 : : {
394 : 246 : PyObject *return_value = NULL;
395 : : static const char * const _keywords[] = {"data", "sep", "bytes_per_sep", NULL};
396 : : static _PyArg_Parser _parser = {NULL, _keywords, "hexlify", 0};
397 : : PyObject *argsbuf[3];
398 [ - + ]: 246 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
399 : 246 : Py_buffer data = {NULL, NULL};
400 : 246 : PyObject *sep = NULL;
401 : 246 : int bytes_per_sep = 1;
402 : :
403 [ + - + + : 246 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
+ - - + ]
404 [ + + ]: 246 : if (!args) {
405 : 4 : goto exit;
406 : : }
407 [ + + ]: 242 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
408 : 6 : goto exit;
409 : : }
410 [ - + ]: 236 : if (!PyBuffer_IsContiguous(&data, 'C')) {
411 : 0 : _PyArg_BadArgument("hexlify", "argument 'data'", "contiguous buffer", args[0]);
412 : 0 : goto exit;
413 : : }
414 [ + + ]: 236 : if (!noptargs) {
415 : 232 : goto skip_optional_pos;
416 : : }
417 [ + - ]: 4 : if (args[1]) {
418 : 4 : sep = args[1];
419 [ - + ]: 4 : if (!--noptargs) {
420 : 0 : goto skip_optional_pos;
421 : : }
422 : : }
423 : 4 : bytes_per_sep = _PyLong_AsInt(args[2]);
424 [ - + - - ]: 4 : if (bytes_per_sep == -1 && PyErr_Occurred()) {
425 : 0 : goto exit;
426 : : }
427 : 4 : skip_optional_pos:
428 : 236 : return_value = binascii_hexlify_impl(module, &data, sep, bytes_per_sep);
429 : :
430 : 246 : exit:
431 : : /* Cleanup for data */
432 [ + + ]: 246 : if (data.obj) {
433 : 236 : PyBuffer_Release(&data);
434 : : }
435 : :
436 : 246 : return return_value;
437 : : }
438 : :
439 : : PyDoc_STRVAR(binascii_a2b_hex__doc__,
440 : : "a2b_hex($module, hexstr, /)\n"
441 : : "--\n"
442 : : "\n"
443 : : "Binary data of hexadecimal representation.\n"
444 : : "\n"
445 : : "hexstr must contain an even number of hex digits (upper or lower case).\n"
446 : : "This function is also available as \"unhexlify()\".");
447 : :
448 : : #define BINASCII_A2B_HEX_METHODDEF \
449 : : {"a2b_hex", (PyCFunction)binascii_a2b_hex, METH_O, binascii_a2b_hex__doc__},
450 : :
451 : : static PyObject *
452 : : binascii_a2b_hex_impl(PyObject *module, Py_buffer *hexstr);
453 : :
454 : : static PyObject *
455 : 58 : binascii_a2b_hex(PyObject *module, PyObject *arg)
456 : : {
457 : 58 : PyObject *return_value = NULL;
458 : 58 : Py_buffer hexstr = {NULL, NULL};
459 : :
460 [ + + ]: 58 : if (!ascii_buffer_converter(arg, &hexstr)) {
461 : 4 : goto exit;
462 : : }
463 : 54 : return_value = binascii_a2b_hex_impl(module, &hexstr);
464 : :
465 : 58 : exit:
466 : : /* Cleanup for hexstr */
467 [ + + ]: 58 : if (hexstr.obj)
468 : 50 : PyBuffer_Release(&hexstr);
469 : :
470 : 58 : return return_value;
471 : : }
472 : :
473 : : PyDoc_STRVAR(binascii_unhexlify__doc__,
474 : : "unhexlify($module, hexstr, /)\n"
475 : : "--\n"
476 : : "\n"
477 : : "Binary data of hexadecimal representation.\n"
478 : : "\n"
479 : : "hexstr must contain an even number of hex digits (upper or lower case).");
480 : :
481 : : #define BINASCII_UNHEXLIFY_METHODDEF \
482 : : {"unhexlify", (PyCFunction)binascii_unhexlify, METH_O, binascii_unhexlify__doc__},
483 : :
484 : : static PyObject *
485 : : binascii_unhexlify_impl(PyObject *module, Py_buffer *hexstr);
486 : :
487 : : static PyObject *
488 : 17422 : binascii_unhexlify(PyObject *module, PyObject *arg)
489 : : {
490 : 17422 : PyObject *return_value = NULL;
491 : 17422 : Py_buffer hexstr = {NULL, NULL};
492 : :
493 [ + + ]: 17422 : if (!ascii_buffer_converter(arg, &hexstr)) {
494 : 4 : goto exit;
495 : : }
496 : 17418 : return_value = binascii_unhexlify_impl(module, &hexstr);
497 : :
498 : 17422 : exit:
499 : : /* Cleanup for hexstr */
500 [ + + ]: 17422 : if (hexstr.obj)
501 : 17068 : PyBuffer_Release(&hexstr);
502 : :
503 : 17422 : return return_value;
504 : : }
505 : :
506 : : PyDoc_STRVAR(binascii_a2b_qp__doc__,
507 : : "a2b_qp($module, /, data, header=False)\n"
508 : : "--\n"
509 : : "\n"
510 : : "Decode a string of qp-encoded data.");
511 : :
512 : : #define BINASCII_A2B_QP_METHODDEF \
513 : : {"a2b_qp", _PyCFunction_CAST(binascii_a2b_qp), METH_FASTCALL|METH_KEYWORDS, binascii_a2b_qp__doc__},
514 : :
515 : : static PyObject *
516 : : binascii_a2b_qp_impl(PyObject *module, Py_buffer *data, int header);
517 : :
518 : : static PyObject *
519 : 166 : binascii_a2b_qp(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
520 : : {
521 : 166 : PyObject *return_value = NULL;
522 : : static const char * const _keywords[] = {"data", "header", NULL};
523 : : static _PyArg_Parser _parser = {NULL, _keywords, "a2b_qp", 0};
524 : : PyObject *argsbuf[2];
525 [ + + ]: 166 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
526 : 166 : Py_buffer data = {NULL, NULL};
527 : 166 : int header = 0;
528 : :
529 [ + + + + : 166 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+ - - + ]
530 [ + + ]: 166 : if (!args) {
531 : 4 : goto exit;
532 : : }
533 [ + + ]: 162 : if (!ascii_buffer_converter(args[0], &data)) {
534 : 4 : goto exit;
535 : : }
536 [ + + ]: 158 : if (!noptargs) {
537 : 72 : goto skip_optional_pos;
538 : : }
539 : 86 : header = _PyLong_AsInt(args[1]);
540 [ - + - - ]: 86 : if (header == -1 && PyErr_Occurred()) {
541 : 0 : goto exit;
542 : : }
543 : 86 : skip_optional_pos:
544 : 158 : return_value = binascii_a2b_qp_impl(module, &data, header);
545 : :
546 : 166 : exit:
547 : : /* Cleanup for data */
548 [ + + ]: 166 : if (data.obj)
549 : 154 : PyBuffer_Release(&data);
550 : :
551 : 166 : return return_value;
552 : : }
553 : :
554 : : PyDoc_STRVAR(binascii_b2a_qp__doc__,
555 : : "b2a_qp($module, /, data, quotetabs=False, istext=True, header=False)\n"
556 : : "--\n"
557 : : "\n"
558 : : "Encode a string using quoted-printable encoding.\n"
559 : : "\n"
560 : : "On encoding, when istext is set, newlines are not encoded, and white\n"
561 : : "space at end of lines is. When istext is not set, \\r and \\n (CR/LF)\n"
562 : : "are both encoded. When quotetabs is set, space and tabs are encoded.");
563 : :
564 : : #define BINASCII_B2A_QP_METHODDEF \
565 : : {"b2a_qp", _PyCFunction_CAST(binascii_b2a_qp), METH_FASTCALL|METH_KEYWORDS, binascii_b2a_qp__doc__},
566 : :
567 : : static PyObject *
568 : : binascii_b2a_qp_impl(PyObject *module, Py_buffer *data, int quotetabs,
569 : : int istext, int header);
570 : :
571 : : static PyObject *
572 : 246 : binascii_b2a_qp(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
573 : : {
574 : 246 : PyObject *return_value = NULL;
575 : : static const char * const _keywords[] = {"data", "quotetabs", "istext", "header", NULL};
576 : : static _PyArg_Parser _parser = {NULL, _keywords, "b2a_qp", 0};
577 : : PyObject *argsbuf[4];
578 [ + + ]: 246 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
579 : 246 : Py_buffer data = {NULL, NULL};
580 : 246 : int quotetabs = 0;
581 : 246 : int istext = 1;
582 : 246 : int header = 0;
583 : :
584 [ + + + + : 246 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 4, 0, argsbuf);
+ - - + ]
585 [ + + ]: 246 : if (!args) {
586 : 8 : goto exit;
587 : : }
588 [ + + ]: 238 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
589 : 4 : goto exit;
590 : : }
591 [ - + ]: 234 : if (!PyBuffer_IsContiguous(&data, 'C')) {
592 : 0 : _PyArg_BadArgument("b2a_qp", "argument 'data'", "contiguous buffer", args[0]);
593 : 0 : goto exit;
594 : : }
595 [ + + ]: 234 : if (!noptargs) {
596 : 112 : goto skip_optional_pos;
597 : : }
598 [ + + ]: 122 : if (args[1]) {
599 : 82 : quotetabs = _PyLong_AsInt(args[1]);
600 [ - + - - ]: 82 : if (quotetabs == -1 && PyErr_Occurred()) {
601 : 0 : goto exit;
602 : : }
603 [ + + ]: 82 : if (!--noptargs) {
604 : 28 : goto skip_optional_pos;
605 : : }
606 : : }
607 [ + + ]: 94 : if (args[2]) {
608 : 25 : istext = _PyLong_AsInt(args[2]);
609 [ - + - - ]: 25 : if (istext == -1 && PyErr_Occurred()) {
610 : 0 : goto exit;
611 : : }
612 [ + + ]: 25 : if (!--noptargs) {
613 : 24 : goto skip_optional_pos;
614 : : }
615 : : }
616 : 70 : header = _PyLong_AsInt(args[3]);
617 [ - + - - ]: 70 : if (header == -1 && PyErr_Occurred()) {
618 : 0 : goto exit;
619 : : }
620 : 70 : skip_optional_pos:
621 : 234 : return_value = binascii_b2a_qp_impl(module, &data, quotetabs, istext, header);
622 : :
623 : 246 : exit:
624 : : /* Cleanup for data */
625 [ + + ]: 246 : if (data.obj) {
626 : 234 : PyBuffer_Release(&data);
627 : : }
628 : :
629 : 246 : return return_value;
630 : : }
631 : : /*[clinic end generated code: output=ba9ed7b810b8762d input=a9049054013a1b77]*/
|
