Debian Codegraph @

Objects/clinic/longobject.c.h

raw
1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
6 # include "pycore_gc.h" // PyGC_Head
7 # include "pycore_runtime.h" // _Py_ID()
8 #endif
9 #include "pycore_abstract.h" // _PyNumber_Index()
10 #include "pycore_modsupport.h" // _PyArg_UnpackKeywords()
11
12 static PyObject *
13 long_new_impl(PyTypeObject *type, PyObject *x, PyObject *obase);
14
15 static PyObject *
16 long_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
17 {
18 PyObject *return_value = NULL;
19 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
20
21 #define NUM_KEYWORDS 1
22 static struct {
23 PyGC_Head _this_is_not_used;
24 PyObject_VAR_HEAD
25 Py_hash_t ob_hash;
26 PyObject *ob_item[NUM_KEYWORDS];
27 } _kwtuple = {
28 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
29 .ob_hash = -1,
30 .ob_item = { &_Py_ID(base), },
31 };
32 #undef NUM_KEYWORDS
33 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
34
35 #else // !Py_BUILD_CORE
36 # define KWTUPLE NULL
37 #endif // !Py_BUILD_CORE
38
39 static const char * const _keywords[] = {"", "base", NULL};
40 static _PyArg_Parser _parser = {
41 .keywords = _keywords,
42 .fname = "int",
43 .kwtuple = KWTUPLE,
44 };
45 #undef KWTUPLE
46 PyObject *argsbuf[2];
47 PyObject * const *fastargs;
48 Py_ssize_t nargs = PyTuple_GET_SIZE(args);
49 Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
50 PyObject *x = NULL;
51 PyObject *obase = NULL;
52
53 fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser,
54 /*minpos*/ 0, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
55 if (!fastargs) {
56 goto exit;
57 }
58 if (nargs < 1) {
59 goto skip_optional_posonly;
60 }
61 noptargs--;
62 x = fastargs[0];
63 skip_optional_posonly:
64 if (!noptargs) {
65 goto skip_optional_pos;
66 }
67 obase = fastargs[1];
68 skip_optional_pos:
69 return_value = long_new_impl(type, x, obase);
70
71 exit:
72 return return_value;
73 }
74
75 PyDoc_STRVAR(int___getnewargs____doc__,
76 "__getnewargs__($self, /)\n"
77 "--\n"
78 "\n");
79
80 #define INT___GETNEWARGS___METHODDEF \
81 {"__getnewargs__", (PyCFunction)int___getnewargs__, METH_NOARGS, int___getnewargs____doc__},
82
83 static PyObject *
84 int___getnewargs___impl(PyObject *self);
85
86 static PyObject *
87 int___getnewargs__(PyObject *self, PyObject *Py_UNUSED(ignored))
88 {
89 return int___getnewargs___impl(self);
90 }
91
92 PyDoc_STRVAR(int___format____doc__,
93 "__format__($self, format_spec, /)\n"
94 "--\n"
95 "\n"
96 "Convert to a string according to format_spec.");
97
98 #define INT___FORMAT___METHODDEF \
99 {"__format__", (PyCFunction)int___format__, METH_O, int___format____doc__},
100
101 static PyObject *
102 int___format___impl(PyObject *self, PyObject *format_spec);
103
104 static PyObject *
105 int___format__(PyObject *self, PyObject *arg)
106 {
107 PyObject *return_value = NULL;
108 PyObject *format_spec;
109
110 if (!PyUnicode_Check(arg)) {
111 _PyArg_BadArgument("__format__", "argument", "str", arg);
112 goto exit;
113 }
114 format_spec = arg;
115 return_value = int___format___impl(self, format_spec);
116
117 exit:
118 return return_value;
119 }
120
121 PyDoc_STRVAR(int___round____doc__,
122 "__round__($self, ndigits=None, /)\n"
123 "--\n"
124 "\n"
125 "Rounding an Integral returns itself.\n"
126 "\n"
127 "Rounding with an ndigits argument also returns an integer.");
128
129 #define INT___ROUND___METHODDEF \
130 {"__round__", _PyCFunction_CAST(int___round__), METH_FASTCALL, int___round____doc__},
131
132 static PyObject *
133 int___round___impl(PyObject *self, PyObject *o_ndigits);
134
135 static PyObject *
136 int___round__(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
137 {
138 PyObject *return_value = NULL;
139 PyObject *o_ndigits = Py_None;
140
141 if (!_PyArg_CheckPositional("__round__", nargs, 0, 1)) {
142 goto exit;
143 }
144 if (nargs < 1) {
145 goto skip_optional;
146 }
147 o_ndigits = args[0];
148 skip_optional:
149 return_value = int___round___impl(self, o_ndigits);
150
151 exit:
152 return return_value;
153 }
154
155 PyDoc_STRVAR(int___sizeof____doc__,
156 "__sizeof__($self, /)\n"
157 "--\n"
158 "\n"
159 "Returns size in memory, in bytes.");
160
161 #define INT___SIZEOF___METHODDEF \
162 {"__sizeof__", (PyCFunction)int___sizeof__, METH_NOARGS, int___sizeof____doc__},
163
164 static Py_ssize_t
165 int___sizeof___impl(PyObject *self);
166
167 static PyObject *
168 int___sizeof__(PyObject *self, PyObject *Py_UNUSED(ignored))
169 {
170 PyObject *return_value = NULL;
171 Py_ssize_t _return_value;
172
173 _return_value = int___sizeof___impl(self);
174 if ((_return_value == -1) && PyErr_Occurred()) {
175 goto exit;
176 }
177 return_value = PyLong_FromSsize_t(_return_value);
178
179 exit:
180 return return_value;
181 }
182
183 PyDoc_STRVAR(int_bit_length__doc__,
184 "bit_length($self, /)\n"
185 "--\n"
186 "\n"
187 "Number of bits necessary to represent self in binary.\n"
188 "\n"
189 ">>> bin(37)\n"
190 "\'0b100101\'\n"
191 ">>> (37).bit_length()\n"
192 "6");
193
194 #define INT_BIT_LENGTH_METHODDEF \
195 {"bit_length", (PyCFunction)int_bit_length, METH_NOARGS, int_bit_length__doc__},
196
197 static PyObject *
198 int_bit_length_impl(PyObject *self);
199
200 static PyObject *
201 int_bit_length(PyObject *self, PyObject *Py_UNUSED(ignored))
202 {
203 return int_bit_length_impl(self);
204 }
205
206 PyDoc_STRVAR(int_bit_count__doc__,
207 "bit_count($self, /)\n"
208 "--\n"
209 "\n"
210 "Number of ones in the binary representation of the absolute value of self.\n"
211 "\n"
212 "Also known as the population count.\n"
213 "\n"
214 ">>> bin(13)\n"
215 "\'0b1101\'\n"
216 ">>> (13).bit_count()\n"
217 "3");
218
219 #define INT_BIT_COUNT_METHODDEF \
220 {"bit_count", (PyCFunction)int_bit_count, METH_NOARGS, int_bit_count__doc__},
221
222 static PyObject *
223 int_bit_count_impl(PyObject *self);
224
225 static PyObject *
226 int_bit_count(PyObject *self, PyObject *Py_UNUSED(ignored))
227 {
228 return int_bit_count_impl(self);
229 }
230
231 PyDoc_STRVAR(int_as_integer_ratio__doc__,
232 "as_integer_ratio($self, /)\n"
233 "--\n"
234 "\n"
235 "Return a pair of integers, whose ratio is equal to the original int.\n"
236 "\n"
237 "The ratio is in lowest terms and has a positive denominator.\n"
238 "\n"
239 ">>> (10).as_integer_ratio()\n"
240 "(10, 1)\n"
241 ">>> (-10).as_integer_ratio()\n"
242 "(-10, 1)\n"
243 ">>> (0).as_integer_ratio()\n"
244 "(0, 1)");
245
246 #define INT_AS_INTEGER_RATIO_METHODDEF \
247 {"as_integer_ratio", (PyCFunction)int_as_integer_ratio, METH_NOARGS, int_as_integer_ratio__doc__},
248
249 static PyObject *
250 int_as_integer_ratio_impl(PyObject *self);
251
252 static PyObject *
253 int_as_integer_ratio(PyObject *self, PyObject *Py_UNUSED(ignored))
254 {
255 return int_as_integer_ratio_impl(self);
256 }
257
258 PyDoc_STRVAR(int_to_bytes__doc__,
259 "to_bytes($self, /, length=1, byteorder=\'big\', *, signed=False)\n"
260 "--\n"
261 "\n"
262 "Return an array of bytes representing an integer.\n"
263 "\n"
264 " length\n"
265 " Length of bytes object to use. An OverflowError is raised if\n"
266 " the integer is not representable with the given number of bytes.\n"
267 " Default is length 1.\n"
268 " byteorder\n"
269 " The byte order used to represent the integer. If byteorder is\n"
270 " \'big\', the most significant byte is at the beginning of the byte\n"
271 " array. If byteorder is \'little\', the most significant byte is at\n"
272 " the end of the byte array. To request the native byte order of\n"
273 " the host system, use sys.byteorder as the byte order value.\n"
274 " Default is to use \'big\'.\n"
275 " signed\n"
276 " Determines whether two\'s complement is used to represent the\n"
277 " integer. If signed is False and a negative integer is given,\n"
278 " an OverflowError is raised.");
279
280 #define INT_TO_BYTES_METHODDEF \
281 {"to_bytes", _PyCFunction_CAST(int_to_bytes), METH_FASTCALL|METH_KEYWORDS, int_to_bytes__doc__},
282
283 static PyObject *
284 int_to_bytes_impl(PyObject *self, Py_ssize_t length, PyObject *byteorder,
285 int is_signed);
286
287 static PyObject *
288 int_to_bytes(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
289 {
290 PyObject *return_value = NULL;
291 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
292
293 #define NUM_KEYWORDS 3
294 static struct {
295 PyGC_Head _this_is_not_used;
296 PyObject_VAR_HEAD
297 Py_hash_t ob_hash;
298 PyObject *ob_item[NUM_KEYWORDS];
299 } _kwtuple = {
300 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
301 .ob_hash = -1,
302 .ob_item = { &_Py_ID(length), &_Py_ID(byteorder), &_Py_ID(signed), },
303 };
304 #undef NUM_KEYWORDS
305 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
306
307 #else // !Py_BUILD_CORE
308 # define KWTUPLE NULL
309 #endif // !Py_BUILD_CORE
310
311 static const char * const _keywords[] = {"length", "byteorder", "signed", NULL};
312 static _PyArg_Parser _parser = {
313 .keywords = _keywords,
314 .fname = "to_bytes",
315 .kwtuple = KWTUPLE,
316 };
317 #undef KWTUPLE
318 PyObject *argsbuf[3];
319 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
320 Py_ssize_t length = 1;
321 PyObject *byteorder = NULL;
322 int is_signed = 0;
323
324 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
325 /*minpos*/ 0, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
326 if (!args) {
327 goto exit;
328 }
329 if (!noptargs) {
330 goto skip_optional_pos;
331 }
332 if (args[0]) {
333 {
334 Py_ssize_t ival = -1;
335 PyObject *iobj = _PyNumber_Index(args[0]);
336 if (iobj != NULL) {
337 ival = PyLong_AsSsize_t(iobj);
338 Py_DECREF(iobj);
339 }
340 if (ival == -1 && PyErr_Occurred()) {
341 goto exit;
342 }
343 length = ival;
344 }
345 if (!--noptargs) {
346 goto skip_optional_pos;
347 }
348 }
349 if (args[1]) {
350 if (!PyUnicode_Check(args[1])) {
351 _PyArg_BadArgument("to_bytes", "argument 'byteorder'", "str", args[1]);
352 goto exit;
353 }
354 byteorder = args[1];
355 if (!--noptargs) {
356 goto skip_optional_pos;
357 }
358 }
359 skip_optional_pos:
360 if (!noptargs) {
361 goto skip_optional_kwonly;
362 }
363 is_signed = PyObject_IsTrue(args[2]);
364 if (is_signed < 0) {
365 goto exit;
366 }
367 skip_optional_kwonly:
368 return_value = int_to_bytes_impl(self, length, byteorder, is_signed);
369
370 exit:
371 return return_value;
372 }
373
374 PyDoc_STRVAR(int_from_bytes__doc__,
375 "from_bytes($type, /, bytes, byteorder=\'big\', *, signed=False)\n"
376 "--\n"
377 "\n"
378 "Return the integer represented by the given array of bytes.\n"
379 "\n"
380 " bytes\n"
381 " Holds the array of bytes to convert. The argument must either\n"
382 " support the buffer protocol or be an iterable object producing\n"
383 " bytes. Bytes and bytearray are examples of built-in objects that\n"
384 " support the buffer protocol.\n"
385 " byteorder\n"
386 " The byte order used to represent the integer. If byteorder is\n"
387 " \'big\', the most significant byte is at the beginning of the byte\n"
388 " array. If byteorder is \'little\', the most significant byte is at\n"
389 " the end of the byte array. To request the native byte order of\n"
390 " the host system, use sys.byteorder as the byte order value.\n"
391 " Default is to use \'big\'.\n"
392 " signed\n"
393 " Indicates whether two\'s complement is used to represent the\n"
394 " integer.");
395
396 #define INT_FROM_BYTES_METHODDEF \
397 {"from_bytes", _PyCFunction_CAST(int_from_bytes), METH_FASTCALL|METH_KEYWORDS|METH_CLASS, int_from_bytes__doc__},
398
399 static PyObject *
400 int_from_bytes_impl(PyTypeObject *type, PyObject *bytes_obj,
401 PyObject *byteorder, int is_signed);
402
403 static PyObject *
404 int_from_bytes(PyObject *type, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
405 {
406 PyObject *return_value = NULL;
407 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
408
409 #define NUM_KEYWORDS 3
410 static struct {
411 PyGC_Head _this_is_not_used;
412 PyObject_VAR_HEAD
413 Py_hash_t ob_hash;
414 PyObject *ob_item[NUM_KEYWORDS];
415 } _kwtuple = {
416 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
417 .ob_hash = -1,
418 .ob_item = { &_Py_ID(bytes), &_Py_ID(byteorder), &_Py_ID(signed), },
419 };
420 #undef NUM_KEYWORDS
421 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
422
423 #else // !Py_BUILD_CORE
424 # define KWTUPLE NULL
425 #endif // !Py_BUILD_CORE
426
427 static const char * const _keywords[] = {"bytes", "byteorder", "signed", NULL};
428 static _PyArg_Parser _parser = {
429 .keywords = _keywords,
430 .fname = "from_bytes",
431 .kwtuple = KWTUPLE,
432 };
433 #undef KWTUPLE
434 PyObject *argsbuf[3];
435 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
436 PyObject *bytes_obj;
437 PyObject *byteorder = NULL;
438 int is_signed = 0;
439
440 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
441 /*minpos*/ 1, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
442 if (!args) {
443 goto exit;
444 }
445 bytes_obj = args[0];
446 if (!noptargs) {
447 goto skip_optional_pos;
448 }
449 if (args[1]) {
450 if (!PyUnicode_Check(args[1])) {
451 _PyArg_BadArgument("from_bytes", "argument 'byteorder'", "str", args[1]);
452 goto exit;
453 }
454 byteorder = args[1];
455 if (!--noptargs) {
456 goto skip_optional_pos;
457 }
458 }
459 skip_optional_pos:
460 if (!noptargs) {
461 goto skip_optional_kwonly;
462 }
463 is_signed = PyObject_IsTrue(args[2]);
464 if (is_signed < 0) {
465 goto exit;
466 }
467 skip_optional_kwonly:
468 return_value = int_from_bytes_impl((PyTypeObject *)type, bytes_obj, byteorder, is_signed);
469
470 exit:
471 return return_value;
472 }
473
474 PyDoc_STRVAR(int_is_integer__doc__,
475 "is_integer($self, /)\n"
476 "--\n"
477 "\n"
478 "Returns True. Exists for duck type compatibility with float.is_integer.");
479
480 #define INT_IS_INTEGER_METHODDEF \
481 {"is_integer", (PyCFunction)int_is_integer, METH_NOARGS, int_is_integer__doc__},
482
483 static PyObject *
484 int_is_integer_impl(PyObject *self);
485
486 static PyObject *
487 int_is_integer(PyObject *self, PyObject *Py_UNUSED(ignored))
488 {
489 return int_is_integer_impl(self);
490 }
491 /*[clinic end generated code: output=93d4c37f650e1a65 input=a9049054013a1b77]*/