1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 PyDoc_STRVAR(bytes_split__doc__,
6 "split($self, /, sep=None, maxsplit=-1)\n"
7 "--\n"
8 "\n"
9 "Return a list of the sections in the bytes, using sep as the delimiter.\n"
10 "\n"
11 " sep\n"
12 " The delimiter according which to split the bytes.\n"
13 " None (the default value) means split on ASCII whitespace characters\n"
14 " (space, tab, return, newline, formfeed, vertical tab).\n"
15 " maxsplit\n"
16 " Maximum number of splits to do.\n"
17 " -1 (the default value) means no limit.");
18
19 #define BYTES_SPLIT_METHODDEF \
20 {"split", (PyCFunction)(void(*)(void))bytes_split, METH_FASTCALL|METH_KEYWORDS, bytes_split__doc__},
21
22 static PyObject *
23 bytes_split_impl(PyBytesObject *self, PyObject *sep, Py_ssize_t maxsplit);
24
25 static PyObject *
bytes_split(PyBytesObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)26 bytes_split(PyBytesObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
27 {
28 PyObject *return_value = NULL;
29 static const char * const _keywords[] = {"sep", "maxsplit", NULL};
30 static _PyArg_Parser _parser = {NULL, _keywords, "split", 0};
31 PyObject *argsbuf[2];
32 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
33 PyObject *sep = Py_None;
34 Py_ssize_t maxsplit = -1;
35
36 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
37 if (!args) {
38 goto exit;
39 }
40 if (!noptargs) {
41 goto skip_optional_pos;
42 }
43 if (args[0]) {
44 sep = args[0];
45 if (!--noptargs) {
46 goto skip_optional_pos;
47 }
48 }
49 if (PyFloat_Check(args[1])) {
50 PyErr_SetString(PyExc_TypeError,
51 "integer argument expected, got float" );
52 goto exit;
53 }
54 {
55 Py_ssize_t ival = -1;
56 PyObject *iobj = PyNumber_Index(args[1]);
57 if (iobj != NULL) {
58 ival = PyLong_AsSsize_t(iobj);
59 Py_DECREF(iobj);
60 }
61 if (ival == -1 && PyErr_Occurred()) {
62 goto exit;
63 }
64 maxsplit = ival;
65 }
66 skip_optional_pos:
67 return_value = bytes_split_impl(self, sep, maxsplit);
68
69 exit:
70 return return_value;
71 }
72
73 PyDoc_STRVAR(bytes_partition__doc__,
74 "partition($self, sep, /)\n"
75 "--\n"
76 "\n"
77 "Partition the bytes into three parts using the given separator.\n"
78 "\n"
79 "This will search for the separator sep in the bytes. If the separator is found,\n"
80 "returns a 3-tuple containing the part before the separator, the separator\n"
81 "itself, and the part after it.\n"
82 "\n"
83 "If the separator is not found, returns a 3-tuple containing the original bytes\n"
84 "object and two empty bytes objects.");
85
86 #define BYTES_PARTITION_METHODDEF \
87 {"partition", (PyCFunction)bytes_partition, METH_O, bytes_partition__doc__},
88
89 static PyObject *
90 bytes_partition_impl(PyBytesObject *self, Py_buffer *sep);
91
92 static PyObject *
bytes_partition(PyBytesObject * self,PyObject * arg)93 bytes_partition(PyBytesObject *self, PyObject *arg)
94 {
95 PyObject *return_value = NULL;
96 Py_buffer sep = {NULL, NULL};
97
98 if (PyObject_GetBuffer(arg, &sep, PyBUF_SIMPLE) != 0) {
99 goto exit;
100 }
101 if (!PyBuffer_IsContiguous(&sep, 'C')) {
102 _PyArg_BadArgument("partition", "argument", "contiguous buffer", arg);
103 goto exit;
104 }
105 return_value = bytes_partition_impl(self, &sep);
106
107 exit:
108 /* Cleanup for sep */
109 if (sep.obj) {
110 PyBuffer_Release(&sep);
111 }
112
113 return return_value;
114 }
115
116 PyDoc_STRVAR(bytes_rpartition__doc__,
117 "rpartition($self, sep, /)\n"
118 "--\n"
119 "\n"
120 "Partition the bytes into three parts using the given separator.\n"
121 "\n"
122 "This will search for the separator sep in the bytes, starting at the end. If\n"
123 "the separator is found, returns a 3-tuple containing the part before the\n"
124 "separator, the separator itself, and the part after it.\n"
125 "\n"
126 "If the separator is not found, returns a 3-tuple containing two empty bytes\n"
127 "objects and the original bytes object.");
128
129 #define BYTES_RPARTITION_METHODDEF \
130 {"rpartition", (PyCFunction)bytes_rpartition, METH_O, bytes_rpartition__doc__},
131
132 static PyObject *
133 bytes_rpartition_impl(PyBytesObject *self, Py_buffer *sep);
134
135 static PyObject *
bytes_rpartition(PyBytesObject * self,PyObject * arg)136 bytes_rpartition(PyBytesObject *self, PyObject *arg)
137 {
138 PyObject *return_value = NULL;
139 Py_buffer sep = {NULL, NULL};
140
141 if (PyObject_GetBuffer(arg, &sep, PyBUF_SIMPLE) != 0) {
142 goto exit;
143 }
144 if (!PyBuffer_IsContiguous(&sep, 'C')) {
145 _PyArg_BadArgument("rpartition", "argument", "contiguous buffer", arg);
146 goto exit;
147 }
148 return_value = bytes_rpartition_impl(self, &sep);
149
150 exit:
151 /* Cleanup for sep */
152 if (sep.obj) {
153 PyBuffer_Release(&sep);
154 }
155
156 return return_value;
157 }
158
159 PyDoc_STRVAR(bytes_rsplit__doc__,
160 "rsplit($self, /, sep=None, maxsplit=-1)\n"
161 "--\n"
162 "\n"
163 "Return a list of the sections in the bytes, using sep as the delimiter.\n"
164 "\n"
165 " sep\n"
166 " The delimiter according which to split the bytes.\n"
167 " None (the default value) means split on ASCII whitespace characters\n"
168 " (space, tab, return, newline, formfeed, vertical tab).\n"
169 " maxsplit\n"
170 " Maximum number of splits to do.\n"
171 " -1 (the default value) means no limit.\n"
172 "\n"
173 "Splitting is done starting at the end of the bytes and working to the front.");
174
175 #define BYTES_RSPLIT_METHODDEF \
176 {"rsplit", (PyCFunction)(void(*)(void))bytes_rsplit, METH_FASTCALL|METH_KEYWORDS, bytes_rsplit__doc__},
177
178 static PyObject *
179 bytes_rsplit_impl(PyBytesObject *self, PyObject *sep, Py_ssize_t maxsplit);
180
181 static PyObject *
bytes_rsplit(PyBytesObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)182 bytes_rsplit(PyBytesObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
183 {
184 PyObject *return_value = NULL;
185 static const char * const _keywords[] = {"sep", "maxsplit", NULL};
186 static _PyArg_Parser _parser = {NULL, _keywords, "rsplit", 0};
187 PyObject *argsbuf[2];
188 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
189 PyObject *sep = Py_None;
190 Py_ssize_t maxsplit = -1;
191
192 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
193 if (!args) {
194 goto exit;
195 }
196 if (!noptargs) {
197 goto skip_optional_pos;
198 }
199 if (args[0]) {
200 sep = args[0];
201 if (!--noptargs) {
202 goto skip_optional_pos;
203 }
204 }
205 if (PyFloat_Check(args[1])) {
206 PyErr_SetString(PyExc_TypeError,
207 "integer argument expected, got float" );
208 goto exit;
209 }
210 {
211 Py_ssize_t ival = -1;
212 PyObject *iobj = PyNumber_Index(args[1]);
213 if (iobj != NULL) {
214 ival = PyLong_AsSsize_t(iobj);
215 Py_DECREF(iobj);
216 }
217 if (ival == -1 && PyErr_Occurred()) {
218 goto exit;
219 }
220 maxsplit = ival;
221 }
222 skip_optional_pos:
223 return_value = bytes_rsplit_impl(self, sep, maxsplit);
224
225 exit:
226 return return_value;
227 }
228
229 PyDoc_STRVAR(bytes_join__doc__,
230 "join($self, iterable_of_bytes, /)\n"
231 "--\n"
232 "\n"
233 "Concatenate any number of bytes objects.\n"
234 "\n"
235 "The bytes whose method is called is inserted in between each pair.\n"
236 "\n"
237 "The result is returned as a new bytes object.\n"
238 "\n"
239 "Example: b\'.\'.join([b\'ab\', b\'pq\', b\'rs\']) -> b\'ab.pq.rs\'.");
240
241 #define BYTES_JOIN_METHODDEF \
242 {"join", (PyCFunction)bytes_join, METH_O, bytes_join__doc__},
243
244 PyDoc_STRVAR(bytes_strip__doc__,
245 "strip($self, bytes=None, /)\n"
246 "--\n"
247 "\n"
248 "Strip leading and trailing bytes contained in the argument.\n"
249 "\n"
250 "If the argument is omitted or None, strip leading and trailing ASCII whitespace.");
251
252 #define BYTES_STRIP_METHODDEF \
253 {"strip", (PyCFunction)(void(*)(void))bytes_strip, METH_FASTCALL, bytes_strip__doc__},
254
255 static PyObject *
256 bytes_strip_impl(PyBytesObject *self, PyObject *bytes);
257
258 static PyObject *
bytes_strip(PyBytesObject * self,PyObject * const * args,Py_ssize_t nargs)259 bytes_strip(PyBytesObject *self, PyObject *const *args, Py_ssize_t nargs)
260 {
261 PyObject *return_value = NULL;
262 PyObject *bytes = Py_None;
263
264 if (!_PyArg_CheckPositional("strip", nargs, 0, 1)) {
265 goto exit;
266 }
267 if (nargs < 1) {
268 goto skip_optional;
269 }
270 bytes = args[0];
271 skip_optional:
272 return_value = bytes_strip_impl(self, bytes);
273
274 exit:
275 return return_value;
276 }
277
278 PyDoc_STRVAR(bytes_lstrip__doc__,
279 "lstrip($self, bytes=None, /)\n"
280 "--\n"
281 "\n"
282 "Strip leading bytes contained in the argument.\n"
283 "\n"
284 "If the argument is omitted or None, strip leading ASCII whitespace.");
285
286 #define BYTES_LSTRIP_METHODDEF \
287 {"lstrip", (PyCFunction)(void(*)(void))bytes_lstrip, METH_FASTCALL, bytes_lstrip__doc__},
288
289 static PyObject *
290 bytes_lstrip_impl(PyBytesObject *self, PyObject *bytes);
291
292 static PyObject *
bytes_lstrip(PyBytesObject * self,PyObject * const * args,Py_ssize_t nargs)293 bytes_lstrip(PyBytesObject *self, PyObject *const *args, Py_ssize_t nargs)
294 {
295 PyObject *return_value = NULL;
296 PyObject *bytes = Py_None;
297
298 if (!_PyArg_CheckPositional("lstrip", nargs, 0, 1)) {
299 goto exit;
300 }
301 if (nargs < 1) {
302 goto skip_optional;
303 }
304 bytes = args[0];
305 skip_optional:
306 return_value = bytes_lstrip_impl(self, bytes);
307
308 exit:
309 return return_value;
310 }
311
312 PyDoc_STRVAR(bytes_rstrip__doc__,
313 "rstrip($self, bytes=None, /)\n"
314 "--\n"
315 "\n"
316 "Strip trailing bytes contained in the argument.\n"
317 "\n"
318 "If the argument is omitted or None, strip trailing ASCII whitespace.");
319
320 #define BYTES_RSTRIP_METHODDEF \
321 {"rstrip", (PyCFunction)(void(*)(void))bytes_rstrip, METH_FASTCALL, bytes_rstrip__doc__},
322
323 static PyObject *
324 bytes_rstrip_impl(PyBytesObject *self, PyObject *bytes);
325
326 static PyObject *
bytes_rstrip(PyBytesObject * self,PyObject * const * args,Py_ssize_t nargs)327 bytes_rstrip(PyBytesObject *self, PyObject *const *args, Py_ssize_t nargs)
328 {
329 PyObject *return_value = NULL;
330 PyObject *bytes = Py_None;
331
332 if (!_PyArg_CheckPositional("rstrip", nargs, 0, 1)) {
333 goto exit;
334 }
335 if (nargs < 1) {
336 goto skip_optional;
337 }
338 bytes = args[0];
339 skip_optional:
340 return_value = bytes_rstrip_impl(self, bytes);
341
342 exit:
343 return return_value;
344 }
345
346 PyDoc_STRVAR(bytes_translate__doc__,
347 "translate($self, table, /, delete=b\'\')\n"
348 "--\n"
349 "\n"
350 "Return a copy with each character mapped by the given translation table.\n"
351 "\n"
352 " table\n"
353 " Translation table, which must be a bytes object of length 256.\n"
354 "\n"
355 "All characters occurring in the optional argument delete are removed.\n"
356 "The remaining characters are mapped through the given translation table.");
357
358 #define BYTES_TRANSLATE_METHODDEF \
359 {"translate", (PyCFunction)(void(*)(void))bytes_translate, METH_FASTCALL|METH_KEYWORDS, bytes_translate__doc__},
360
361 static PyObject *
362 bytes_translate_impl(PyBytesObject *self, PyObject *table,
363 PyObject *deletechars);
364
365 static PyObject *
bytes_translate(PyBytesObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)366 bytes_translate(PyBytesObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
367 {
368 PyObject *return_value = NULL;
369 static const char * const _keywords[] = {"", "delete", NULL};
370 static _PyArg_Parser _parser = {NULL, _keywords, "translate", 0};
371 PyObject *argsbuf[2];
372 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
373 PyObject *table;
374 PyObject *deletechars = NULL;
375
376 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
377 if (!args) {
378 goto exit;
379 }
380 table = args[0];
381 if (!noptargs) {
382 goto skip_optional_pos;
383 }
384 deletechars = args[1];
385 skip_optional_pos:
386 return_value = bytes_translate_impl(self, table, deletechars);
387
388 exit:
389 return return_value;
390 }
391
392 PyDoc_STRVAR(bytes_maketrans__doc__,
393 "maketrans(frm, to, /)\n"
394 "--\n"
395 "\n"
396 "Return a translation table useable for the bytes or bytearray translate method.\n"
397 "\n"
398 "The returned table will be one where each byte in frm is mapped to the byte at\n"
399 "the same position in to.\n"
400 "\n"
401 "The bytes objects frm and to must be of the same length.");
402
403 #define BYTES_MAKETRANS_METHODDEF \
404 {"maketrans", (PyCFunction)(void(*)(void))bytes_maketrans, METH_FASTCALL|METH_STATIC, bytes_maketrans__doc__},
405
406 static PyObject *
407 bytes_maketrans_impl(Py_buffer *frm, Py_buffer *to);
408
409 static PyObject *
bytes_maketrans(void * null,PyObject * const * args,Py_ssize_t nargs)410 bytes_maketrans(void *null, PyObject *const *args, Py_ssize_t nargs)
411 {
412 PyObject *return_value = NULL;
413 Py_buffer frm = {NULL, NULL};
414 Py_buffer to = {NULL, NULL};
415
416 if (!_PyArg_CheckPositional("maketrans", nargs, 2, 2)) {
417 goto exit;
418 }
419 if (PyObject_GetBuffer(args[0], &frm, PyBUF_SIMPLE) != 0) {
420 goto exit;
421 }
422 if (!PyBuffer_IsContiguous(&frm, 'C')) {
423 _PyArg_BadArgument("maketrans", "argument 1", "contiguous buffer", args[0]);
424 goto exit;
425 }
426 if (PyObject_GetBuffer(args[1], &to, PyBUF_SIMPLE) != 0) {
427 goto exit;
428 }
429 if (!PyBuffer_IsContiguous(&to, 'C')) {
430 _PyArg_BadArgument("maketrans", "argument 2", "contiguous buffer", args[1]);
431 goto exit;
432 }
433 return_value = bytes_maketrans_impl(&frm, &to);
434
435 exit:
436 /* Cleanup for frm */
437 if (frm.obj) {
438 PyBuffer_Release(&frm);
439 }
440 /* Cleanup for to */
441 if (to.obj) {
442 PyBuffer_Release(&to);
443 }
444
445 return return_value;
446 }
447
448 PyDoc_STRVAR(bytes_replace__doc__,
449 "replace($self, old, new, count=-1, /)\n"
450 "--\n"
451 "\n"
452 "Return a copy with all occurrences of substring old replaced by new.\n"
453 "\n"
454 " count\n"
455 " Maximum number of occurrences to replace.\n"
456 " -1 (the default value) means replace all occurrences.\n"
457 "\n"
458 "If the optional argument count is given, only the first count occurrences are\n"
459 "replaced.");
460
461 #define BYTES_REPLACE_METHODDEF \
462 {"replace", (PyCFunction)(void(*)(void))bytes_replace, METH_FASTCALL, bytes_replace__doc__},
463
464 static PyObject *
465 bytes_replace_impl(PyBytesObject *self, Py_buffer *old, Py_buffer *new,
466 Py_ssize_t count);
467
468 static PyObject *
bytes_replace(PyBytesObject * self,PyObject * const * args,Py_ssize_t nargs)469 bytes_replace(PyBytesObject *self, PyObject *const *args, Py_ssize_t nargs)
470 {
471 PyObject *return_value = NULL;
472 Py_buffer old = {NULL, NULL};
473 Py_buffer new = {NULL, NULL};
474 Py_ssize_t count = -1;
475
476 if (!_PyArg_CheckPositional("replace", nargs, 2, 3)) {
477 goto exit;
478 }
479 if (PyObject_GetBuffer(args[0], &old, PyBUF_SIMPLE) != 0) {
480 goto exit;
481 }
482 if (!PyBuffer_IsContiguous(&old, 'C')) {
483 _PyArg_BadArgument("replace", "argument 1", "contiguous buffer", args[0]);
484 goto exit;
485 }
486 if (PyObject_GetBuffer(args[1], &new, PyBUF_SIMPLE) != 0) {
487 goto exit;
488 }
489 if (!PyBuffer_IsContiguous(&new, 'C')) {
490 _PyArg_BadArgument("replace", "argument 2", "contiguous buffer", args[1]);
491 goto exit;
492 }
493 if (nargs < 3) {
494 goto skip_optional;
495 }
496 if (PyFloat_Check(args[2])) {
497 PyErr_SetString(PyExc_TypeError,
498 "integer argument expected, got float" );
499 goto exit;
500 }
501 {
502 Py_ssize_t ival = -1;
503 PyObject *iobj = PyNumber_Index(args[2]);
504 if (iobj != NULL) {
505 ival = PyLong_AsSsize_t(iobj);
506 Py_DECREF(iobj);
507 }
508 if (ival == -1 && PyErr_Occurred()) {
509 goto exit;
510 }
511 count = ival;
512 }
513 skip_optional:
514 return_value = bytes_replace_impl(self, &old, &new, count);
515
516 exit:
517 /* Cleanup for old */
518 if (old.obj) {
519 PyBuffer_Release(&old);
520 }
521 /* Cleanup for new */
522 if (new.obj) {
523 PyBuffer_Release(&new);
524 }
525
526 return return_value;
527 }
528
529 PyDoc_STRVAR(bytes_decode__doc__,
530 "decode($self, /, encoding=\'utf-8\', errors=\'strict\')\n"
531 "--\n"
532 "\n"
533 "Decode the bytes using the codec registered for encoding.\n"
534 "\n"
535 " encoding\n"
536 " The encoding with which to decode the bytes.\n"
537 " errors\n"
538 " The error handling scheme to use for the handling of decoding errors.\n"
539 " The default is \'strict\' meaning that decoding errors raise a\n"
540 " UnicodeDecodeError. Other possible values are \'ignore\' and \'replace\'\n"
541 " as well as any other name registered with codecs.register_error that\n"
542 " can handle UnicodeDecodeErrors.");
543
544 #define BYTES_DECODE_METHODDEF \
545 {"decode", (PyCFunction)(void(*)(void))bytes_decode, METH_FASTCALL|METH_KEYWORDS, bytes_decode__doc__},
546
547 static PyObject *
548 bytes_decode_impl(PyBytesObject *self, const char *encoding,
549 const char *errors);
550
551 static PyObject *
bytes_decode(PyBytesObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)552 bytes_decode(PyBytesObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
553 {
554 PyObject *return_value = NULL;
555 static const char * const _keywords[] = {"encoding", "errors", NULL};
556 static _PyArg_Parser _parser = {NULL, _keywords, "decode", 0};
557 PyObject *argsbuf[2];
558 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
559 const char *encoding = NULL;
560 const char *errors = NULL;
561
562 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
563 if (!args) {
564 goto exit;
565 }
566 if (!noptargs) {
567 goto skip_optional_pos;
568 }
569 if (args[0]) {
570 if (!PyUnicode_Check(args[0])) {
571 _PyArg_BadArgument("decode", "argument 'encoding'", "str", args[0]);
572 goto exit;
573 }
574 Py_ssize_t encoding_length;
575 encoding = PyUnicode_AsUTF8AndSize(args[0], &encoding_length);
576 if (encoding == NULL) {
577 goto exit;
578 }
579 if (strlen(encoding) != (size_t)encoding_length) {
580 PyErr_SetString(PyExc_ValueError, "embedded null character");
581 goto exit;
582 }
583 if (!--noptargs) {
584 goto skip_optional_pos;
585 }
586 }
587 if (!PyUnicode_Check(args[1])) {
588 _PyArg_BadArgument("decode", "argument 'errors'", "str", args[1]);
589 goto exit;
590 }
591 Py_ssize_t errors_length;
592 errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
593 if (errors == NULL) {
594 goto exit;
595 }
596 if (strlen(errors) != (size_t)errors_length) {
597 PyErr_SetString(PyExc_ValueError, "embedded null character");
598 goto exit;
599 }
600 skip_optional_pos:
601 return_value = bytes_decode_impl(self, encoding, errors);
602
603 exit:
604 return return_value;
605 }
606
607 PyDoc_STRVAR(bytes_splitlines__doc__,
608 "splitlines($self, /, keepends=False)\n"
609 "--\n"
610 "\n"
611 "Return a list of the lines in the bytes, breaking at line boundaries.\n"
612 "\n"
613 "Line breaks are not included in the resulting list unless keepends is given and\n"
614 "true.");
615
616 #define BYTES_SPLITLINES_METHODDEF \
617 {"splitlines", (PyCFunction)(void(*)(void))bytes_splitlines, METH_FASTCALL|METH_KEYWORDS, bytes_splitlines__doc__},
618
619 static PyObject *
620 bytes_splitlines_impl(PyBytesObject *self, int keepends);
621
622 static PyObject *
bytes_splitlines(PyBytesObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)623 bytes_splitlines(PyBytesObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
624 {
625 PyObject *return_value = NULL;
626 static const char * const _keywords[] = {"keepends", NULL};
627 static _PyArg_Parser _parser = {NULL, _keywords, "splitlines", 0};
628 PyObject *argsbuf[1];
629 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
630 int keepends = 0;
631
632 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
633 if (!args) {
634 goto exit;
635 }
636 if (!noptargs) {
637 goto skip_optional_pos;
638 }
639 if (PyFloat_Check(args[0])) {
640 PyErr_SetString(PyExc_TypeError,
641 "integer argument expected, got float" );
642 goto exit;
643 }
644 keepends = _PyLong_AsInt(args[0]);
645 if (keepends == -1 && PyErr_Occurred()) {
646 goto exit;
647 }
648 skip_optional_pos:
649 return_value = bytes_splitlines_impl(self, keepends);
650
651 exit:
652 return return_value;
653 }
654
655 PyDoc_STRVAR(bytes_fromhex__doc__,
656 "fromhex($type, string, /)\n"
657 "--\n"
658 "\n"
659 "Create a bytes object from a string of hexadecimal numbers.\n"
660 "\n"
661 "Spaces between two numbers are accepted.\n"
662 "Example: bytes.fromhex(\'B9 01EF\') -> b\'\\\\xb9\\\\x01\\\\xef\'.");
663
664 #define BYTES_FROMHEX_METHODDEF \
665 {"fromhex", (PyCFunction)bytes_fromhex, METH_O|METH_CLASS, bytes_fromhex__doc__},
666
667 static PyObject *
668 bytes_fromhex_impl(PyTypeObject *type, PyObject *string);
669
670 static PyObject *
bytes_fromhex(PyTypeObject * type,PyObject * arg)671 bytes_fromhex(PyTypeObject *type, PyObject *arg)
672 {
673 PyObject *return_value = NULL;
674 PyObject *string;
675
676 if (!PyUnicode_Check(arg)) {
677 _PyArg_BadArgument("fromhex", "argument", "str", arg);
678 goto exit;
679 }
680 if (PyUnicode_READY(arg) == -1) {
681 goto exit;
682 }
683 string = arg;
684 return_value = bytes_fromhex_impl(type, string);
685
686 exit:
687 return return_value;
688 }
689
690 PyDoc_STRVAR(bytes_hex__doc__,
691 "hex($self, /, sep=<unrepresentable>, bytes_per_sep=1)\n"
692 "--\n"
693 "\n"
694 "Create a str of hexadecimal numbers from a bytes object.\n"
695 "\n"
696 " sep\n"
697 " An optional single character or byte to separate hex bytes.\n"
698 " bytes_per_sep\n"
699 " How many bytes between separators. Positive values count from the\n"
700 " right, negative values count from the left.\n"
701 "\n"
702 "Example:\n"
703 ">>> value = b\'\\xb9\\x01\\xef\'\n"
704 ">>> value.hex()\n"
705 "\'b901ef\'\n"
706 ">>> value.hex(\':\')\n"
707 "\'b9:01:ef\'\n"
708 ">>> value.hex(\':\', 2)\n"
709 "\'b9:01ef\'\n"
710 ">>> value.hex(\':\', -2)\n"
711 "\'b901:ef\'");
712
713 #define BYTES_HEX_METHODDEF \
714 {"hex", (PyCFunction)(void(*)(void))bytes_hex, METH_FASTCALL|METH_KEYWORDS, bytes_hex__doc__},
715
716 static PyObject *
717 bytes_hex_impl(PyBytesObject *self, PyObject *sep, int bytes_per_sep);
718
719 static PyObject *
bytes_hex(PyBytesObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)720 bytes_hex(PyBytesObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
721 {
722 PyObject *return_value = NULL;
723 static const char * const _keywords[] = {"sep", "bytes_per_sep", NULL};
724 static _PyArg_Parser _parser = {NULL, _keywords, "hex", 0};
725 PyObject *argsbuf[2];
726 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
727 PyObject *sep = NULL;
728 int bytes_per_sep = 1;
729
730 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
731 if (!args) {
732 goto exit;
733 }
734 if (!noptargs) {
735 goto skip_optional_pos;
736 }
737 if (args[0]) {
738 sep = args[0];
739 if (!--noptargs) {
740 goto skip_optional_pos;
741 }
742 }
743 if (PyFloat_Check(args[1])) {
744 PyErr_SetString(PyExc_TypeError,
745 "integer argument expected, got float" );
746 goto exit;
747 }
748 bytes_per_sep = _PyLong_AsInt(args[1]);
749 if (bytes_per_sep == -1 && PyErr_Occurred()) {
750 goto exit;
751 }
752 skip_optional_pos:
753 return_value = bytes_hex_impl(self, sep, bytes_per_sep);
754
755 exit:
756 return return_value;
757 }
758 /*[clinic end generated code: output=ca60dfccf8d51e88 input=a9049054013a1b77]*/
759