LCOV - code coverage report
Current view: top level - Objects/clinic - bytearrayobject.c.h (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 31 385 8.1 %
Date: 2023-03-20 08:15:36 Functions: 2 25 8.0 %
Branches: 17 292 5.8 %

           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                 :            : static int
      12                 :            : bytearray___init___impl(PyByteArrayObject *self, PyObject *arg,
      13                 :            :                         const char *encoding, const char *errors);
      14                 :            : 
      15                 :            : static int
      16                 :        417 : bytearray___init__(PyObject *self, PyObject *args, PyObject *kwargs)
      17                 :            : {
      18                 :        417 :     int return_value = -1;
      19                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
      20                 :            : 
      21                 :            :     #define NUM_KEYWORDS 3
      22                 :            :     static struct {
      23                 :            :         PyGC_Head _this_is_not_used;
      24                 :            :         PyObject_VAR_HEAD
      25                 :            :         PyObject *ob_item[NUM_KEYWORDS];
      26                 :            :     } _kwtuple = {
      27                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
      28                 :            :         .ob_item = { &_Py_ID(source), &_Py_ID(encoding), &_Py_ID(errors), },
      29                 :            :     };
      30                 :            :     #undef NUM_KEYWORDS
      31                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
      32                 :            : 
      33                 :            :     #else  // !Py_BUILD_CORE
      34                 :            :     #  define KWTUPLE NULL
      35                 :            :     #endif  // !Py_BUILD_CORE
      36                 :            : 
      37                 :            :     static const char * const _keywords[] = {"source", "encoding", "errors", NULL};
      38                 :            :     static _PyArg_Parser _parser = {
      39                 :            :         .keywords = _keywords,
      40                 :            :         .fname = "bytearray",
      41                 :            :         .kwtuple = KWTUPLE,
      42                 :            :     };
      43                 :            :     #undef KWTUPLE
      44                 :            :     PyObject *argsbuf[3];
      45                 :            :     PyObject * const *fastargs;
      46                 :        417 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
      47         [ -  + ]:        417 :     Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
      48                 :        417 :     PyObject *arg = NULL;
      49                 :        417 :     const char *encoding = NULL;
      50                 :        417 :     const char *errors = NULL;
      51                 :            : 
      52   [ +  -  +  -  :        417 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 3, 0, argsbuf);
             +  -  +  - ]
      53         [ -  + ]:        417 :     if (!fastargs) {
      54                 :          0 :         goto exit;
      55                 :            :     }
      56         [ +  + ]:        417 :     if (!noptargs) {
      57                 :         28 :         goto skip_optional_pos;
      58                 :            :     }
      59         [ +  - ]:        389 :     if (fastargs[0]) {
      60                 :        389 :         arg = fastargs[0];
      61         [ +  - ]:        389 :         if (!--noptargs) {
      62                 :        389 :             goto skip_optional_pos;
      63                 :            :         }
      64                 :            :     }
      65         [ #  # ]:          0 :     if (fastargs[1]) {
      66         [ #  # ]:          0 :         if (!PyUnicode_Check(fastargs[1])) {
      67                 :          0 :             _PyArg_BadArgument("bytearray", "argument 'encoding'", "str", fastargs[1]);
      68                 :          0 :             goto exit;
      69                 :            :         }
      70                 :            :         Py_ssize_t encoding_length;
      71                 :          0 :         encoding = PyUnicode_AsUTF8AndSize(fastargs[1], &encoding_length);
      72         [ #  # ]:          0 :         if (encoding == NULL) {
      73                 :          0 :             goto exit;
      74                 :            :         }
      75         [ #  # ]:          0 :         if (strlen(encoding) != (size_t)encoding_length) {
      76                 :          0 :             PyErr_SetString(PyExc_ValueError, "embedded null character");
      77                 :          0 :             goto exit;
      78                 :            :         }
      79         [ #  # ]:          0 :         if (!--noptargs) {
      80                 :          0 :             goto skip_optional_pos;
      81                 :            :         }
      82                 :            :     }
      83         [ #  # ]:          0 :     if (!PyUnicode_Check(fastargs[2])) {
      84                 :          0 :         _PyArg_BadArgument("bytearray", "argument 'errors'", "str", fastargs[2]);
      85                 :          0 :         goto exit;
      86                 :            :     }
      87                 :            :     Py_ssize_t errors_length;
      88                 :          0 :     errors = PyUnicode_AsUTF8AndSize(fastargs[2], &errors_length);
      89         [ #  # ]:          0 :     if (errors == NULL) {
      90                 :          0 :         goto exit;
      91                 :            :     }
      92         [ #  # ]:          0 :     if (strlen(errors) != (size_t)errors_length) {
      93                 :          0 :         PyErr_SetString(PyExc_ValueError, "embedded null character");
      94                 :          0 :         goto exit;
      95                 :            :     }
      96                 :          0 : skip_optional_pos:
      97                 :        417 :     return_value = bytearray___init___impl((PyByteArrayObject *)self, arg, encoding, errors);
      98                 :            : 
      99                 :        417 : exit:
     100                 :        417 :     return return_value;
     101                 :            : }
     102                 :            : 
     103                 :            : PyDoc_STRVAR(bytearray_clear__doc__,
     104                 :            : "clear($self, /)\n"
     105                 :            : "--\n"
     106                 :            : "\n"
     107                 :            : "Remove all items from the bytearray.");
     108                 :            : 
     109                 :            : #define BYTEARRAY_CLEAR_METHODDEF    \
     110                 :            :     {"clear", (PyCFunction)bytearray_clear, METH_NOARGS, bytearray_clear__doc__},
     111                 :            : 
     112                 :            : static PyObject *
     113                 :            : bytearray_clear_impl(PyByteArrayObject *self);
     114                 :            : 
     115                 :            : static PyObject *
     116                 :          0 : bytearray_clear(PyByteArrayObject *self, PyObject *Py_UNUSED(ignored))
     117                 :            : {
     118                 :          0 :     return bytearray_clear_impl(self);
     119                 :            : }
     120                 :            : 
     121                 :            : PyDoc_STRVAR(bytearray_copy__doc__,
     122                 :            : "copy($self, /)\n"
     123                 :            : "--\n"
     124                 :            : "\n"
     125                 :            : "Return a copy of B.");
     126                 :            : 
     127                 :            : #define BYTEARRAY_COPY_METHODDEF    \
     128                 :            :     {"copy", (PyCFunction)bytearray_copy, METH_NOARGS, bytearray_copy__doc__},
     129                 :            : 
     130                 :            : static PyObject *
     131                 :            : bytearray_copy_impl(PyByteArrayObject *self);
     132                 :            : 
     133                 :            : static PyObject *
     134                 :          0 : bytearray_copy(PyByteArrayObject *self, PyObject *Py_UNUSED(ignored))
     135                 :            : {
     136                 :          0 :     return bytearray_copy_impl(self);
     137                 :            : }
     138                 :            : 
     139                 :            : PyDoc_STRVAR(bytearray_removeprefix__doc__,
     140                 :            : "removeprefix($self, prefix, /)\n"
     141                 :            : "--\n"
     142                 :            : "\n"
     143                 :            : "Return a bytearray with the given prefix string removed if present.\n"
     144                 :            : "\n"
     145                 :            : "If the bytearray starts with the prefix string, return\n"
     146                 :            : "bytearray[len(prefix):].  Otherwise, return a copy of the original\n"
     147                 :            : "bytearray.");
     148                 :            : 
     149                 :            : #define BYTEARRAY_REMOVEPREFIX_METHODDEF    \
     150                 :            :     {"removeprefix", (PyCFunction)bytearray_removeprefix, METH_O, bytearray_removeprefix__doc__},
     151                 :            : 
     152                 :            : static PyObject *
     153                 :            : bytearray_removeprefix_impl(PyByteArrayObject *self, Py_buffer *prefix);
     154                 :            : 
     155                 :            : static PyObject *
     156                 :          0 : bytearray_removeprefix(PyByteArrayObject *self, PyObject *arg)
     157                 :            : {
     158                 :          0 :     PyObject *return_value = NULL;
     159                 :          0 :     Py_buffer prefix = {NULL, NULL};
     160                 :            : 
     161         [ #  # ]:          0 :     if (PyObject_GetBuffer(arg, &prefix, PyBUF_SIMPLE) != 0) {
     162                 :          0 :         goto exit;
     163                 :            :     }
     164         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&prefix, 'C')) {
     165                 :          0 :         _PyArg_BadArgument("removeprefix", "argument", "contiguous buffer", arg);
     166                 :          0 :         goto exit;
     167                 :            :     }
     168                 :          0 :     return_value = bytearray_removeprefix_impl(self, &prefix);
     169                 :            : 
     170                 :          0 : exit:
     171                 :            :     /* Cleanup for prefix */
     172         [ #  # ]:          0 :     if (prefix.obj) {
     173                 :          0 :        PyBuffer_Release(&prefix);
     174                 :            :     }
     175                 :            : 
     176                 :          0 :     return return_value;
     177                 :            : }
     178                 :            : 
     179                 :            : PyDoc_STRVAR(bytearray_removesuffix__doc__,
     180                 :            : "removesuffix($self, suffix, /)\n"
     181                 :            : "--\n"
     182                 :            : "\n"
     183                 :            : "Return a bytearray with the given suffix string removed if present.\n"
     184                 :            : "\n"
     185                 :            : "If the bytearray ends with the suffix string and that suffix is not\n"
     186                 :            : "empty, return bytearray[:-len(suffix)].  Otherwise, return a copy of\n"
     187                 :            : "the original bytearray.");
     188                 :            : 
     189                 :            : #define BYTEARRAY_REMOVESUFFIX_METHODDEF    \
     190                 :            :     {"removesuffix", (PyCFunction)bytearray_removesuffix, METH_O, bytearray_removesuffix__doc__},
     191                 :            : 
     192                 :            : static PyObject *
     193                 :            : bytearray_removesuffix_impl(PyByteArrayObject *self, Py_buffer *suffix);
     194                 :            : 
     195                 :            : static PyObject *
     196                 :          0 : bytearray_removesuffix(PyByteArrayObject *self, PyObject *arg)
     197                 :            : {
     198                 :          0 :     PyObject *return_value = NULL;
     199                 :          0 :     Py_buffer suffix = {NULL, NULL};
     200                 :            : 
     201         [ #  # ]:          0 :     if (PyObject_GetBuffer(arg, &suffix, PyBUF_SIMPLE) != 0) {
     202                 :          0 :         goto exit;
     203                 :            :     }
     204         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&suffix, 'C')) {
     205                 :          0 :         _PyArg_BadArgument("removesuffix", "argument", "contiguous buffer", arg);
     206                 :          0 :         goto exit;
     207                 :            :     }
     208                 :          0 :     return_value = bytearray_removesuffix_impl(self, &suffix);
     209                 :            : 
     210                 :          0 : exit:
     211                 :            :     /* Cleanup for suffix */
     212         [ #  # ]:          0 :     if (suffix.obj) {
     213                 :          0 :        PyBuffer_Release(&suffix);
     214                 :            :     }
     215                 :            : 
     216                 :          0 :     return return_value;
     217                 :            : }
     218                 :            : 
     219                 :            : PyDoc_STRVAR(bytearray_translate__doc__,
     220                 :            : "translate($self, table, /, delete=b\'\')\n"
     221                 :            : "--\n"
     222                 :            : "\n"
     223                 :            : "Return a copy with each character mapped by the given translation table.\n"
     224                 :            : "\n"
     225                 :            : "  table\n"
     226                 :            : "    Translation table, which must be a bytes object of length 256.\n"
     227                 :            : "\n"
     228                 :            : "All characters occurring in the optional argument delete are removed.\n"
     229                 :            : "The remaining characters are mapped through the given translation table.");
     230                 :            : 
     231                 :            : #define BYTEARRAY_TRANSLATE_METHODDEF    \
     232                 :            :     {"translate", _PyCFunction_CAST(bytearray_translate), METH_FASTCALL|METH_KEYWORDS, bytearray_translate__doc__},
     233                 :            : 
     234                 :            : static PyObject *
     235                 :            : bytearray_translate_impl(PyByteArrayObject *self, PyObject *table,
     236                 :            :                          PyObject *deletechars);
     237                 :            : 
     238                 :            : static PyObject *
     239                 :         56 : bytearray_translate(PyByteArrayObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     240                 :            : {
     241                 :         56 :     PyObject *return_value = NULL;
     242                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     243                 :            : 
     244                 :            :     #define NUM_KEYWORDS 1
     245                 :            :     static struct {
     246                 :            :         PyGC_Head _this_is_not_used;
     247                 :            :         PyObject_VAR_HEAD
     248                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     249                 :            :     } _kwtuple = {
     250                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     251                 :            :         .ob_item = { &_Py_ID(delete), },
     252                 :            :     };
     253                 :            :     #undef NUM_KEYWORDS
     254                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     255                 :            : 
     256                 :            :     #else  // !Py_BUILD_CORE
     257                 :            :     #  define KWTUPLE NULL
     258                 :            :     #endif  // !Py_BUILD_CORE
     259                 :            : 
     260                 :            :     static const char * const _keywords[] = {"", "delete", NULL};
     261                 :            :     static _PyArg_Parser _parser = {
     262                 :            :         .keywords = _keywords,
     263                 :            :         .fname = "translate",
     264                 :            :         .kwtuple = KWTUPLE,
     265                 :            :     };
     266                 :            :     #undef KWTUPLE
     267                 :            :     PyObject *argsbuf[2];
     268         [ -  + ]:         56 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
     269                 :            :     PyObject *table;
     270                 :         56 :     PyObject *deletechars = NULL;
     271                 :            : 
     272   [ +  -  +  -  :         56 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
             +  -  -  + ]
     273         [ -  + ]:         56 :     if (!args) {
     274                 :          0 :         goto exit;
     275                 :            :     }
     276                 :         56 :     table = args[0];
     277         [ +  - ]:         56 :     if (!noptargs) {
     278                 :         56 :         goto skip_optional_pos;
     279                 :            :     }
     280                 :          0 :     deletechars = args[1];
     281                 :         56 : skip_optional_pos:
     282                 :         56 :     return_value = bytearray_translate_impl(self, table, deletechars);
     283                 :            : 
     284                 :         56 : exit:
     285                 :         56 :     return return_value;
     286                 :            : }
     287                 :            : 
     288                 :            : PyDoc_STRVAR(bytearray_maketrans__doc__,
     289                 :            : "maketrans(frm, to, /)\n"
     290                 :            : "--\n"
     291                 :            : "\n"
     292                 :            : "Return a translation table useable for the bytes or bytearray translate method.\n"
     293                 :            : "\n"
     294                 :            : "The returned table will be one where each byte in frm is mapped to the byte at\n"
     295                 :            : "the same position in to.\n"
     296                 :            : "\n"
     297                 :            : "The bytes objects frm and to must be of the same length.");
     298                 :            : 
     299                 :            : #define BYTEARRAY_MAKETRANS_METHODDEF    \
     300                 :            :     {"maketrans", _PyCFunction_CAST(bytearray_maketrans), METH_FASTCALL|METH_STATIC, bytearray_maketrans__doc__},
     301                 :            : 
     302                 :            : static PyObject *
     303                 :            : bytearray_maketrans_impl(Py_buffer *frm, Py_buffer *to);
     304                 :            : 
     305                 :            : static PyObject *
     306                 :          0 : bytearray_maketrans(void *null, PyObject *const *args, Py_ssize_t nargs)
     307                 :            : {
     308                 :          0 :     PyObject *return_value = NULL;
     309                 :          0 :     Py_buffer frm = {NULL, NULL};
     310                 :          0 :     Py_buffer to = {NULL, NULL};
     311                 :            : 
     312   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("maketrans", nargs, 2, 2)) {
                   #  # ]
     313                 :          0 :         goto exit;
     314                 :            :     }
     315         [ #  # ]:          0 :     if (PyObject_GetBuffer(args[0], &frm, PyBUF_SIMPLE) != 0) {
     316                 :          0 :         goto exit;
     317                 :            :     }
     318         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&frm, 'C')) {
     319                 :          0 :         _PyArg_BadArgument("maketrans", "argument 1", "contiguous buffer", args[0]);
     320                 :          0 :         goto exit;
     321                 :            :     }
     322         [ #  # ]:          0 :     if (PyObject_GetBuffer(args[1], &to, PyBUF_SIMPLE) != 0) {
     323                 :          0 :         goto exit;
     324                 :            :     }
     325         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&to, 'C')) {
     326                 :          0 :         _PyArg_BadArgument("maketrans", "argument 2", "contiguous buffer", args[1]);
     327                 :          0 :         goto exit;
     328                 :            :     }
     329                 :          0 :     return_value = bytearray_maketrans_impl(&frm, &to);
     330                 :            : 
     331                 :          0 : exit:
     332                 :            :     /* Cleanup for frm */
     333         [ #  # ]:          0 :     if (frm.obj) {
     334                 :          0 :        PyBuffer_Release(&frm);
     335                 :            :     }
     336                 :            :     /* Cleanup for to */
     337         [ #  # ]:          0 :     if (to.obj) {
     338                 :          0 :        PyBuffer_Release(&to);
     339                 :            :     }
     340                 :            : 
     341                 :          0 :     return return_value;
     342                 :            : }
     343                 :            : 
     344                 :            : PyDoc_STRVAR(bytearray_replace__doc__,
     345                 :            : "replace($self, old, new, count=-1, /)\n"
     346                 :            : "--\n"
     347                 :            : "\n"
     348                 :            : "Return a copy with all occurrences of substring old replaced by new.\n"
     349                 :            : "\n"
     350                 :            : "  count\n"
     351                 :            : "    Maximum number of occurrences to replace.\n"
     352                 :            : "    -1 (the default value) means replace all occurrences.\n"
     353                 :            : "\n"
     354                 :            : "If the optional argument count is given, only the first count occurrences are\n"
     355                 :            : "replaced.");
     356                 :            : 
     357                 :            : #define BYTEARRAY_REPLACE_METHODDEF    \
     358                 :            :     {"replace", _PyCFunction_CAST(bytearray_replace), METH_FASTCALL, bytearray_replace__doc__},
     359                 :            : 
     360                 :            : static PyObject *
     361                 :            : bytearray_replace_impl(PyByteArrayObject *self, Py_buffer *old,
     362                 :            :                        Py_buffer *new, Py_ssize_t count);
     363                 :            : 
     364                 :            : static PyObject *
     365                 :          0 : bytearray_replace(PyByteArrayObject *self, PyObject *const *args, Py_ssize_t nargs)
     366                 :            : {
     367                 :          0 :     PyObject *return_value = NULL;
     368                 :          0 :     Py_buffer old = {NULL, NULL};
     369                 :          0 :     Py_buffer new = {NULL, NULL};
     370                 :          0 :     Py_ssize_t count = -1;
     371                 :            : 
     372   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("replace", nargs, 2, 3)) {
                   #  # ]
     373                 :          0 :         goto exit;
     374                 :            :     }
     375         [ #  # ]:          0 :     if (PyObject_GetBuffer(args[0], &old, PyBUF_SIMPLE) != 0) {
     376                 :          0 :         goto exit;
     377                 :            :     }
     378         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&old, 'C')) {
     379                 :          0 :         _PyArg_BadArgument("replace", "argument 1", "contiguous buffer", args[0]);
     380                 :          0 :         goto exit;
     381                 :            :     }
     382         [ #  # ]:          0 :     if (PyObject_GetBuffer(args[1], &new, PyBUF_SIMPLE) != 0) {
     383                 :          0 :         goto exit;
     384                 :            :     }
     385         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&new, 'C')) {
     386                 :          0 :         _PyArg_BadArgument("replace", "argument 2", "contiguous buffer", args[1]);
     387                 :          0 :         goto exit;
     388                 :            :     }
     389         [ #  # ]:          0 :     if (nargs < 3) {
     390                 :          0 :         goto skip_optional;
     391                 :            :     }
     392                 :            :     {
     393                 :          0 :         Py_ssize_t ival = -1;
     394                 :          0 :         PyObject *iobj = _PyNumber_Index(args[2]);
     395         [ #  # ]:          0 :         if (iobj != NULL) {
     396                 :          0 :             ival = PyLong_AsSsize_t(iobj);
     397                 :          0 :             Py_DECREF(iobj);
     398                 :            :         }
     399   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
     400                 :          0 :             goto exit;
     401                 :            :         }
     402                 :          0 :         count = ival;
     403                 :            :     }
     404                 :          0 : skip_optional:
     405                 :          0 :     return_value = bytearray_replace_impl(self, &old, &new, count);
     406                 :            : 
     407                 :          0 : exit:
     408                 :            :     /* Cleanup for old */
     409         [ #  # ]:          0 :     if (old.obj) {
     410                 :          0 :        PyBuffer_Release(&old);
     411                 :            :     }
     412                 :            :     /* Cleanup for new */
     413         [ #  # ]:          0 :     if (new.obj) {
     414                 :          0 :        PyBuffer_Release(&new);
     415                 :            :     }
     416                 :            : 
     417                 :          0 :     return return_value;
     418                 :            : }
     419                 :            : 
     420                 :            : PyDoc_STRVAR(bytearray_split__doc__,
     421                 :            : "split($self, /, sep=None, maxsplit=-1)\n"
     422                 :            : "--\n"
     423                 :            : "\n"
     424                 :            : "Return a list of the sections in the bytearray, using sep as the delimiter.\n"
     425                 :            : "\n"
     426                 :            : "  sep\n"
     427                 :            : "    The delimiter according which to split the bytearray.\n"
     428                 :            : "    None (the default value) means split on ASCII whitespace characters\n"
     429                 :            : "    (space, tab, return, newline, formfeed, vertical tab).\n"
     430                 :            : "  maxsplit\n"
     431                 :            : "    Maximum number of splits to do.\n"
     432                 :            : "    -1 (the default value) means no limit.");
     433                 :            : 
     434                 :            : #define BYTEARRAY_SPLIT_METHODDEF    \
     435                 :            :     {"split", _PyCFunction_CAST(bytearray_split), METH_FASTCALL|METH_KEYWORDS, bytearray_split__doc__},
     436                 :            : 
     437                 :            : static PyObject *
     438                 :            : bytearray_split_impl(PyByteArrayObject *self, PyObject *sep,
     439                 :            :                      Py_ssize_t maxsplit);
     440                 :            : 
     441                 :            : static PyObject *
     442                 :          0 : bytearray_split(PyByteArrayObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     443                 :            : {
     444                 :          0 :     PyObject *return_value = NULL;
     445                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     446                 :            : 
     447                 :            :     #define NUM_KEYWORDS 2
     448                 :            :     static struct {
     449                 :            :         PyGC_Head _this_is_not_used;
     450                 :            :         PyObject_VAR_HEAD
     451                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     452                 :            :     } _kwtuple = {
     453                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     454                 :            :         .ob_item = { &_Py_ID(sep), &_Py_ID(maxsplit), },
     455                 :            :     };
     456                 :            :     #undef NUM_KEYWORDS
     457                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     458                 :            : 
     459                 :            :     #else  // !Py_BUILD_CORE
     460                 :            :     #  define KWTUPLE NULL
     461                 :            :     #endif  // !Py_BUILD_CORE
     462                 :            : 
     463                 :            :     static const char * const _keywords[] = {"sep", "maxsplit", NULL};
     464                 :            :     static _PyArg_Parser _parser = {
     465                 :            :         .keywords = _keywords,
     466                 :            :         .fname = "split",
     467                 :            :         .kwtuple = KWTUPLE,
     468                 :            :     };
     469                 :            :     #undef KWTUPLE
     470                 :            :     PyObject *argsbuf[2];
     471         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     472                 :          0 :     PyObject *sep = Py_None;
     473                 :          0 :     Py_ssize_t maxsplit = -1;
     474                 :            : 
     475   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
             #  #  #  # ]
     476         [ #  # ]:          0 :     if (!args) {
     477                 :          0 :         goto exit;
     478                 :            :     }
     479         [ #  # ]:          0 :     if (!noptargs) {
     480                 :          0 :         goto skip_optional_pos;
     481                 :            :     }
     482         [ #  # ]:          0 :     if (args[0]) {
     483                 :          0 :         sep = args[0];
     484         [ #  # ]:          0 :         if (!--noptargs) {
     485                 :          0 :             goto skip_optional_pos;
     486                 :            :         }
     487                 :            :     }
     488                 :            :     {
     489                 :          0 :         Py_ssize_t ival = -1;
     490                 :          0 :         PyObject *iobj = _PyNumber_Index(args[1]);
     491         [ #  # ]:          0 :         if (iobj != NULL) {
     492                 :          0 :             ival = PyLong_AsSsize_t(iobj);
     493                 :          0 :             Py_DECREF(iobj);
     494                 :            :         }
     495   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
     496                 :          0 :             goto exit;
     497                 :            :         }
     498                 :          0 :         maxsplit = ival;
     499                 :            :     }
     500                 :          0 : skip_optional_pos:
     501                 :          0 :     return_value = bytearray_split_impl(self, sep, maxsplit);
     502                 :            : 
     503                 :          0 : exit:
     504                 :          0 :     return return_value;
     505                 :            : }
     506                 :            : 
     507                 :            : PyDoc_STRVAR(bytearray_partition__doc__,
     508                 :            : "partition($self, sep, /)\n"
     509                 :            : "--\n"
     510                 :            : "\n"
     511                 :            : "Partition the bytearray into three parts using the given separator.\n"
     512                 :            : "\n"
     513                 :            : "This will search for the separator sep in the bytearray. If the separator is\n"
     514                 :            : "found, returns a 3-tuple containing the part before the separator, the\n"
     515                 :            : "separator itself, and the part after it as new bytearray objects.\n"
     516                 :            : "\n"
     517                 :            : "If the separator is not found, returns a 3-tuple containing the copy of the\n"
     518                 :            : "original bytearray object and two empty bytearray objects.");
     519                 :            : 
     520                 :            : #define BYTEARRAY_PARTITION_METHODDEF    \
     521                 :            :     {"partition", (PyCFunction)bytearray_partition, METH_O, bytearray_partition__doc__},
     522                 :            : 
     523                 :            : PyDoc_STRVAR(bytearray_rpartition__doc__,
     524                 :            : "rpartition($self, sep, /)\n"
     525                 :            : "--\n"
     526                 :            : "\n"
     527                 :            : "Partition the bytearray into three parts using the given separator.\n"
     528                 :            : "\n"
     529                 :            : "This will search for the separator sep in the bytearray, starting at the end.\n"
     530                 :            : "If the separator is found, returns a 3-tuple containing the part before the\n"
     531                 :            : "separator, the separator itself, and the part after it as new bytearray\n"
     532                 :            : "objects.\n"
     533                 :            : "\n"
     534                 :            : "If the separator is not found, returns a 3-tuple containing two empty bytearray\n"
     535                 :            : "objects and the copy of the original bytearray object.");
     536                 :            : 
     537                 :            : #define BYTEARRAY_RPARTITION_METHODDEF    \
     538                 :            :     {"rpartition", (PyCFunction)bytearray_rpartition, METH_O, bytearray_rpartition__doc__},
     539                 :            : 
     540                 :            : PyDoc_STRVAR(bytearray_rsplit__doc__,
     541                 :            : "rsplit($self, /, sep=None, maxsplit=-1)\n"
     542                 :            : "--\n"
     543                 :            : "\n"
     544                 :            : "Return a list of the sections in the bytearray, using sep as the delimiter.\n"
     545                 :            : "\n"
     546                 :            : "  sep\n"
     547                 :            : "    The delimiter according which to split the bytearray.\n"
     548                 :            : "    None (the default value) means split on ASCII whitespace characters\n"
     549                 :            : "    (space, tab, return, newline, formfeed, vertical tab).\n"
     550                 :            : "  maxsplit\n"
     551                 :            : "    Maximum number of splits to do.\n"
     552                 :            : "    -1 (the default value) means no limit.\n"
     553                 :            : "\n"
     554                 :            : "Splitting is done starting at the end of the bytearray and working to the front.");
     555                 :            : 
     556                 :            : #define BYTEARRAY_RSPLIT_METHODDEF    \
     557                 :            :     {"rsplit", _PyCFunction_CAST(bytearray_rsplit), METH_FASTCALL|METH_KEYWORDS, bytearray_rsplit__doc__},
     558                 :            : 
     559                 :            : static PyObject *
     560                 :            : bytearray_rsplit_impl(PyByteArrayObject *self, PyObject *sep,
     561                 :            :                       Py_ssize_t maxsplit);
     562                 :            : 
     563                 :            : static PyObject *
     564                 :          0 : bytearray_rsplit(PyByteArrayObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     565                 :            : {
     566                 :          0 :     PyObject *return_value = NULL;
     567                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     568                 :            : 
     569                 :            :     #define NUM_KEYWORDS 2
     570                 :            :     static struct {
     571                 :            :         PyGC_Head _this_is_not_used;
     572                 :            :         PyObject_VAR_HEAD
     573                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     574                 :            :     } _kwtuple = {
     575                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     576                 :            :         .ob_item = { &_Py_ID(sep), &_Py_ID(maxsplit), },
     577                 :            :     };
     578                 :            :     #undef NUM_KEYWORDS
     579                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     580                 :            : 
     581                 :            :     #else  // !Py_BUILD_CORE
     582                 :            :     #  define KWTUPLE NULL
     583                 :            :     #endif  // !Py_BUILD_CORE
     584                 :            : 
     585                 :            :     static const char * const _keywords[] = {"sep", "maxsplit", NULL};
     586                 :            :     static _PyArg_Parser _parser = {
     587                 :            :         .keywords = _keywords,
     588                 :            :         .fname = "rsplit",
     589                 :            :         .kwtuple = KWTUPLE,
     590                 :            :     };
     591                 :            :     #undef KWTUPLE
     592                 :            :     PyObject *argsbuf[2];
     593         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     594                 :          0 :     PyObject *sep = Py_None;
     595                 :          0 :     Py_ssize_t maxsplit = -1;
     596                 :            : 
     597   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
             #  #  #  # ]
     598         [ #  # ]:          0 :     if (!args) {
     599                 :          0 :         goto exit;
     600                 :            :     }
     601         [ #  # ]:          0 :     if (!noptargs) {
     602                 :          0 :         goto skip_optional_pos;
     603                 :            :     }
     604         [ #  # ]:          0 :     if (args[0]) {
     605                 :          0 :         sep = args[0];
     606         [ #  # ]:          0 :         if (!--noptargs) {
     607                 :          0 :             goto skip_optional_pos;
     608                 :            :         }
     609                 :            :     }
     610                 :            :     {
     611                 :          0 :         Py_ssize_t ival = -1;
     612                 :          0 :         PyObject *iobj = _PyNumber_Index(args[1]);
     613         [ #  # ]:          0 :         if (iobj != NULL) {
     614                 :          0 :             ival = PyLong_AsSsize_t(iobj);
     615                 :          0 :             Py_DECREF(iobj);
     616                 :            :         }
     617   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
     618                 :          0 :             goto exit;
     619                 :            :         }
     620                 :          0 :         maxsplit = ival;
     621                 :            :     }
     622                 :          0 : skip_optional_pos:
     623                 :          0 :     return_value = bytearray_rsplit_impl(self, sep, maxsplit);
     624                 :            : 
     625                 :          0 : exit:
     626                 :          0 :     return return_value;
     627                 :            : }
     628                 :            : 
     629                 :            : PyDoc_STRVAR(bytearray_reverse__doc__,
     630                 :            : "reverse($self, /)\n"
     631                 :            : "--\n"
     632                 :            : "\n"
     633                 :            : "Reverse the order of the values in B in place.");
     634                 :            : 
     635                 :            : #define BYTEARRAY_REVERSE_METHODDEF    \
     636                 :            :     {"reverse", (PyCFunction)bytearray_reverse, METH_NOARGS, bytearray_reverse__doc__},
     637                 :            : 
     638                 :            : static PyObject *
     639                 :            : bytearray_reverse_impl(PyByteArrayObject *self);
     640                 :            : 
     641                 :            : static PyObject *
     642                 :          0 : bytearray_reverse(PyByteArrayObject *self, PyObject *Py_UNUSED(ignored))
     643                 :            : {
     644                 :          0 :     return bytearray_reverse_impl(self);
     645                 :            : }
     646                 :            : 
     647                 :            : PyDoc_STRVAR(bytearray_insert__doc__,
     648                 :            : "insert($self, index, item, /)\n"
     649                 :            : "--\n"
     650                 :            : "\n"
     651                 :            : "Insert a single item into the bytearray before the given index.\n"
     652                 :            : "\n"
     653                 :            : "  index\n"
     654                 :            : "    The index where the value is to be inserted.\n"
     655                 :            : "  item\n"
     656                 :            : "    The item to be inserted.");
     657                 :            : 
     658                 :            : #define BYTEARRAY_INSERT_METHODDEF    \
     659                 :            :     {"insert", _PyCFunction_CAST(bytearray_insert), METH_FASTCALL, bytearray_insert__doc__},
     660                 :            : 
     661                 :            : static PyObject *
     662                 :            : bytearray_insert_impl(PyByteArrayObject *self, Py_ssize_t index, int item);
     663                 :            : 
     664                 :            : static PyObject *
     665                 :          0 : bytearray_insert(PyByteArrayObject *self, PyObject *const *args, Py_ssize_t nargs)
     666                 :            : {
     667                 :          0 :     PyObject *return_value = NULL;
     668                 :            :     Py_ssize_t index;
     669                 :            :     int item;
     670                 :            : 
     671   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("insert", nargs, 2, 2)) {
                   #  # ]
     672                 :          0 :         goto exit;
     673                 :            :     }
     674                 :            :     {
     675                 :          0 :         Py_ssize_t ival = -1;
     676                 :          0 :         PyObject *iobj = _PyNumber_Index(args[0]);
     677         [ #  # ]:          0 :         if (iobj != NULL) {
     678                 :          0 :             ival = PyLong_AsSsize_t(iobj);
     679                 :          0 :             Py_DECREF(iobj);
     680                 :            :         }
     681   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
     682                 :          0 :             goto exit;
     683                 :            :         }
     684                 :          0 :         index = ival;
     685                 :            :     }
     686         [ #  # ]:          0 :     if (!_getbytevalue(args[1], &item)) {
     687                 :          0 :         goto exit;
     688                 :            :     }
     689                 :          0 :     return_value = bytearray_insert_impl(self, index, item);
     690                 :            : 
     691                 :          0 : exit:
     692                 :          0 :     return return_value;
     693                 :            : }
     694                 :            : 
     695                 :            : PyDoc_STRVAR(bytearray_append__doc__,
     696                 :            : "append($self, item, /)\n"
     697                 :            : "--\n"
     698                 :            : "\n"
     699                 :            : "Append a single item to the end of the bytearray.\n"
     700                 :            : "\n"
     701                 :            : "  item\n"
     702                 :            : "    The item to be appended.");
     703                 :            : 
     704                 :            : #define BYTEARRAY_APPEND_METHODDEF    \
     705                 :            :     {"append", (PyCFunction)bytearray_append, METH_O, bytearray_append__doc__},
     706                 :            : 
     707                 :            : static PyObject *
     708                 :            : bytearray_append_impl(PyByteArrayObject *self, int item);
     709                 :            : 
     710                 :            : static PyObject *
     711                 :          0 : bytearray_append(PyByteArrayObject *self, PyObject *arg)
     712                 :            : {
     713                 :          0 :     PyObject *return_value = NULL;
     714                 :            :     int item;
     715                 :            : 
     716         [ #  # ]:          0 :     if (!_getbytevalue(arg, &item)) {
     717                 :          0 :         goto exit;
     718                 :            :     }
     719                 :          0 :     return_value = bytearray_append_impl(self, item);
     720                 :            : 
     721                 :          0 : exit:
     722                 :          0 :     return return_value;
     723                 :            : }
     724                 :            : 
     725                 :            : PyDoc_STRVAR(bytearray_extend__doc__,
     726                 :            : "extend($self, iterable_of_ints, /)\n"
     727                 :            : "--\n"
     728                 :            : "\n"
     729                 :            : "Append all the items from the iterator or sequence to the end of the bytearray.\n"
     730                 :            : "\n"
     731                 :            : "  iterable_of_ints\n"
     732                 :            : "    The iterable of items to append.");
     733                 :            : 
     734                 :            : #define BYTEARRAY_EXTEND_METHODDEF    \
     735                 :            :     {"extend", (PyCFunction)bytearray_extend, METH_O, bytearray_extend__doc__},
     736                 :            : 
     737                 :            : PyDoc_STRVAR(bytearray_pop__doc__,
     738                 :            : "pop($self, index=-1, /)\n"
     739                 :            : "--\n"
     740                 :            : "\n"
     741                 :            : "Remove and return a single item from B.\n"
     742                 :            : "\n"
     743                 :            : "  index\n"
     744                 :            : "    The index from where to remove the item.\n"
     745                 :            : "    -1 (the default value) means remove the last item.\n"
     746                 :            : "\n"
     747                 :            : "If no index argument is given, will pop the last item.");
     748                 :            : 
     749                 :            : #define BYTEARRAY_POP_METHODDEF    \
     750                 :            :     {"pop", _PyCFunction_CAST(bytearray_pop), METH_FASTCALL, bytearray_pop__doc__},
     751                 :            : 
     752                 :            : static PyObject *
     753                 :            : bytearray_pop_impl(PyByteArrayObject *self, Py_ssize_t index);
     754                 :            : 
     755                 :            : static PyObject *
     756                 :          0 : bytearray_pop(PyByteArrayObject *self, PyObject *const *args, Py_ssize_t nargs)
     757                 :            : {
     758                 :          0 :     PyObject *return_value = NULL;
     759                 :          0 :     Py_ssize_t index = -1;
     760                 :            : 
     761   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("pop", nargs, 0, 1)) {
                   #  # ]
     762                 :          0 :         goto exit;
     763                 :            :     }
     764         [ #  # ]:          0 :     if (nargs < 1) {
     765                 :          0 :         goto skip_optional;
     766                 :            :     }
     767                 :            :     {
     768                 :          0 :         Py_ssize_t ival = -1;
     769                 :          0 :         PyObject *iobj = _PyNumber_Index(args[0]);
     770         [ #  # ]:          0 :         if (iobj != NULL) {
     771                 :          0 :             ival = PyLong_AsSsize_t(iobj);
     772                 :          0 :             Py_DECREF(iobj);
     773                 :            :         }
     774   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
     775                 :          0 :             goto exit;
     776                 :            :         }
     777                 :          0 :         index = ival;
     778                 :            :     }
     779                 :          0 : skip_optional:
     780                 :          0 :     return_value = bytearray_pop_impl(self, index);
     781                 :            : 
     782                 :          0 : exit:
     783                 :          0 :     return return_value;
     784                 :            : }
     785                 :            : 
     786                 :            : PyDoc_STRVAR(bytearray_remove__doc__,
     787                 :            : "remove($self, value, /)\n"
     788                 :            : "--\n"
     789                 :            : "\n"
     790                 :            : "Remove the first occurrence of a value in the bytearray.\n"
     791                 :            : "\n"
     792                 :            : "  value\n"
     793                 :            : "    The value to remove.");
     794                 :            : 
     795                 :            : #define BYTEARRAY_REMOVE_METHODDEF    \
     796                 :            :     {"remove", (PyCFunction)bytearray_remove, METH_O, bytearray_remove__doc__},
     797                 :            : 
     798                 :            : static PyObject *
     799                 :            : bytearray_remove_impl(PyByteArrayObject *self, int value);
     800                 :            : 
     801                 :            : static PyObject *
     802                 :          0 : bytearray_remove(PyByteArrayObject *self, PyObject *arg)
     803                 :            : {
     804                 :          0 :     PyObject *return_value = NULL;
     805                 :            :     int value;
     806                 :            : 
     807         [ #  # ]:          0 :     if (!_getbytevalue(arg, &value)) {
     808                 :          0 :         goto exit;
     809                 :            :     }
     810                 :          0 :     return_value = bytearray_remove_impl(self, value);
     811                 :            : 
     812                 :          0 : exit:
     813                 :          0 :     return return_value;
     814                 :            : }
     815                 :            : 
     816                 :            : PyDoc_STRVAR(bytearray_strip__doc__,
     817                 :            : "strip($self, bytes=None, /)\n"
     818                 :            : "--\n"
     819                 :            : "\n"
     820                 :            : "Strip leading and trailing bytes contained in the argument.\n"
     821                 :            : "\n"
     822                 :            : "If the argument is omitted or None, strip leading and trailing ASCII whitespace.");
     823                 :            : 
     824                 :            : #define BYTEARRAY_STRIP_METHODDEF    \
     825                 :            :     {"strip", _PyCFunction_CAST(bytearray_strip), METH_FASTCALL, bytearray_strip__doc__},
     826                 :            : 
     827                 :            : static PyObject *
     828                 :            : bytearray_strip_impl(PyByteArrayObject *self, PyObject *bytes);
     829                 :            : 
     830                 :            : static PyObject *
     831                 :          0 : bytearray_strip(PyByteArrayObject *self, PyObject *const *args, Py_ssize_t nargs)
     832                 :            : {
     833                 :          0 :     PyObject *return_value = NULL;
     834                 :          0 :     PyObject *bytes = Py_None;
     835                 :            : 
     836   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("strip", nargs, 0, 1)) {
                   #  # ]
     837                 :          0 :         goto exit;
     838                 :            :     }
     839         [ #  # ]:          0 :     if (nargs < 1) {
     840                 :          0 :         goto skip_optional;
     841                 :            :     }
     842                 :          0 :     bytes = args[0];
     843                 :          0 : skip_optional:
     844                 :          0 :     return_value = bytearray_strip_impl(self, bytes);
     845                 :            : 
     846                 :          0 : exit:
     847                 :          0 :     return return_value;
     848                 :            : }
     849                 :            : 
     850                 :            : PyDoc_STRVAR(bytearray_lstrip__doc__,
     851                 :            : "lstrip($self, bytes=None, /)\n"
     852                 :            : "--\n"
     853                 :            : "\n"
     854                 :            : "Strip leading bytes contained in the argument.\n"
     855                 :            : "\n"
     856                 :            : "If the argument is omitted or None, strip leading ASCII whitespace.");
     857                 :            : 
     858                 :            : #define BYTEARRAY_LSTRIP_METHODDEF    \
     859                 :            :     {"lstrip", _PyCFunction_CAST(bytearray_lstrip), METH_FASTCALL, bytearray_lstrip__doc__},
     860                 :            : 
     861                 :            : static PyObject *
     862                 :            : bytearray_lstrip_impl(PyByteArrayObject *self, PyObject *bytes);
     863                 :            : 
     864                 :            : static PyObject *
     865                 :          0 : bytearray_lstrip(PyByteArrayObject *self, PyObject *const *args, Py_ssize_t nargs)
     866                 :            : {
     867                 :          0 :     PyObject *return_value = NULL;
     868                 :          0 :     PyObject *bytes = Py_None;
     869                 :            : 
     870   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("lstrip", nargs, 0, 1)) {
                   #  # ]
     871                 :          0 :         goto exit;
     872                 :            :     }
     873         [ #  # ]:          0 :     if (nargs < 1) {
     874                 :          0 :         goto skip_optional;
     875                 :            :     }
     876                 :          0 :     bytes = args[0];
     877                 :          0 : skip_optional:
     878                 :          0 :     return_value = bytearray_lstrip_impl(self, bytes);
     879                 :            : 
     880                 :          0 : exit:
     881                 :          0 :     return return_value;
     882                 :            : }
     883                 :            : 
     884                 :            : PyDoc_STRVAR(bytearray_rstrip__doc__,
     885                 :            : "rstrip($self, bytes=None, /)\n"
     886                 :            : "--\n"
     887                 :            : "\n"
     888                 :            : "Strip trailing bytes contained in the argument.\n"
     889                 :            : "\n"
     890                 :            : "If the argument is omitted or None, strip trailing ASCII whitespace.");
     891                 :            : 
     892                 :            : #define BYTEARRAY_RSTRIP_METHODDEF    \
     893                 :            :     {"rstrip", _PyCFunction_CAST(bytearray_rstrip), METH_FASTCALL, bytearray_rstrip__doc__},
     894                 :            : 
     895                 :            : static PyObject *
     896                 :            : bytearray_rstrip_impl(PyByteArrayObject *self, PyObject *bytes);
     897                 :            : 
     898                 :            : static PyObject *
     899                 :          0 : bytearray_rstrip(PyByteArrayObject *self, PyObject *const *args, Py_ssize_t nargs)
     900                 :            : {
     901                 :          0 :     PyObject *return_value = NULL;
     902                 :          0 :     PyObject *bytes = Py_None;
     903                 :            : 
     904   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("rstrip", nargs, 0, 1)) {
                   #  # ]
     905                 :          0 :         goto exit;
     906                 :            :     }
     907         [ #  # ]:          0 :     if (nargs < 1) {
     908                 :          0 :         goto skip_optional;
     909                 :            :     }
     910                 :          0 :     bytes = args[0];
     911                 :          0 : skip_optional:
     912                 :          0 :     return_value = bytearray_rstrip_impl(self, bytes);
     913                 :            : 
     914                 :          0 : exit:
     915                 :          0 :     return return_value;
     916                 :            : }
     917                 :            : 
     918                 :            : PyDoc_STRVAR(bytearray_decode__doc__,
     919                 :            : "decode($self, /, encoding=\'utf-8\', errors=\'strict\')\n"
     920                 :            : "--\n"
     921                 :            : "\n"
     922                 :            : "Decode the bytearray using the codec registered for encoding.\n"
     923                 :            : "\n"
     924                 :            : "  encoding\n"
     925                 :            : "    The encoding with which to decode the bytearray.\n"
     926                 :            : "  errors\n"
     927                 :            : "    The error handling scheme to use for the handling of decoding errors.\n"
     928                 :            : "    The default is \'strict\' meaning that decoding errors raise a\n"
     929                 :            : "    UnicodeDecodeError. Other possible values are \'ignore\' and \'replace\'\n"
     930                 :            : "    as well as any other name registered with codecs.register_error that\n"
     931                 :            : "    can handle UnicodeDecodeErrors.");
     932                 :            : 
     933                 :            : #define BYTEARRAY_DECODE_METHODDEF    \
     934                 :            :     {"decode", _PyCFunction_CAST(bytearray_decode), METH_FASTCALL|METH_KEYWORDS, bytearray_decode__doc__},
     935                 :            : 
     936                 :            : static PyObject *
     937                 :            : bytearray_decode_impl(PyByteArrayObject *self, const char *encoding,
     938                 :            :                       const char *errors);
     939                 :            : 
     940                 :            : static PyObject *
     941                 :          0 : bytearray_decode(PyByteArrayObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     942                 :            : {
     943                 :          0 :     PyObject *return_value = NULL;
     944                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     945                 :            : 
     946                 :            :     #define NUM_KEYWORDS 2
     947                 :            :     static struct {
     948                 :            :         PyGC_Head _this_is_not_used;
     949                 :            :         PyObject_VAR_HEAD
     950                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     951                 :            :     } _kwtuple = {
     952                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     953                 :            :         .ob_item = { &_Py_ID(encoding), &_Py_ID(errors), },
     954                 :            :     };
     955                 :            :     #undef NUM_KEYWORDS
     956                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     957                 :            : 
     958                 :            :     #else  // !Py_BUILD_CORE
     959                 :            :     #  define KWTUPLE NULL
     960                 :            :     #endif  // !Py_BUILD_CORE
     961                 :            : 
     962                 :            :     static const char * const _keywords[] = {"encoding", "errors", NULL};
     963                 :            :     static _PyArg_Parser _parser = {
     964                 :            :         .keywords = _keywords,
     965                 :            :         .fname = "decode",
     966                 :            :         .kwtuple = KWTUPLE,
     967                 :            :     };
     968                 :            :     #undef KWTUPLE
     969                 :            :     PyObject *argsbuf[2];
     970         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     971                 :          0 :     const char *encoding = NULL;
     972                 :          0 :     const char *errors = NULL;
     973                 :            : 
     974   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
             #  #  #  # ]
     975         [ #  # ]:          0 :     if (!args) {
     976                 :          0 :         goto exit;
     977                 :            :     }
     978         [ #  # ]:          0 :     if (!noptargs) {
     979                 :          0 :         goto skip_optional_pos;
     980                 :            :     }
     981         [ #  # ]:          0 :     if (args[0]) {
     982         [ #  # ]:          0 :         if (!PyUnicode_Check(args[0])) {
     983                 :          0 :             _PyArg_BadArgument("decode", "argument 'encoding'", "str", args[0]);
     984                 :          0 :             goto exit;
     985                 :            :         }
     986                 :            :         Py_ssize_t encoding_length;
     987                 :          0 :         encoding = PyUnicode_AsUTF8AndSize(args[0], &encoding_length);
     988         [ #  # ]:          0 :         if (encoding == NULL) {
     989                 :          0 :             goto exit;
     990                 :            :         }
     991         [ #  # ]:          0 :         if (strlen(encoding) != (size_t)encoding_length) {
     992                 :          0 :             PyErr_SetString(PyExc_ValueError, "embedded null character");
     993                 :          0 :             goto exit;
     994                 :            :         }
     995         [ #  # ]:          0 :         if (!--noptargs) {
     996                 :          0 :             goto skip_optional_pos;
     997                 :            :         }
     998                 :            :     }
     999         [ #  # ]:          0 :     if (!PyUnicode_Check(args[1])) {
    1000                 :          0 :         _PyArg_BadArgument("decode", "argument 'errors'", "str", args[1]);
    1001                 :          0 :         goto exit;
    1002                 :            :     }
    1003                 :            :     Py_ssize_t errors_length;
    1004                 :          0 :     errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
    1005         [ #  # ]:          0 :     if (errors == NULL) {
    1006                 :          0 :         goto exit;
    1007                 :            :     }
    1008         [ #  # ]:          0 :     if (strlen(errors) != (size_t)errors_length) {
    1009                 :          0 :         PyErr_SetString(PyExc_ValueError, "embedded null character");
    1010                 :          0 :         goto exit;
    1011                 :            :     }
    1012                 :          0 : skip_optional_pos:
    1013                 :          0 :     return_value = bytearray_decode_impl(self, encoding, errors);
    1014                 :            : 
    1015                 :          0 : exit:
    1016                 :          0 :     return return_value;
    1017                 :            : }
    1018                 :            : 
    1019                 :            : PyDoc_STRVAR(bytearray_join__doc__,
    1020                 :            : "join($self, iterable_of_bytes, /)\n"
    1021                 :            : "--\n"
    1022                 :            : "\n"
    1023                 :            : "Concatenate any number of bytes/bytearray objects.\n"
    1024                 :            : "\n"
    1025                 :            : "The bytearray whose method is called is inserted in between each pair.\n"
    1026                 :            : "\n"
    1027                 :            : "The result is returned as a new bytearray object.");
    1028                 :            : 
    1029                 :            : #define BYTEARRAY_JOIN_METHODDEF    \
    1030                 :            :     {"join", (PyCFunction)bytearray_join, METH_O, bytearray_join__doc__},
    1031                 :            : 
    1032                 :            : PyDoc_STRVAR(bytearray_splitlines__doc__,
    1033                 :            : "splitlines($self, /, keepends=False)\n"
    1034                 :            : "--\n"
    1035                 :            : "\n"
    1036                 :            : "Return a list of the lines in the bytearray, breaking at line boundaries.\n"
    1037                 :            : "\n"
    1038                 :            : "Line breaks are not included in the resulting list unless keepends is given and\n"
    1039                 :            : "true.");
    1040                 :            : 
    1041                 :            : #define BYTEARRAY_SPLITLINES_METHODDEF    \
    1042                 :            :     {"splitlines", _PyCFunction_CAST(bytearray_splitlines), METH_FASTCALL|METH_KEYWORDS, bytearray_splitlines__doc__},
    1043                 :            : 
    1044                 :            : static PyObject *
    1045                 :            : bytearray_splitlines_impl(PyByteArrayObject *self, int keepends);
    1046                 :            : 
    1047                 :            : static PyObject *
    1048                 :          0 : bytearray_splitlines(PyByteArrayObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1049                 :            : {
    1050                 :          0 :     PyObject *return_value = NULL;
    1051                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1052                 :            : 
    1053                 :            :     #define NUM_KEYWORDS 1
    1054                 :            :     static struct {
    1055                 :            :         PyGC_Head _this_is_not_used;
    1056                 :            :         PyObject_VAR_HEAD
    1057                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1058                 :            :     } _kwtuple = {
    1059                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1060                 :            :         .ob_item = { &_Py_ID(keepends), },
    1061                 :            :     };
    1062                 :            :     #undef NUM_KEYWORDS
    1063                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1064                 :            : 
    1065                 :            :     #else  // !Py_BUILD_CORE
    1066                 :            :     #  define KWTUPLE NULL
    1067                 :            :     #endif  // !Py_BUILD_CORE
    1068                 :            : 
    1069                 :            :     static const char * const _keywords[] = {"keepends", NULL};
    1070                 :            :     static _PyArg_Parser _parser = {
    1071                 :            :         .keywords = _keywords,
    1072                 :            :         .fname = "splitlines",
    1073                 :            :         .kwtuple = KWTUPLE,
    1074                 :            :     };
    1075                 :            :     #undef KWTUPLE
    1076                 :            :     PyObject *argsbuf[1];
    1077         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
    1078                 :          0 :     int keepends = 0;
    1079                 :            : 
    1080   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             #  #  #  # ]
    1081         [ #  # ]:          0 :     if (!args) {
    1082                 :          0 :         goto exit;
    1083                 :            :     }
    1084         [ #  # ]:          0 :     if (!noptargs) {
    1085                 :          0 :         goto skip_optional_pos;
    1086                 :            :     }
    1087                 :          0 :     keepends = PyObject_IsTrue(args[0]);
    1088         [ #  # ]:          0 :     if (keepends < 0) {
    1089                 :          0 :         goto exit;
    1090                 :            :     }
    1091                 :          0 : skip_optional_pos:
    1092                 :          0 :     return_value = bytearray_splitlines_impl(self, keepends);
    1093                 :            : 
    1094                 :          0 : exit:
    1095                 :          0 :     return return_value;
    1096                 :            : }
    1097                 :            : 
    1098                 :            : PyDoc_STRVAR(bytearray_fromhex__doc__,
    1099                 :            : "fromhex($type, string, /)\n"
    1100                 :            : "--\n"
    1101                 :            : "\n"
    1102                 :            : "Create a bytearray object from a string of hexadecimal numbers.\n"
    1103                 :            : "\n"
    1104                 :            : "Spaces between two numbers are accepted.\n"
    1105                 :            : "Example: bytearray.fromhex(\'B9 01EF\') -> bytearray(b\'\\\\xb9\\\\x01\\\\xef\')");
    1106                 :            : 
    1107                 :            : #define BYTEARRAY_FROMHEX_METHODDEF    \
    1108                 :            :     {"fromhex", (PyCFunction)bytearray_fromhex, METH_O|METH_CLASS, bytearray_fromhex__doc__},
    1109                 :            : 
    1110                 :            : static PyObject *
    1111                 :            : bytearray_fromhex_impl(PyTypeObject *type, PyObject *string);
    1112                 :            : 
    1113                 :            : static PyObject *
    1114                 :          0 : bytearray_fromhex(PyTypeObject *type, PyObject *arg)
    1115                 :            : {
    1116                 :          0 :     PyObject *return_value = NULL;
    1117                 :            :     PyObject *string;
    1118                 :            : 
    1119         [ #  # ]:          0 :     if (!PyUnicode_Check(arg)) {
    1120                 :          0 :         _PyArg_BadArgument("fromhex", "argument", "str", arg);
    1121                 :          0 :         goto exit;
    1122                 :            :     }
    1123         [ #  # ]:          0 :     if (PyUnicode_READY(arg) == -1) {
    1124                 :          0 :         goto exit;
    1125                 :            :     }
    1126                 :          0 :     string = arg;
    1127                 :          0 :     return_value = bytearray_fromhex_impl(type, string);
    1128                 :            : 
    1129                 :          0 : exit:
    1130                 :          0 :     return return_value;
    1131                 :            : }
    1132                 :            : 
    1133                 :            : PyDoc_STRVAR(bytearray_hex__doc__,
    1134                 :            : "hex($self, /, sep=<unrepresentable>, bytes_per_sep=1)\n"
    1135                 :            : "--\n"
    1136                 :            : "\n"
    1137                 :            : "Create a string of hexadecimal numbers from a bytearray object.\n"
    1138                 :            : "\n"
    1139                 :            : "  sep\n"
    1140                 :            : "    An optional single character or byte to separate hex bytes.\n"
    1141                 :            : "  bytes_per_sep\n"
    1142                 :            : "    How many bytes between separators.  Positive values count from the\n"
    1143                 :            : "    right, negative values count from the left.\n"
    1144                 :            : "\n"
    1145                 :            : "Example:\n"
    1146                 :            : ">>> value = bytearray([0xb9, 0x01, 0xef])\n"
    1147                 :            : ">>> value.hex()\n"
    1148                 :            : "\'b901ef\'\n"
    1149                 :            : ">>> value.hex(\':\')\n"
    1150                 :            : "\'b9:01:ef\'\n"
    1151                 :            : ">>> value.hex(\':\', 2)\n"
    1152                 :            : "\'b9:01ef\'\n"
    1153                 :            : ">>> value.hex(\':\', -2)\n"
    1154                 :            : "\'b901:ef\'");
    1155                 :            : 
    1156                 :            : #define BYTEARRAY_HEX_METHODDEF    \
    1157                 :            :     {"hex", _PyCFunction_CAST(bytearray_hex), METH_FASTCALL|METH_KEYWORDS, bytearray_hex__doc__},
    1158                 :            : 
    1159                 :            : static PyObject *
    1160                 :            : bytearray_hex_impl(PyByteArrayObject *self, PyObject *sep, int bytes_per_sep);
    1161                 :            : 
    1162                 :            : static PyObject *
    1163                 :          0 : bytearray_hex(PyByteArrayObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1164                 :            : {
    1165                 :          0 :     PyObject *return_value = NULL;
    1166                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1167                 :            : 
    1168                 :            :     #define NUM_KEYWORDS 2
    1169                 :            :     static struct {
    1170                 :            :         PyGC_Head _this_is_not_used;
    1171                 :            :         PyObject_VAR_HEAD
    1172                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1173                 :            :     } _kwtuple = {
    1174                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1175                 :            :         .ob_item = { &_Py_ID(sep), &_Py_ID(bytes_per_sep), },
    1176                 :            :     };
    1177                 :            :     #undef NUM_KEYWORDS
    1178                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1179                 :            : 
    1180                 :            :     #else  // !Py_BUILD_CORE
    1181                 :            :     #  define KWTUPLE NULL
    1182                 :            :     #endif  // !Py_BUILD_CORE
    1183                 :            : 
    1184                 :            :     static const char * const _keywords[] = {"sep", "bytes_per_sep", NULL};
    1185                 :            :     static _PyArg_Parser _parser = {
    1186                 :            :         .keywords = _keywords,
    1187                 :            :         .fname = "hex",
    1188                 :            :         .kwtuple = KWTUPLE,
    1189                 :            :     };
    1190                 :            :     #undef KWTUPLE
    1191                 :            :     PyObject *argsbuf[2];
    1192         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
    1193                 :          0 :     PyObject *sep = NULL;
    1194                 :          0 :     int bytes_per_sep = 1;
    1195                 :            : 
    1196   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
             #  #  #  # ]
    1197         [ #  # ]:          0 :     if (!args) {
    1198                 :          0 :         goto exit;
    1199                 :            :     }
    1200         [ #  # ]:          0 :     if (!noptargs) {
    1201                 :          0 :         goto skip_optional_pos;
    1202                 :            :     }
    1203         [ #  # ]:          0 :     if (args[0]) {
    1204                 :          0 :         sep = args[0];
    1205         [ #  # ]:          0 :         if (!--noptargs) {
    1206                 :          0 :             goto skip_optional_pos;
    1207                 :            :         }
    1208                 :            :     }
    1209                 :          0 :     bytes_per_sep = _PyLong_AsInt(args[1]);
    1210   [ #  #  #  # ]:          0 :     if (bytes_per_sep == -1 && PyErr_Occurred()) {
    1211                 :          0 :         goto exit;
    1212                 :            :     }
    1213                 :          0 : skip_optional_pos:
    1214                 :          0 :     return_value = bytearray_hex_impl(self, sep, bytes_per_sep);
    1215                 :            : 
    1216                 :          0 : exit:
    1217                 :          0 :     return return_value;
    1218                 :            : }
    1219                 :            : 
    1220                 :            : PyDoc_STRVAR(bytearray_reduce__doc__,
    1221                 :            : "__reduce__($self, /)\n"
    1222                 :            : "--\n"
    1223                 :            : "\n"
    1224                 :            : "Return state information for pickling.");
    1225                 :            : 
    1226                 :            : #define BYTEARRAY_REDUCE_METHODDEF    \
    1227                 :            :     {"__reduce__", (PyCFunction)bytearray_reduce, METH_NOARGS, bytearray_reduce__doc__},
    1228                 :            : 
    1229                 :            : static PyObject *
    1230                 :            : bytearray_reduce_impl(PyByteArrayObject *self);
    1231                 :            : 
    1232                 :            : static PyObject *
    1233                 :          0 : bytearray_reduce(PyByteArrayObject *self, PyObject *Py_UNUSED(ignored))
    1234                 :            : {
    1235                 :          0 :     return bytearray_reduce_impl(self);
    1236                 :            : }
    1237                 :            : 
    1238                 :            : PyDoc_STRVAR(bytearray_reduce_ex__doc__,
    1239                 :            : "__reduce_ex__($self, proto=0, /)\n"
    1240                 :            : "--\n"
    1241                 :            : "\n"
    1242                 :            : "Return state information for pickling.");
    1243                 :            : 
    1244                 :            : #define BYTEARRAY_REDUCE_EX_METHODDEF    \
    1245                 :            :     {"__reduce_ex__", _PyCFunction_CAST(bytearray_reduce_ex), METH_FASTCALL, bytearray_reduce_ex__doc__},
    1246                 :            : 
    1247                 :            : static PyObject *
    1248                 :            : bytearray_reduce_ex_impl(PyByteArrayObject *self, int proto);
    1249                 :            : 
    1250                 :            : static PyObject *
    1251                 :          0 : bytearray_reduce_ex(PyByteArrayObject *self, PyObject *const *args, Py_ssize_t nargs)
    1252                 :            : {
    1253                 :          0 :     PyObject *return_value = NULL;
    1254                 :          0 :     int proto = 0;
    1255                 :            : 
    1256   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("__reduce_ex__", nargs, 0, 1)) {
                   #  # ]
    1257                 :          0 :         goto exit;
    1258                 :            :     }
    1259         [ #  # ]:          0 :     if (nargs < 1) {
    1260                 :          0 :         goto skip_optional;
    1261                 :            :     }
    1262                 :          0 :     proto = _PyLong_AsInt(args[0]);
    1263   [ #  #  #  # ]:          0 :     if (proto == -1 && PyErr_Occurred()) {
    1264                 :          0 :         goto exit;
    1265                 :            :     }
    1266                 :          0 : skip_optional:
    1267                 :          0 :     return_value = bytearray_reduce_ex_impl(self, proto);
    1268                 :            : 
    1269                 :          0 : exit:
    1270                 :          0 :     return return_value;
    1271                 :            : }
    1272                 :            : 
    1273                 :            : PyDoc_STRVAR(bytearray_sizeof__doc__,
    1274                 :            : "__sizeof__($self, /)\n"
    1275                 :            : "--\n"
    1276                 :            : "\n"
    1277                 :            : "Returns the size of the bytearray object in memory, in bytes.");
    1278                 :            : 
    1279                 :            : #define BYTEARRAY_SIZEOF_METHODDEF    \
    1280                 :            :     {"__sizeof__", (PyCFunction)bytearray_sizeof, METH_NOARGS, bytearray_sizeof__doc__},
    1281                 :            : 
    1282                 :            : static PyObject *
    1283                 :            : bytearray_sizeof_impl(PyByteArrayObject *self);
    1284                 :            : 
    1285                 :            : static PyObject *
    1286                 :          0 : bytearray_sizeof(PyByteArrayObject *self, PyObject *Py_UNUSED(ignored))
    1287                 :            : {
    1288                 :          0 :     return bytearray_sizeof_impl(self);
    1289                 :            : }
    1290                 :            : /*[clinic end generated code: output=022698e8b0faa272 input=a9049054013a1b77]*/

Generated by: LCOV version 1.14