mirror of
https://github.com/python/cpython.git
synced 2024-11-25 10:54:51 +08:00
750 lines
20 KiB
C
Generated
750 lines
20 KiB
C
Generated
/*[clinic input]
|
|
preserve
|
|
[clinic start generated code]*/
|
|
|
|
PyDoc_STRVAR(binascii_a2b_uu__doc__,
|
|
"a2b_uu($module, data, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Decode a line of uuencoded data.");
|
|
|
|
#define BINASCII_A2B_UU_METHODDEF \
|
|
{"a2b_uu", (PyCFunction)binascii_a2b_uu, METH_O, binascii_a2b_uu__doc__},
|
|
|
|
static PyObject *
|
|
binascii_a2b_uu_impl(PyObject *module, Py_buffer *data);
|
|
|
|
static PyObject *
|
|
binascii_a2b_uu(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
|
|
if (!ascii_buffer_converter(arg, &data)) {
|
|
goto exit;
|
|
}
|
|
return_value = binascii_a2b_uu_impl(module, &data);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj)
|
|
PyBuffer_Release(&data);
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_b2a_uu__doc__,
|
|
"b2a_uu($module, data, /, *, backtick=False)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Uuencode line of data.");
|
|
|
|
#define BINASCII_B2A_UU_METHODDEF \
|
|
{"b2a_uu", (PyCFunction)(void(*)(void))binascii_b2a_uu, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_uu__doc__},
|
|
|
|
static PyObject *
|
|
binascii_b2a_uu_impl(PyObject *module, Py_buffer *data, int backtick);
|
|
|
|
static PyObject *
|
|
binascii_b2a_uu(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
static const char * const _keywords[] = {"", "backtick", NULL};
|
|
static _PyArg_Parser _parser = {NULL, _keywords, "b2a_uu", 0};
|
|
PyObject *argsbuf[2];
|
|
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
|
|
Py_buffer data = {NULL, NULL};
|
|
int backtick = 0;
|
|
|
|
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
|
|
if (!args) {
|
|
goto exit;
|
|
}
|
|
if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("b2a_uu", "argument 1", "contiguous buffer", args[0]);
|
|
goto exit;
|
|
}
|
|
if (!noptargs) {
|
|
goto skip_optional_kwonly;
|
|
}
|
|
backtick = _PyLong_AsInt(args[1]);
|
|
if (backtick == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional_kwonly:
|
|
return_value = binascii_b2a_uu_impl(module, &data, backtick);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_a2b_base64__doc__,
|
|
"a2b_base64($module, data, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Decode a line of base64 data.");
|
|
|
|
#define BINASCII_A2B_BASE64_METHODDEF \
|
|
{"a2b_base64", (PyCFunction)binascii_a2b_base64, METH_O, binascii_a2b_base64__doc__},
|
|
|
|
static PyObject *
|
|
binascii_a2b_base64_impl(PyObject *module, Py_buffer *data);
|
|
|
|
static PyObject *
|
|
binascii_a2b_base64(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
|
|
if (!ascii_buffer_converter(arg, &data)) {
|
|
goto exit;
|
|
}
|
|
return_value = binascii_a2b_base64_impl(module, &data);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj)
|
|
PyBuffer_Release(&data);
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_b2a_base64__doc__,
|
|
"b2a_base64($module, data, /, *, newline=True)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Base64-code line of data.");
|
|
|
|
#define BINASCII_B2A_BASE64_METHODDEF \
|
|
{"b2a_base64", (PyCFunction)(void(*)(void))binascii_b2a_base64, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_base64__doc__},
|
|
|
|
static PyObject *
|
|
binascii_b2a_base64_impl(PyObject *module, Py_buffer *data, int newline);
|
|
|
|
static PyObject *
|
|
binascii_b2a_base64(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
static const char * const _keywords[] = {"", "newline", NULL};
|
|
static _PyArg_Parser _parser = {NULL, _keywords, "b2a_base64", 0};
|
|
PyObject *argsbuf[2];
|
|
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
|
|
Py_buffer data = {NULL, NULL};
|
|
int newline = 1;
|
|
|
|
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
|
|
if (!args) {
|
|
goto exit;
|
|
}
|
|
if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("b2a_base64", "argument 1", "contiguous buffer", args[0]);
|
|
goto exit;
|
|
}
|
|
if (!noptargs) {
|
|
goto skip_optional_kwonly;
|
|
}
|
|
newline = _PyLong_AsInt(args[1]);
|
|
if (newline == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional_kwonly:
|
|
return_value = binascii_b2a_base64_impl(module, &data, newline);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_a2b_hqx__doc__,
|
|
"a2b_hqx($module, data, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Decode .hqx coding.");
|
|
|
|
#define BINASCII_A2B_HQX_METHODDEF \
|
|
{"a2b_hqx", (PyCFunction)binascii_a2b_hqx, METH_O, binascii_a2b_hqx__doc__},
|
|
|
|
static PyObject *
|
|
binascii_a2b_hqx_impl(PyObject *module, Py_buffer *data);
|
|
|
|
static PyObject *
|
|
binascii_a2b_hqx(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
|
|
if (!ascii_buffer_converter(arg, &data)) {
|
|
goto exit;
|
|
}
|
|
return_value = binascii_a2b_hqx_impl(module, &data);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj)
|
|
PyBuffer_Release(&data);
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_rlecode_hqx__doc__,
|
|
"rlecode_hqx($module, data, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Binhex RLE-code binary data.");
|
|
|
|
#define BINASCII_RLECODE_HQX_METHODDEF \
|
|
{"rlecode_hqx", (PyCFunction)binascii_rlecode_hqx, METH_O, binascii_rlecode_hqx__doc__},
|
|
|
|
static PyObject *
|
|
binascii_rlecode_hqx_impl(PyObject *module, Py_buffer *data);
|
|
|
|
static PyObject *
|
|
binascii_rlecode_hqx(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
|
|
if (PyObject_GetBuffer(arg, &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("rlecode_hqx", "argument", "contiguous buffer", arg);
|
|
goto exit;
|
|
}
|
|
return_value = binascii_rlecode_hqx_impl(module, &data);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_b2a_hqx__doc__,
|
|
"b2a_hqx($module, data, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Encode .hqx data.");
|
|
|
|
#define BINASCII_B2A_HQX_METHODDEF \
|
|
{"b2a_hqx", (PyCFunction)binascii_b2a_hqx, METH_O, binascii_b2a_hqx__doc__},
|
|
|
|
static PyObject *
|
|
binascii_b2a_hqx_impl(PyObject *module, Py_buffer *data);
|
|
|
|
static PyObject *
|
|
binascii_b2a_hqx(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
|
|
if (PyObject_GetBuffer(arg, &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("b2a_hqx", "argument", "contiguous buffer", arg);
|
|
goto exit;
|
|
}
|
|
return_value = binascii_b2a_hqx_impl(module, &data);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_rledecode_hqx__doc__,
|
|
"rledecode_hqx($module, data, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Decode hexbin RLE-coded string.");
|
|
|
|
#define BINASCII_RLEDECODE_HQX_METHODDEF \
|
|
{"rledecode_hqx", (PyCFunction)binascii_rledecode_hqx, METH_O, binascii_rledecode_hqx__doc__},
|
|
|
|
static PyObject *
|
|
binascii_rledecode_hqx_impl(PyObject *module, Py_buffer *data);
|
|
|
|
static PyObject *
|
|
binascii_rledecode_hqx(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
|
|
if (PyObject_GetBuffer(arg, &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("rledecode_hqx", "argument", "contiguous buffer", arg);
|
|
goto exit;
|
|
}
|
|
return_value = binascii_rledecode_hqx_impl(module, &data);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_crc_hqx__doc__,
|
|
"crc_hqx($module, data, crc, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Compute CRC-CCITT incrementally.");
|
|
|
|
#define BINASCII_CRC_HQX_METHODDEF \
|
|
{"crc_hqx", (PyCFunction)(void(*)(void))binascii_crc_hqx, METH_FASTCALL, binascii_crc_hqx__doc__},
|
|
|
|
static PyObject *
|
|
binascii_crc_hqx_impl(PyObject *module, Py_buffer *data, unsigned int crc);
|
|
|
|
static PyObject *
|
|
binascii_crc_hqx(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
unsigned int crc;
|
|
|
|
if (!_PyArg_CheckPositional("crc_hqx", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("crc_hqx", "argument 1", "contiguous buffer", args[0]);
|
|
goto exit;
|
|
}
|
|
crc = (unsigned int)PyLong_AsUnsignedLongMask(args[1]);
|
|
if (crc == (unsigned int)-1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
return_value = binascii_crc_hqx_impl(module, &data, crc);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_crc32__doc__,
|
|
"crc32($module, data, crc=0, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Compute CRC-32 incrementally.");
|
|
|
|
#define BINASCII_CRC32_METHODDEF \
|
|
{"crc32", (PyCFunction)(void(*)(void))binascii_crc32, METH_FASTCALL, binascii_crc32__doc__},
|
|
|
|
static unsigned int
|
|
binascii_crc32_impl(PyObject *module, Py_buffer *data, unsigned int crc);
|
|
|
|
static PyObject *
|
|
binascii_crc32(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
unsigned int crc = 0;
|
|
unsigned int _return_value;
|
|
|
|
if (!_PyArg_CheckPositional("crc32", nargs, 1, 2)) {
|
|
goto exit;
|
|
}
|
|
if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("crc32", "argument 1", "contiguous buffer", args[0]);
|
|
goto exit;
|
|
}
|
|
if (nargs < 2) {
|
|
goto skip_optional;
|
|
}
|
|
crc = (unsigned int)PyLong_AsUnsignedLongMask(args[1]);
|
|
if (crc == (unsigned int)-1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional:
|
|
_return_value = binascii_crc32_impl(module, &data, crc);
|
|
if ((_return_value == (unsigned int)-1) && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
return_value = PyLong_FromUnsignedLong((unsigned long)_return_value);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_b2a_hex__doc__,
|
|
"b2a_hex($module, /, data, sep=<unrepresentable>, bytes_per_sep=1)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Hexadecimal representation of binary data.\n"
|
|
"\n"
|
|
" sep\n"
|
|
" An optional single character or byte to separate hex bytes.\n"
|
|
" bytes_per_sep\n"
|
|
" How many bytes between separators. Positive values count from the\n"
|
|
" right, negative values count from the left.\n"
|
|
"\n"
|
|
"The return value is a bytes object. This function is also\n"
|
|
"available as \"hexlify()\".\n"
|
|
"\n"
|
|
"Example:\n"
|
|
">>> binascii.b2a_hex(b\'\\xb9\\x01\\xef\')\n"
|
|
"b\'b901ef\'\n"
|
|
">>> binascii.hexlify(b\'\\xb9\\x01\\xef\', \':\')\n"
|
|
"b\'b9:01:ef\'\n"
|
|
">>> binascii.b2a_hex(b\'\\xb9\\x01\\xef\', b\'_\', 2)\n"
|
|
"b\'b9_01ef\'");
|
|
|
|
#define BINASCII_B2A_HEX_METHODDEF \
|
|
{"b2a_hex", (PyCFunction)(void(*)(void))binascii_b2a_hex, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_hex__doc__},
|
|
|
|
static PyObject *
|
|
binascii_b2a_hex_impl(PyObject *module, Py_buffer *data, PyObject *sep,
|
|
int bytes_per_sep);
|
|
|
|
static PyObject *
|
|
binascii_b2a_hex(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
static const char * const _keywords[] = {"data", "sep", "bytes_per_sep", NULL};
|
|
static _PyArg_Parser _parser = {NULL, _keywords, "b2a_hex", 0};
|
|
PyObject *argsbuf[3];
|
|
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
|
|
Py_buffer data = {NULL, NULL};
|
|
PyObject *sep = NULL;
|
|
int bytes_per_sep = 1;
|
|
|
|
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
|
|
if (!args) {
|
|
goto exit;
|
|
}
|
|
if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("b2a_hex", "argument 'data'", "contiguous buffer", args[0]);
|
|
goto exit;
|
|
}
|
|
if (!noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
if (args[1]) {
|
|
sep = args[1];
|
|
if (!--noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
}
|
|
bytes_per_sep = _PyLong_AsInt(args[2]);
|
|
if (bytes_per_sep == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional_pos:
|
|
return_value = binascii_b2a_hex_impl(module, &data, sep, bytes_per_sep);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_hexlify__doc__,
|
|
"hexlify($module, /, data, sep=<unrepresentable>, bytes_per_sep=1)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Hexadecimal representation of binary data.\n"
|
|
"\n"
|
|
" sep\n"
|
|
" An optional single character or byte to separate hex bytes.\n"
|
|
" bytes_per_sep\n"
|
|
" How many bytes between separators. Positive values count from the\n"
|
|
" right, negative values count from the left.\n"
|
|
"\n"
|
|
"The return value is a bytes object. This function is also\n"
|
|
"available as \"b2a_hex()\".");
|
|
|
|
#define BINASCII_HEXLIFY_METHODDEF \
|
|
{"hexlify", (PyCFunction)(void(*)(void))binascii_hexlify, METH_FASTCALL|METH_KEYWORDS, binascii_hexlify__doc__},
|
|
|
|
static PyObject *
|
|
binascii_hexlify_impl(PyObject *module, Py_buffer *data, PyObject *sep,
|
|
int bytes_per_sep);
|
|
|
|
static PyObject *
|
|
binascii_hexlify(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
static const char * const _keywords[] = {"data", "sep", "bytes_per_sep", NULL};
|
|
static _PyArg_Parser _parser = {NULL, _keywords, "hexlify", 0};
|
|
PyObject *argsbuf[3];
|
|
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
|
|
Py_buffer data = {NULL, NULL};
|
|
PyObject *sep = NULL;
|
|
int bytes_per_sep = 1;
|
|
|
|
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
|
|
if (!args) {
|
|
goto exit;
|
|
}
|
|
if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("hexlify", "argument 'data'", "contiguous buffer", args[0]);
|
|
goto exit;
|
|
}
|
|
if (!noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
if (args[1]) {
|
|
sep = args[1];
|
|
if (!--noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
}
|
|
bytes_per_sep = _PyLong_AsInt(args[2]);
|
|
if (bytes_per_sep == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional_pos:
|
|
return_value = binascii_hexlify_impl(module, &data, sep, bytes_per_sep);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_a2b_hex__doc__,
|
|
"a2b_hex($module, hexstr, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Binary data of hexadecimal representation.\n"
|
|
"\n"
|
|
"hexstr must contain an even number of hex digits (upper or lower case).\n"
|
|
"This function is also available as \"unhexlify()\".");
|
|
|
|
#define BINASCII_A2B_HEX_METHODDEF \
|
|
{"a2b_hex", (PyCFunction)binascii_a2b_hex, METH_O, binascii_a2b_hex__doc__},
|
|
|
|
static PyObject *
|
|
binascii_a2b_hex_impl(PyObject *module, Py_buffer *hexstr);
|
|
|
|
static PyObject *
|
|
binascii_a2b_hex(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer hexstr = {NULL, NULL};
|
|
|
|
if (!ascii_buffer_converter(arg, &hexstr)) {
|
|
goto exit;
|
|
}
|
|
return_value = binascii_a2b_hex_impl(module, &hexstr);
|
|
|
|
exit:
|
|
/* Cleanup for hexstr */
|
|
if (hexstr.obj)
|
|
PyBuffer_Release(&hexstr);
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_unhexlify__doc__,
|
|
"unhexlify($module, hexstr, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Binary data of hexadecimal representation.\n"
|
|
"\n"
|
|
"hexstr must contain an even number of hex digits (upper or lower case).");
|
|
|
|
#define BINASCII_UNHEXLIFY_METHODDEF \
|
|
{"unhexlify", (PyCFunction)binascii_unhexlify, METH_O, binascii_unhexlify__doc__},
|
|
|
|
static PyObject *
|
|
binascii_unhexlify_impl(PyObject *module, Py_buffer *hexstr);
|
|
|
|
static PyObject *
|
|
binascii_unhexlify(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer hexstr = {NULL, NULL};
|
|
|
|
if (!ascii_buffer_converter(arg, &hexstr)) {
|
|
goto exit;
|
|
}
|
|
return_value = binascii_unhexlify_impl(module, &hexstr);
|
|
|
|
exit:
|
|
/* Cleanup for hexstr */
|
|
if (hexstr.obj)
|
|
PyBuffer_Release(&hexstr);
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_a2b_qp__doc__,
|
|
"a2b_qp($module, /, data, header=False)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Decode a string of qp-encoded data.");
|
|
|
|
#define BINASCII_A2B_QP_METHODDEF \
|
|
{"a2b_qp", (PyCFunction)(void(*)(void))binascii_a2b_qp, METH_FASTCALL|METH_KEYWORDS, binascii_a2b_qp__doc__},
|
|
|
|
static PyObject *
|
|
binascii_a2b_qp_impl(PyObject *module, Py_buffer *data, int header);
|
|
|
|
static PyObject *
|
|
binascii_a2b_qp(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
static const char * const _keywords[] = {"data", "header", NULL};
|
|
static _PyArg_Parser _parser = {NULL, _keywords, "a2b_qp", 0};
|
|
PyObject *argsbuf[2];
|
|
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
|
|
Py_buffer data = {NULL, NULL};
|
|
int header = 0;
|
|
|
|
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
|
|
if (!args) {
|
|
goto exit;
|
|
}
|
|
if (!ascii_buffer_converter(args[0], &data)) {
|
|
goto exit;
|
|
}
|
|
if (!noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
header = _PyLong_AsInt(args[1]);
|
|
if (header == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional_pos:
|
|
return_value = binascii_a2b_qp_impl(module, &data, header);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj)
|
|
PyBuffer_Release(&data);
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_b2a_qp__doc__,
|
|
"b2a_qp($module, /, data, quotetabs=False, istext=True, header=False)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Encode a string using quoted-printable encoding.\n"
|
|
"\n"
|
|
"On encoding, when istext is set, newlines are not encoded, and white\n"
|
|
"space at end of lines is. When istext is not set, \\r and \\n (CR/LF)\n"
|
|
"are both encoded. When quotetabs is set, space and tabs are encoded.");
|
|
|
|
#define BINASCII_B2A_QP_METHODDEF \
|
|
{"b2a_qp", (PyCFunction)(void(*)(void))binascii_b2a_qp, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_qp__doc__},
|
|
|
|
static PyObject *
|
|
binascii_b2a_qp_impl(PyObject *module, Py_buffer *data, int quotetabs,
|
|
int istext, int header);
|
|
|
|
static PyObject *
|
|
binascii_b2a_qp(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
static const char * const _keywords[] = {"data", "quotetabs", "istext", "header", NULL};
|
|
static _PyArg_Parser _parser = {NULL, _keywords, "b2a_qp", 0};
|
|
PyObject *argsbuf[4];
|
|
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
|
|
Py_buffer data = {NULL, NULL};
|
|
int quotetabs = 0;
|
|
int istext = 1;
|
|
int header = 0;
|
|
|
|
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 4, 0, argsbuf);
|
|
if (!args) {
|
|
goto exit;
|
|
}
|
|
if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("b2a_qp", "argument 'data'", "contiguous buffer", args[0]);
|
|
goto exit;
|
|
}
|
|
if (!noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
if (args[1]) {
|
|
quotetabs = _PyLong_AsInt(args[1]);
|
|
if (quotetabs == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
if (!--noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
}
|
|
if (args[2]) {
|
|
istext = _PyLong_AsInt(args[2]);
|
|
if (istext == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
if (!--noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
}
|
|
header = _PyLong_AsInt(args[3]);
|
|
if (header == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional_pos:
|
|
return_value = binascii_b2a_qp_impl(module, &data, quotetabs, istext, header);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
/*[clinic end generated code: output=95a0178f30801b89 input=a9049054013a1b77]*/
|