Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : PyDoc_STRVAR(EncodingMap_size__doc__,
6 : : "size($self, /)\n"
7 : : "--\n"
8 : : "\n"
9 : : "Return the size (in bytes) of this object.");
10 : :
11 : : #define ENCODINGMAP_SIZE_METHODDEF \
12 : : {"size", (PyCFunction)EncodingMap_size, METH_NOARGS, EncodingMap_size__doc__},
13 : :
14 : : static PyObject *
15 : : EncodingMap_size_impl(struct encoding_map *self);
16 : :
17 : : static PyObject *
18 : 0 : EncodingMap_size(struct encoding_map *self, PyObject *Py_UNUSED(ignored))
19 : : {
20 : 0 : return EncodingMap_size_impl(self);
21 : : }
22 : :
23 : : PyDoc_STRVAR(unicode_title__doc__,
24 : : "title($self, /)\n"
25 : : "--\n"
26 : : "\n"
27 : : "Return a version of the string where each word is titlecased.\n"
28 : : "\n"
29 : : "More specifically, words start with uppercased characters and all remaining\n"
30 : : "cased characters have lower case.");
31 : :
32 : : #define UNICODE_TITLE_METHODDEF \
33 : : {"title", (PyCFunction)unicode_title, METH_NOARGS, unicode_title__doc__},
34 : :
35 : : static PyObject *
36 : : unicode_title_impl(PyObject *self);
37 : :
38 : : static PyObject *
39 : 4458340 : unicode_title(PyObject *self, PyObject *Py_UNUSED(ignored))
40 : : {
41 : 4458340 : return unicode_title_impl(self);
42 : : }
43 : :
44 : : PyDoc_STRVAR(unicode_capitalize__doc__,
45 : : "capitalize($self, /)\n"
46 : : "--\n"
47 : : "\n"
48 : : "Return a capitalized version of the string.\n"
49 : : "\n"
50 : : "More specifically, make the first character have upper case and the rest lower\n"
51 : : "case.");
52 : :
53 : : #define UNICODE_CAPITALIZE_METHODDEF \
54 : : {"capitalize", (PyCFunction)unicode_capitalize, METH_NOARGS, unicode_capitalize__doc__},
55 : :
56 : : static PyObject *
57 : : unicode_capitalize_impl(PyObject *self);
58 : :
59 : : static PyObject *
60 : 24187 : unicode_capitalize(PyObject *self, PyObject *Py_UNUSED(ignored))
61 : : {
62 : 24187 : return unicode_capitalize_impl(self);
63 : : }
64 : :
65 : : PyDoc_STRVAR(unicode_casefold__doc__,
66 : : "casefold($self, /)\n"
67 : : "--\n"
68 : : "\n"
69 : : "Return a version of the string suitable for caseless comparisons.");
70 : :
71 : : #define UNICODE_CASEFOLD_METHODDEF \
72 : : {"casefold", (PyCFunction)unicode_casefold, METH_NOARGS, unicode_casefold__doc__},
73 : :
74 : : static PyObject *
75 : : unicode_casefold_impl(PyObject *self);
76 : :
77 : : static PyObject *
78 : 700 : unicode_casefold(PyObject *self, PyObject *Py_UNUSED(ignored))
79 : : {
80 : 700 : return unicode_casefold_impl(self);
81 : : }
82 : :
83 : : PyDoc_STRVAR(unicode_center__doc__,
84 : : "center($self, width, fillchar=\' \', /)\n"
85 : : "--\n"
86 : : "\n"
87 : : "Return a centered string of length width.\n"
88 : : "\n"
89 : : "Padding is done using the specified fill character (default is a space).");
90 : :
91 : : #define UNICODE_CENTER_METHODDEF \
92 : : {"center", _PyCFunction_CAST(unicode_center), METH_FASTCALL, unicode_center__doc__},
93 : :
94 : : static PyObject *
95 : : unicode_center_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
96 : :
97 : : static PyObject *
98 : 7867 : unicode_center(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
99 : : {
100 : 7867 : PyObject *return_value = NULL;
101 : : Py_ssize_t width;
102 : 7867 : Py_UCS4 fillchar = ' ';
103 : :
104 [ + + - + : 7867 : if (!_PyArg_CheckPositional("center", nargs, 1, 2)) {
+ - ]
105 : 1 : goto exit;
106 : : }
107 : : {
108 : 7866 : Py_ssize_t ival = -1;
109 : 7866 : PyObject *iobj = _PyNumber_Index(args[0]);
110 [ + - ]: 7866 : if (iobj != NULL) {
111 : 7866 : ival = PyLong_AsSsize_t(iobj);
112 : 7866 : Py_DECREF(iobj);
113 : : }
114 [ - + - - ]: 7866 : if (ival == -1 && PyErr_Occurred()) {
115 : 0 : goto exit;
116 : : }
117 : 7866 : width = ival;
118 : : }
119 [ + + ]: 7866 : if (nargs < 2) {
120 : 7860 : goto skip_optional;
121 : : }
122 [ - + ]: 6 : if (!convert_uc(args[1], &fillchar)) {
123 : 0 : goto exit;
124 : : }
125 : 6 : skip_optional:
126 : 7866 : return_value = unicode_center_impl(self, width, fillchar);
127 : :
128 : 7867 : exit:
129 : 7867 : return return_value;
130 : : }
131 : :
132 : : PyDoc_STRVAR(unicode_encode__doc__,
133 : : "encode($self, /, encoding=\'utf-8\', errors=\'strict\')\n"
134 : : "--\n"
135 : : "\n"
136 : : "Encode the string using the codec registered for encoding.\n"
137 : : "\n"
138 : : " encoding\n"
139 : : " The encoding in which to encode the string.\n"
140 : : " errors\n"
141 : : " The error handling scheme to use for encoding errors.\n"
142 : : " The default is \'strict\' meaning that encoding errors raise a\n"
143 : : " UnicodeEncodeError. Other possible values are \'ignore\', \'replace\' and\n"
144 : : " \'xmlcharrefreplace\' as well as any other name registered with\n"
145 : : " codecs.register_error that can handle UnicodeEncodeErrors.");
146 : :
147 : : #define UNICODE_ENCODE_METHODDEF \
148 : : {"encode", _PyCFunction_CAST(unicode_encode), METH_FASTCALL|METH_KEYWORDS, unicode_encode__doc__},
149 : :
150 : : static PyObject *
151 : : unicode_encode_impl(PyObject *self, const char *encoding, const char *errors);
152 : :
153 : : static PyObject *
154 : 5176737 : unicode_encode(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
155 : : {
156 : 5176737 : PyObject *return_value = NULL;
157 : : static const char * const _keywords[] = {"encoding", "errors", NULL};
158 : : static _PyArg_Parser _parser = {NULL, _keywords, "encode", 0};
159 : : PyObject *argsbuf[2];
160 [ + + ]: 5176737 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
161 : 5176737 : const char *encoding = NULL;
162 : 5176737 : const char *errors = NULL;
163 : :
164 [ + + + - : 5176737 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
+ + - + ]
165 [ + + ]: 5176737 : if (!args) {
166 : 1 : goto exit;
167 : : }
168 [ + + ]: 5176736 : if (!noptargs) {
169 : 93551 : goto skip_optional_pos;
170 : : }
171 [ + + ]: 5083185 : if (args[0]) {
172 [ - + ]: 5083183 : if (!PyUnicode_Check(args[0])) {
173 : 0 : _PyArg_BadArgument("encode", "argument 'encoding'", "str", args[0]);
174 : 0 : goto exit;
175 : : }
176 : : Py_ssize_t encoding_length;
177 : 5083183 : encoding = PyUnicode_AsUTF8AndSize(args[0], &encoding_length);
178 [ - + ]: 5083183 : if (encoding == NULL) {
179 : 0 : goto exit;
180 : : }
181 [ - + ]: 5083183 : if (strlen(encoding) != (size_t)encoding_length) {
182 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
183 : 0 : goto exit;
184 : : }
185 [ + + ]: 5083183 : if (!--noptargs) {
186 : 1728006 : goto skip_optional_pos;
187 : : }
188 : : }
189 [ - + ]: 3355179 : if (!PyUnicode_Check(args[1])) {
190 : 0 : _PyArg_BadArgument("encode", "argument 'errors'", "str", args[1]);
191 : 0 : goto exit;
192 : : }
193 : : Py_ssize_t errors_length;
194 : 3355179 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
195 [ - + ]: 3355179 : if (errors == NULL) {
196 : 0 : goto exit;
197 : : }
198 [ - + ]: 3355179 : if (strlen(errors) != (size_t)errors_length) {
199 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
200 : 0 : goto exit;
201 : : }
202 : 3355179 : skip_optional_pos:
203 : 5176736 : return_value = unicode_encode_impl(self, encoding, errors);
204 : :
205 : 5176737 : exit:
206 : 5176737 : return return_value;
207 : : }
208 : :
209 : : PyDoc_STRVAR(unicode_expandtabs__doc__,
210 : : "expandtabs($self, /, tabsize=8)\n"
211 : : "--\n"
212 : : "\n"
213 : : "Return a copy where all tab characters are expanded using spaces.\n"
214 : : "\n"
215 : : "If tabsize is not given, a tab size of 8 characters is assumed.");
216 : :
217 : : #define UNICODE_EXPANDTABS_METHODDEF \
218 : : {"expandtabs", _PyCFunction_CAST(unicode_expandtabs), METH_FASTCALL|METH_KEYWORDS, unicode_expandtabs__doc__},
219 : :
220 : : static PyObject *
221 : : unicode_expandtabs_impl(PyObject *self, int tabsize);
222 : :
223 : : static PyObject *
224 : 52044 : unicode_expandtabs(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
225 : : {
226 : 52044 : PyObject *return_value = NULL;
227 : : static const char * const _keywords[] = {"tabsize", NULL};
228 : : static _PyArg_Parser _parser = {NULL, _keywords, "expandtabs", 0};
229 : : PyObject *argsbuf[1];
230 [ + + ]: 52044 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
231 : 52044 : int tabsize = 8;
232 : :
233 [ + + + - : 52044 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+ + - + ]
234 [ + + ]: 52044 : if (!args) {
235 : 1 : goto exit;
236 : : }
237 [ + + ]: 52043 : if (!noptargs) {
238 : 7236 : goto skip_optional_pos;
239 : : }
240 : 44807 : tabsize = _PyLong_AsInt(args[0]);
241 [ - + - - ]: 44807 : if (tabsize == -1 && PyErr_Occurred()) {
242 : 0 : goto exit;
243 : : }
244 : 44807 : skip_optional_pos:
245 : 52043 : return_value = unicode_expandtabs_impl(self, tabsize);
246 : :
247 : 52044 : exit:
248 : 52044 : return return_value;
249 : : }
250 : :
251 : : PyDoc_STRVAR(unicode_isascii__doc__,
252 : : "isascii($self, /)\n"
253 : : "--\n"
254 : : "\n"
255 : : "Return True if all characters in the string are ASCII, False otherwise.\n"
256 : : "\n"
257 : : "ASCII characters have code points in the range U+0000-U+007F.\n"
258 : : "Empty string is ASCII too.");
259 : :
260 : : #define UNICODE_ISASCII_METHODDEF \
261 : : {"isascii", (PyCFunction)unicode_isascii, METH_NOARGS, unicode_isascii__doc__},
262 : :
263 : : static PyObject *
264 : : unicode_isascii_impl(PyObject *self);
265 : :
266 : : static PyObject *
267 : 102012 : unicode_isascii(PyObject *self, PyObject *Py_UNUSED(ignored))
268 : : {
269 : 102012 : return unicode_isascii_impl(self);
270 : : }
271 : :
272 : : PyDoc_STRVAR(unicode_islower__doc__,
273 : : "islower($self, /)\n"
274 : : "--\n"
275 : : "\n"
276 : : "Return True if the string is a lowercase string, False otherwise.\n"
277 : : "\n"
278 : : "A string is lowercase if all cased characters in the string are lowercase and\n"
279 : : "there is at least one cased character in the string.");
280 : :
281 : : #define UNICODE_ISLOWER_METHODDEF \
282 : : {"islower", (PyCFunction)unicode_islower, METH_NOARGS, unicode_islower__doc__},
283 : :
284 : : static PyObject *
285 : : unicode_islower_impl(PyObject *self);
286 : :
287 : : static PyObject *
288 : 2233428 : unicode_islower(PyObject *self, PyObject *Py_UNUSED(ignored))
289 : : {
290 : 2233428 : return unicode_islower_impl(self);
291 : : }
292 : :
293 : : PyDoc_STRVAR(unicode_isupper__doc__,
294 : : "isupper($self, /)\n"
295 : : "--\n"
296 : : "\n"
297 : : "Return True if the string is an uppercase string, False otherwise.\n"
298 : : "\n"
299 : : "A string is uppercase if all cased characters in the string are uppercase and\n"
300 : : "there is at least one cased character in the string.");
301 : :
302 : : #define UNICODE_ISUPPER_METHODDEF \
303 : : {"isupper", (PyCFunction)unicode_isupper, METH_NOARGS, unicode_isupper__doc__},
304 : :
305 : : static PyObject *
306 : : unicode_isupper_impl(PyObject *self);
307 : :
308 : : static PyObject *
309 : 3627593 : unicode_isupper(PyObject *self, PyObject *Py_UNUSED(ignored))
310 : : {
311 : 3627593 : return unicode_isupper_impl(self);
312 : : }
313 : :
314 : : PyDoc_STRVAR(unicode_istitle__doc__,
315 : : "istitle($self, /)\n"
316 : : "--\n"
317 : : "\n"
318 : : "Return True if the string is a title-cased string, False otherwise.\n"
319 : : "\n"
320 : : "In a title-cased string, upper- and title-case characters may only\n"
321 : : "follow uncased characters and lowercase characters only cased ones.");
322 : :
323 : : #define UNICODE_ISTITLE_METHODDEF \
324 : : {"istitle", (PyCFunction)unicode_istitle, METH_NOARGS, unicode_istitle__doc__},
325 : :
326 : : static PyObject *
327 : : unicode_istitle_impl(PyObject *self);
328 : :
329 : : static PyObject *
330 : 2228271 : unicode_istitle(PyObject *self, PyObject *Py_UNUSED(ignored))
331 : : {
332 : 2228271 : return unicode_istitle_impl(self);
333 : : }
334 : :
335 : : PyDoc_STRVAR(unicode_isspace__doc__,
336 : : "isspace($self, /)\n"
337 : : "--\n"
338 : : "\n"
339 : : "Return True if the string is a whitespace string, False otherwise.\n"
340 : : "\n"
341 : : "A string is whitespace if all characters in the string are whitespace and there\n"
342 : : "is at least one character in the string.");
343 : :
344 : : #define UNICODE_ISSPACE_METHODDEF \
345 : : {"isspace", (PyCFunction)unicode_isspace, METH_NOARGS, unicode_isspace__doc__},
346 : :
347 : : static PyObject *
348 : : unicode_isspace_impl(PyObject *self);
349 : :
350 : : static PyObject *
351 : 3418282 : unicode_isspace(PyObject *self, PyObject *Py_UNUSED(ignored))
352 : : {
353 : 3418282 : return unicode_isspace_impl(self);
354 : : }
355 : :
356 : : PyDoc_STRVAR(unicode_isalpha__doc__,
357 : : "isalpha($self, /)\n"
358 : : "--\n"
359 : : "\n"
360 : : "Return True if the string is an alphabetic string, False otherwise.\n"
361 : : "\n"
362 : : "A string is alphabetic if all characters in the string are alphabetic and there\n"
363 : : "is at least one character in the string.");
364 : :
365 : : #define UNICODE_ISALPHA_METHODDEF \
366 : : {"isalpha", (PyCFunction)unicode_isalpha, METH_NOARGS, unicode_isalpha__doc__},
367 : :
368 : : static PyObject *
369 : : unicode_isalpha_impl(PyObject *self);
370 : :
371 : : static PyObject *
372 : 2272295 : unicode_isalpha(PyObject *self, PyObject *Py_UNUSED(ignored))
373 : : {
374 : 2272295 : return unicode_isalpha_impl(self);
375 : : }
376 : :
377 : : PyDoc_STRVAR(unicode_isalnum__doc__,
378 : : "isalnum($self, /)\n"
379 : : "--\n"
380 : : "\n"
381 : : "Return True if the string is an alpha-numeric string, False otherwise.\n"
382 : : "\n"
383 : : "A string is alpha-numeric if all characters in the string are alpha-numeric and\n"
384 : : "there is at least one character in the string.");
385 : :
386 : : #define UNICODE_ISALNUM_METHODDEF \
387 : : {"isalnum", (PyCFunction)unicode_isalnum, METH_NOARGS, unicode_isalnum__doc__},
388 : :
389 : : static PyObject *
390 : : unicode_isalnum_impl(PyObject *self);
391 : :
392 : : static PyObject *
393 : 2332685 : unicode_isalnum(PyObject *self, PyObject *Py_UNUSED(ignored))
394 : : {
395 : 2332685 : return unicode_isalnum_impl(self);
396 : : }
397 : :
398 : : PyDoc_STRVAR(unicode_isdecimal__doc__,
399 : : "isdecimal($self, /)\n"
400 : : "--\n"
401 : : "\n"
402 : : "Return True if the string is a decimal string, False otherwise.\n"
403 : : "\n"
404 : : "A string is a decimal string if all characters in the string are decimal and\n"
405 : : "there is at least one character in the string.");
406 : :
407 : : #define UNICODE_ISDECIMAL_METHODDEF \
408 : : {"isdecimal", (PyCFunction)unicode_isdecimal, METH_NOARGS, unicode_isdecimal__doc__},
409 : :
410 : : static PyObject *
411 : : unicode_isdecimal_impl(PyObject *self);
412 : :
413 : : static PyObject *
414 : 2228410 : unicode_isdecimal(PyObject *self, PyObject *Py_UNUSED(ignored))
415 : : {
416 : 2228410 : return unicode_isdecimal_impl(self);
417 : : }
418 : :
419 : : PyDoc_STRVAR(unicode_isdigit__doc__,
420 : : "isdigit($self, /)\n"
421 : : "--\n"
422 : : "\n"
423 : : "Return True if the string is a digit string, False otherwise.\n"
424 : : "\n"
425 : : "A string is a digit string if all characters in the string are digits and there\n"
426 : : "is at least one character in the string.");
427 : :
428 : : #define UNICODE_ISDIGIT_METHODDEF \
429 : : {"isdigit", (PyCFunction)unicode_isdigit, METH_NOARGS, unicode_isdigit__doc__},
430 : :
431 : : static PyObject *
432 : : unicode_isdigit_impl(PyObject *self);
433 : :
434 : : static PyObject *
435 : 2250464 : unicode_isdigit(PyObject *self, PyObject *Py_UNUSED(ignored))
436 : : {
437 : 2250464 : return unicode_isdigit_impl(self);
438 : : }
439 : :
440 : : PyDoc_STRVAR(unicode_isnumeric__doc__,
441 : : "isnumeric($self, /)\n"
442 : : "--\n"
443 : : "\n"
444 : : "Return True if the string is a numeric string, False otherwise.\n"
445 : : "\n"
446 : : "A string is numeric if all characters in the string are numeric and there is at\n"
447 : : "least one character in the string.");
448 : :
449 : : #define UNICODE_ISNUMERIC_METHODDEF \
450 : : {"isnumeric", (PyCFunction)unicode_isnumeric, METH_NOARGS, unicode_isnumeric__doc__},
451 : :
452 : : static PyObject *
453 : : unicode_isnumeric_impl(PyObject *self);
454 : :
455 : : static PyObject *
456 : 2228253 : unicode_isnumeric(PyObject *self, PyObject *Py_UNUSED(ignored))
457 : : {
458 : 2228253 : return unicode_isnumeric_impl(self);
459 : : }
460 : :
461 : : PyDoc_STRVAR(unicode_isidentifier__doc__,
462 : : "isidentifier($self, /)\n"
463 : : "--\n"
464 : : "\n"
465 : : "Return True if the string is a valid Python identifier, False otherwise.\n"
466 : : "\n"
467 : : "Call keyword.iskeyword(s) to test whether string s is a reserved identifier,\n"
468 : : "such as \"def\" or \"class\".");
469 : :
470 : : #define UNICODE_ISIDENTIFIER_METHODDEF \
471 : : {"isidentifier", (PyCFunction)unicode_isidentifier, METH_NOARGS, unicode_isidentifier__doc__},
472 : :
473 : : static PyObject *
474 : : unicode_isidentifier_impl(PyObject *self);
475 : :
476 : : static PyObject *
477 : 5969044 : unicode_isidentifier(PyObject *self, PyObject *Py_UNUSED(ignored))
478 : : {
479 : 5969044 : return unicode_isidentifier_impl(self);
480 : : }
481 : :
482 : : PyDoc_STRVAR(unicode_isprintable__doc__,
483 : : "isprintable($self, /)\n"
484 : : "--\n"
485 : : "\n"
486 : : "Return True if the string is printable, False otherwise.\n"
487 : : "\n"
488 : : "A string is printable if all of its characters are considered printable in\n"
489 : : "repr() or if it is empty.");
490 : :
491 : : #define UNICODE_ISPRINTABLE_METHODDEF \
492 : : {"isprintable", (PyCFunction)unicode_isprintable, METH_NOARGS, unicode_isprintable__doc__},
493 : :
494 : : static PyObject *
495 : : unicode_isprintable_impl(PyObject *self);
496 : :
497 : : static PyObject *
498 : 1422395 : unicode_isprintable(PyObject *self, PyObject *Py_UNUSED(ignored))
499 : : {
500 : 1422395 : return unicode_isprintable_impl(self);
501 : : }
502 : :
503 : : PyDoc_STRVAR(unicode_join__doc__,
504 : : "join($self, iterable, /)\n"
505 : : "--\n"
506 : : "\n"
507 : : "Concatenate any number of strings.\n"
508 : : "\n"
509 : : "The string whose method is called is inserted in between each given string.\n"
510 : : "The result is returned as a new string.\n"
511 : : "\n"
512 : : "Example: \'.\'.join([\'ab\', \'pq\', \'rs\']) -> \'ab.pq.rs\'");
513 : :
514 : : #define UNICODE_JOIN_METHODDEF \
515 : : {"join", (PyCFunction)unicode_join, METH_O, unicode_join__doc__},
516 : :
517 : : PyDoc_STRVAR(unicode_ljust__doc__,
518 : : "ljust($self, width, fillchar=\' \', /)\n"
519 : : "--\n"
520 : : "\n"
521 : : "Return a left-justified string of length width.\n"
522 : : "\n"
523 : : "Padding is done using the specified fill character (default is a space).");
524 : :
525 : : #define UNICODE_LJUST_METHODDEF \
526 : : {"ljust", _PyCFunction_CAST(unicode_ljust), METH_FASTCALL, unicode_ljust__doc__},
527 : :
528 : : static PyObject *
529 : : unicode_ljust_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
530 : :
531 : : static PyObject *
532 : 25594 : unicode_ljust(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
533 : : {
534 : 25594 : PyObject *return_value = NULL;
535 : : Py_ssize_t width;
536 : 25594 : Py_UCS4 fillchar = ' ';
537 : :
538 [ + + - + : 25594 : if (!_PyArg_CheckPositional("ljust", nargs, 1, 2)) {
+ - ]
539 : 1 : goto exit;
540 : : }
541 : : {
542 : 25593 : Py_ssize_t ival = -1;
543 : 25593 : PyObject *iobj = _PyNumber_Index(args[0]);
544 [ + - ]: 25593 : if (iobj != NULL) {
545 : 25593 : ival = PyLong_AsSsize_t(iobj);
546 : 25593 : Py_DECREF(iobj);
547 : : }
548 [ - + - - ]: 25593 : if (ival == -1 && PyErr_Occurred()) {
549 : 0 : goto exit;
550 : : }
551 : 25593 : width = ival;
552 : : }
553 [ + + ]: 25593 : if (nargs < 2) {
554 : 25568 : goto skip_optional;
555 : : }
556 [ - + ]: 25 : if (!convert_uc(args[1], &fillchar)) {
557 : 0 : goto exit;
558 : : }
559 : 25 : skip_optional:
560 : 25593 : return_value = unicode_ljust_impl(self, width, fillchar);
561 : :
562 : 25594 : exit:
563 : 25594 : return return_value;
564 : : }
565 : :
566 : : PyDoc_STRVAR(unicode_lower__doc__,
567 : : "lower($self, /)\n"
568 : : "--\n"
569 : : "\n"
570 : : "Return a copy of the string converted to lowercase.");
571 : :
572 : : #define UNICODE_LOWER_METHODDEF \
573 : : {"lower", (PyCFunction)unicode_lower, METH_NOARGS, unicode_lower__doc__},
574 : :
575 : : static PyObject *
576 : : unicode_lower_impl(PyObject *self);
577 : :
578 : : static PyObject *
579 : 4095028 : unicode_lower(PyObject *self, PyObject *Py_UNUSED(ignored))
580 : : {
581 : 4095028 : return unicode_lower_impl(self);
582 : : }
583 : :
584 : : PyDoc_STRVAR(unicode_strip__doc__,
585 : : "strip($self, chars=None, /)\n"
586 : : "--\n"
587 : : "\n"
588 : : "Return a copy of the string with leading and trailing whitespace removed.\n"
589 : : "\n"
590 : : "If chars is given and not None, remove characters in chars instead.");
591 : :
592 : : #define UNICODE_STRIP_METHODDEF \
593 : : {"strip", _PyCFunction_CAST(unicode_strip), METH_FASTCALL, unicode_strip__doc__},
594 : :
595 : : static PyObject *
596 : : unicode_strip_impl(PyObject *self, PyObject *chars);
597 : :
598 : : static PyObject *
599 : 1130154 : unicode_strip(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
600 : : {
601 : 1130154 : PyObject *return_value = NULL;
602 : 1130154 : PyObject *chars = Py_None;
603 : :
604 [ + - + + : 1130154 : if (!_PyArg_CheckPositional("strip", nargs, 0, 1)) {
+ - ]
605 : 1 : goto exit;
606 : : }
607 [ + + ]: 1130153 : if (nargs < 1) {
608 : 1091231 : goto skip_optional;
609 : : }
610 : 38922 : chars = args[0];
611 : 1130153 : skip_optional:
612 : 1130153 : return_value = unicode_strip_impl(self, chars);
613 : :
614 : 1130154 : exit:
615 : 1130154 : return return_value;
616 : : }
617 : :
618 : : PyDoc_STRVAR(unicode_lstrip__doc__,
619 : : "lstrip($self, chars=None, /)\n"
620 : : "--\n"
621 : : "\n"
622 : : "Return a copy of the string with leading whitespace removed.\n"
623 : : "\n"
624 : : "If chars is given and not None, remove characters in chars instead.");
625 : :
626 : : #define UNICODE_LSTRIP_METHODDEF \
627 : : {"lstrip", _PyCFunction_CAST(unicode_lstrip), METH_FASTCALL, unicode_lstrip__doc__},
628 : :
629 : : static PyObject *
630 : : unicode_lstrip_impl(PyObject *self, PyObject *chars);
631 : :
632 : : static PyObject *
633 : 230150 : unicode_lstrip(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
634 : : {
635 : 230150 : PyObject *return_value = NULL;
636 : 230150 : PyObject *chars = Py_None;
637 : :
638 [ + - + + : 230150 : if (!_PyArg_CheckPositional("lstrip", nargs, 0, 1)) {
+ - ]
639 : 1 : goto exit;
640 : : }
641 [ + + ]: 230149 : if (nargs < 1) {
642 : 29325 : goto skip_optional;
643 : : }
644 : 200824 : chars = args[0];
645 : 230149 : skip_optional:
646 : 230149 : return_value = unicode_lstrip_impl(self, chars);
647 : :
648 : 230150 : exit:
649 : 230150 : return return_value;
650 : : }
651 : :
652 : : PyDoc_STRVAR(unicode_rstrip__doc__,
653 : : "rstrip($self, chars=None, /)\n"
654 : : "--\n"
655 : : "\n"
656 : : "Return a copy of the string with trailing whitespace removed.\n"
657 : : "\n"
658 : : "If chars is given and not None, remove characters in chars instead.");
659 : :
660 : : #define UNICODE_RSTRIP_METHODDEF \
661 : : {"rstrip", _PyCFunction_CAST(unicode_rstrip), METH_FASTCALL, unicode_rstrip__doc__},
662 : :
663 : : static PyObject *
664 : : unicode_rstrip_impl(PyObject *self, PyObject *chars);
665 : :
666 : : static PyObject *
667 : 5373173 : unicode_rstrip(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
668 : : {
669 : 5373173 : PyObject *return_value = NULL;
670 : 5373173 : PyObject *chars = Py_None;
671 : :
672 [ + - + + : 5373173 : if (!_PyArg_CheckPositional("rstrip", nargs, 0, 1)) {
+ - ]
673 : 1 : goto exit;
674 : : }
675 [ + + ]: 5373172 : if (nargs < 1) {
676 : 74429 : goto skip_optional;
677 : : }
678 : 5298743 : chars = args[0];
679 : 5373172 : skip_optional:
680 : 5373172 : return_value = unicode_rstrip_impl(self, chars);
681 : :
682 : 5373173 : exit:
683 : 5373173 : return return_value;
684 : : }
685 : :
686 : : PyDoc_STRVAR(unicode_replace__doc__,
687 : : "replace($self, old, new, count=-1, /)\n"
688 : : "--\n"
689 : : "\n"
690 : : "Return a copy with all occurrences of substring old replaced by new.\n"
691 : : "\n"
692 : : " count\n"
693 : : " Maximum number of occurrences to replace.\n"
694 : : " -1 (the default value) means replace all occurrences.\n"
695 : : "\n"
696 : : "If the optional argument count is given, only the first count occurrences are\n"
697 : : "replaced.");
698 : :
699 : : #define UNICODE_REPLACE_METHODDEF \
700 : : {"replace", _PyCFunction_CAST(unicode_replace), METH_FASTCALL, unicode_replace__doc__},
701 : :
702 : : static PyObject *
703 : : unicode_replace_impl(PyObject *self, PyObject *old, PyObject *new,
704 : : Py_ssize_t count);
705 : :
706 : : static PyObject *
707 : 3276283 : unicode_replace(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
708 : : {
709 : 3276283 : PyObject *return_value = NULL;
710 : : PyObject *old;
711 : : PyObject *new;
712 : 3276283 : Py_ssize_t count = -1;
713 : :
714 [ + + - + : 3276283 : if (!_PyArg_CheckPositional("replace", nargs, 2, 3)) {
+ - ]
715 : 2 : goto exit;
716 : : }
717 [ + + ]: 3276281 : if (!PyUnicode_Check(args[0])) {
718 : 5 : _PyArg_BadArgument("replace", "argument 1", "str", args[0]);
719 : 5 : goto exit;
720 : : }
721 [ - + ]: 3276276 : if (PyUnicode_READY(args[0]) == -1) {
722 : 0 : goto exit;
723 : : }
724 : 3276276 : old = args[0];
725 [ + + ]: 3276276 : if (!PyUnicode_Check(args[1])) {
726 : 3 : _PyArg_BadArgument("replace", "argument 2", "str", args[1]);
727 : 3 : goto exit;
728 : : }
729 [ - + ]: 3276273 : if (PyUnicode_READY(args[1]) == -1) {
730 : 0 : goto exit;
731 : : }
732 : 3276273 : new = args[1];
733 [ + + ]: 3276273 : if (nargs < 3) {
734 : 3211284 : goto skip_optional;
735 : : }
736 : : {
737 : 64989 : Py_ssize_t ival = -1;
738 : 64989 : PyObject *iobj = _PyNumber_Index(args[2]);
739 [ + - ]: 64989 : if (iobj != NULL) {
740 : 64989 : ival = PyLong_AsSsize_t(iobj);
741 : 64989 : Py_DECREF(iobj);
742 : : }
743 [ + + - + ]: 64989 : if (ival == -1 && PyErr_Occurred()) {
744 : 0 : goto exit;
745 : : }
746 : 64989 : count = ival;
747 : : }
748 : 3276273 : skip_optional:
749 : 3276273 : return_value = unicode_replace_impl(self, old, new, count);
750 : :
751 : 3276283 : exit:
752 : 3276283 : return return_value;
753 : : }
754 : :
755 : : PyDoc_STRVAR(unicode_removeprefix__doc__,
756 : : "removeprefix($self, prefix, /)\n"
757 : : "--\n"
758 : : "\n"
759 : : "Return a str with the given prefix string removed if present.\n"
760 : : "\n"
761 : : "If the string starts with the prefix string, return string[len(prefix):].\n"
762 : : "Otherwise, return a copy of the original string.");
763 : :
764 : : #define UNICODE_REMOVEPREFIX_METHODDEF \
765 : : {"removeprefix", (PyCFunction)unicode_removeprefix, METH_O, unicode_removeprefix__doc__},
766 : :
767 : : static PyObject *
768 : : unicode_removeprefix_impl(PyObject *self, PyObject *prefix);
769 : :
770 : : static PyObject *
771 : 30318 : unicode_removeprefix(PyObject *self, PyObject *arg)
772 : : {
773 : 30318 : PyObject *return_value = NULL;
774 : : PyObject *prefix;
775 : :
776 [ + + ]: 30318 : if (!PyUnicode_Check(arg)) {
777 : 4 : _PyArg_BadArgument("removeprefix", "argument", "str", arg);
778 : 4 : goto exit;
779 : : }
780 [ - + ]: 30314 : if (PyUnicode_READY(arg) == -1) {
781 : 0 : goto exit;
782 : : }
783 : 30314 : prefix = arg;
784 : 30314 : return_value = unicode_removeprefix_impl(self, prefix);
785 : :
786 : 30318 : exit:
787 : 30318 : return return_value;
788 : : }
789 : :
790 : : PyDoc_STRVAR(unicode_removesuffix__doc__,
791 : : "removesuffix($self, suffix, /)\n"
792 : : "--\n"
793 : : "\n"
794 : : "Return a str with the given suffix string removed if present.\n"
795 : : "\n"
796 : : "If the string ends with the suffix string and that suffix is not empty,\n"
797 : : "return string[:-len(suffix)]. Otherwise, return a copy of the original\n"
798 : : "string.");
799 : :
800 : : #define UNICODE_REMOVESUFFIX_METHODDEF \
801 : : {"removesuffix", (PyCFunction)unicode_removesuffix, METH_O, unicode_removesuffix__doc__},
802 : :
803 : : static PyObject *
804 : : unicode_removesuffix_impl(PyObject *self, PyObject *suffix);
805 : :
806 : : static PyObject *
807 : 32 : unicode_removesuffix(PyObject *self, PyObject *arg)
808 : : {
809 : 32 : PyObject *return_value = NULL;
810 : : PyObject *suffix;
811 : :
812 [ + + ]: 32 : if (!PyUnicode_Check(arg)) {
813 : 4 : _PyArg_BadArgument("removesuffix", "argument", "str", arg);
814 : 4 : goto exit;
815 : : }
816 [ - + ]: 28 : if (PyUnicode_READY(arg) == -1) {
817 : 0 : goto exit;
818 : : }
819 : 28 : suffix = arg;
820 : 28 : return_value = unicode_removesuffix_impl(self, suffix);
821 : :
822 : 32 : exit:
823 : 32 : return return_value;
824 : : }
825 : :
826 : : PyDoc_STRVAR(unicode_rjust__doc__,
827 : : "rjust($self, width, fillchar=\' \', /)\n"
828 : : "--\n"
829 : : "\n"
830 : : "Return a right-justified string of length width.\n"
831 : : "\n"
832 : : "Padding is done using the specified fill character (default is a space).");
833 : :
834 : : #define UNICODE_RJUST_METHODDEF \
835 : : {"rjust", _PyCFunction_CAST(unicode_rjust), METH_FASTCALL, unicode_rjust__doc__},
836 : :
837 : : static PyObject *
838 : : unicode_rjust_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
839 : :
840 : : static PyObject *
841 : 48169 : unicode_rjust(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
842 : : {
843 : 48169 : PyObject *return_value = NULL;
844 : : Py_ssize_t width;
845 : 48169 : Py_UCS4 fillchar = ' ';
846 : :
847 [ + + - + : 48169 : if (!_PyArg_CheckPositional("rjust", nargs, 1, 2)) {
+ - ]
848 : 1 : goto exit;
849 : : }
850 : : {
851 : 48168 : Py_ssize_t ival = -1;
852 : 48168 : PyObject *iobj = _PyNumber_Index(args[0]);
853 [ + - ]: 48168 : if (iobj != NULL) {
854 : 48168 : ival = PyLong_AsSsize_t(iobj);
855 : 48168 : Py_DECREF(iobj);
856 : : }
857 [ - + - - ]: 48168 : if (ival == -1 && PyErr_Occurred()) {
858 : 0 : goto exit;
859 : : }
860 : 48168 : width = ival;
861 : : }
862 [ + + ]: 48168 : if (nargs < 2) {
863 : 48136 : goto skip_optional;
864 : : }
865 [ - + ]: 32 : if (!convert_uc(args[1], &fillchar)) {
866 : 0 : goto exit;
867 : : }
868 : 32 : skip_optional:
869 : 48168 : return_value = unicode_rjust_impl(self, width, fillchar);
870 : :
871 : 48169 : exit:
872 : 48169 : return return_value;
873 : : }
874 : :
875 : : PyDoc_STRVAR(unicode_split__doc__,
876 : : "split($self, /, sep=None, maxsplit=-1)\n"
877 : : "--\n"
878 : : "\n"
879 : : "Return a list of the substrings in the string, using sep as the separator string.\n"
880 : : "\n"
881 : : " sep\n"
882 : : " The separator used to split the string.\n"
883 : : "\n"
884 : : " When set to None (the default value), will split on any whitespace\n"
885 : : " character (including \\\\n \\\\r \\\\t \\\\f and spaces) and will discard\n"
886 : : " empty strings from the result.\n"
887 : : " maxsplit\n"
888 : : " Maximum number of splits (starting from the left).\n"
889 : : " -1 (the default value) means no limit.\n"
890 : : "\n"
891 : : "Note, str.split() is mainly useful for data that has been intentionally\n"
892 : : "delimited. With natural text that includes punctuation, consider using\n"
893 : : "the regular expression module.");
894 : :
895 : : #define UNICODE_SPLIT_METHODDEF \
896 : : {"split", _PyCFunction_CAST(unicode_split), METH_FASTCALL|METH_KEYWORDS, unicode_split__doc__},
897 : :
898 : : static PyObject *
899 : : unicode_split_impl(PyObject *self, PyObject *sep, Py_ssize_t maxsplit);
900 : :
901 : : static PyObject *
902 : 2217864 : unicode_split(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
903 : : {
904 : 2217864 : PyObject *return_value = NULL;
905 : : static const char * const _keywords[] = {"sep", "maxsplit", NULL};
906 : : static _PyArg_Parser _parser = {NULL, _keywords, "split", 0};
907 : : PyObject *argsbuf[2];
908 [ + + ]: 2217864 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
909 : 2217864 : PyObject *sep = Py_None;
910 : 2217864 : Py_ssize_t maxsplit = -1;
911 : :
912 [ + + + - : 2217864 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
+ + - + ]
913 [ + + ]: 2217864 : if (!args) {
914 : 1 : goto exit;
915 : : }
916 [ + + ]: 2217863 : if (!noptargs) {
917 : 489750 : goto skip_optional_pos;
918 : : }
919 [ + + ]: 1728113 : if (args[0]) {
920 : 1726900 : sep = args[0];
921 [ + + ]: 1726900 : if (!--noptargs) {
922 : 1650951 : goto skip_optional_pos;
923 : : }
924 : : }
925 : : {
926 : 77162 : Py_ssize_t ival = -1;
927 : 77162 : PyObject *iobj = _PyNumber_Index(args[1]);
928 [ + - ]: 77162 : if (iobj != NULL) {
929 : 77162 : ival = PyLong_AsSsize_t(iobj);
930 : 77162 : Py_DECREF(iobj);
931 : : }
932 [ + + - + ]: 77162 : if (ival == -1 && PyErr_Occurred()) {
933 : 0 : goto exit;
934 : : }
935 : 77162 : maxsplit = ival;
936 : : }
937 : 2217863 : skip_optional_pos:
938 : 2217863 : return_value = unicode_split_impl(self, sep, maxsplit);
939 : :
940 : 2217864 : exit:
941 : 2217864 : return return_value;
942 : : }
943 : :
944 : : PyDoc_STRVAR(unicode_partition__doc__,
945 : : "partition($self, sep, /)\n"
946 : : "--\n"
947 : : "\n"
948 : : "Partition the string into three parts using the given separator.\n"
949 : : "\n"
950 : : "This will search for the separator in the string. If the separator is found,\n"
951 : : "returns a 3-tuple containing the part before the separator, the separator\n"
952 : : "itself, and the part after it.\n"
953 : : "\n"
954 : : "If the separator is not found, returns a 3-tuple containing the original string\n"
955 : : "and two empty strings.");
956 : :
957 : : #define UNICODE_PARTITION_METHODDEF \
958 : : {"partition", (PyCFunction)unicode_partition, METH_O, unicode_partition__doc__},
959 : :
960 : : PyDoc_STRVAR(unicode_rpartition__doc__,
961 : : "rpartition($self, sep, /)\n"
962 : : "--\n"
963 : : "\n"
964 : : "Partition the string into three parts using the given separator.\n"
965 : : "\n"
966 : : "This will search for the separator in the string, starting at the end. If\n"
967 : : "the separator is found, returns a 3-tuple containing the part before the\n"
968 : : "separator, the separator itself, and the part after it.\n"
969 : : "\n"
970 : : "If the separator is not found, returns a 3-tuple containing two empty strings\n"
971 : : "and the original string.");
972 : :
973 : : #define UNICODE_RPARTITION_METHODDEF \
974 : : {"rpartition", (PyCFunction)unicode_rpartition, METH_O, unicode_rpartition__doc__},
975 : :
976 : : PyDoc_STRVAR(unicode_rsplit__doc__,
977 : : "rsplit($self, /, sep=None, maxsplit=-1)\n"
978 : : "--\n"
979 : : "\n"
980 : : "Return a list of the substrings in the string, using sep as the separator string.\n"
981 : : "\n"
982 : : " sep\n"
983 : : " The separator used to split the string.\n"
984 : : "\n"
985 : : " When set to None (the default value), will split on any whitespace\n"
986 : : " character (including \\\\n \\\\r \\\\t \\\\f and spaces) and will discard\n"
987 : : " empty strings from the result.\n"
988 : : " maxsplit\n"
989 : : " Maximum number of splits (starting from the left).\n"
990 : : " -1 (the default value) means no limit.\n"
991 : : "\n"
992 : : "Splitting starts at the end of the string and works to the front.");
993 : :
994 : : #define UNICODE_RSPLIT_METHODDEF \
995 : : {"rsplit", _PyCFunction_CAST(unicode_rsplit), METH_FASTCALL|METH_KEYWORDS, unicode_rsplit__doc__},
996 : :
997 : : static PyObject *
998 : : unicode_rsplit_impl(PyObject *self, PyObject *sep, Py_ssize_t maxsplit);
999 : :
1000 : : static PyObject *
1001 : 3831 : unicode_rsplit(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1002 : : {
1003 : 3831 : PyObject *return_value = NULL;
1004 : : static const char * const _keywords[] = {"sep", "maxsplit", NULL};
1005 : : static _PyArg_Parser _parser = {NULL, _keywords, "rsplit", 0};
1006 : : PyObject *argsbuf[2];
1007 [ + + ]: 3831 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
1008 : 3831 : PyObject *sep = Py_None;
1009 : 3831 : Py_ssize_t maxsplit = -1;
1010 : :
1011 [ + + + - : 3831 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
+ + - + ]
1012 [ + + ]: 3831 : if (!args) {
1013 : 1 : goto exit;
1014 : : }
1015 [ + + ]: 3830 : if (!noptargs) {
1016 : 11 : goto skip_optional_pos;
1017 : : }
1018 [ + + ]: 3819 : if (args[0]) {
1019 : 3818 : sep = args[0];
1020 [ + + ]: 3818 : if (!--noptargs) {
1021 : 63 : goto skip_optional_pos;
1022 : : }
1023 : : }
1024 : : {
1025 : 3756 : Py_ssize_t ival = -1;
1026 : 3756 : PyObject *iobj = _PyNumber_Index(args[1]);
1027 [ + - ]: 3756 : if (iobj != NULL) {
1028 : 3756 : ival = PyLong_AsSsize_t(iobj);
1029 : 3756 : Py_DECREF(iobj);
1030 : : }
1031 [ + + - + ]: 3756 : if (ival == -1 && PyErr_Occurred()) {
1032 : 0 : goto exit;
1033 : : }
1034 : 3756 : maxsplit = ival;
1035 : : }
1036 : 3830 : skip_optional_pos:
1037 : 3830 : return_value = unicode_rsplit_impl(self, sep, maxsplit);
1038 : :
1039 : 3831 : exit:
1040 : 3831 : return return_value;
1041 : : }
1042 : :
1043 : : PyDoc_STRVAR(unicode_splitlines__doc__,
1044 : : "splitlines($self, /, keepends=False)\n"
1045 : : "--\n"
1046 : : "\n"
1047 : : "Return a list of the lines in the string, breaking at line boundaries.\n"
1048 : : "\n"
1049 : : "Line breaks are not included in the resulting list unless keepends is given and\n"
1050 : : "true.");
1051 : :
1052 : : #define UNICODE_SPLITLINES_METHODDEF \
1053 : : {"splitlines", _PyCFunction_CAST(unicode_splitlines), METH_FASTCALL|METH_KEYWORDS, unicode_splitlines__doc__},
1054 : :
1055 : : static PyObject *
1056 : : unicode_splitlines_impl(PyObject *self, int keepends);
1057 : :
1058 : : static PyObject *
1059 : 287351 : unicode_splitlines(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1060 : : {
1061 : 287351 : PyObject *return_value = NULL;
1062 : : static const char * const _keywords[] = {"keepends", NULL};
1063 : : static _PyArg_Parser _parser = {NULL, _keywords, "splitlines", 0};
1064 : : PyObject *argsbuf[1];
1065 [ + + ]: 287351 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
1066 : 287351 : int keepends = 0;
1067 : :
1068 [ + + + - : 287351 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+ + - + ]
1069 [ + + ]: 287351 : if (!args) {
1070 : 1 : goto exit;
1071 : : }
1072 [ + + ]: 287350 : if (!noptargs) {
1073 : 75322 : goto skip_optional_pos;
1074 : : }
1075 : 212028 : keepends = _PyLong_AsInt(args[0]);
1076 [ - + - - ]: 212028 : if (keepends == -1 && PyErr_Occurred()) {
1077 : 0 : goto exit;
1078 : : }
1079 : 212028 : skip_optional_pos:
1080 : 287350 : return_value = unicode_splitlines_impl(self, keepends);
1081 : :
1082 : 287351 : exit:
1083 : 287351 : return return_value;
1084 : : }
1085 : :
1086 : : PyDoc_STRVAR(unicode_swapcase__doc__,
1087 : : "swapcase($self, /)\n"
1088 : : "--\n"
1089 : : "\n"
1090 : : "Convert uppercase characters to lowercase and lowercase characters to uppercase.");
1091 : :
1092 : : #define UNICODE_SWAPCASE_METHODDEF \
1093 : : {"swapcase", (PyCFunction)unicode_swapcase, METH_NOARGS, unicode_swapcase__doc__},
1094 : :
1095 : : static PyObject *
1096 : : unicode_swapcase_impl(PyObject *self);
1097 : :
1098 : : static PyObject *
1099 : 29 : unicode_swapcase(PyObject *self, PyObject *Py_UNUSED(ignored))
1100 : : {
1101 : 29 : return unicode_swapcase_impl(self);
1102 : : }
1103 : :
1104 : : PyDoc_STRVAR(unicode_maketrans__doc__,
1105 : : "maketrans(x, y=<unrepresentable>, z=<unrepresentable>, /)\n"
1106 : : "--\n"
1107 : : "\n"
1108 : : "Return a translation table usable for str.translate().\n"
1109 : : "\n"
1110 : : "If there is only one argument, it must be a dictionary mapping Unicode\n"
1111 : : "ordinals (integers) or characters to Unicode ordinals, strings or None.\n"
1112 : : "Character keys will be then converted to ordinals.\n"
1113 : : "If there are two arguments, they must be strings of equal length, and\n"
1114 : : "in the resulting dictionary, each character in x will be mapped to the\n"
1115 : : "character at the same position in y. If there is a third argument, it\n"
1116 : : "must be a string, whose characters will be mapped to None in the result.");
1117 : :
1118 : : #define UNICODE_MAKETRANS_METHODDEF \
1119 : : {"maketrans", _PyCFunction_CAST(unicode_maketrans), METH_FASTCALL|METH_STATIC, unicode_maketrans__doc__},
1120 : :
1121 : : static PyObject *
1122 : : unicode_maketrans_impl(PyObject *x, PyObject *y, PyObject *z);
1123 : :
1124 : : static PyObject *
1125 : 141 : unicode_maketrans(void *null, PyObject *const *args, Py_ssize_t nargs)
1126 : : {
1127 : 141 : PyObject *return_value = NULL;
1128 : : PyObject *x;
1129 : 141 : PyObject *y = NULL;
1130 : 141 : PyObject *z = NULL;
1131 : :
1132 [ + + - + : 141 : if (!_PyArg_CheckPositional("maketrans", nargs, 1, 3)) {
+ - ]
1133 : 1 : goto exit;
1134 : : }
1135 : 140 : x = args[0];
1136 [ + + ]: 140 : if (nargs < 2) {
1137 : 111 : goto skip_optional;
1138 : : }
1139 [ + + ]: 29 : if (!PyUnicode_Check(args[1])) {
1140 : 1 : _PyArg_BadArgument("maketrans", "argument 2", "str", args[1]);
1141 : 1 : goto exit;
1142 : : }
1143 [ - + ]: 28 : if (PyUnicode_READY(args[1]) == -1) {
1144 : 0 : goto exit;
1145 : : }
1146 : 28 : y = args[1];
1147 [ + + ]: 28 : if (nargs < 3) {
1148 : 25 : goto skip_optional;
1149 : : }
1150 [ + + ]: 3 : if (!PyUnicode_Check(args[2])) {
1151 : 1 : _PyArg_BadArgument("maketrans", "argument 3", "str", args[2]);
1152 : 1 : goto exit;
1153 : : }
1154 [ - + ]: 2 : if (PyUnicode_READY(args[2]) == -1) {
1155 : 0 : goto exit;
1156 : : }
1157 : 2 : z = args[2];
1158 : 138 : skip_optional:
1159 : 138 : return_value = unicode_maketrans_impl(x, y, z);
1160 : :
1161 : 141 : exit:
1162 : 141 : return return_value;
1163 : : }
1164 : :
1165 : : PyDoc_STRVAR(unicode_translate__doc__,
1166 : : "translate($self, table, /)\n"
1167 : : "--\n"
1168 : : "\n"
1169 : : "Replace each character in the string using the given translation table.\n"
1170 : : "\n"
1171 : : " table\n"
1172 : : " Translation table, which must be a mapping of Unicode ordinals to\n"
1173 : : " Unicode ordinals, strings, or None.\n"
1174 : : "\n"
1175 : : "The table must implement lookup/indexing via __getitem__, for instance a\n"
1176 : : "dictionary or list. If this operation raises LookupError, the character is\n"
1177 : : "left untouched. Characters mapped to None are deleted.");
1178 : :
1179 : : #define UNICODE_TRANSLATE_METHODDEF \
1180 : : {"translate", (PyCFunction)unicode_translate, METH_O, unicode_translate__doc__},
1181 : :
1182 : : PyDoc_STRVAR(unicode_upper__doc__,
1183 : : "upper($self, /)\n"
1184 : : "--\n"
1185 : : "\n"
1186 : : "Return a copy of the string converted to uppercase.");
1187 : :
1188 : : #define UNICODE_UPPER_METHODDEF \
1189 : : {"upper", (PyCFunction)unicode_upper, METH_NOARGS, unicode_upper__doc__},
1190 : :
1191 : : static PyObject *
1192 : : unicode_upper_impl(PyObject *self);
1193 : :
1194 : : static PyObject *
1195 : 3411960 : unicode_upper(PyObject *self, PyObject *Py_UNUSED(ignored))
1196 : : {
1197 : 3411960 : return unicode_upper_impl(self);
1198 : : }
1199 : :
1200 : : PyDoc_STRVAR(unicode_zfill__doc__,
1201 : : "zfill($self, width, /)\n"
1202 : : "--\n"
1203 : : "\n"
1204 : : "Pad a numeric string with zeros on the left, to fill a field of the given width.\n"
1205 : : "\n"
1206 : : "The string is never truncated.");
1207 : :
1208 : : #define UNICODE_ZFILL_METHODDEF \
1209 : : {"zfill", (PyCFunction)unicode_zfill, METH_O, unicode_zfill__doc__},
1210 : :
1211 : : static PyObject *
1212 : : unicode_zfill_impl(PyObject *self, Py_ssize_t width);
1213 : :
1214 : : static PyObject *
1215 : 176 : unicode_zfill(PyObject *self, PyObject *arg)
1216 : : {
1217 : 176 : PyObject *return_value = NULL;
1218 : : Py_ssize_t width;
1219 : :
1220 : : {
1221 : 176 : Py_ssize_t ival = -1;
1222 : 176 : PyObject *iobj = _PyNumber_Index(arg);
1223 [ + - ]: 176 : if (iobj != NULL) {
1224 : 176 : ival = PyLong_AsSsize_t(iobj);
1225 : 176 : Py_DECREF(iobj);
1226 : : }
1227 [ - + - - ]: 176 : if (ival == -1 && PyErr_Occurred()) {
1228 : 0 : goto exit;
1229 : : }
1230 : 176 : width = ival;
1231 : : }
1232 : 176 : return_value = unicode_zfill_impl(self, width);
1233 : :
1234 : 176 : exit:
1235 : 176 : return return_value;
1236 : : }
1237 : :
1238 : : PyDoc_STRVAR(unicode___format____doc__,
1239 : : "__format__($self, format_spec, /)\n"
1240 : : "--\n"
1241 : : "\n"
1242 : : "Return a formatted version of the string as described by format_spec.");
1243 : :
1244 : : #define UNICODE___FORMAT___METHODDEF \
1245 : : {"__format__", (PyCFunction)unicode___format__, METH_O, unicode___format____doc__},
1246 : :
1247 : : static PyObject *
1248 : : unicode___format___impl(PyObject *self, PyObject *format_spec);
1249 : :
1250 : : static PyObject *
1251 : 7931 : unicode___format__(PyObject *self, PyObject *arg)
1252 : : {
1253 : 7931 : PyObject *return_value = NULL;
1254 : : PyObject *format_spec;
1255 : :
1256 [ - + ]: 7931 : if (!PyUnicode_Check(arg)) {
1257 : 0 : _PyArg_BadArgument("__format__", "argument", "str", arg);
1258 : 0 : goto exit;
1259 : : }
1260 [ - + ]: 7931 : if (PyUnicode_READY(arg) == -1) {
1261 : 0 : goto exit;
1262 : : }
1263 : 7931 : format_spec = arg;
1264 : 7931 : return_value = unicode___format___impl(self, format_spec);
1265 : :
1266 : 7931 : exit:
1267 : 7931 : return return_value;
1268 : : }
1269 : :
1270 : : PyDoc_STRVAR(unicode_sizeof__doc__,
1271 : : "__sizeof__($self, /)\n"
1272 : : "--\n"
1273 : : "\n"
1274 : : "Return the size of the string in memory, in bytes.");
1275 : :
1276 : : #define UNICODE_SIZEOF_METHODDEF \
1277 : : {"__sizeof__", (PyCFunction)unicode_sizeof, METH_NOARGS, unicode_sizeof__doc__},
1278 : :
1279 : : static PyObject *
1280 : : unicode_sizeof_impl(PyObject *self);
1281 : :
1282 : : static PyObject *
1283 : 12 : unicode_sizeof(PyObject *self, PyObject *Py_UNUSED(ignored))
1284 : : {
1285 : 12 : return unicode_sizeof_impl(self);
1286 : : }
1287 : :
1288 : : static PyObject *
1289 : : unicode_new_impl(PyTypeObject *type, PyObject *x, const char *encoding,
1290 : : const char *errors);
1291 : :
1292 : : static PyObject *
1293 : 1199241 : unicode_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1294 : : {
1295 : 1199241 : PyObject *return_value = NULL;
1296 : : static const char * const _keywords[] = {"object", "encoding", "errors", NULL};
1297 : : static _PyArg_Parser _parser = {NULL, _keywords, "str", 0};
1298 : : PyObject *argsbuf[3];
1299 : : PyObject * const *fastargs;
1300 : 1199241 : Py_ssize_t nargs = PyTuple_GET_SIZE(args);
1301 [ + + ]: 1199241 : Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
1302 : 1199241 : PyObject *x = NULL;
1303 : 1199241 : const char *encoding = NULL;
1304 : 1199241 : const char *errors = NULL;
1305 : :
1306 [ + + + - : 1199241 : fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 3, 0, argsbuf);
+ - + - ]
1307 [ + + ]: 1199241 : if (!fastargs) {
1308 : 3 : goto exit;
1309 : : }
1310 [ + + ]: 1199238 : if (!noptargs) {
1311 : 15097 : goto skip_optional_pos;
1312 : : }
1313 [ + + ]: 1184141 : if (fastargs[0]) {
1314 : 1184140 : x = fastargs[0];
1315 [ + + ]: 1184140 : if (!--noptargs) {
1316 : 724847 : goto skip_optional_pos;
1317 : : }
1318 : : }
1319 [ + + ]: 459294 : if (fastargs[1]) {
1320 [ + + ]: 459287 : if (!PyUnicode_Check(fastargs[1])) {
1321 : 3 : _PyArg_BadArgument("str", "argument 'encoding'", "str", fastargs[1]);
1322 : 3 : goto exit;
1323 : : }
1324 : : Py_ssize_t encoding_length;
1325 : 459284 : encoding = PyUnicode_AsUTF8AndSize(fastargs[1], &encoding_length);
1326 [ - + ]: 459284 : if (encoding == NULL) {
1327 : 0 : goto exit;
1328 : : }
1329 [ - + ]: 459284 : if (strlen(encoding) != (size_t)encoding_length) {
1330 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1331 : 0 : goto exit;
1332 : : }
1333 [ + + ]: 459284 : if (!--noptargs) {
1334 : 248350 : goto skip_optional_pos;
1335 : : }
1336 : : }
1337 [ + + ]: 210941 : if (!PyUnicode_Check(fastargs[2])) {
1338 : 1 : _PyArg_BadArgument("str", "argument 'errors'", "str", fastargs[2]);
1339 : 1 : goto exit;
1340 : : }
1341 : : Py_ssize_t errors_length;
1342 : 210940 : errors = PyUnicode_AsUTF8AndSize(fastargs[2], &errors_length);
1343 [ - + ]: 210940 : if (errors == NULL) {
1344 : 0 : goto exit;
1345 : : }
1346 [ - + ]: 210940 : if (strlen(errors) != (size_t)errors_length) {
1347 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1348 : 0 : goto exit;
1349 : : }
1350 : 210940 : skip_optional_pos:
1351 : 1199234 : return_value = unicode_new_impl(type, x, encoding, errors);
1352 : :
1353 : 1199241 : exit:
1354 : 1199241 : return return_value;
1355 : : }
1356 : : /*[clinic end generated code: output=b5dd7cefead9a8e7 input=a9049054013a1b77]*/
|
