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 | 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 * |
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 | backtick = _PyLong_AsInt(args[1]); |
74 | if (backtick == -1 && PyErr_Occurred()) { |
75 | goto exit; |
76 | } |
77 | skip_optional_kwonly: |
78 | return_value = binascii_b2a_uu_impl(module, &data, backtick); |
79 | |
80 | exit: |
81 | /* Cleanup for data */ |
82 | if (data.obj) { |
83 | PyBuffer_Release(&data); |
84 | } |
85 | |
86 | return return_value; |
87 | } |
88 | |
89 | PyDoc_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 | |
98 | static PyObject * |
99 | binascii_a2b_base64_impl(PyObject *module, Py_buffer *data); |
100 | |
101 | static PyObject * |
102 | binascii_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 | |
112 | exit: |
113 | /* Cleanup for data */ |
114 | if (data.obj) |
115 | PyBuffer_Release(&data); |
116 | |
117 | return return_value; |
118 | } |
119 | |
120 | PyDoc_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 | |
129 | static PyObject * |
130 | binascii_b2a_base64_impl(PyObject *module, Py_buffer *data, int newline); |
131 | |
132 | static PyObject * |
133 | binascii_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 | } |
161 | skip_optional_kwonly: |
162 | return_value = binascii_b2a_base64_impl(module, &data, newline); |
163 | |
164 | exit: |
165 | /* Cleanup for data */ |
166 | if (data.obj) { |
167 | PyBuffer_Release(&data); |
168 | } |
169 | |
170 | return return_value; |
171 | } |
172 | |
173 | PyDoc_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 | |
182 | static PyObject * |
183 | binascii_a2b_hqx_impl(PyObject *module, Py_buffer *data); |
184 | |
185 | static PyObject * |
186 | binascii_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 | |
196 | exit: |
197 | /* Cleanup for data */ |
198 | if (data.obj) |
199 | PyBuffer_Release(&data); |
200 | |
201 | return return_value; |
202 | } |
203 | |
204 | PyDoc_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 | |
213 | static PyObject * |
214 | binascii_rlecode_hqx_impl(PyObject *module, Py_buffer *data); |
215 | |
216 | static PyObject * |
217 | binascii_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 | |
231 | exit: |
232 | /* Cleanup for data */ |
233 | if (data.obj) { |
234 | PyBuffer_Release(&data); |
235 | } |
236 | |
237 | return return_value; |
238 | } |
239 | |
240 | PyDoc_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 | |
249 | static PyObject * |
250 | binascii_b2a_hqx_impl(PyObject *module, Py_buffer *data); |
251 | |
252 | static PyObject * |
253 | binascii_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 | |
267 | exit: |
268 | /* Cleanup for data */ |
269 | if (data.obj) { |
270 | PyBuffer_Release(&data); |
271 | } |
272 | |
273 | return return_value; |
274 | } |
275 | |
276 | PyDoc_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 | |
285 | static PyObject * |
286 | binascii_rledecode_hqx_impl(PyObject *module, Py_buffer *data); |
287 | |
288 | static PyObject * |
289 | binascii_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 | |
303 | exit: |
304 | /* Cleanup for data */ |
305 | if (data.obj) { |
306 | PyBuffer_Release(&data); |
307 | } |
308 | |
309 | return return_value; |
310 | } |
311 | |
312 | PyDoc_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 | |
321 | static PyObject * |
322 | binascii_crc_hqx_impl(PyObject *module, Py_buffer *data, unsigned int crc); |
323 | |
324 | static PyObject * |
325 | binascii_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 | |
347 | exit: |
348 | /* Cleanup for data */ |
349 | if (data.obj) { |
350 | PyBuffer_Release(&data); |
351 | } |
352 | |
353 | return return_value; |
354 | } |
355 | |
356 | PyDoc_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 | |
365 | static unsigned int |
366 | binascii_crc32_impl(PyObject *module, Py_buffer *data, unsigned int crc); |
367 | |
368 | static PyObject * |
369 | binascii_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 | } |
393 | skip_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 | |
400 | exit: |
401 | /* Cleanup for data */ |
402 | if (data.obj) { |
403 | PyBuffer_Release(&data); |
404 | } |
405 | |
406 | return return_value; |
407 | } |
408 | |
409 | PyDoc_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 | |
435 | static PyObject * |
436 | binascii_b2a_hex_impl(PyObject *module, Py_buffer *data, PyObject *sep, |
437 | int bytes_per_sep); |
438 | |
439 | static PyObject * |
440 | binascii_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 | } |
475 | skip_optional_pos: |
476 | return_value = binascii_b2a_hex_impl(module, &data, sep, bytes_per_sep); |
477 | |
478 | exit: |
479 | /* Cleanup for data */ |
480 | if (data.obj) { |
481 | PyBuffer_Release(&data); |
482 | } |
483 | |
484 | return return_value; |
485 | } |
486 | |
487 | PyDoc_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 | |
505 | static PyObject * |
506 | binascii_hexlify_impl(PyObject *module, Py_buffer *data, PyObject *sep, |
507 | int bytes_per_sep); |
508 | |
509 | static PyObject * |
510 | binascii_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 | } |
545 | skip_optional_pos: |
546 | return_value = binascii_hexlify_impl(module, &data, sep, bytes_per_sep); |
547 | |
548 | exit: |
549 | /* Cleanup for data */ |
550 | if (data.obj) { |
551 | PyBuffer_Release(&data); |
552 | } |
553 | |
554 | return return_value; |
555 | } |
556 | |
557 | PyDoc_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 | |
569 | static PyObject * |
570 | binascii_a2b_hex_impl(PyObject *module, Py_buffer *hexstr); |
571 | |
572 | static PyObject * |
573 | binascii_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 | |
583 | exit: |
584 | /* Cleanup for hexstr */ |
585 | if (hexstr.obj) |
586 | PyBuffer_Release(&hexstr); |
587 | |
588 | return return_value; |
589 | } |
590 | |
591 | PyDoc_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 | |
602 | static PyObject * |
603 | binascii_unhexlify_impl(PyObject *module, Py_buffer *hexstr); |
604 | |
605 | static PyObject * |
606 | binascii_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 | |
616 | exit: |
617 | /* Cleanup for hexstr */ |
618 | if (hexstr.obj) |
619 | PyBuffer_Release(&hexstr); |
620 | |
621 | return return_value; |
622 | } |
623 | |
624 | PyDoc_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 | |
633 | static PyObject * |
634 | binascii_a2b_qp_impl(PyObject *module, Py_buffer *data, int ); |
635 | |
636 | static PyObject * |
637 | binascii_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 = 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 | } |
661 | skip_optional_pos: |
662 | return_value = binascii_a2b_qp_impl(module, &data, header); |
663 | |
664 | exit: |
665 | /* Cleanup for data */ |
666 | if (data.obj) |
667 | PyBuffer_Release(&data); |
668 | |
669 | return return_value; |
670 | } |
671 | |
672 | PyDoc_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 | |
685 | static PyObject * |
686 | binascii_b2a_qp_impl(PyObject *module, Py_buffer *data, int quotetabs, |
687 | int istext, int ); |
688 | |
689 | static PyObject * |
690 | binascii_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 = 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 | } |
738 | skip_optional_pos: |
739 | return_value = binascii_b2a_qp_impl(module, &data, quotetabs, istext, header); |
740 | |
741 | exit: |
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 | |