LCOV - code coverage report
Current view: | top level - Modules/clinic - binascii.c.h (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 0 | 259 | 0.0 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 0 | 12 | 0.0 %
|  |  | Branches: | 0 | 224 | 0.0 %

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

Generated by: LCOV version 1.14