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