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