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