Nuitka
The Python compiler
Loading...
Searching...
No Matches
HelpersBuiltinTypeMethods.c
1// Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
2
3/* WARNING, this code is GENERATED. Modify the template HelperBuiltinMethodOperation.c.j2 instead! */
4
5/* This file is included from another C file, help IDEs to still parse it on its own. */
6#ifdef __IDE_ONLY__
7#include "nuitka/prelude.h"
8#endif
9
10#if PYTHON_VERSION < 0x300
11static PyObject *str_builtin_capitalize = NULL;
12#endif
13#if PYTHON_VERSION < 0x300
14static PyObject *str_builtin_center = NULL;
15#endif
16#if PYTHON_VERSION < 0x300
17static PyObject *str_builtin_count = NULL;
18#endif
19#if PYTHON_VERSION < 0x300
20static PyObject *str_builtin_decode = NULL;
21#endif
22#if PYTHON_VERSION < 0x300
23static PyObject *str_builtin_encode = NULL;
24#endif
25#if PYTHON_VERSION < 0x300
26static PyObject *str_builtin_endswith = NULL;
27#endif
28#if PYTHON_VERSION < 0x300
29static PyObject *str_builtin_expandtabs = NULL;
30#endif
31#if PYTHON_VERSION < 0x300
32static PyObject *str_builtin_find = NULL;
33#endif
34#if PYTHON_VERSION < 0x300
35PyObject *str_builtin_format = NULL;
36#endif
37#if PYTHON_VERSION < 0x300
38static PyObject *str_builtin_index = NULL;
39#endif
40#if PYTHON_VERSION < 0x300
41static PyObject *str_builtin_isalnum = NULL;
42#endif
43#if PYTHON_VERSION < 0x300
44static PyObject *str_builtin_isalpha = NULL;
45#endif
46#if PYTHON_VERSION < 0x300
47static PyObject *str_builtin_isdigit = NULL;
48#endif
49#if PYTHON_VERSION < 0x300
50static PyObject *str_builtin_islower = NULL;
51#endif
52#if PYTHON_VERSION < 0x300
53static PyObject *str_builtin_isspace = NULL;
54#endif
55#if PYTHON_VERSION < 0x300
56static PyObject *str_builtin_istitle = NULL;
57#endif
58#if PYTHON_VERSION < 0x300
59static PyObject *str_builtin_isupper = NULL;
60#endif
61#if PYTHON_VERSION < 0x300
62static PyObject *str_builtin_join = NULL;
63#endif
64#if PYTHON_VERSION < 0x300
65static PyObject *str_builtin_ljust = NULL;
66#endif
67#if PYTHON_VERSION < 0x300
68static PyObject *str_builtin_lower = NULL;
69#endif
70#if PYTHON_VERSION < 0x300
71static PyObject *str_builtin_lstrip = NULL;
72#endif
73#if PYTHON_VERSION < 0x300
74static PyObject *str_builtin_partition = NULL;
75#endif
76#if PYTHON_VERSION < 0x300
77static PyObject *str_builtin_replace = NULL;
78#endif
79#if PYTHON_VERSION < 0x300
80static PyObject *str_builtin_rfind = NULL;
81#endif
82#if PYTHON_VERSION < 0x300
83static PyObject *str_builtin_rindex = NULL;
84#endif
85#if PYTHON_VERSION < 0x300
86static PyObject *str_builtin_rjust = NULL;
87#endif
88#if PYTHON_VERSION < 0x300
89static PyObject *str_builtin_rpartition = NULL;
90#endif
91#if PYTHON_VERSION < 0x300
92static PyObject *str_builtin_rsplit = NULL;
93#endif
94#if PYTHON_VERSION < 0x300
95static PyObject *str_builtin_rstrip = NULL;
96#endif
97#if PYTHON_VERSION < 0x300
98static PyObject *str_builtin_split = NULL;
99#endif
100#if PYTHON_VERSION < 0x300
101static PyObject *str_builtin_splitlines = NULL;
102#endif
103#if PYTHON_VERSION < 0x300
104static PyObject *str_builtin_startswith = NULL;
105#endif
106#if PYTHON_VERSION < 0x300
107static PyObject *str_builtin_strip = NULL;
108#endif
109#if PYTHON_VERSION < 0x300
110static PyObject *str_builtin_swapcase = NULL;
111#endif
112#if PYTHON_VERSION < 0x300
113static PyObject *str_builtin_title = NULL;
114#endif
115#if PYTHON_VERSION < 0x300
116static PyObject *str_builtin_translate = NULL;
117#endif
118#if PYTHON_VERSION < 0x300
119static PyObject *str_builtin_upper = NULL;
120#endif
121#if PYTHON_VERSION < 0x300
122static PyObject *str_builtin_zfill = NULL;
123#endif
124#if PYTHON_VERSION < 0x300
125static void _initStrBuiltinMethods(void) {
126 str_builtin_capitalize = PyObject_GetAttrString((PyObject *)&PyString_Type, "capitalize");
127 str_builtin_center = PyObject_GetAttrString((PyObject *)&PyString_Type, "center");
128 str_builtin_count = PyObject_GetAttrString((PyObject *)&PyString_Type, "count");
129 str_builtin_decode = PyObject_GetAttrString((PyObject *)&PyString_Type, "decode");
130 str_builtin_encode = PyObject_GetAttrString((PyObject *)&PyString_Type, "encode");
131 str_builtin_endswith = PyObject_GetAttrString((PyObject *)&PyString_Type, "endswith");
132 str_builtin_expandtabs = PyObject_GetAttrString((PyObject *)&PyString_Type, "expandtabs");
133 str_builtin_find = PyObject_GetAttrString((PyObject *)&PyString_Type, "find");
134 str_builtin_format = PyObject_GetAttrString((PyObject *)&PyString_Type, "format");
135 str_builtin_index = PyObject_GetAttrString((PyObject *)&PyString_Type, "index");
136 str_builtin_isalnum = PyObject_GetAttrString((PyObject *)&PyString_Type, "isalnum");
137 str_builtin_isalpha = PyObject_GetAttrString((PyObject *)&PyString_Type, "isalpha");
138 str_builtin_isdigit = PyObject_GetAttrString((PyObject *)&PyString_Type, "isdigit");
139 str_builtin_islower = PyObject_GetAttrString((PyObject *)&PyString_Type, "islower");
140 str_builtin_isspace = PyObject_GetAttrString((PyObject *)&PyString_Type, "isspace");
141 str_builtin_istitle = PyObject_GetAttrString((PyObject *)&PyString_Type, "istitle");
142 str_builtin_isupper = PyObject_GetAttrString((PyObject *)&PyString_Type, "isupper");
143 str_builtin_join = PyObject_GetAttrString((PyObject *)&PyString_Type, "join");
144 str_builtin_ljust = PyObject_GetAttrString((PyObject *)&PyString_Type, "ljust");
145 str_builtin_lower = PyObject_GetAttrString((PyObject *)&PyString_Type, "lower");
146 str_builtin_lstrip = PyObject_GetAttrString((PyObject *)&PyString_Type, "lstrip");
147 str_builtin_partition = PyObject_GetAttrString((PyObject *)&PyString_Type, "partition");
148 str_builtin_replace = PyObject_GetAttrString((PyObject *)&PyString_Type, "replace");
149 str_builtin_rfind = PyObject_GetAttrString((PyObject *)&PyString_Type, "rfind");
150 str_builtin_rindex = PyObject_GetAttrString((PyObject *)&PyString_Type, "rindex");
151 str_builtin_rjust = PyObject_GetAttrString((PyObject *)&PyString_Type, "rjust");
152 str_builtin_rpartition = PyObject_GetAttrString((PyObject *)&PyString_Type, "rpartition");
153 str_builtin_rsplit = PyObject_GetAttrString((PyObject *)&PyString_Type, "rsplit");
154 str_builtin_rstrip = PyObject_GetAttrString((PyObject *)&PyString_Type, "rstrip");
155 str_builtin_split = PyObject_GetAttrString((PyObject *)&PyString_Type, "split");
156 str_builtin_splitlines = PyObject_GetAttrString((PyObject *)&PyString_Type, "splitlines");
157 str_builtin_startswith = PyObject_GetAttrString((PyObject *)&PyString_Type, "startswith");
158 str_builtin_strip = PyObject_GetAttrString((PyObject *)&PyString_Type, "strip");
159 str_builtin_swapcase = PyObject_GetAttrString((PyObject *)&PyString_Type, "swapcase");
160 str_builtin_title = PyObject_GetAttrString((PyObject *)&PyString_Type, "title");
161 str_builtin_translate = PyObject_GetAttrString((PyObject *)&PyString_Type, "translate");
162 str_builtin_upper = PyObject_GetAttrString((PyObject *)&PyString_Type, "upper");
163 str_builtin_zfill = PyObject_GetAttrString((PyObject *)&PyString_Type, "zfill");
164}
165#endif
166#if PYTHON_VERSION >= 0x300
167static PyObject *bytes_builtin_capitalize = NULL;
168#endif
169#if PYTHON_VERSION >= 0x300
170static PyObject *bytes_builtin_center = NULL;
171#endif
172#if PYTHON_VERSION >= 0x300
173static PyObject *bytes_builtin_count = NULL;
174#endif
175#if PYTHON_VERSION >= 0x300
176static PyObject *bytes_builtin_decode = NULL;
177#endif
178#if PYTHON_VERSION >= 0x300
179static PyObject *bytes_builtin_endswith = NULL;
180#endif
181#if PYTHON_VERSION >= 0x300
182static PyObject *bytes_builtin_expandtabs = NULL;
183#endif
184#if PYTHON_VERSION >= 0x300
185static PyObject *bytes_builtin_find = NULL;
186#endif
187#if PYTHON_VERSION >= 0x300
188static PyObject *bytes_builtin_index = NULL;
189#endif
190#if PYTHON_VERSION >= 0x300
191static PyObject *bytes_builtin_isalnum = NULL;
192#endif
193#if PYTHON_VERSION >= 0x300
194static PyObject *bytes_builtin_isalpha = NULL;
195#endif
196#if PYTHON_VERSION >= 0x300
197static PyObject *bytes_builtin_isdigit = NULL;
198#endif
199#if PYTHON_VERSION >= 0x300
200static PyObject *bytes_builtin_islower = NULL;
201#endif
202#if PYTHON_VERSION >= 0x300
203static PyObject *bytes_builtin_isspace = NULL;
204#endif
205#if PYTHON_VERSION >= 0x300
206static PyObject *bytes_builtin_istitle = NULL;
207#endif
208#if PYTHON_VERSION >= 0x300
209static PyObject *bytes_builtin_isupper = NULL;
210#endif
211#if PYTHON_VERSION >= 0x300
212static PyObject *bytes_builtin_join = NULL;
213#endif
214#if PYTHON_VERSION >= 0x300
215static PyObject *bytes_builtin_ljust = NULL;
216#endif
217#if PYTHON_VERSION >= 0x300
218static PyObject *bytes_builtin_lower = NULL;
219#endif
220#if PYTHON_VERSION >= 0x300
221static PyObject *bytes_builtin_lstrip = NULL;
222#endif
223#if PYTHON_VERSION >= 0x300
224static PyObject *bytes_builtin_partition = NULL;
225#endif
226#if PYTHON_VERSION >= 0x300
227static PyObject *bytes_builtin_replace = NULL;
228#endif
229#if PYTHON_VERSION >= 0x300
230static PyObject *bytes_builtin_rfind = NULL;
231#endif
232#if PYTHON_VERSION >= 0x300
233static PyObject *bytes_builtin_rindex = NULL;
234#endif
235#if PYTHON_VERSION >= 0x300
236static PyObject *bytes_builtin_rjust = NULL;
237#endif
238#if PYTHON_VERSION >= 0x300
239static PyObject *bytes_builtin_rpartition = NULL;
240#endif
241#if PYTHON_VERSION >= 0x300
242static PyObject *bytes_builtin_rsplit = NULL;
243#endif
244#if PYTHON_VERSION >= 0x300
245static PyObject *bytes_builtin_rstrip = NULL;
246#endif
247#if PYTHON_VERSION >= 0x300
248static PyObject *bytes_builtin_split = NULL;
249#endif
250#if PYTHON_VERSION >= 0x300
251static PyObject *bytes_builtin_splitlines = NULL;
252#endif
253#if PYTHON_VERSION >= 0x300
254static PyObject *bytes_builtin_startswith = NULL;
255#endif
256#if PYTHON_VERSION >= 0x300
257static PyObject *bytes_builtin_strip = NULL;
258#endif
259#if PYTHON_VERSION >= 0x300
260static PyObject *bytes_builtin_swapcase = NULL;
261#endif
262#if PYTHON_VERSION >= 0x300
263static PyObject *bytes_builtin_title = NULL;
264#endif
265#if PYTHON_VERSION >= 0x300
266static PyObject *bytes_builtin_translate = NULL;
267#endif
268#if PYTHON_VERSION >= 0x300
269static PyObject *bytes_builtin_upper = NULL;
270#endif
271#if PYTHON_VERSION >= 0x300
272static PyObject *bytes_builtin_zfill = NULL;
273#endif
274#if PYTHON_VERSION >= 0x300
275static void _initBytesBuiltinMethods(void) {
276 bytes_builtin_capitalize = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "capitalize");
277 bytes_builtin_center = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "center");
278 bytes_builtin_count = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "count");
279 bytes_builtin_decode = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "decode");
280 bytes_builtin_endswith = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "endswith");
281 bytes_builtin_expandtabs = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "expandtabs");
282 bytes_builtin_find = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "find");
283 bytes_builtin_index = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "index");
284 bytes_builtin_isalnum = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "isalnum");
285 bytes_builtin_isalpha = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "isalpha");
286 bytes_builtin_isdigit = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "isdigit");
287 bytes_builtin_islower = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "islower");
288 bytes_builtin_isspace = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "isspace");
289 bytes_builtin_istitle = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "istitle");
290 bytes_builtin_isupper = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "isupper");
291 bytes_builtin_join = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "join");
292 bytes_builtin_ljust = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "ljust");
293 bytes_builtin_lower = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "lower");
294 bytes_builtin_lstrip = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "lstrip");
295 bytes_builtin_partition = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "partition");
296 bytes_builtin_replace = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "replace");
297 bytes_builtin_rfind = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "rfind");
298 bytes_builtin_rindex = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "rindex");
299 bytes_builtin_rjust = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "rjust");
300 bytes_builtin_rpartition = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "rpartition");
301 bytes_builtin_rsplit = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "rsplit");
302 bytes_builtin_rstrip = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "rstrip");
303 bytes_builtin_split = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "split");
304 bytes_builtin_splitlines = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "splitlines");
305 bytes_builtin_startswith = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "startswith");
306 bytes_builtin_strip = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "strip");
307 bytes_builtin_swapcase = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "swapcase");
308 bytes_builtin_title = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "title");
309 bytes_builtin_translate = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "translate");
310 bytes_builtin_upper = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "upper");
311 bytes_builtin_zfill = PyObject_GetAttrString((PyObject *)&PyBytes_Type, "zfill");
312}
313#endif
314static PyObject *unicode_builtin_capitalize = NULL;
315#if PYTHON_VERSION >= 0x300
316static PyObject *unicode_builtin_casefold = NULL;
317#endif
318static PyObject *unicode_builtin_center = NULL;
319static PyObject *unicode_builtin_count = NULL;
320#if PYTHON_VERSION < 0x300
321static PyObject *unicode_builtin_decode = NULL;
322#endif
323static PyObject *unicode_builtin_encode = NULL;
324static PyObject *unicode_builtin_endswith = NULL;
325static PyObject *unicode_builtin_expandtabs = NULL;
326static PyObject *unicode_builtin_find = NULL;
327PyObject *unicode_builtin_format = NULL;
328#if PYTHON_VERSION >= 0x300
329static PyObject *unicode_builtin_format_map = NULL;
330#endif
331static PyObject *unicode_builtin_index = NULL;
332static PyObject *unicode_builtin_isalnum = NULL;
333static PyObject *unicode_builtin_isalpha = NULL;
334#if PYTHON_VERSION >= 0x300
335static PyObject *unicode_builtin_isascii = NULL;
336#endif
337static PyObject *unicode_builtin_isdecimal = NULL;
338static PyObject *unicode_builtin_isdigit = NULL;
339#if PYTHON_VERSION >= 0x300
340static PyObject *unicode_builtin_isidentifier = NULL;
341#endif
342static PyObject *unicode_builtin_islower = NULL;
343static PyObject *unicode_builtin_isnumeric = NULL;
344#if PYTHON_VERSION >= 0x300
345static PyObject *unicode_builtin_isprintable = NULL;
346#endif
347static PyObject *unicode_builtin_isspace = NULL;
348static PyObject *unicode_builtin_istitle = NULL;
349static PyObject *unicode_builtin_isupper = NULL;
350static PyObject *unicode_builtin_join = NULL;
351static PyObject *unicode_builtin_ljust = NULL;
352static PyObject *unicode_builtin_lower = NULL;
353static PyObject *unicode_builtin_lstrip = NULL;
354#if PYTHON_VERSION >= 0x300
355static PyObject *unicode_builtin_maketrans = NULL;
356#endif
357static PyObject *unicode_builtin_partition = NULL;
358static PyObject *unicode_builtin_replace = NULL;
359static PyObject *unicode_builtin_rfind = NULL;
360static PyObject *unicode_builtin_rindex = NULL;
361static PyObject *unicode_builtin_rjust = NULL;
362static PyObject *unicode_builtin_rpartition = NULL;
363static PyObject *unicode_builtin_rsplit = NULL;
364static PyObject *unicode_builtin_rstrip = NULL;
365static PyObject *unicode_builtin_split = NULL;
366static PyObject *unicode_builtin_splitlines = NULL;
367static PyObject *unicode_builtin_startswith = NULL;
368static PyObject *unicode_builtin_strip = NULL;
369static PyObject *unicode_builtin_swapcase = NULL;
370static PyObject *unicode_builtin_title = NULL;
371static PyObject *unicode_builtin_translate = NULL;
372static PyObject *unicode_builtin_upper = NULL;
373static PyObject *unicode_builtin_zfill = NULL;
374static void _initUnicodeBuiltinMethods(void) {
375 unicode_builtin_capitalize = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "capitalize");
376#if PYTHON_VERSION >= 0x300
377 unicode_builtin_casefold = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "casefold");
378#endif
379 unicode_builtin_center = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "center");
380 unicode_builtin_count = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "count");
381#if PYTHON_VERSION < 0x300
382 unicode_builtin_decode = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "decode");
383#endif
384 unicode_builtin_encode = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "encode");
385 unicode_builtin_endswith = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "endswith");
386 unicode_builtin_expandtabs = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "expandtabs");
387 unicode_builtin_find = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "find");
388 unicode_builtin_format = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "format");
389#if PYTHON_VERSION >= 0x300
390 unicode_builtin_format_map = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "format_map");
391#endif
392 unicode_builtin_index = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "index");
393 unicode_builtin_isalnum = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "isalnum");
394 unicode_builtin_isalpha = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "isalpha");
395#if PYTHON_VERSION >= 0x300
396 unicode_builtin_isascii = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "isascii");
397#endif
398 unicode_builtin_isdecimal = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "isdecimal");
399 unicode_builtin_isdigit = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "isdigit");
400#if PYTHON_VERSION >= 0x300
401 unicode_builtin_isidentifier = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "isidentifier");
402#endif
403 unicode_builtin_islower = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "islower");
404 unicode_builtin_isnumeric = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "isnumeric");
405#if PYTHON_VERSION >= 0x300
406 unicode_builtin_isprintable = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "isprintable");
407#endif
408 unicode_builtin_isspace = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "isspace");
409 unicode_builtin_istitle = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "istitle");
410 unicode_builtin_isupper = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "isupper");
411 unicode_builtin_join = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "join");
412 unicode_builtin_ljust = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "ljust");
413 unicode_builtin_lower = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "lower");
414 unicode_builtin_lstrip = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "lstrip");
415#if PYTHON_VERSION >= 0x300
416 unicode_builtin_maketrans = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "maketrans");
417#endif
418 unicode_builtin_partition = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "partition");
419 unicode_builtin_replace = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "replace");
420 unicode_builtin_rfind = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "rfind");
421 unicode_builtin_rindex = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "rindex");
422 unicode_builtin_rjust = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "rjust");
423 unicode_builtin_rpartition = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "rpartition");
424 unicode_builtin_rsplit = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "rsplit");
425 unicode_builtin_rstrip = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "rstrip");
426 unicode_builtin_split = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "split");
427 unicode_builtin_splitlines = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "splitlines");
428 unicode_builtin_startswith = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "startswith");
429 unicode_builtin_strip = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "strip");
430 unicode_builtin_swapcase = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "swapcase");
431 unicode_builtin_title = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "title");
432 unicode_builtin_translate = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "translate");
433 unicode_builtin_upper = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "upper");
434 unicode_builtin_zfill = PyObject_GetAttrString((PyObject *)&PyUnicode_Type, "zfill");
435}
436static PyObject *dict_builtin_clear = NULL;
437static PyObject *dict_builtin_copy = NULL;
438PyObject *dict_builtin_fromkeys = NULL;
439static PyObject *dict_builtin_get = NULL;
440#if PYTHON_VERSION < 0x300
441static PyObject *dict_builtin_has_key = NULL;
442#endif
443static PyObject *dict_builtin_items = NULL;
444#if PYTHON_VERSION < 0x300
445static PyObject *dict_builtin_iteritems = NULL;
446#endif
447#if PYTHON_VERSION < 0x300
448static PyObject *dict_builtin_iterkeys = NULL;
449#endif
450#if PYTHON_VERSION < 0x300
451static PyObject *dict_builtin_itervalues = NULL;
452#endif
453static PyObject *dict_builtin_keys = NULL;
454static PyObject *dict_builtin_pop = NULL;
455static PyObject *dict_builtin_popitem = NULL;
456static PyObject *dict_builtin_setdefault = NULL;
457static PyObject *dict_builtin_update = NULL;
458static PyObject *dict_builtin_values = NULL;
459#if PYTHON_VERSION < 0x300
460static PyObject *dict_builtin_viewitems = NULL;
461#endif
462#if PYTHON_VERSION < 0x300
463static PyObject *dict_builtin_viewkeys = NULL;
464#endif
465#if PYTHON_VERSION < 0x300
466static PyObject *dict_builtin_viewvalues = NULL;
467#endif
468static void _initDictBuiltinMethods(void) {
469 dict_builtin_clear = PyObject_GetAttrString((PyObject *)&PyDict_Type, "clear");
470 dict_builtin_copy = PyObject_GetAttrString((PyObject *)&PyDict_Type, "copy");
471 dict_builtin_fromkeys = PyObject_GetAttrString((PyObject *)&PyDict_Type, "fromkeys");
472 dict_builtin_get = PyObject_GetAttrString((PyObject *)&PyDict_Type, "get");
473#if PYTHON_VERSION < 0x300
474 dict_builtin_has_key = PyObject_GetAttrString((PyObject *)&PyDict_Type, "has_key");
475#endif
476 dict_builtin_items = PyObject_GetAttrString((PyObject *)&PyDict_Type, "items");
477#if PYTHON_VERSION < 0x300
478 dict_builtin_iteritems = PyObject_GetAttrString((PyObject *)&PyDict_Type, "iteritems");
479#endif
480#if PYTHON_VERSION < 0x300
481 dict_builtin_iterkeys = PyObject_GetAttrString((PyObject *)&PyDict_Type, "iterkeys");
482#endif
483#if PYTHON_VERSION < 0x300
484 dict_builtin_itervalues = PyObject_GetAttrString((PyObject *)&PyDict_Type, "itervalues");
485#endif
486 dict_builtin_keys = PyObject_GetAttrString((PyObject *)&PyDict_Type, "keys");
487 dict_builtin_pop = PyObject_GetAttrString((PyObject *)&PyDict_Type, "pop");
488 dict_builtin_popitem = PyObject_GetAttrString((PyObject *)&PyDict_Type, "popitem");
489 dict_builtin_setdefault = PyObject_GetAttrString((PyObject *)&PyDict_Type, "setdefault");
490 dict_builtin_update = PyObject_GetAttrString((PyObject *)&PyDict_Type, "update");
491 dict_builtin_values = PyObject_GetAttrString((PyObject *)&PyDict_Type, "values");
492#if PYTHON_VERSION < 0x300
493 dict_builtin_viewitems = PyObject_GetAttrString((PyObject *)&PyDict_Type, "viewitems");
494#endif
495#if PYTHON_VERSION < 0x300
496 dict_builtin_viewkeys = PyObject_GetAttrString((PyObject *)&PyDict_Type, "viewkeys");
497#endif
498#if PYTHON_VERSION < 0x300
499 dict_builtin_viewvalues = PyObject_GetAttrString((PyObject *)&PyDict_Type, "viewvalues");
500#endif
501}
502static PyObject *list_builtin_append = NULL;
503#if PYTHON_VERSION >= 0x300
504static PyObject *list_builtin_clear = NULL;
505#endif
506#if PYTHON_VERSION >= 0x300
507static PyObject *list_builtin_copy = NULL;
508#endif
509static PyObject *list_builtin_count = NULL;
510static PyObject *list_builtin_extend = NULL;
511static PyObject *list_builtin_index = NULL;
512static PyObject *list_builtin_insert = NULL;
513static PyObject *list_builtin_pop = NULL;
514static PyObject *list_builtin_remove = NULL;
515static PyObject *list_builtin_reverse = NULL;
516static PyObject *list_builtin_sort = NULL;
517static void _initListBuiltinMethods(void) {
518 list_builtin_append = PyObject_GetAttrString((PyObject *)&PyList_Type, "append");
519#if PYTHON_VERSION >= 0x300
520 list_builtin_clear = PyObject_GetAttrString((PyObject *)&PyList_Type, "clear");
521#endif
522#if PYTHON_VERSION >= 0x300
523 list_builtin_copy = PyObject_GetAttrString((PyObject *)&PyList_Type, "copy");
524#endif
525 list_builtin_count = PyObject_GetAttrString((PyObject *)&PyList_Type, "count");
526 list_builtin_extend = PyObject_GetAttrString((PyObject *)&PyList_Type, "extend");
527 list_builtin_index = PyObject_GetAttrString((PyObject *)&PyList_Type, "index");
528 list_builtin_insert = PyObject_GetAttrString((PyObject *)&PyList_Type, "insert");
529 list_builtin_pop = PyObject_GetAttrString((PyObject *)&PyList_Type, "pop");
530 list_builtin_remove = PyObject_GetAttrString((PyObject *)&PyList_Type, "remove");
531 list_builtin_reverse = PyObject_GetAttrString((PyObject *)&PyList_Type, "reverse");
532 list_builtin_sort = PyObject_GetAttrString((PyObject *)&PyList_Type, "sort");
533}
534PyObject *DICT_POP2(PyThreadState *tstate, PyObject *dict, PyObject *key) {
535 CHECK_OBJECT(dict);
536 assert(PyDict_CheckExact(dict));
537
538 CHECK_OBJECT(key);
539
540 PyObject *called = dict_builtin_pop;
541 CHECK_OBJECT(called);
542
543 PyObject *args[2] = {dict, key};
544 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
545
546 CHECK_OBJECT_X(result);
547 return result;
548}
549PyObject *DICT_POP3(PyThreadState *tstate, PyObject *dict, PyObject *key, PyObject *default_value) {
550 CHECK_OBJECT(dict);
551 assert(PyDict_CheckExact(dict));
552
553 CHECK_OBJECT(key);
554 CHECK_OBJECT(default_value);
555
556 PyObject *called = dict_builtin_pop;
557 CHECK_OBJECT(called);
558
559 PyObject *args[3] = {dict, key, default_value};
560 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
561
562 CHECK_OBJECT_X(result);
563 return result;
564}
565PyObject *DICT_POPITEM(PyThreadState *tstate, PyObject *dict) {
566 CHECK_OBJECT(dict);
567 assert(PyDict_CheckExact(dict));
568
569 PyObject *called = dict_builtin_popitem;
570 CHECK_OBJECT(called);
571
572 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, dict);
573
574 CHECK_OBJECT_X(result);
575 assert(result == NULL || PyTuple_CheckExact(result));
576 return result;
577}
578PyObject *DICT_SETDEFAULT2(PyThreadState *tstate, PyObject *dict, PyObject *key) {
579 CHECK_OBJECT(dict);
580 assert(PyDict_CheckExact(dict));
581
582 CHECK_OBJECT(key);
583
584 PyObject *called = dict_builtin_setdefault;
585 CHECK_OBJECT(called);
586
587 PyObject *args[2] = {dict, key};
588 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
589
590 CHECK_OBJECT_X(result);
591 return result;
592}
593PyObject *DICT_SETDEFAULT3(PyThreadState *tstate, PyObject *dict, PyObject *key, PyObject *default_value) {
594 CHECK_OBJECT(dict);
595 assert(PyDict_CheckExact(dict));
596
597 CHECK_OBJECT(key);
598 CHECK_OBJECT(default_value);
599
600 PyObject *called = dict_builtin_setdefault;
601 CHECK_OBJECT(called);
602
603 PyObject *args[3] = {dict, key, default_value};
604 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
605
606 CHECK_OBJECT_X(result);
607 return result;
608}
609PyObject *LIST_POP1(PyThreadState *tstate, PyObject *list) {
610 CHECK_OBJECT(list);
611 assert(PyList_CheckExact(list));
612
613 PyObject *called = list_builtin_pop;
614 CHECK_OBJECT(called);
615
616 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, list);
617
618 CHECK_OBJECT_X(result);
619 return result;
620}
621PyObject *LIST_POP2(PyThreadState *tstate, PyObject *list, PyObject *index) {
622 CHECK_OBJECT(list);
623 assert(PyList_CheckExact(list));
624
625 CHECK_OBJECT(index);
626
627 PyObject *called = list_builtin_pop;
628 CHECK_OBJECT(called);
629
630 PyObject *args[2] = {list, index};
631 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
632
633 CHECK_OBJECT_X(result);
634 return result;
635}
636#if PYTHON_VERSION < 0x300
637PyObject *STR_CAPITALIZE(PyThreadState *tstate, PyObject *str) {
638 CHECK_OBJECT(str);
639 assert(PyString_CheckExact(str));
640
641 PyObject *called = str_builtin_capitalize;
642 CHECK_OBJECT(called);
643
644 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
645
646 CHECK_OBJECT_X(result);
647 assert(result == NULL || Nuitka_String_CheckExact(result));
648 return result;
649}
650PyObject *STR_CENTER2(PyThreadState *tstate, PyObject *str, PyObject *width) {
651 CHECK_OBJECT(str);
652 assert(PyString_CheckExact(str));
653
654 CHECK_OBJECT(width);
655
656 PyObject *called = str_builtin_center;
657 CHECK_OBJECT(called);
658
659 PyObject *args[2] = {str, width};
660 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
661
662 CHECK_OBJECT_X(result);
663 assert(result == NULL || Nuitka_String_CheckExact(result));
664 return result;
665}
666PyObject *STR_CENTER3(PyThreadState *tstate, PyObject *str, PyObject *width, PyObject *fillchar) {
667 CHECK_OBJECT(str);
668 assert(PyString_CheckExact(str));
669
670 CHECK_OBJECT(width);
671 CHECK_OBJECT(fillchar);
672
673 PyObject *called = str_builtin_center;
674 CHECK_OBJECT(called);
675
676 PyObject *args[3] = {str, width, fillchar};
677 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
678
679 CHECK_OBJECT_X(result);
680 assert(result == NULL || Nuitka_String_CheckExact(result));
681 return result;
682}
683PyObject *STR_COUNT2(PyThreadState *tstate, PyObject *str, PyObject *sub) {
684 CHECK_OBJECT(str);
685 assert(PyString_CheckExact(str));
686
687 CHECK_OBJECT(sub);
688
689 PyObject *called = str_builtin_count;
690 CHECK_OBJECT(called);
691
692 PyObject *args[2] = {str, sub};
693 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
694
695 CHECK_OBJECT_X(result);
696 return result;
697}
698PyObject *STR_COUNT3(PyThreadState *tstate, PyObject *str, PyObject *sub, PyObject *start) {
699 CHECK_OBJECT(str);
700 assert(PyString_CheckExact(str));
701
702 CHECK_OBJECT(sub);
703 CHECK_OBJECT(start);
704
705 PyObject *called = str_builtin_count;
706 CHECK_OBJECT(called);
707
708 PyObject *args[3] = {str, sub, start};
709 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
710
711 CHECK_OBJECT_X(result);
712 return result;
713}
714PyObject *STR_COUNT4(PyThreadState *tstate, PyObject *str, PyObject *sub, PyObject *start, PyObject *end) {
715 CHECK_OBJECT(str);
716 assert(PyString_CheckExact(str));
717
718 CHECK_OBJECT(sub);
719 CHECK_OBJECT(start);
720 CHECK_OBJECT(end);
721
722 PyObject *called = str_builtin_count;
723 CHECK_OBJECT(called);
724
725 PyObject *args[4] = {str, sub, start, end};
726 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
727
728 CHECK_OBJECT_X(result);
729 return result;
730}
731PyObject *STR_DECODE1(PyThreadState *tstate, PyObject *str) {
732 CHECK_OBJECT(str);
733 assert(PyString_CheckExact(str));
734
735 PyObject *called = str_builtin_decode;
736 CHECK_OBJECT(called);
737
738 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
739
740 CHECK_OBJECT_X(result);
741 return result;
742}
743PyObject *STR_DECODE2(PyThreadState *tstate, PyObject *str, PyObject *encoding) {
744 CHECK_OBJECT(str);
745 assert(PyString_CheckExact(str));
746
747 CHECK_OBJECT(encoding);
748
749 PyObject *called = str_builtin_decode;
750 CHECK_OBJECT(called);
751
752 PyObject *args[2] = {str, encoding};
753 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
754
755 CHECK_OBJECT_X(result);
756 return result;
757}
758PyObject *STR_DECODE3(PyThreadState *tstate, PyObject *str, PyObject *encoding, PyObject *errors) {
759 CHECK_OBJECT(str);
760 assert(PyString_CheckExact(str));
761
762 if (encoding == NULL) {
763 encoding = PyString_FromString(PyUnicode_GetDefaultEncoding());
764 } else {
765 Py_INCREF(encoding);
766 }
767 CHECK_OBJECT(errors);
768
769 PyObject *called = str_builtin_decode;
770 CHECK_OBJECT(called);
771
772 PyObject *args[3] = {str, encoding, errors};
773 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
774
775 Py_DECREF(encoding);
776
777 CHECK_OBJECT_X(result);
778 return result;
779}
780PyObject *STR_ENCODE1(PyThreadState *tstate, PyObject *str) {
781 CHECK_OBJECT(str);
782 assert(PyString_CheckExact(str));
783
784 PyObject *called = str_builtin_encode;
785 CHECK_OBJECT(called);
786
787 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
788
789 CHECK_OBJECT_X(result);
790 return result;
791}
792PyObject *STR_ENCODE2(PyThreadState *tstate, PyObject *str, PyObject *encoding) {
793 CHECK_OBJECT(str);
794 assert(PyString_CheckExact(str));
795
796 CHECK_OBJECT(encoding);
797
798 PyObject *called = str_builtin_encode;
799 CHECK_OBJECT(called);
800
801 PyObject *args[2] = {str, encoding};
802 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
803
804 CHECK_OBJECT_X(result);
805 return result;
806}
807PyObject *STR_ENCODE3(PyThreadState *tstate, PyObject *str, PyObject *encoding, PyObject *errors) {
808 CHECK_OBJECT(str);
809 assert(PyString_CheckExact(str));
810
811 CHECK_OBJECT(encoding);
812 CHECK_OBJECT(errors);
813
814 PyObject *called = str_builtin_encode;
815 CHECK_OBJECT(called);
816
817 PyObject *args[3] = {str, encoding, errors};
818 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
819
820 CHECK_OBJECT_X(result);
821 return result;
822}
823PyObject *STR_ENDSWITH2(PyThreadState *tstate, PyObject *str, PyObject *suffix) {
824 CHECK_OBJECT(str);
825 assert(PyString_CheckExact(str));
826
827 CHECK_OBJECT(suffix);
828
829 PyObject *called = str_builtin_endswith;
830 CHECK_OBJECT(called);
831
832 PyObject *args[2] = {str, suffix};
833 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
834
835 CHECK_OBJECT_X(result);
836 assert(result == NULL || PyBool_Check(result));
837 return result;
838}
839PyObject *STR_ENDSWITH3(PyThreadState *tstate, PyObject *str, PyObject *suffix, PyObject *start) {
840 CHECK_OBJECT(str);
841 assert(PyString_CheckExact(str));
842
843 CHECK_OBJECT(suffix);
844 CHECK_OBJECT(start);
845
846 PyObject *called = str_builtin_endswith;
847 CHECK_OBJECT(called);
848
849 PyObject *args[3] = {str, suffix, start};
850 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
851
852 CHECK_OBJECT_X(result);
853 assert(result == NULL || PyBool_Check(result));
854 return result;
855}
856PyObject *STR_ENDSWITH4(PyThreadState *tstate, PyObject *str, PyObject *suffix, PyObject *start, PyObject *end) {
857 CHECK_OBJECT(str);
858 assert(PyString_CheckExact(str));
859
860 CHECK_OBJECT(suffix);
861 CHECK_OBJECT(start);
862 CHECK_OBJECT(end);
863
864 PyObject *called = str_builtin_endswith;
865 CHECK_OBJECT(called);
866
867 PyObject *args[4] = {str, suffix, start, end};
868 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
869
870 CHECK_OBJECT_X(result);
871 assert(result == NULL || PyBool_Check(result));
872 return result;
873}
874PyObject *STR_EXPANDTABS1(PyThreadState *tstate, PyObject *str) {
875 CHECK_OBJECT(str);
876 assert(PyString_CheckExact(str));
877
878 PyObject *called = str_builtin_expandtabs;
879 CHECK_OBJECT(called);
880
881 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
882
883 CHECK_OBJECT_X(result);
884 assert(result == NULL || Nuitka_String_CheckExact(result));
885 return result;
886}
887PyObject *STR_EXPANDTABS2(PyThreadState *tstate, PyObject *str, PyObject *tabsize) {
888 CHECK_OBJECT(str);
889 assert(PyString_CheckExact(str));
890
891 CHECK_OBJECT(tabsize);
892
893 PyObject *called = str_builtin_expandtabs;
894 CHECK_OBJECT(called);
895
896 PyObject *args[2] = {str, tabsize};
897 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
898
899 CHECK_OBJECT_X(result);
900 assert(result == NULL || Nuitka_String_CheckExact(result));
901 return result;
902}
903PyObject *STR_FIND2(PyThreadState *tstate, PyObject *str, PyObject *sub) {
904 CHECK_OBJECT(str);
905 assert(PyString_CheckExact(str));
906
907 CHECK_OBJECT(sub);
908
909 PyObject *called = str_builtin_find;
910 CHECK_OBJECT(called);
911
912 PyObject *args[2] = {str, sub};
913 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
914
915 CHECK_OBJECT_X(result);
916 return result;
917}
918PyObject *STR_FIND3(PyThreadState *tstate, PyObject *str, PyObject *sub, PyObject *start) {
919 CHECK_OBJECT(str);
920 assert(PyString_CheckExact(str));
921
922 CHECK_OBJECT(sub);
923 CHECK_OBJECT(start);
924
925 PyObject *called = str_builtin_find;
926 CHECK_OBJECT(called);
927
928 PyObject *args[3] = {str, sub, start};
929 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
930
931 CHECK_OBJECT_X(result);
932 return result;
933}
934PyObject *STR_FIND4(PyThreadState *tstate, PyObject *str, PyObject *sub, PyObject *start, PyObject *end) {
935 CHECK_OBJECT(str);
936 assert(PyString_CheckExact(str));
937
938 CHECK_OBJECT(sub);
939 CHECK_OBJECT(start);
940 CHECK_OBJECT(end);
941
942 PyObject *called = str_builtin_find;
943 CHECK_OBJECT(called);
944
945 PyObject *args[4] = {str, sub, start, end};
946 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
947
948 CHECK_OBJECT_X(result);
949 return result;
950}
951PyObject *STR_INDEX2(PyThreadState *tstate, PyObject *str, PyObject *sub) {
952 CHECK_OBJECT(str);
953 assert(PyString_CheckExact(str));
954
955 CHECK_OBJECT(sub);
956
957 PyObject *called = str_builtin_index;
958 CHECK_OBJECT(called);
959
960 PyObject *args[2] = {str, sub};
961 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
962
963 CHECK_OBJECT_X(result);
964 return result;
965}
966PyObject *STR_INDEX3(PyThreadState *tstate, PyObject *str, PyObject *sub, PyObject *start) {
967 CHECK_OBJECT(str);
968 assert(PyString_CheckExact(str));
969
970 CHECK_OBJECT(sub);
971 CHECK_OBJECT(start);
972
973 PyObject *called = str_builtin_index;
974 CHECK_OBJECT(called);
975
976 PyObject *args[3] = {str, sub, start};
977 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
978
979 CHECK_OBJECT_X(result);
980 return result;
981}
982PyObject *STR_INDEX4(PyThreadState *tstate, PyObject *str, PyObject *sub, PyObject *start, PyObject *end) {
983 CHECK_OBJECT(str);
984 assert(PyString_CheckExact(str));
985
986 CHECK_OBJECT(sub);
987 CHECK_OBJECT(start);
988 CHECK_OBJECT(end);
989
990 PyObject *called = str_builtin_index;
991 CHECK_OBJECT(called);
992
993 PyObject *args[4] = {str, sub, start, end};
994 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
995
996 CHECK_OBJECT_X(result);
997 return result;
998}
999PyObject *STR_ISALNUM(PyThreadState *tstate, PyObject *str) {
1000 CHECK_OBJECT(str);
1001 assert(PyString_CheckExact(str));
1002
1003 PyObject *called = str_builtin_isalnum;
1004 CHECK_OBJECT(called);
1005
1006 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1007
1008 CHECK_OBJECT_X(result);
1009 assert(result == NULL || PyBool_Check(result));
1010 return result;
1011}
1012PyObject *STR_ISALPHA(PyThreadState *tstate, PyObject *str) {
1013 CHECK_OBJECT(str);
1014 assert(PyString_CheckExact(str));
1015
1016 PyObject *called = str_builtin_isalpha;
1017 CHECK_OBJECT(called);
1018
1019 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1020
1021 CHECK_OBJECT_X(result);
1022 assert(result == NULL || PyBool_Check(result));
1023 return result;
1024}
1025PyObject *STR_ISDIGIT(PyThreadState *tstate, PyObject *str) {
1026 CHECK_OBJECT(str);
1027 assert(PyString_CheckExact(str));
1028
1029 PyObject *called = str_builtin_isdigit;
1030 CHECK_OBJECT(called);
1031
1032 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1033
1034 CHECK_OBJECT_X(result);
1035 assert(result == NULL || PyBool_Check(result));
1036 return result;
1037}
1038PyObject *STR_ISLOWER(PyThreadState *tstate, PyObject *str) {
1039 CHECK_OBJECT(str);
1040 assert(PyString_CheckExact(str));
1041
1042 PyObject *called = str_builtin_islower;
1043 CHECK_OBJECT(called);
1044
1045 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1046
1047 CHECK_OBJECT_X(result);
1048 assert(result == NULL || PyBool_Check(result));
1049 return result;
1050}
1051PyObject *STR_ISSPACE(PyThreadState *tstate, PyObject *str) {
1052 CHECK_OBJECT(str);
1053 assert(PyString_CheckExact(str));
1054
1055 PyObject *called = str_builtin_isspace;
1056 CHECK_OBJECT(called);
1057
1058 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1059
1060 CHECK_OBJECT_X(result);
1061 assert(result == NULL || PyBool_Check(result));
1062 return result;
1063}
1064PyObject *STR_ISTITLE(PyThreadState *tstate, PyObject *str) {
1065 CHECK_OBJECT(str);
1066 assert(PyString_CheckExact(str));
1067
1068 PyObject *called = str_builtin_istitle;
1069 CHECK_OBJECT(called);
1070
1071 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1072
1073 CHECK_OBJECT_X(result);
1074 assert(result == NULL || PyBool_Check(result));
1075 return result;
1076}
1077PyObject *STR_ISUPPER(PyThreadState *tstate, PyObject *str) {
1078 CHECK_OBJECT(str);
1079 assert(PyString_CheckExact(str));
1080
1081 PyObject *called = str_builtin_isupper;
1082 CHECK_OBJECT(called);
1083
1084 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1085
1086 CHECK_OBJECT_X(result);
1087 assert(result == NULL || PyBool_Check(result));
1088 return result;
1089}
1090PyObject *STR_LJUST2(PyThreadState *tstate, PyObject *str, PyObject *width) {
1091 CHECK_OBJECT(str);
1092 assert(PyString_CheckExact(str));
1093
1094 CHECK_OBJECT(width);
1095
1096 PyObject *called = str_builtin_ljust;
1097 CHECK_OBJECT(called);
1098
1099 PyObject *args[2] = {str, width};
1100 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1101
1102 CHECK_OBJECT_X(result);
1103 assert(result == NULL || Nuitka_String_CheckExact(result));
1104 return result;
1105}
1106PyObject *STR_LJUST3(PyThreadState *tstate, PyObject *str, PyObject *width, PyObject *fillchar) {
1107 CHECK_OBJECT(str);
1108 assert(PyString_CheckExact(str));
1109
1110 CHECK_OBJECT(width);
1111 CHECK_OBJECT(fillchar);
1112
1113 PyObject *called = str_builtin_ljust;
1114 CHECK_OBJECT(called);
1115
1116 PyObject *args[3] = {str, width, fillchar};
1117 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
1118
1119 CHECK_OBJECT_X(result);
1120 assert(result == NULL || Nuitka_String_CheckExact(result));
1121 return result;
1122}
1123PyObject *STR_LOWER(PyThreadState *tstate, PyObject *str) {
1124 CHECK_OBJECT(str);
1125 assert(PyString_CheckExact(str));
1126
1127 PyObject *called = str_builtin_lower;
1128 CHECK_OBJECT(called);
1129
1130 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1131
1132 CHECK_OBJECT_X(result);
1133 assert(result == NULL || Nuitka_String_CheckExact(result));
1134 return result;
1135}
1136PyObject *STR_LSTRIP1(PyThreadState *tstate, PyObject *str) {
1137 CHECK_OBJECT(str);
1138 assert(PyString_CheckExact(str));
1139
1140 PyObject *called = str_builtin_lstrip;
1141 CHECK_OBJECT(called);
1142
1143 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1144
1145 CHECK_OBJECT_X(result);
1146 assert(result == NULL || Nuitka_String_CheckExact(result));
1147 return result;
1148}
1149PyObject *STR_LSTRIP2(PyThreadState *tstate, PyObject *str, PyObject *chars) {
1150 CHECK_OBJECT(str);
1151 assert(PyString_CheckExact(str));
1152
1153 CHECK_OBJECT(chars);
1154
1155 PyObject *called = str_builtin_lstrip;
1156 CHECK_OBJECT(called);
1157
1158 PyObject *args[2] = {str, chars};
1159 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1160
1161 CHECK_OBJECT_X(result);
1162 assert(result == NULL || Nuitka_String_CheckExact(result));
1163 return result;
1164}
1165PyObject *STR_PARTITION(PyThreadState *tstate, PyObject *str, PyObject *sep) {
1166 CHECK_OBJECT(str);
1167 assert(PyString_CheckExact(str));
1168
1169 CHECK_OBJECT(sep);
1170
1171 PyObject *called = str_builtin_partition;
1172 CHECK_OBJECT(called);
1173
1174 PyObject *args[2] = {str, sep};
1175 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1176
1177 CHECK_OBJECT_X(result);
1178 assert(result == NULL || PyTuple_CheckExact(result));
1179 return result;
1180}
1181PyObject *STR_REPLACE3(PyThreadState *tstate, PyObject *str, PyObject *old, PyObject *new_value) {
1182 CHECK_OBJECT(str);
1183 assert(PyString_CheckExact(str));
1184
1185 CHECK_OBJECT(old);
1186 CHECK_OBJECT(new_value);
1187
1188 PyObject *called = str_builtin_replace;
1189 CHECK_OBJECT(called);
1190
1191 PyObject *args[3] = {str, old, new_value};
1192 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
1193
1194 CHECK_OBJECT_X(result);
1195 assert(result == NULL || Nuitka_String_CheckExact(result));
1196 return result;
1197}
1198PyObject *STR_REPLACE4(PyThreadState *tstate, PyObject *str, PyObject *old, PyObject *new_value, PyObject *count) {
1199 CHECK_OBJECT(str);
1200 assert(PyString_CheckExact(str));
1201
1202 CHECK_OBJECT(old);
1203 CHECK_OBJECT(new_value);
1204 CHECK_OBJECT(count);
1205
1206 PyObject *called = str_builtin_replace;
1207 CHECK_OBJECT(called);
1208
1209 PyObject *args[4] = {str, old, new_value, count};
1210 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
1211
1212 CHECK_OBJECT_X(result);
1213 assert(result == NULL || Nuitka_String_CheckExact(result));
1214 return result;
1215}
1216PyObject *STR_RFIND2(PyThreadState *tstate, PyObject *str, PyObject *sub) {
1217 CHECK_OBJECT(str);
1218 assert(PyString_CheckExact(str));
1219
1220 CHECK_OBJECT(sub);
1221
1222 PyObject *called = str_builtin_rfind;
1223 CHECK_OBJECT(called);
1224
1225 PyObject *args[2] = {str, sub};
1226 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1227
1228 CHECK_OBJECT_X(result);
1229 return result;
1230}
1231PyObject *STR_RFIND3(PyThreadState *tstate, PyObject *str, PyObject *sub, PyObject *start) {
1232 CHECK_OBJECT(str);
1233 assert(PyString_CheckExact(str));
1234
1235 CHECK_OBJECT(sub);
1236 CHECK_OBJECT(start);
1237
1238 PyObject *called = str_builtin_rfind;
1239 CHECK_OBJECT(called);
1240
1241 PyObject *args[3] = {str, sub, start};
1242 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
1243
1244 CHECK_OBJECT_X(result);
1245 return result;
1246}
1247PyObject *STR_RFIND4(PyThreadState *tstate, PyObject *str, PyObject *sub, PyObject *start, PyObject *end) {
1248 CHECK_OBJECT(str);
1249 assert(PyString_CheckExact(str));
1250
1251 CHECK_OBJECT(sub);
1252 CHECK_OBJECT(start);
1253 CHECK_OBJECT(end);
1254
1255 PyObject *called = str_builtin_rfind;
1256 CHECK_OBJECT(called);
1257
1258 PyObject *args[4] = {str, sub, start, end};
1259 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
1260
1261 CHECK_OBJECT_X(result);
1262 return result;
1263}
1264PyObject *STR_RINDEX2(PyThreadState *tstate, PyObject *str, PyObject *sub) {
1265 CHECK_OBJECT(str);
1266 assert(PyString_CheckExact(str));
1267
1268 CHECK_OBJECT(sub);
1269
1270 PyObject *called = str_builtin_rindex;
1271 CHECK_OBJECT(called);
1272
1273 PyObject *args[2] = {str, sub};
1274 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1275
1276 CHECK_OBJECT_X(result);
1277 return result;
1278}
1279PyObject *STR_RINDEX3(PyThreadState *tstate, PyObject *str, PyObject *sub, PyObject *start) {
1280 CHECK_OBJECT(str);
1281 assert(PyString_CheckExact(str));
1282
1283 CHECK_OBJECT(sub);
1284 CHECK_OBJECT(start);
1285
1286 PyObject *called = str_builtin_rindex;
1287 CHECK_OBJECT(called);
1288
1289 PyObject *args[3] = {str, sub, start};
1290 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
1291
1292 CHECK_OBJECT_X(result);
1293 return result;
1294}
1295PyObject *STR_RINDEX4(PyThreadState *tstate, PyObject *str, PyObject *sub, PyObject *start, PyObject *end) {
1296 CHECK_OBJECT(str);
1297 assert(PyString_CheckExact(str));
1298
1299 CHECK_OBJECT(sub);
1300 CHECK_OBJECT(start);
1301 CHECK_OBJECT(end);
1302
1303 PyObject *called = str_builtin_rindex;
1304 CHECK_OBJECT(called);
1305
1306 PyObject *args[4] = {str, sub, start, end};
1307 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
1308
1309 CHECK_OBJECT_X(result);
1310 return result;
1311}
1312PyObject *STR_RJUST2(PyThreadState *tstate, PyObject *str, PyObject *width) {
1313 CHECK_OBJECT(str);
1314 assert(PyString_CheckExact(str));
1315
1316 CHECK_OBJECT(width);
1317
1318 PyObject *called = str_builtin_rjust;
1319 CHECK_OBJECT(called);
1320
1321 PyObject *args[2] = {str, width};
1322 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1323
1324 CHECK_OBJECT_X(result);
1325 assert(result == NULL || Nuitka_String_CheckExact(result));
1326 return result;
1327}
1328PyObject *STR_RJUST3(PyThreadState *tstate, PyObject *str, PyObject *width, PyObject *fillchar) {
1329 CHECK_OBJECT(str);
1330 assert(PyString_CheckExact(str));
1331
1332 CHECK_OBJECT(width);
1333 CHECK_OBJECT(fillchar);
1334
1335 PyObject *called = str_builtin_rjust;
1336 CHECK_OBJECT(called);
1337
1338 PyObject *args[3] = {str, width, fillchar};
1339 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
1340
1341 CHECK_OBJECT_X(result);
1342 assert(result == NULL || Nuitka_String_CheckExact(result));
1343 return result;
1344}
1345PyObject *STR_RPARTITION(PyThreadState *tstate, PyObject *str, PyObject *sep) {
1346 CHECK_OBJECT(str);
1347 assert(PyString_CheckExact(str));
1348
1349 CHECK_OBJECT(sep);
1350
1351 PyObject *called = str_builtin_rpartition;
1352 CHECK_OBJECT(called);
1353
1354 PyObject *args[2] = {str, sep};
1355 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1356
1357 CHECK_OBJECT_X(result);
1358 assert(result == NULL || PyTuple_CheckExact(result));
1359 return result;
1360}
1361PyObject *STR_RSPLIT1(PyThreadState *tstate, PyObject *str) {
1362 CHECK_OBJECT(str);
1363 assert(PyString_CheckExact(str));
1364
1365 PyObject *called = str_builtin_rsplit;
1366 CHECK_OBJECT(called);
1367
1368 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1369
1370 CHECK_OBJECT_X(result);
1371 assert(result == NULL || PyList_CheckExact(result));
1372 return result;
1373}
1374PyObject *STR_RSPLIT2(PyThreadState *tstate, PyObject *str, PyObject *sep) {
1375 CHECK_OBJECT(str);
1376 assert(PyString_CheckExact(str));
1377
1378 CHECK_OBJECT(sep);
1379
1380 PyObject *called = str_builtin_rsplit;
1381 CHECK_OBJECT(called);
1382
1383 PyObject *args[2] = {str, sep};
1384 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1385
1386 CHECK_OBJECT_X(result);
1387 assert(result == NULL || PyList_CheckExact(result));
1388 return result;
1389}
1390PyObject *STR_RSPLIT3(PyThreadState *tstate, PyObject *str, PyObject *sep, PyObject *maxsplit) {
1391 CHECK_OBJECT(str);
1392 assert(PyString_CheckExact(str));
1393
1394 CHECK_OBJECT(sep);
1395 CHECK_OBJECT(maxsplit);
1396
1397 PyObject *called = str_builtin_rsplit;
1398 CHECK_OBJECT(called);
1399
1400 PyObject *args[3] = {str, sep, maxsplit};
1401 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
1402
1403 CHECK_OBJECT_X(result);
1404 assert(result == NULL || PyList_CheckExact(result));
1405 return result;
1406}
1407PyObject *STR_RSTRIP1(PyThreadState *tstate, PyObject *str) {
1408 CHECK_OBJECT(str);
1409 assert(PyString_CheckExact(str));
1410
1411 PyObject *called = str_builtin_rstrip;
1412 CHECK_OBJECT(called);
1413
1414 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1415
1416 CHECK_OBJECT_X(result);
1417 assert(result == NULL || Nuitka_String_CheckExact(result));
1418 return result;
1419}
1420PyObject *STR_RSTRIP2(PyThreadState *tstate, PyObject *str, PyObject *chars) {
1421 CHECK_OBJECT(str);
1422 assert(PyString_CheckExact(str));
1423
1424 CHECK_OBJECT(chars);
1425
1426 PyObject *called = str_builtin_rstrip;
1427 CHECK_OBJECT(called);
1428
1429 PyObject *args[2] = {str, chars};
1430 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1431
1432 CHECK_OBJECT_X(result);
1433 assert(result == NULL || Nuitka_String_CheckExact(result));
1434 return result;
1435}
1436PyObject *STR_SPLIT1(PyThreadState *tstate, PyObject *str) {
1437 CHECK_OBJECT(str);
1438 assert(PyString_CheckExact(str));
1439
1440 PyObject *called = str_builtin_split;
1441 CHECK_OBJECT(called);
1442
1443 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1444
1445 CHECK_OBJECT_X(result);
1446 assert(result == NULL || PyList_CheckExact(result));
1447 return result;
1448}
1449PyObject *STR_SPLIT2(PyThreadState *tstate, PyObject *str, PyObject *sep) {
1450 CHECK_OBJECT(str);
1451 assert(PyString_CheckExact(str));
1452
1453 CHECK_OBJECT(sep);
1454
1455 PyObject *called = str_builtin_split;
1456 CHECK_OBJECT(called);
1457
1458 PyObject *args[2] = {str, sep};
1459 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1460
1461 CHECK_OBJECT_X(result);
1462 assert(result == NULL || PyList_CheckExact(result));
1463 return result;
1464}
1465PyObject *STR_SPLIT3(PyThreadState *tstate, PyObject *str, PyObject *sep, PyObject *maxsplit) {
1466 CHECK_OBJECT(str);
1467 assert(PyString_CheckExact(str));
1468
1469 CHECK_OBJECT(sep);
1470 CHECK_OBJECT(maxsplit);
1471
1472 PyObject *called = str_builtin_split;
1473 CHECK_OBJECT(called);
1474
1475 PyObject *args[3] = {str, sep, maxsplit};
1476 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
1477
1478 CHECK_OBJECT_X(result);
1479 assert(result == NULL || PyList_CheckExact(result));
1480 return result;
1481}
1482PyObject *STR_SPLITLINES1(PyThreadState *tstate, PyObject *str) {
1483 CHECK_OBJECT(str);
1484 assert(PyString_CheckExact(str));
1485
1486 PyObject *called = str_builtin_splitlines;
1487 CHECK_OBJECT(called);
1488
1489 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1490
1491 CHECK_OBJECT_X(result);
1492 assert(result == NULL || PyList_CheckExact(result));
1493 return result;
1494}
1495PyObject *STR_SPLITLINES2(PyThreadState *tstate, PyObject *str, PyObject *keepends) {
1496 CHECK_OBJECT(str);
1497 assert(PyString_CheckExact(str));
1498
1499 CHECK_OBJECT(keepends);
1500
1501 PyObject *called = str_builtin_splitlines;
1502 CHECK_OBJECT(called);
1503
1504 PyObject *args[2] = {str, keepends};
1505 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1506
1507 CHECK_OBJECT_X(result);
1508 assert(result == NULL || PyList_CheckExact(result));
1509 return result;
1510}
1511PyObject *STR_STARTSWITH2(PyThreadState *tstate, PyObject *str, PyObject *prefix) {
1512 CHECK_OBJECT(str);
1513 assert(PyString_CheckExact(str));
1514
1515 CHECK_OBJECT(prefix);
1516
1517 PyObject *called = str_builtin_startswith;
1518 CHECK_OBJECT(called);
1519
1520 PyObject *args[2] = {str, prefix};
1521 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1522
1523 CHECK_OBJECT_X(result);
1524 assert(result == NULL || PyBool_Check(result));
1525 return result;
1526}
1527PyObject *STR_STARTSWITH3(PyThreadState *tstate, PyObject *str, PyObject *prefix, PyObject *start) {
1528 CHECK_OBJECT(str);
1529 assert(PyString_CheckExact(str));
1530
1531 CHECK_OBJECT(prefix);
1532 CHECK_OBJECT(start);
1533
1534 PyObject *called = str_builtin_startswith;
1535 CHECK_OBJECT(called);
1536
1537 PyObject *args[3] = {str, prefix, start};
1538 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
1539
1540 CHECK_OBJECT_X(result);
1541 assert(result == NULL || PyBool_Check(result));
1542 return result;
1543}
1544PyObject *STR_STARTSWITH4(PyThreadState *tstate, PyObject *str, PyObject *prefix, PyObject *start, PyObject *end) {
1545 CHECK_OBJECT(str);
1546 assert(PyString_CheckExact(str));
1547
1548 CHECK_OBJECT(prefix);
1549 CHECK_OBJECT(start);
1550 CHECK_OBJECT(end);
1551
1552 PyObject *called = str_builtin_startswith;
1553 CHECK_OBJECT(called);
1554
1555 PyObject *args[4] = {str, prefix, start, end};
1556 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
1557
1558 CHECK_OBJECT_X(result);
1559 assert(result == NULL || PyBool_Check(result));
1560 return result;
1561}
1562PyObject *STR_STRIP1(PyThreadState *tstate, PyObject *str) {
1563 CHECK_OBJECT(str);
1564 assert(PyString_CheckExact(str));
1565
1566 PyObject *called = str_builtin_strip;
1567 CHECK_OBJECT(called);
1568
1569 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1570
1571 CHECK_OBJECT_X(result);
1572 assert(result == NULL || Nuitka_String_CheckExact(result));
1573 return result;
1574}
1575PyObject *STR_STRIP2(PyThreadState *tstate, PyObject *str, PyObject *chars) {
1576 CHECK_OBJECT(str);
1577 assert(PyString_CheckExact(str));
1578
1579 CHECK_OBJECT(chars);
1580
1581 PyObject *called = str_builtin_strip;
1582 CHECK_OBJECT(called);
1583
1584 PyObject *args[2] = {str, chars};
1585 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1586
1587 CHECK_OBJECT_X(result);
1588 assert(result == NULL || Nuitka_String_CheckExact(result));
1589 return result;
1590}
1591PyObject *STR_SWAPCASE(PyThreadState *tstate, PyObject *str) {
1592 CHECK_OBJECT(str);
1593 assert(PyString_CheckExact(str));
1594
1595 PyObject *called = str_builtin_swapcase;
1596 CHECK_OBJECT(called);
1597
1598 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1599
1600 CHECK_OBJECT_X(result);
1601 assert(result == NULL || Nuitka_String_CheckExact(result));
1602 return result;
1603}
1604PyObject *STR_TITLE(PyThreadState *tstate, PyObject *str) {
1605 CHECK_OBJECT(str);
1606 assert(PyString_CheckExact(str));
1607
1608 PyObject *called = str_builtin_title;
1609 CHECK_OBJECT(called);
1610
1611 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1612
1613 CHECK_OBJECT_X(result);
1614 assert(result == NULL || Nuitka_String_CheckExact(result));
1615 return result;
1616}
1617PyObject *STR_TRANSLATE(PyThreadState *tstate, PyObject *str, PyObject *table) {
1618 CHECK_OBJECT(str);
1619 assert(PyString_CheckExact(str));
1620
1621 CHECK_OBJECT(table);
1622
1623 PyObject *called = str_builtin_translate;
1624 CHECK_OBJECT(called);
1625
1626 PyObject *args[2] = {str, table};
1627 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1628
1629 CHECK_OBJECT_X(result);
1630 assert(result == NULL || Nuitka_String_CheckExact(result));
1631 return result;
1632}
1633PyObject *STR_UPPER(PyThreadState *tstate, PyObject *str) {
1634 CHECK_OBJECT(str);
1635 assert(PyString_CheckExact(str));
1636
1637 PyObject *called = str_builtin_upper;
1638 CHECK_OBJECT(called);
1639
1640 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, str);
1641
1642 CHECK_OBJECT_X(result);
1643 assert(result == NULL || Nuitka_String_CheckExact(result));
1644 return result;
1645}
1646PyObject *STR_ZFILL(PyThreadState *tstate, PyObject *str, PyObject *width) {
1647 CHECK_OBJECT(str);
1648 assert(PyString_CheckExact(str));
1649
1650 CHECK_OBJECT(width);
1651
1652 PyObject *called = str_builtin_zfill;
1653 CHECK_OBJECT(called);
1654
1655 PyObject *args[2] = {str, width};
1656 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1657
1658 CHECK_OBJECT_X(result);
1659 assert(result == NULL || Nuitka_String_CheckExact(result));
1660 return result;
1661}
1662#endif
1663PyObject *UNICODE_CAPITALIZE(PyThreadState *tstate, PyObject *unicode) {
1664 CHECK_OBJECT(unicode);
1665 assert(PyUnicode_CheckExact(unicode));
1666
1667 PyObject *called = unicode_builtin_capitalize;
1668 CHECK_OBJECT(called);
1669
1670 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
1671
1672 CHECK_OBJECT_X(result);
1673 return result;
1674}
1675PyObject *UNICODE_CENTER2(PyThreadState *tstate, PyObject *unicode, PyObject *width) {
1676 CHECK_OBJECT(unicode);
1677 assert(PyUnicode_CheckExact(unicode));
1678
1679 CHECK_OBJECT(width);
1680
1681 PyObject *called = unicode_builtin_center;
1682 CHECK_OBJECT(called);
1683
1684 PyObject *args[2] = {unicode, width};
1685 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1686
1687 CHECK_OBJECT_X(result);
1688 return result;
1689}
1690PyObject *UNICODE_CENTER3(PyThreadState *tstate, PyObject *unicode, PyObject *width, PyObject *fillchar) {
1691 CHECK_OBJECT(unicode);
1692 assert(PyUnicode_CheckExact(unicode));
1693
1694 CHECK_OBJECT(width);
1695 CHECK_OBJECT(fillchar);
1696
1697 PyObject *called = unicode_builtin_center;
1698 CHECK_OBJECT(called);
1699
1700 PyObject *args[3] = {unicode, width, fillchar};
1701 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
1702
1703 CHECK_OBJECT_X(result);
1704 return result;
1705}
1706PyObject *UNICODE_COUNT2(PyThreadState *tstate, PyObject *unicode, PyObject *sub) {
1707 CHECK_OBJECT(unicode);
1708 assert(PyUnicode_CheckExact(unicode));
1709
1710 CHECK_OBJECT(sub);
1711
1712 PyObject *called = unicode_builtin_count;
1713 CHECK_OBJECT(called);
1714
1715 PyObject *args[2] = {unicode, sub};
1716 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1717
1718 CHECK_OBJECT_X(result);
1719 return result;
1720}
1721PyObject *UNICODE_COUNT3(PyThreadState *tstate, PyObject *unicode, PyObject *sub, PyObject *start) {
1722 CHECK_OBJECT(unicode);
1723 assert(PyUnicode_CheckExact(unicode));
1724
1725 CHECK_OBJECT(sub);
1726 CHECK_OBJECT(start);
1727
1728 PyObject *called = unicode_builtin_count;
1729 CHECK_OBJECT(called);
1730
1731 PyObject *args[3] = {unicode, sub, start};
1732 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
1733
1734 CHECK_OBJECT_X(result);
1735 return result;
1736}
1737PyObject *UNICODE_COUNT4(PyThreadState *tstate, PyObject *unicode, PyObject *sub, PyObject *start, PyObject *end) {
1738 CHECK_OBJECT(unicode);
1739 assert(PyUnicode_CheckExact(unicode));
1740
1741 CHECK_OBJECT(sub);
1742 CHECK_OBJECT(start);
1743 CHECK_OBJECT(end);
1744
1745 PyObject *called = unicode_builtin_count;
1746 CHECK_OBJECT(called);
1747
1748 PyObject *args[4] = {unicode, sub, start, end};
1749 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
1750
1751 CHECK_OBJECT_X(result);
1752 return result;
1753}
1754PyObject *UNICODE_ENCODE1(PyThreadState *tstate, PyObject *unicode) {
1755 CHECK_OBJECT(unicode);
1756 assert(PyUnicode_CheckExact(unicode));
1757
1758 PyObject *called = unicode_builtin_encode;
1759 CHECK_OBJECT(called);
1760
1761 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
1762
1763 CHECK_OBJECT_X(result);
1764 return result;
1765}
1766PyObject *UNICODE_ENCODE2(PyThreadState *tstate, PyObject *unicode, PyObject *encoding) {
1767 CHECK_OBJECT(unicode);
1768 assert(PyUnicode_CheckExact(unicode));
1769
1770 CHECK_OBJECT(encoding);
1771
1772 PyObject *called = unicode_builtin_encode;
1773 CHECK_OBJECT(called);
1774
1775 PyObject *args[2] = {unicode, encoding};
1776 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1777
1778 CHECK_OBJECT_X(result);
1779 return result;
1780}
1781PyObject *UNICODE_ENCODE3(PyThreadState *tstate, PyObject *unicode, PyObject *encoding, PyObject *errors) {
1782 CHECK_OBJECT(unicode);
1783 assert(PyUnicode_CheckExact(unicode));
1784
1785 CHECK_OBJECT(encoding);
1786 CHECK_OBJECT(errors);
1787
1788 PyObject *called = unicode_builtin_encode;
1789 CHECK_OBJECT(called);
1790
1791 PyObject *args[3] = {unicode, encoding, errors};
1792 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
1793
1794 CHECK_OBJECT_X(result);
1795 return result;
1796}
1797PyObject *UNICODE_ENDSWITH2(PyThreadState *tstate, PyObject *unicode, PyObject *suffix) {
1798 CHECK_OBJECT(unicode);
1799 assert(PyUnicode_CheckExact(unicode));
1800
1801 CHECK_OBJECT(suffix);
1802
1803 PyObject *called = unicode_builtin_endswith;
1804 CHECK_OBJECT(called);
1805
1806 PyObject *args[2] = {unicode, suffix};
1807 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1808
1809 CHECK_OBJECT_X(result);
1810 return result;
1811}
1812PyObject *UNICODE_ENDSWITH3(PyThreadState *tstate, PyObject *unicode, PyObject *suffix, PyObject *start) {
1813 CHECK_OBJECT(unicode);
1814 assert(PyUnicode_CheckExact(unicode));
1815
1816 CHECK_OBJECT(suffix);
1817 CHECK_OBJECT(start);
1818
1819 PyObject *called = unicode_builtin_endswith;
1820 CHECK_OBJECT(called);
1821
1822 PyObject *args[3] = {unicode, suffix, start};
1823 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
1824
1825 CHECK_OBJECT_X(result);
1826 return result;
1827}
1828PyObject *UNICODE_ENDSWITH4(PyThreadState *tstate, PyObject *unicode, PyObject *suffix, PyObject *start,
1829 PyObject *end) {
1830 CHECK_OBJECT(unicode);
1831 assert(PyUnicode_CheckExact(unicode));
1832
1833 CHECK_OBJECT(suffix);
1834 CHECK_OBJECT(start);
1835 CHECK_OBJECT(end);
1836
1837 PyObject *called = unicode_builtin_endswith;
1838 CHECK_OBJECT(called);
1839
1840 PyObject *args[4] = {unicode, suffix, start, end};
1841 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
1842
1843 CHECK_OBJECT_X(result);
1844 return result;
1845}
1846PyObject *UNICODE_EXPANDTABS1(PyThreadState *tstate, PyObject *unicode) {
1847 CHECK_OBJECT(unicode);
1848 assert(PyUnicode_CheckExact(unicode));
1849
1850 PyObject *called = unicode_builtin_expandtabs;
1851 CHECK_OBJECT(called);
1852
1853 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
1854
1855 CHECK_OBJECT_X(result);
1856 return result;
1857}
1858PyObject *UNICODE_EXPANDTABS2(PyThreadState *tstate, PyObject *unicode, PyObject *tabsize) {
1859 CHECK_OBJECT(unicode);
1860 assert(PyUnicode_CheckExact(unicode));
1861
1862 CHECK_OBJECT(tabsize);
1863
1864 PyObject *called = unicode_builtin_expandtabs;
1865 CHECK_OBJECT(called);
1866
1867 PyObject *args[2] = {unicode, tabsize};
1868 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1869
1870 CHECK_OBJECT_X(result);
1871 return result;
1872}
1873PyObject *UNICODE_FIND2(PyThreadState *tstate, PyObject *unicode, PyObject *sub) {
1874 CHECK_OBJECT(unicode);
1875 assert(PyUnicode_CheckExact(unicode));
1876
1877 CHECK_OBJECT(sub);
1878
1879 PyObject *called = unicode_builtin_find;
1880 CHECK_OBJECT(called);
1881
1882 PyObject *args[2] = {unicode, sub};
1883 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1884
1885 CHECK_OBJECT_X(result);
1886 return result;
1887}
1888PyObject *UNICODE_FIND3(PyThreadState *tstate, PyObject *unicode, PyObject *sub, PyObject *start) {
1889 CHECK_OBJECT(unicode);
1890 assert(PyUnicode_CheckExact(unicode));
1891
1892 CHECK_OBJECT(sub);
1893 CHECK_OBJECT(start);
1894
1895 PyObject *called = unicode_builtin_find;
1896 CHECK_OBJECT(called);
1897
1898 PyObject *args[3] = {unicode, sub, start};
1899 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
1900
1901 CHECK_OBJECT_X(result);
1902 return result;
1903}
1904PyObject *UNICODE_FIND4(PyThreadState *tstate, PyObject *unicode, PyObject *sub, PyObject *start, PyObject *end) {
1905 CHECK_OBJECT(unicode);
1906 assert(PyUnicode_CheckExact(unicode));
1907
1908 CHECK_OBJECT(sub);
1909 CHECK_OBJECT(start);
1910 CHECK_OBJECT(end);
1911
1912 PyObject *called = unicode_builtin_find;
1913 CHECK_OBJECT(called);
1914
1915 PyObject *args[4] = {unicode, sub, start, end};
1916 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
1917
1918 CHECK_OBJECT_X(result);
1919 return result;
1920}
1921PyObject *UNICODE_INDEX2(PyThreadState *tstate, PyObject *unicode, PyObject *sub) {
1922 CHECK_OBJECT(unicode);
1923 assert(PyUnicode_CheckExact(unicode));
1924
1925 CHECK_OBJECT(sub);
1926
1927 PyObject *called = unicode_builtin_index;
1928 CHECK_OBJECT(called);
1929
1930 PyObject *args[2] = {unicode, sub};
1931 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
1932
1933 CHECK_OBJECT_X(result);
1934 return result;
1935}
1936PyObject *UNICODE_INDEX3(PyThreadState *tstate, PyObject *unicode, PyObject *sub, PyObject *start) {
1937 CHECK_OBJECT(unicode);
1938 assert(PyUnicode_CheckExact(unicode));
1939
1940 CHECK_OBJECT(sub);
1941 CHECK_OBJECT(start);
1942
1943 PyObject *called = unicode_builtin_index;
1944 CHECK_OBJECT(called);
1945
1946 PyObject *args[3] = {unicode, sub, start};
1947 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
1948
1949 CHECK_OBJECT_X(result);
1950 return result;
1951}
1952PyObject *UNICODE_INDEX4(PyThreadState *tstate, PyObject *unicode, PyObject *sub, PyObject *start, PyObject *end) {
1953 CHECK_OBJECT(unicode);
1954 assert(PyUnicode_CheckExact(unicode));
1955
1956 CHECK_OBJECT(sub);
1957 CHECK_OBJECT(start);
1958 CHECK_OBJECT(end);
1959
1960 PyObject *called = unicode_builtin_index;
1961 CHECK_OBJECT(called);
1962
1963 PyObject *args[4] = {unicode, sub, start, end};
1964 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
1965
1966 CHECK_OBJECT_X(result);
1967 return result;
1968}
1969PyObject *UNICODE_ISALNUM(PyThreadState *tstate, PyObject *unicode) {
1970 CHECK_OBJECT(unicode);
1971 assert(PyUnicode_CheckExact(unicode));
1972
1973 PyObject *called = unicode_builtin_isalnum;
1974 CHECK_OBJECT(called);
1975
1976 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
1977
1978 CHECK_OBJECT_X(result);
1979 return result;
1980}
1981PyObject *UNICODE_ISALPHA(PyThreadState *tstate, PyObject *unicode) {
1982 CHECK_OBJECT(unicode);
1983 assert(PyUnicode_CheckExact(unicode));
1984
1985 PyObject *called = unicode_builtin_isalpha;
1986 CHECK_OBJECT(called);
1987
1988 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
1989
1990 CHECK_OBJECT_X(result);
1991 return result;
1992}
1993PyObject *UNICODE_ISDIGIT(PyThreadState *tstate, PyObject *unicode) {
1994 CHECK_OBJECT(unicode);
1995 assert(PyUnicode_CheckExact(unicode));
1996
1997 PyObject *called = unicode_builtin_isdigit;
1998 CHECK_OBJECT(called);
1999
2000 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2001
2002 CHECK_OBJECT_X(result);
2003 return result;
2004}
2005PyObject *UNICODE_ISLOWER(PyThreadState *tstate, PyObject *unicode) {
2006 CHECK_OBJECT(unicode);
2007 assert(PyUnicode_CheckExact(unicode));
2008
2009 PyObject *called = unicode_builtin_islower;
2010 CHECK_OBJECT(called);
2011
2012 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2013
2014 CHECK_OBJECT_X(result);
2015 return result;
2016}
2017PyObject *UNICODE_ISSPACE(PyThreadState *tstate, PyObject *unicode) {
2018 CHECK_OBJECT(unicode);
2019 assert(PyUnicode_CheckExact(unicode));
2020
2021 PyObject *called = unicode_builtin_isspace;
2022 CHECK_OBJECT(called);
2023
2024 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2025
2026 CHECK_OBJECT_X(result);
2027 return result;
2028}
2029PyObject *UNICODE_ISTITLE(PyThreadState *tstate, PyObject *unicode) {
2030 CHECK_OBJECT(unicode);
2031 assert(PyUnicode_CheckExact(unicode));
2032
2033 PyObject *called = unicode_builtin_istitle;
2034 CHECK_OBJECT(called);
2035
2036 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2037
2038 CHECK_OBJECT_X(result);
2039 return result;
2040}
2041PyObject *UNICODE_ISUPPER(PyThreadState *tstate, PyObject *unicode) {
2042 CHECK_OBJECT(unicode);
2043 assert(PyUnicode_CheckExact(unicode));
2044
2045 PyObject *called = unicode_builtin_isupper;
2046 CHECK_OBJECT(called);
2047
2048 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2049
2050 CHECK_OBJECT_X(result);
2051 return result;
2052}
2053PyObject *UNICODE_LJUST2(PyThreadState *tstate, PyObject *unicode, PyObject *width) {
2054 CHECK_OBJECT(unicode);
2055 assert(PyUnicode_CheckExact(unicode));
2056
2057 CHECK_OBJECT(width);
2058
2059 PyObject *called = unicode_builtin_ljust;
2060 CHECK_OBJECT(called);
2061
2062 PyObject *args[2] = {unicode, width};
2063 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2064
2065 CHECK_OBJECT_X(result);
2066 return result;
2067}
2068PyObject *UNICODE_LJUST3(PyThreadState *tstate, PyObject *unicode, PyObject *width, PyObject *fillchar) {
2069 CHECK_OBJECT(unicode);
2070 assert(PyUnicode_CheckExact(unicode));
2071
2072 CHECK_OBJECT(width);
2073 CHECK_OBJECT(fillchar);
2074
2075 PyObject *called = unicode_builtin_ljust;
2076 CHECK_OBJECT(called);
2077
2078 PyObject *args[3] = {unicode, width, fillchar};
2079 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
2080
2081 CHECK_OBJECT_X(result);
2082 return result;
2083}
2084PyObject *UNICODE_LOWER(PyThreadState *tstate, PyObject *unicode) {
2085 CHECK_OBJECT(unicode);
2086 assert(PyUnicode_CheckExact(unicode));
2087
2088 PyObject *called = unicode_builtin_lower;
2089 CHECK_OBJECT(called);
2090
2091 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2092
2093 CHECK_OBJECT_X(result);
2094 return result;
2095}
2096PyObject *UNICODE_LSTRIP1(PyThreadState *tstate, PyObject *unicode) {
2097 CHECK_OBJECT(unicode);
2098 assert(PyUnicode_CheckExact(unicode));
2099
2100 PyObject *called = unicode_builtin_lstrip;
2101 CHECK_OBJECT(called);
2102
2103 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2104
2105 CHECK_OBJECT_X(result);
2106 return result;
2107}
2108PyObject *UNICODE_LSTRIP2(PyThreadState *tstate, PyObject *unicode, PyObject *chars) {
2109 CHECK_OBJECT(unicode);
2110 assert(PyUnicode_CheckExact(unicode));
2111
2112 CHECK_OBJECT(chars);
2113
2114 PyObject *called = unicode_builtin_lstrip;
2115 CHECK_OBJECT(called);
2116
2117 PyObject *args[2] = {unicode, chars};
2118 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2119
2120 CHECK_OBJECT_X(result);
2121 return result;
2122}
2123PyObject *UNICODE_REPLACE3(PyThreadState *tstate, PyObject *unicode, PyObject *old, PyObject *new_value) {
2124 CHECK_OBJECT(unicode);
2125 assert(PyUnicode_CheckExact(unicode));
2126
2127 CHECK_OBJECT(old);
2128 CHECK_OBJECT(new_value);
2129
2130 PyObject *called = unicode_builtin_replace;
2131 CHECK_OBJECT(called);
2132
2133 PyObject *args[3] = {unicode, old, new_value};
2134 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
2135
2136 CHECK_OBJECT_X(result);
2137 return result;
2138}
2139PyObject *UNICODE_REPLACE4(PyThreadState *tstate, PyObject *unicode, PyObject *old, PyObject *new_value,
2140 PyObject *count) {
2141 CHECK_OBJECT(unicode);
2142 assert(PyUnicode_CheckExact(unicode));
2143
2144 CHECK_OBJECT(old);
2145 CHECK_OBJECT(new_value);
2146 CHECK_OBJECT(count);
2147
2148 PyObject *called = unicode_builtin_replace;
2149 CHECK_OBJECT(called);
2150
2151 PyObject *args[4] = {unicode, old, new_value, count};
2152 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
2153
2154 CHECK_OBJECT_X(result);
2155 return result;
2156}
2157PyObject *UNICODE_RFIND2(PyThreadState *tstate, PyObject *unicode, PyObject *sub) {
2158 CHECK_OBJECT(unicode);
2159 assert(PyUnicode_CheckExact(unicode));
2160
2161 CHECK_OBJECT(sub);
2162
2163 PyObject *called = unicode_builtin_rfind;
2164 CHECK_OBJECT(called);
2165
2166 PyObject *args[2] = {unicode, sub};
2167 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2168
2169 CHECK_OBJECT_X(result);
2170 return result;
2171}
2172PyObject *UNICODE_RFIND3(PyThreadState *tstate, PyObject *unicode, PyObject *sub, PyObject *start) {
2173 CHECK_OBJECT(unicode);
2174 assert(PyUnicode_CheckExact(unicode));
2175
2176 CHECK_OBJECT(sub);
2177 CHECK_OBJECT(start);
2178
2179 PyObject *called = unicode_builtin_rfind;
2180 CHECK_OBJECT(called);
2181
2182 PyObject *args[3] = {unicode, sub, start};
2183 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
2184
2185 CHECK_OBJECT_X(result);
2186 return result;
2187}
2188PyObject *UNICODE_RFIND4(PyThreadState *tstate, PyObject *unicode, PyObject *sub, PyObject *start, PyObject *end) {
2189 CHECK_OBJECT(unicode);
2190 assert(PyUnicode_CheckExact(unicode));
2191
2192 CHECK_OBJECT(sub);
2193 CHECK_OBJECT(start);
2194 CHECK_OBJECT(end);
2195
2196 PyObject *called = unicode_builtin_rfind;
2197 CHECK_OBJECT(called);
2198
2199 PyObject *args[4] = {unicode, sub, start, end};
2200 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
2201
2202 CHECK_OBJECT_X(result);
2203 return result;
2204}
2205PyObject *UNICODE_RINDEX2(PyThreadState *tstate, PyObject *unicode, PyObject *sub) {
2206 CHECK_OBJECT(unicode);
2207 assert(PyUnicode_CheckExact(unicode));
2208
2209 CHECK_OBJECT(sub);
2210
2211 PyObject *called = unicode_builtin_rindex;
2212 CHECK_OBJECT(called);
2213
2214 PyObject *args[2] = {unicode, sub};
2215 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2216
2217 CHECK_OBJECT_X(result);
2218 return result;
2219}
2220PyObject *UNICODE_RINDEX3(PyThreadState *tstate, PyObject *unicode, PyObject *sub, PyObject *start) {
2221 CHECK_OBJECT(unicode);
2222 assert(PyUnicode_CheckExact(unicode));
2223
2224 CHECK_OBJECT(sub);
2225 CHECK_OBJECT(start);
2226
2227 PyObject *called = unicode_builtin_rindex;
2228 CHECK_OBJECT(called);
2229
2230 PyObject *args[3] = {unicode, sub, start};
2231 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
2232
2233 CHECK_OBJECT_X(result);
2234 return result;
2235}
2236PyObject *UNICODE_RINDEX4(PyThreadState *tstate, PyObject *unicode, PyObject *sub, PyObject *start, PyObject *end) {
2237 CHECK_OBJECT(unicode);
2238 assert(PyUnicode_CheckExact(unicode));
2239
2240 CHECK_OBJECT(sub);
2241 CHECK_OBJECT(start);
2242 CHECK_OBJECT(end);
2243
2244 PyObject *called = unicode_builtin_rindex;
2245 CHECK_OBJECT(called);
2246
2247 PyObject *args[4] = {unicode, sub, start, end};
2248 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
2249
2250 CHECK_OBJECT_X(result);
2251 return result;
2252}
2253PyObject *UNICODE_RJUST2(PyThreadState *tstate, PyObject *unicode, PyObject *width) {
2254 CHECK_OBJECT(unicode);
2255 assert(PyUnicode_CheckExact(unicode));
2256
2257 CHECK_OBJECT(width);
2258
2259 PyObject *called = unicode_builtin_rjust;
2260 CHECK_OBJECT(called);
2261
2262 PyObject *args[2] = {unicode, width};
2263 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2264
2265 CHECK_OBJECT_X(result);
2266 return result;
2267}
2268PyObject *UNICODE_RJUST3(PyThreadState *tstate, PyObject *unicode, PyObject *width, PyObject *fillchar) {
2269 CHECK_OBJECT(unicode);
2270 assert(PyUnicode_CheckExact(unicode));
2271
2272 CHECK_OBJECT(width);
2273 CHECK_OBJECT(fillchar);
2274
2275 PyObject *called = unicode_builtin_rjust;
2276 CHECK_OBJECT(called);
2277
2278 PyObject *args[3] = {unicode, width, fillchar};
2279 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
2280
2281 CHECK_OBJECT_X(result);
2282 return result;
2283}
2284PyObject *UNICODE_RSPLIT1(PyThreadState *tstate, PyObject *unicode) {
2285 CHECK_OBJECT(unicode);
2286 assert(PyUnicode_CheckExact(unicode));
2287
2288 PyObject *called = unicode_builtin_rsplit;
2289 CHECK_OBJECT(called);
2290
2291 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2292
2293 CHECK_OBJECT_X(result);
2294 return result;
2295}
2296PyObject *UNICODE_RSPLIT2(PyThreadState *tstate, PyObject *unicode, PyObject *sep) {
2297 CHECK_OBJECT(unicode);
2298 assert(PyUnicode_CheckExact(unicode));
2299
2300 CHECK_OBJECT(sep);
2301
2302 PyObject *called = unicode_builtin_rsplit;
2303 CHECK_OBJECT(called);
2304
2305 PyObject *args[2] = {unicode, sep};
2306 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2307
2308 CHECK_OBJECT_X(result);
2309 return result;
2310}
2311PyObject *UNICODE_RSPLIT3(PyThreadState *tstate, PyObject *unicode, PyObject *sep, PyObject *maxsplit) {
2312 CHECK_OBJECT(unicode);
2313 assert(PyUnicode_CheckExact(unicode));
2314
2315 CHECK_OBJECT(sep);
2316 CHECK_OBJECT(maxsplit);
2317
2318 PyObject *called = unicode_builtin_rsplit;
2319 CHECK_OBJECT(called);
2320
2321 PyObject *args[3] = {unicode, sep, maxsplit};
2322 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
2323
2324 CHECK_OBJECT_X(result);
2325 return result;
2326}
2327PyObject *UNICODE_RSTRIP1(PyThreadState *tstate, PyObject *unicode) {
2328 CHECK_OBJECT(unicode);
2329 assert(PyUnicode_CheckExact(unicode));
2330
2331 PyObject *called = unicode_builtin_rstrip;
2332 CHECK_OBJECT(called);
2333
2334 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2335
2336 CHECK_OBJECT_X(result);
2337 return result;
2338}
2339PyObject *UNICODE_RSTRIP2(PyThreadState *tstate, PyObject *unicode, PyObject *chars) {
2340 CHECK_OBJECT(unicode);
2341 assert(PyUnicode_CheckExact(unicode));
2342
2343 CHECK_OBJECT(chars);
2344
2345 PyObject *called = unicode_builtin_rstrip;
2346 CHECK_OBJECT(called);
2347
2348 PyObject *args[2] = {unicode, chars};
2349 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2350
2351 CHECK_OBJECT_X(result);
2352 return result;
2353}
2354PyObject *UNICODE_SPLIT1(PyThreadState *tstate, PyObject *unicode) {
2355 CHECK_OBJECT(unicode);
2356 assert(PyUnicode_CheckExact(unicode));
2357
2358 PyObject *called = unicode_builtin_split;
2359 CHECK_OBJECT(called);
2360
2361 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2362
2363 CHECK_OBJECT_X(result);
2364 return result;
2365}
2366PyObject *UNICODE_SPLIT2(PyThreadState *tstate, PyObject *unicode, PyObject *sep) {
2367 CHECK_OBJECT(unicode);
2368 assert(PyUnicode_CheckExact(unicode));
2369
2370 CHECK_OBJECT(sep);
2371
2372 PyObject *called = unicode_builtin_split;
2373 CHECK_OBJECT(called);
2374
2375 PyObject *args[2] = {unicode, sep};
2376 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2377
2378 CHECK_OBJECT_X(result);
2379 return result;
2380}
2381PyObject *UNICODE_SPLIT3(PyThreadState *tstate, PyObject *unicode, PyObject *sep, PyObject *maxsplit) {
2382 CHECK_OBJECT(unicode);
2383 assert(PyUnicode_CheckExact(unicode));
2384
2385 CHECK_OBJECT(sep);
2386 CHECK_OBJECT(maxsplit);
2387
2388 PyObject *called = unicode_builtin_split;
2389 CHECK_OBJECT(called);
2390
2391 PyObject *args[3] = {unicode, sep, maxsplit};
2392 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
2393
2394 CHECK_OBJECT_X(result);
2395 return result;
2396}
2397PyObject *UNICODE_SPLITLINES1(PyThreadState *tstate, PyObject *unicode) {
2398 CHECK_OBJECT(unicode);
2399 assert(PyUnicode_CheckExact(unicode));
2400
2401 PyObject *called = unicode_builtin_splitlines;
2402 CHECK_OBJECT(called);
2403
2404 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2405
2406 CHECK_OBJECT_X(result);
2407 return result;
2408}
2409PyObject *UNICODE_SPLITLINES2(PyThreadState *tstate, PyObject *unicode, PyObject *keepends) {
2410 CHECK_OBJECT(unicode);
2411 assert(PyUnicode_CheckExact(unicode));
2412
2413 CHECK_OBJECT(keepends);
2414
2415 PyObject *called = unicode_builtin_splitlines;
2416 CHECK_OBJECT(called);
2417
2418 PyObject *args[2] = {unicode, keepends};
2419 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2420
2421 CHECK_OBJECT_X(result);
2422 return result;
2423}
2424PyObject *UNICODE_STARTSWITH2(PyThreadState *tstate, PyObject *unicode, PyObject *prefix) {
2425 CHECK_OBJECT(unicode);
2426 assert(PyUnicode_CheckExact(unicode));
2427
2428 CHECK_OBJECT(prefix);
2429
2430 PyObject *called = unicode_builtin_startswith;
2431 CHECK_OBJECT(called);
2432
2433 PyObject *args[2] = {unicode, prefix};
2434 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2435
2436 CHECK_OBJECT_X(result);
2437 return result;
2438}
2439PyObject *UNICODE_STARTSWITH3(PyThreadState *tstate, PyObject *unicode, PyObject *prefix, PyObject *start) {
2440 CHECK_OBJECT(unicode);
2441 assert(PyUnicode_CheckExact(unicode));
2442
2443 CHECK_OBJECT(prefix);
2444 CHECK_OBJECT(start);
2445
2446 PyObject *called = unicode_builtin_startswith;
2447 CHECK_OBJECT(called);
2448
2449 PyObject *args[3] = {unicode, prefix, start};
2450 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
2451
2452 CHECK_OBJECT_X(result);
2453 return result;
2454}
2455PyObject *UNICODE_STARTSWITH4(PyThreadState *tstate, PyObject *unicode, PyObject *prefix, PyObject *start,
2456 PyObject *end) {
2457 CHECK_OBJECT(unicode);
2458 assert(PyUnicode_CheckExact(unicode));
2459
2460 CHECK_OBJECT(prefix);
2461 CHECK_OBJECT(start);
2462 CHECK_OBJECT(end);
2463
2464 PyObject *called = unicode_builtin_startswith;
2465 CHECK_OBJECT(called);
2466
2467 PyObject *args[4] = {unicode, prefix, start, end};
2468 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
2469
2470 CHECK_OBJECT_X(result);
2471 return result;
2472}
2473PyObject *UNICODE_STRIP1(PyThreadState *tstate, PyObject *unicode) {
2474 CHECK_OBJECT(unicode);
2475 assert(PyUnicode_CheckExact(unicode));
2476
2477 PyObject *called = unicode_builtin_strip;
2478 CHECK_OBJECT(called);
2479
2480 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2481
2482 CHECK_OBJECT_X(result);
2483 return result;
2484}
2485PyObject *UNICODE_STRIP2(PyThreadState *tstate, PyObject *unicode, PyObject *chars) {
2486 CHECK_OBJECT(unicode);
2487 assert(PyUnicode_CheckExact(unicode));
2488
2489 CHECK_OBJECT(chars);
2490
2491 PyObject *called = unicode_builtin_strip;
2492 CHECK_OBJECT(called);
2493
2494 PyObject *args[2] = {unicode, chars};
2495 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2496
2497 CHECK_OBJECT_X(result);
2498 return result;
2499}
2500PyObject *UNICODE_SWAPCASE(PyThreadState *tstate, PyObject *unicode) {
2501 CHECK_OBJECT(unicode);
2502 assert(PyUnicode_CheckExact(unicode));
2503
2504 PyObject *called = unicode_builtin_swapcase;
2505 CHECK_OBJECT(called);
2506
2507 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2508
2509 CHECK_OBJECT_X(result);
2510 return result;
2511}
2512PyObject *UNICODE_TITLE(PyThreadState *tstate, PyObject *unicode) {
2513 CHECK_OBJECT(unicode);
2514 assert(PyUnicode_CheckExact(unicode));
2515
2516 PyObject *called = unicode_builtin_title;
2517 CHECK_OBJECT(called);
2518
2519 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2520
2521 CHECK_OBJECT_X(result);
2522 return result;
2523}
2524PyObject *UNICODE_TRANSLATE(PyThreadState *tstate, PyObject *unicode, PyObject *table) {
2525 CHECK_OBJECT(unicode);
2526 assert(PyUnicode_CheckExact(unicode));
2527
2528 CHECK_OBJECT(table);
2529
2530 PyObject *called = unicode_builtin_translate;
2531 CHECK_OBJECT(called);
2532
2533 PyObject *args[2] = {unicode, table};
2534 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2535
2536 CHECK_OBJECT_X(result);
2537 return result;
2538}
2539PyObject *UNICODE_UPPER(PyThreadState *tstate, PyObject *unicode) {
2540 CHECK_OBJECT(unicode);
2541 assert(PyUnicode_CheckExact(unicode));
2542
2543 PyObject *called = unicode_builtin_upper;
2544 CHECK_OBJECT(called);
2545
2546 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, unicode);
2547
2548 CHECK_OBJECT_X(result);
2549 return result;
2550}
2551PyObject *UNICODE_ZFILL(PyThreadState *tstate, PyObject *unicode, PyObject *width) {
2552 CHECK_OBJECT(unicode);
2553 assert(PyUnicode_CheckExact(unicode));
2554
2555 CHECK_OBJECT(width);
2556
2557 PyObject *called = unicode_builtin_zfill;
2558 CHECK_OBJECT(called);
2559
2560 PyObject *args[2] = {unicode, width};
2561 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2562
2563 CHECK_OBJECT_X(result);
2564 return result;
2565}
2566#if PYTHON_VERSION >= 0x300
2567PyObject *BYTES_CAPITALIZE(PyThreadState *tstate, PyObject *bytes) {
2568 CHECK_OBJECT(bytes);
2569 assert(PyBytes_CheckExact(bytes));
2570
2571 PyObject *called = bytes_builtin_capitalize;
2572 CHECK_OBJECT(called);
2573
2574 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
2575
2576 CHECK_OBJECT_X(result);
2577 assert(result == NULL || PyBytes_CheckExact(result));
2578 return result;
2579}
2580PyObject *BYTES_CENTER2(PyThreadState *tstate, PyObject *bytes, PyObject *width) {
2581 CHECK_OBJECT(bytes);
2582 assert(PyBytes_CheckExact(bytes));
2583
2584 CHECK_OBJECT(width);
2585
2586 PyObject *called = bytes_builtin_center;
2587 CHECK_OBJECT(called);
2588
2589 PyObject *args[2] = {bytes, width};
2590 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2591
2592 CHECK_OBJECT_X(result);
2593 assert(result == NULL || PyBytes_CheckExact(result));
2594 return result;
2595}
2596PyObject *BYTES_CENTER3(PyThreadState *tstate, PyObject *bytes, PyObject *width, PyObject *fillchar) {
2597 CHECK_OBJECT(bytes);
2598 assert(PyBytes_CheckExact(bytes));
2599
2600 CHECK_OBJECT(width);
2601 CHECK_OBJECT(fillchar);
2602
2603 PyObject *called = bytes_builtin_center;
2604 CHECK_OBJECT(called);
2605
2606 PyObject *args[3] = {bytes, width, fillchar};
2607 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
2608
2609 CHECK_OBJECT_X(result);
2610 assert(result == NULL || PyBytes_CheckExact(result));
2611 return result;
2612}
2613PyObject *BYTES_COUNT2(PyThreadState *tstate, PyObject *bytes, PyObject *sub) {
2614 CHECK_OBJECT(bytes);
2615 assert(PyBytes_CheckExact(bytes));
2616
2617 CHECK_OBJECT(sub);
2618
2619 PyObject *called = bytes_builtin_count;
2620 CHECK_OBJECT(called);
2621
2622 PyObject *args[2] = {bytes, sub};
2623 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2624
2625 CHECK_OBJECT_X(result);
2626 return result;
2627}
2628PyObject *BYTES_COUNT3(PyThreadState *tstate, PyObject *bytes, PyObject *sub, PyObject *start) {
2629 CHECK_OBJECT(bytes);
2630 assert(PyBytes_CheckExact(bytes));
2631
2632 CHECK_OBJECT(sub);
2633 CHECK_OBJECT(start);
2634
2635 PyObject *called = bytes_builtin_count;
2636 CHECK_OBJECT(called);
2637
2638 PyObject *args[3] = {bytes, sub, start};
2639 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
2640
2641 CHECK_OBJECT_X(result);
2642 return result;
2643}
2644PyObject *BYTES_COUNT4(PyThreadState *tstate, PyObject *bytes, PyObject *sub, PyObject *start, PyObject *end) {
2645 CHECK_OBJECT(bytes);
2646 assert(PyBytes_CheckExact(bytes));
2647
2648 CHECK_OBJECT(sub);
2649 CHECK_OBJECT(start);
2650 CHECK_OBJECT(end);
2651
2652 PyObject *called = bytes_builtin_count;
2653 CHECK_OBJECT(called);
2654
2655 PyObject *args[4] = {bytes, sub, start, end};
2656 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
2657
2658 CHECK_OBJECT_X(result);
2659 return result;
2660}
2661PyObject *BYTES_DECODE1(PyThreadState *tstate, PyObject *bytes) {
2662 CHECK_OBJECT(bytes);
2663 assert(PyBytes_CheckExact(bytes));
2664
2665 PyObject *called = bytes_builtin_decode;
2666 CHECK_OBJECT(called);
2667
2668 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
2669
2670 CHECK_OBJECT_X(result);
2671 assert(result == NULL || Nuitka_String_CheckExact(result));
2672 return result;
2673}
2674PyObject *BYTES_DECODE2(PyThreadState *tstate, PyObject *bytes, PyObject *encoding) {
2675 CHECK_OBJECT(bytes);
2676 assert(PyBytes_CheckExact(bytes));
2677
2678 CHECK_OBJECT(encoding);
2679
2680 PyObject *called = bytes_builtin_decode;
2681 CHECK_OBJECT(called);
2682
2683 PyObject *args[2] = {bytes, encoding};
2684 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2685
2686 CHECK_OBJECT_X(result);
2687 assert(result == NULL || Nuitka_String_CheckExact(result));
2688 return result;
2689}
2690PyObject *BYTES_DECODE3(PyThreadState *tstate, PyObject *bytes, PyObject *encoding, PyObject *errors) {
2691 CHECK_OBJECT(bytes);
2692 assert(PyBytes_CheckExact(bytes));
2693
2694 CHECK_OBJECT(encoding);
2695 CHECK_OBJECT(errors);
2696
2697 PyObject *called = bytes_builtin_decode;
2698 CHECK_OBJECT(called);
2699
2700 PyObject *args[3] = {bytes, encoding, errors};
2701 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
2702
2703 CHECK_OBJECT_X(result);
2704 assert(result == NULL || Nuitka_String_CheckExact(result));
2705 return result;
2706}
2707PyObject *BYTES_ENDSWITH2(PyThreadState *tstate, PyObject *bytes, PyObject *suffix) {
2708 CHECK_OBJECT(bytes);
2709 assert(PyBytes_CheckExact(bytes));
2710
2711 CHECK_OBJECT(suffix);
2712
2713 PyObject *called = bytes_builtin_endswith;
2714 CHECK_OBJECT(called);
2715
2716 PyObject *args[2] = {bytes, suffix};
2717 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2718
2719 CHECK_OBJECT_X(result);
2720 assert(result == NULL || PyBool_Check(result));
2721 return result;
2722}
2723PyObject *BYTES_ENDSWITH3(PyThreadState *tstate, PyObject *bytes, PyObject *suffix, PyObject *start) {
2724 CHECK_OBJECT(bytes);
2725 assert(PyBytes_CheckExact(bytes));
2726
2727 CHECK_OBJECT(suffix);
2728 CHECK_OBJECT(start);
2729
2730 PyObject *called = bytes_builtin_endswith;
2731 CHECK_OBJECT(called);
2732
2733 PyObject *args[3] = {bytes, suffix, start};
2734 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
2735
2736 CHECK_OBJECT_X(result);
2737 assert(result == NULL || PyBool_Check(result));
2738 return result;
2739}
2740PyObject *BYTES_ENDSWITH4(PyThreadState *tstate, PyObject *bytes, PyObject *suffix, PyObject *start, PyObject *end) {
2741 CHECK_OBJECT(bytes);
2742 assert(PyBytes_CheckExact(bytes));
2743
2744 CHECK_OBJECT(suffix);
2745 CHECK_OBJECT(start);
2746 CHECK_OBJECT(end);
2747
2748 PyObject *called = bytes_builtin_endswith;
2749 CHECK_OBJECT(called);
2750
2751 PyObject *args[4] = {bytes, suffix, start, end};
2752 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
2753
2754 CHECK_OBJECT_X(result);
2755 assert(result == NULL || PyBool_Check(result));
2756 return result;
2757}
2758PyObject *BYTES_EXPANDTABS1(PyThreadState *tstate, PyObject *bytes) {
2759 CHECK_OBJECT(bytes);
2760 assert(PyBytes_CheckExact(bytes));
2761
2762 PyObject *called = bytes_builtin_expandtabs;
2763 CHECK_OBJECT(called);
2764
2765 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
2766
2767 CHECK_OBJECT_X(result);
2768 assert(result == NULL || PyBytes_CheckExact(result));
2769 return result;
2770}
2771PyObject *BYTES_EXPANDTABS2(PyThreadState *tstate, PyObject *bytes, PyObject *tabsize) {
2772 CHECK_OBJECT(bytes);
2773 assert(PyBytes_CheckExact(bytes));
2774
2775 CHECK_OBJECT(tabsize);
2776
2777 PyObject *called = bytes_builtin_expandtabs;
2778 CHECK_OBJECT(called);
2779
2780 PyObject *args[2] = {bytes, tabsize};
2781 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2782
2783 CHECK_OBJECT_X(result);
2784 assert(result == NULL || PyBytes_CheckExact(result));
2785 return result;
2786}
2787PyObject *BYTES_FIND2(PyThreadState *tstate, PyObject *bytes, PyObject *sub) {
2788 CHECK_OBJECT(bytes);
2789 assert(PyBytes_CheckExact(bytes));
2790
2791 CHECK_OBJECT(sub);
2792
2793 PyObject *called = bytes_builtin_find;
2794 CHECK_OBJECT(called);
2795
2796 PyObject *args[2] = {bytes, sub};
2797 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2798
2799 CHECK_OBJECT_X(result);
2800 return result;
2801}
2802PyObject *BYTES_FIND3(PyThreadState *tstate, PyObject *bytes, PyObject *sub, PyObject *start) {
2803 CHECK_OBJECT(bytes);
2804 assert(PyBytes_CheckExact(bytes));
2805
2806 CHECK_OBJECT(sub);
2807 CHECK_OBJECT(start);
2808
2809 PyObject *called = bytes_builtin_find;
2810 CHECK_OBJECT(called);
2811
2812 PyObject *args[3] = {bytes, sub, start};
2813 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
2814
2815 CHECK_OBJECT_X(result);
2816 return result;
2817}
2818PyObject *BYTES_FIND4(PyThreadState *tstate, PyObject *bytes, PyObject *sub, PyObject *start, PyObject *end) {
2819 CHECK_OBJECT(bytes);
2820 assert(PyBytes_CheckExact(bytes));
2821
2822 CHECK_OBJECT(sub);
2823 CHECK_OBJECT(start);
2824 CHECK_OBJECT(end);
2825
2826 PyObject *called = bytes_builtin_find;
2827 CHECK_OBJECT(called);
2828
2829 PyObject *args[4] = {bytes, sub, start, end};
2830 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
2831
2832 CHECK_OBJECT_X(result);
2833 return result;
2834}
2835PyObject *BYTES_INDEX2(PyThreadState *tstate, PyObject *bytes, PyObject *sub) {
2836 CHECK_OBJECT(bytes);
2837 assert(PyBytes_CheckExact(bytes));
2838
2839 CHECK_OBJECT(sub);
2840
2841 PyObject *called = bytes_builtin_index;
2842 CHECK_OBJECT(called);
2843
2844 PyObject *args[2] = {bytes, sub};
2845 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2846
2847 CHECK_OBJECT_X(result);
2848 return result;
2849}
2850PyObject *BYTES_INDEX3(PyThreadState *tstate, PyObject *bytes, PyObject *sub, PyObject *start) {
2851 CHECK_OBJECT(bytes);
2852 assert(PyBytes_CheckExact(bytes));
2853
2854 CHECK_OBJECT(sub);
2855 CHECK_OBJECT(start);
2856
2857 PyObject *called = bytes_builtin_index;
2858 CHECK_OBJECT(called);
2859
2860 PyObject *args[3] = {bytes, sub, start};
2861 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
2862
2863 CHECK_OBJECT_X(result);
2864 return result;
2865}
2866PyObject *BYTES_INDEX4(PyThreadState *tstate, PyObject *bytes, PyObject *sub, PyObject *start, PyObject *end) {
2867 CHECK_OBJECT(bytes);
2868 assert(PyBytes_CheckExact(bytes));
2869
2870 CHECK_OBJECT(sub);
2871 CHECK_OBJECT(start);
2872 CHECK_OBJECT(end);
2873
2874 PyObject *called = bytes_builtin_index;
2875 CHECK_OBJECT(called);
2876
2877 PyObject *args[4] = {bytes, sub, start, end};
2878 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
2879
2880 CHECK_OBJECT_X(result);
2881 return result;
2882}
2883PyObject *BYTES_ISALNUM(PyThreadState *tstate, PyObject *bytes) {
2884 CHECK_OBJECT(bytes);
2885 assert(PyBytes_CheckExact(bytes));
2886
2887 PyObject *called = bytes_builtin_isalnum;
2888 CHECK_OBJECT(called);
2889
2890 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
2891
2892 CHECK_OBJECT_X(result);
2893 assert(result == NULL || PyBool_Check(result));
2894 return result;
2895}
2896PyObject *BYTES_ISALPHA(PyThreadState *tstate, PyObject *bytes) {
2897 CHECK_OBJECT(bytes);
2898 assert(PyBytes_CheckExact(bytes));
2899
2900 PyObject *called = bytes_builtin_isalpha;
2901 CHECK_OBJECT(called);
2902
2903 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
2904
2905 CHECK_OBJECT_X(result);
2906 assert(result == NULL || PyBool_Check(result));
2907 return result;
2908}
2909PyObject *BYTES_ISDIGIT(PyThreadState *tstate, PyObject *bytes) {
2910 CHECK_OBJECT(bytes);
2911 assert(PyBytes_CheckExact(bytes));
2912
2913 PyObject *called = bytes_builtin_isdigit;
2914 CHECK_OBJECT(called);
2915
2916 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
2917
2918 CHECK_OBJECT_X(result);
2919 assert(result == NULL || PyBool_Check(result));
2920 return result;
2921}
2922PyObject *BYTES_ISLOWER(PyThreadState *tstate, PyObject *bytes) {
2923 CHECK_OBJECT(bytes);
2924 assert(PyBytes_CheckExact(bytes));
2925
2926 PyObject *called = bytes_builtin_islower;
2927 CHECK_OBJECT(called);
2928
2929 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
2930
2931 CHECK_OBJECT_X(result);
2932 assert(result == NULL || PyBool_Check(result));
2933 return result;
2934}
2935PyObject *BYTES_ISSPACE(PyThreadState *tstate, PyObject *bytes) {
2936 CHECK_OBJECT(bytes);
2937 assert(PyBytes_CheckExact(bytes));
2938
2939 PyObject *called = bytes_builtin_isspace;
2940 CHECK_OBJECT(called);
2941
2942 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
2943
2944 CHECK_OBJECT_X(result);
2945 assert(result == NULL || PyBool_Check(result));
2946 return result;
2947}
2948PyObject *BYTES_ISTITLE(PyThreadState *tstate, PyObject *bytes) {
2949 CHECK_OBJECT(bytes);
2950 assert(PyBytes_CheckExact(bytes));
2951
2952 PyObject *called = bytes_builtin_istitle;
2953 CHECK_OBJECT(called);
2954
2955 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
2956
2957 CHECK_OBJECT_X(result);
2958 assert(result == NULL || PyBool_Check(result));
2959 return result;
2960}
2961PyObject *BYTES_ISUPPER(PyThreadState *tstate, PyObject *bytes) {
2962 CHECK_OBJECT(bytes);
2963 assert(PyBytes_CheckExact(bytes));
2964
2965 PyObject *called = bytes_builtin_isupper;
2966 CHECK_OBJECT(called);
2967
2968 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
2969
2970 CHECK_OBJECT_X(result);
2971 assert(result == NULL || PyBool_Check(result));
2972 return result;
2973}
2974PyObject *BYTES_JOIN(PyThreadState *tstate, PyObject *bytes, PyObject *iterable) {
2975 CHECK_OBJECT(bytes);
2976 assert(PyBytes_CheckExact(bytes));
2977
2978 CHECK_OBJECT(iterable);
2979
2980 PyObject *called = bytes_builtin_join;
2981 CHECK_OBJECT(called);
2982
2983 PyObject *args[2] = {bytes, iterable};
2984 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
2985
2986 CHECK_OBJECT_X(result);
2987 assert(result == NULL || PyBytes_CheckExact(result));
2988 return result;
2989}
2990PyObject *BYTES_LJUST2(PyThreadState *tstate, PyObject *bytes, PyObject *width) {
2991 CHECK_OBJECT(bytes);
2992 assert(PyBytes_CheckExact(bytes));
2993
2994 CHECK_OBJECT(width);
2995
2996 PyObject *called = bytes_builtin_ljust;
2997 CHECK_OBJECT(called);
2998
2999 PyObject *args[2] = {bytes, width};
3000 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3001
3002 CHECK_OBJECT_X(result);
3003 assert(result == NULL || PyBytes_CheckExact(result));
3004 return result;
3005}
3006PyObject *BYTES_LJUST3(PyThreadState *tstate, PyObject *bytes, PyObject *width, PyObject *fillchar) {
3007 CHECK_OBJECT(bytes);
3008 assert(PyBytes_CheckExact(bytes));
3009
3010 CHECK_OBJECT(width);
3011 CHECK_OBJECT(fillchar);
3012
3013 PyObject *called = bytes_builtin_ljust;
3014 CHECK_OBJECT(called);
3015
3016 PyObject *args[3] = {bytes, width, fillchar};
3017 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
3018
3019 CHECK_OBJECT_X(result);
3020 assert(result == NULL || PyBytes_CheckExact(result));
3021 return result;
3022}
3023PyObject *BYTES_LOWER(PyThreadState *tstate, PyObject *bytes) {
3024 CHECK_OBJECT(bytes);
3025 assert(PyBytes_CheckExact(bytes));
3026
3027 PyObject *called = bytes_builtin_lower;
3028 CHECK_OBJECT(called);
3029
3030 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
3031
3032 CHECK_OBJECT_X(result);
3033 assert(result == NULL || PyBytes_CheckExact(result));
3034 return result;
3035}
3036PyObject *BYTES_LSTRIP1(PyThreadState *tstate, PyObject *bytes) {
3037 CHECK_OBJECT(bytes);
3038 assert(PyBytes_CheckExact(bytes));
3039
3040 PyObject *called = bytes_builtin_lstrip;
3041 CHECK_OBJECT(called);
3042
3043 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
3044
3045 CHECK_OBJECT_X(result);
3046 assert(result == NULL || PyBytes_CheckExact(result));
3047 return result;
3048}
3049PyObject *BYTES_LSTRIP2(PyThreadState *tstate, PyObject *bytes, PyObject *chars) {
3050 CHECK_OBJECT(bytes);
3051 assert(PyBytes_CheckExact(bytes));
3052
3053 CHECK_OBJECT(chars);
3054
3055 PyObject *called = bytes_builtin_lstrip;
3056 CHECK_OBJECT(called);
3057
3058 PyObject *args[2] = {bytes, chars};
3059 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3060
3061 CHECK_OBJECT_X(result);
3062 assert(result == NULL || PyBytes_CheckExact(result));
3063 return result;
3064}
3065PyObject *BYTES_PARTITION(PyThreadState *tstate, PyObject *bytes, PyObject *sep) {
3066 CHECK_OBJECT(bytes);
3067 assert(PyBytes_CheckExact(bytes));
3068
3069 CHECK_OBJECT(sep);
3070
3071 PyObject *called = bytes_builtin_partition;
3072 CHECK_OBJECT(called);
3073
3074 PyObject *args[2] = {bytes, sep};
3075 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3076
3077 CHECK_OBJECT_X(result);
3078 assert(result == NULL || PyTuple_CheckExact(result));
3079 return result;
3080}
3081PyObject *BYTES_REPLACE3(PyThreadState *tstate, PyObject *bytes, PyObject *old, PyObject *new_value) {
3082 CHECK_OBJECT(bytes);
3083 assert(PyBytes_CheckExact(bytes));
3084
3085 CHECK_OBJECT(old);
3086 CHECK_OBJECT(new_value);
3087
3088 PyObject *called = bytes_builtin_replace;
3089 CHECK_OBJECT(called);
3090
3091 PyObject *args[3] = {bytes, old, new_value};
3092 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
3093
3094 CHECK_OBJECT_X(result);
3095 assert(result == NULL || PyBytes_CheckExact(result));
3096 return result;
3097}
3098PyObject *BYTES_REPLACE4(PyThreadState *tstate, PyObject *bytes, PyObject *old, PyObject *new_value, PyObject *count) {
3099 CHECK_OBJECT(bytes);
3100 assert(PyBytes_CheckExact(bytes));
3101
3102 CHECK_OBJECT(old);
3103 CHECK_OBJECT(new_value);
3104 CHECK_OBJECT(count);
3105
3106 PyObject *called = bytes_builtin_replace;
3107 CHECK_OBJECT(called);
3108
3109 PyObject *args[4] = {bytes, old, new_value, count};
3110 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
3111
3112 CHECK_OBJECT_X(result);
3113 assert(result == NULL || PyBytes_CheckExact(result));
3114 return result;
3115}
3116PyObject *BYTES_RFIND2(PyThreadState *tstate, PyObject *bytes, PyObject *sub) {
3117 CHECK_OBJECT(bytes);
3118 assert(PyBytes_CheckExact(bytes));
3119
3120 CHECK_OBJECT(sub);
3121
3122 PyObject *called = bytes_builtin_rfind;
3123 CHECK_OBJECT(called);
3124
3125 PyObject *args[2] = {bytes, sub};
3126 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3127
3128 CHECK_OBJECT_X(result);
3129 return result;
3130}
3131PyObject *BYTES_RFIND3(PyThreadState *tstate, PyObject *bytes, PyObject *sub, PyObject *start) {
3132 CHECK_OBJECT(bytes);
3133 assert(PyBytes_CheckExact(bytes));
3134
3135 CHECK_OBJECT(sub);
3136 CHECK_OBJECT(start);
3137
3138 PyObject *called = bytes_builtin_rfind;
3139 CHECK_OBJECT(called);
3140
3141 PyObject *args[3] = {bytes, sub, start};
3142 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
3143
3144 CHECK_OBJECT_X(result);
3145 return result;
3146}
3147PyObject *BYTES_RFIND4(PyThreadState *tstate, PyObject *bytes, PyObject *sub, PyObject *start, PyObject *end) {
3148 CHECK_OBJECT(bytes);
3149 assert(PyBytes_CheckExact(bytes));
3150
3151 CHECK_OBJECT(sub);
3152 CHECK_OBJECT(start);
3153 CHECK_OBJECT(end);
3154
3155 PyObject *called = bytes_builtin_rfind;
3156 CHECK_OBJECT(called);
3157
3158 PyObject *args[4] = {bytes, sub, start, end};
3159 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
3160
3161 CHECK_OBJECT_X(result);
3162 return result;
3163}
3164PyObject *BYTES_RINDEX2(PyThreadState *tstate, PyObject *bytes, PyObject *sub) {
3165 CHECK_OBJECT(bytes);
3166 assert(PyBytes_CheckExact(bytes));
3167
3168 CHECK_OBJECT(sub);
3169
3170 PyObject *called = bytes_builtin_rindex;
3171 CHECK_OBJECT(called);
3172
3173 PyObject *args[2] = {bytes, sub};
3174 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3175
3176 CHECK_OBJECT_X(result);
3177 return result;
3178}
3179PyObject *BYTES_RINDEX3(PyThreadState *tstate, PyObject *bytes, PyObject *sub, PyObject *start) {
3180 CHECK_OBJECT(bytes);
3181 assert(PyBytes_CheckExact(bytes));
3182
3183 CHECK_OBJECT(sub);
3184 CHECK_OBJECT(start);
3185
3186 PyObject *called = bytes_builtin_rindex;
3187 CHECK_OBJECT(called);
3188
3189 PyObject *args[3] = {bytes, sub, start};
3190 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
3191
3192 CHECK_OBJECT_X(result);
3193 return result;
3194}
3195PyObject *BYTES_RINDEX4(PyThreadState *tstate, PyObject *bytes, PyObject *sub, PyObject *start, PyObject *end) {
3196 CHECK_OBJECT(bytes);
3197 assert(PyBytes_CheckExact(bytes));
3198
3199 CHECK_OBJECT(sub);
3200 CHECK_OBJECT(start);
3201 CHECK_OBJECT(end);
3202
3203 PyObject *called = bytes_builtin_rindex;
3204 CHECK_OBJECT(called);
3205
3206 PyObject *args[4] = {bytes, sub, start, end};
3207 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
3208
3209 CHECK_OBJECT_X(result);
3210 return result;
3211}
3212PyObject *BYTES_RJUST2(PyThreadState *tstate, PyObject *bytes, PyObject *width) {
3213 CHECK_OBJECT(bytes);
3214 assert(PyBytes_CheckExact(bytes));
3215
3216 CHECK_OBJECT(width);
3217
3218 PyObject *called = bytes_builtin_rjust;
3219 CHECK_OBJECT(called);
3220
3221 PyObject *args[2] = {bytes, width};
3222 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3223
3224 CHECK_OBJECT_X(result);
3225 assert(result == NULL || PyBytes_CheckExact(result));
3226 return result;
3227}
3228PyObject *BYTES_RJUST3(PyThreadState *tstate, PyObject *bytes, PyObject *width, PyObject *fillchar) {
3229 CHECK_OBJECT(bytes);
3230 assert(PyBytes_CheckExact(bytes));
3231
3232 CHECK_OBJECT(width);
3233 CHECK_OBJECT(fillchar);
3234
3235 PyObject *called = bytes_builtin_rjust;
3236 CHECK_OBJECT(called);
3237
3238 PyObject *args[3] = {bytes, width, fillchar};
3239 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
3240
3241 CHECK_OBJECT_X(result);
3242 assert(result == NULL || PyBytes_CheckExact(result));
3243 return result;
3244}
3245PyObject *BYTES_RPARTITION(PyThreadState *tstate, PyObject *bytes, PyObject *sep) {
3246 CHECK_OBJECT(bytes);
3247 assert(PyBytes_CheckExact(bytes));
3248
3249 CHECK_OBJECT(sep);
3250
3251 PyObject *called = bytes_builtin_rpartition;
3252 CHECK_OBJECT(called);
3253
3254 PyObject *args[2] = {bytes, sep};
3255 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3256
3257 CHECK_OBJECT_X(result);
3258 assert(result == NULL || PyTuple_CheckExact(result));
3259 return result;
3260}
3261PyObject *BYTES_RSPLIT1(PyThreadState *tstate, PyObject *bytes) {
3262 CHECK_OBJECT(bytes);
3263 assert(PyBytes_CheckExact(bytes));
3264
3265 PyObject *called = bytes_builtin_rsplit;
3266 CHECK_OBJECT(called);
3267
3268 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
3269
3270 CHECK_OBJECT_X(result);
3271 assert(result == NULL || PyList_CheckExact(result));
3272 return result;
3273}
3274PyObject *BYTES_RSPLIT2(PyThreadState *tstate, PyObject *bytes, PyObject *sep) {
3275 CHECK_OBJECT(bytes);
3276 assert(PyBytes_CheckExact(bytes));
3277
3278 CHECK_OBJECT(sep);
3279
3280 PyObject *called = bytes_builtin_rsplit;
3281 CHECK_OBJECT(called);
3282
3283 PyObject *args[2] = {bytes, sep};
3284 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3285
3286 CHECK_OBJECT_X(result);
3287 assert(result == NULL || PyList_CheckExact(result));
3288 return result;
3289}
3290PyObject *BYTES_RSPLIT3(PyThreadState *tstate, PyObject *bytes, PyObject *sep, PyObject *maxsplit) {
3291 CHECK_OBJECT(bytes);
3292 assert(PyBytes_CheckExact(bytes));
3293
3294 CHECK_OBJECT(sep);
3295 CHECK_OBJECT(maxsplit);
3296
3297 PyObject *called = bytes_builtin_rsplit;
3298 CHECK_OBJECT(called);
3299
3300 PyObject *args[3] = {bytes, sep, maxsplit};
3301 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
3302
3303 CHECK_OBJECT_X(result);
3304 assert(result == NULL || PyList_CheckExact(result));
3305 return result;
3306}
3307PyObject *BYTES_RSTRIP1(PyThreadState *tstate, PyObject *bytes) {
3308 CHECK_OBJECT(bytes);
3309 assert(PyBytes_CheckExact(bytes));
3310
3311 PyObject *called = bytes_builtin_rstrip;
3312 CHECK_OBJECT(called);
3313
3314 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
3315
3316 CHECK_OBJECT_X(result);
3317 assert(result == NULL || PyBytes_CheckExact(result));
3318 return result;
3319}
3320PyObject *BYTES_RSTRIP2(PyThreadState *tstate, PyObject *bytes, PyObject *chars) {
3321 CHECK_OBJECT(bytes);
3322 assert(PyBytes_CheckExact(bytes));
3323
3324 CHECK_OBJECT(chars);
3325
3326 PyObject *called = bytes_builtin_rstrip;
3327 CHECK_OBJECT(called);
3328
3329 PyObject *args[2] = {bytes, chars};
3330 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3331
3332 CHECK_OBJECT_X(result);
3333 assert(result == NULL || PyBytes_CheckExact(result));
3334 return result;
3335}
3336PyObject *BYTES_SPLIT1(PyThreadState *tstate, PyObject *bytes) {
3337 CHECK_OBJECT(bytes);
3338 assert(PyBytes_CheckExact(bytes));
3339
3340 PyObject *called = bytes_builtin_split;
3341 CHECK_OBJECT(called);
3342
3343 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
3344
3345 CHECK_OBJECT_X(result);
3346 assert(result == NULL || PyList_CheckExact(result));
3347 return result;
3348}
3349PyObject *BYTES_SPLIT2(PyThreadState *tstate, PyObject *bytes, PyObject *sep) {
3350 CHECK_OBJECT(bytes);
3351 assert(PyBytes_CheckExact(bytes));
3352
3353 CHECK_OBJECT(sep);
3354
3355 PyObject *called = bytes_builtin_split;
3356 CHECK_OBJECT(called);
3357
3358 PyObject *args[2] = {bytes, sep};
3359 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3360
3361 CHECK_OBJECT_X(result);
3362 assert(result == NULL || PyList_CheckExact(result));
3363 return result;
3364}
3365PyObject *BYTES_SPLIT3(PyThreadState *tstate, PyObject *bytes, PyObject *sep, PyObject *maxsplit) {
3366 CHECK_OBJECT(bytes);
3367 assert(PyBytes_CheckExact(bytes));
3368
3369 CHECK_OBJECT(sep);
3370 CHECK_OBJECT(maxsplit);
3371
3372 PyObject *called = bytes_builtin_split;
3373 CHECK_OBJECT(called);
3374
3375 PyObject *args[3] = {bytes, sep, maxsplit};
3376 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
3377
3378 CHECK_OBJECT_X(result);
3379 assert(result == NULL || PyList_CheckExact(result));
3380 return result;
3381}
3382PyObject *BYTES_SPLITLINES1(PyThreadState *tstate, PyObject *bytes) {
3383 CHECK_OBJECT(bytes);
3384 assert(PyBytes_CheckExact(bytes));
3385
3386 PyObject *called = bytes_builtin_splitlines;
3387 CHECK_OBJECT(called);
3388
3389 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
3390
3391 CHECK_OBJECT_X(result);
3392 assert(result == NULL || PyList_CheckExact(result));
3393 return result;
3394}
3395PyObject *BYTES_SPLITLINES2(PyThreadState *tstate, PyObject *bytes, PyObject *keepends) {
3396 CHECK_OBJECT(bytes);
3397 assert(PyBytes_CheckExact(bytes));
3398
3399 CHECK_OBJECT(keepends);
3400
3401 PyObject *called = bytes_builtin_splitlines;
3402 CHECK_OBJECT(called);
3403
3404 PyObject *args[2] = {bytes, keepends};
3405 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3406
3407 CHECK_OBJECT_X(result);
3408 assert(result == NULL || PyList_CheckExact(result));
3409 return result;
3410}
3411PyObject *BYTES_STARTSWITH2(PyThreadState *tstate, PyObject *bytes, PyObject *prefix) {
3412 CHECK_OBJECT(bytes);
3413 assert(PyBytes_CheckExact(bytes));
3414
3415 CHECK_OBJECT(prefix);
3416
3417 PyObject *called = bytes_builtin_startswith;
3418 CHECK_OBJECT(called);
3419
3420 PyObject *args[2] = {bytes, prefix};
3421 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3422
3423 CHECK_OBJECT_X(result);
3424 assert(result == NULL || PyBool_Check(result));
3425 return result;
3426}
3427PyObject *BYTES_STARTSWITH3(PyThreadState *tstate, PyObject *bytes, PyObject *prefix, PyObject *start) {
3428 CHECK_OBJECT(bytes);
3429 assert(PyBytes_CheckExact(bytes));
3430
3431 CHECK_OBJECT(prefix);
3432 CHECK_OBJECT(start);
3433
3434 PyObject *called = bytes_builtin_startswith;
3435 CHECK_OBJECT(called);
3436
3437 PyObject *args[3] = {bytes, prefix, start};
3438 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
3439
3440 CHECK_OBJECT_X(result);
3441 assert(result == NULL || PyBool_Check(result));
3442 return result;
3443}
3444PyObject *BYTES_STARTSWITH4(PyThreadState *tstate, PyObject *bytes, PyObject *prefix, PyObject *start, PyObject *end) {
3445 CHECK_OBJECT(bytes);
3446 assert(PyBytes_CheckExact(bytes));
3447
3448 CHECK_OBJECT(prefix);
3449 CHECK_OBJECT(start);
3450 CHECK_OBJECT(end);
3451
3452 PyObject *called = bytes_builtin_startswith;
3453 CHECK_OBJECT(called);
3454
3455 PyObject *args[4] = {bytes, prefix, start, end};
3456 PyObject *result = CALL_METHODDESCR_WITH_ARGS4(tstate, called, args);
3457
3458 CHECK_OBJECT_X(result);
3459 assert(result == NULL || PyBool_Check(result));
3460 return result;
3461}
3462PyObject *BYTES_STRIP1(PyThreadState *tstate, PyObject *bytes) {
3463 CHECK_OBJECT(bytes);
3464 assert(PyBytes_CheckExact(bytes));
3465
3466 PyObject *called = bytes_builtin_strip;
3467 CHECK_OBJECT(called);
3468
3469 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
3470
3471 CHECK_OBJECT_X(result);
3472 assert(result == NULL || PyBytes_CheckExact(result));
3473 return result;
3474}
3475PyObject *BYTES_STRIP2(PyThreadState *tstate, PyObject *bytes, PyObject *chars) {
3476 CHECK_OBJECT(bytes);
3477 assert(PyBytes_CheckExact(bytes));
3478
3479 CHECK_OBJECT(chars);
3480
3481 PyObject *called = bytes_builtin_strip;
3482 CHECK_OBJECT(called);
3483
3484 PyObject *args[2] = {bytes, chars};
3485 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3486
3487 CHECK_OBJECT_X(result);
3488 assert(result == NULL || PyBytes_CheckExact(result));
3489 return result;
3490}
3491PyObject *BYTES_SWAPCASE(PyThreadState *tstate, PyObject *bytes) {
3492 CHECK_OBJECT(bytes);
3493 assert(PyBytes_CheckExact(bytes));
3494
3495 PyObject *called = bytes_builtin_swapcase;
3496 CHECK_OBJECT(called);
3497
3498 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
3499
3500 CHECK_OBJECT_X(result);
3501 assert(result == NULL || PyBytes_CheckExact(result));
3502 return result;
3503}
3504PyObject *BYTES_TITLE(PyThreadState *tstate, PyObject *bytes) {
3505 CHECK_OBJECT(bytes);
3506 assert(PyBytes_CheckExact(bytes));
3507
3508 PyObject *called = bytes_builtin_title;
3509 CHECK_OBJECT(called);
3510
3511 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
3512
3513 CHECK_OBJECT_X(result);
3514 assert(result == NULL || PyBytes_CheckExact(result));
3515 return result;
3516}
3517PyObject *BYTES_TRANSLATE2(PyThreadState *tstate, PyObject *bytes, PyObject *table) {
3518 CHECK_OBJECT(bytes);
3519 assert(PyBytes_CheckExact(bytes));
3520
3521 CHECK_OBJECT(table);
3522
3523 PyObject *called = bytes_builtin_translate;
3524 CHECK_OBJECT(called);
3525
3526 PyObject *args[2] = {bytes, table};
3527 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3528
3529 CHECK_OBJECT_X(result);
3530 assert(result == NULL || PyBytes_CheckExact(result));
3531 return result;
3532}
3533PyObject *BYTES_TRANSLATE3(PyThreadState *tstate, PyObject *bytes, PyObject *table, PyObject *delete_value) {
3534 CHECK_OBJECT(bytes);
3535 assert(PyBytes_CheckExact(bytes));
3536
3537 CHECK_OBJECT(table);
3538 CHECK_OBJECT(delete_value);
3539
3540 PyObject *called = bytes_builtin_translate;
3541 CHECK_OBJECT(called);
3542
3543 PyObject *args[3] = {bytes, table, delete_value};
3544 PyObject *result = CALL_METHODDESCR_WITH_ARGS3(tstate, called, args);
3545
3546 CHECK_OBJECT_X(result);
3547 assert(result == NULL || PyBytes_CheckExact(result));
3548 return result;
3549}
3550PyObject *BYTES_UPPER(PyThreadState *tstate, PyObject *bytes) {
3551 CHECK_OBJECT(bytes);
3552 assert(PyBytes_CheckExact(bytes));
3553
3554 PyObject *called = bytes_builtin_upper;
3555 CHECK_OBJECT(called);
3556
3557 PyObject *result = CALL_METHODDESCR_WITH_SINGLE_ARG(tstate, called, bytes);
3558
3559 CHECK_OBJECT_X(result);
3560 assert(result == NULL || PyBytes_CheckExact(result));
3561 return result;
3562}
3563PyObject *BYTES_ZFILL(PyThreadState *tstate, PyObject *bytes, PyObject *width) {
3564 CHECK_OBJECT(bytes);
3565 assert(PyBytes_CheckExact(bytes));
3566
3567 CHECK_OBJECT(width);
3568
3569 PyObject *called = bytes_builtin_zfill;
3570 CHECK_OBJECT(called);
3571
3572 PyObject *args[2] = {bytes, width};
3573 PyObject *result = CALL_METHODDESCR_WITH_ARGS2(tstate, called, args);
3574
3575 CHECK_OBJECT_X(result);
3576 assert(result == NULL || PyBytes_CheckExact(result));
3577 return result;
3578}
3579#endif
3580
3581// Part of "Nuitka", an optimizing Python compiler that is compatible and
3582// integrates with CPython, but also works on its own.
3583//
3584// Licensed under the Apache License, Version 2.0 (the "License");
3585// you may not use this file except in compliance with the License.
3586// You may obtain a copy of the License at
3587//
3588// http://www.apache.org/licenses/LICENSE-2.0
3589//
3590// Unless required by applicable law or agreed to in writing, software
3591// distributed under the License is distributed on an "AS IS" BASIS,
3592// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
3593// See the License for the specific language governing permissions and
3594// limitations under the License.