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 the\n"
266 " integer is not representable with the given number of bytes. Default\n"
267 " is length 1.\n"
268 " byteorder\n"
269 " The byte order used to represent the integer. If byteorder is \'big\',\n"
270 " the most significant byte is at the beginning of the byte array. If\n"
271 " byteorder is \'little\', the most significant byte is at the end of the\n"
272 " byte array. To request the native byte order of the host system, use\n"
273 " sys.byteorder as the byte order value. Default is to use \'big\'.\n"
274 " signed\n"
275 " Determines whether two\'s complement is used to represent the integer.\n"
276 " If signed is False and a negative integer is given, an OverflowError\n"
277 " is raised.");
278
279 #define INT_TO_BYTES_METHODDEF \
280 {"to_bytes", _PyCFunction_CAST(int_to_bytes), METH_FASTCALL|METH_KEYWORDS, int_to_bytes__doc__},
281
282 static PyObject *
283 int_to_bytes_impl(PyObject *self, Py_ssize_t length, PyObject *byteorder,
284 int is_signed);
285
286 static PyObject *
287 int_to_bytes(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
288 {
289 PyObject *return_value = NULL;
290 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
291
292 #define NUM_KEYWORDS 3
293 static struct {
294 PyGC_Head _this_is_not_used;
295 PyObject_VAR_HEAD
296 Py_hash_t ob_hash;
297 PyObject *ob_item[NUM_KEYWORDS];
298 } _kwtuple = {
299 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
300 .ob_hash = -1,
301 .ob_item = { &_Py_ID(length), &_Py_ID(byteorder), &_Py_ID(signed), },
302 };
303 #undef NUM_KEYWORDS
304 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
305
306 #else // !Py_BUILD_CORE
307 # define KWTUPLE NULL
308 #endif // !Py_BUILD_CORE
309
310 static const char * const _keywords[] = {"length", "byteorder", "signed", NULL};
311 static _PyArg_Parser _parser = {
312 .keywords = _keywords,
313 .fname = "to_bytes",
314 .kwtuple = KWTUPLE,
315 };
316 #undef KWTUPLE
317 PyObject *argsbuf[3];
318 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
319 Py_ssize_t length = 1;
320 PyObject *byteorder = NULL;
321 int is_signed = 0;
322
323 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
324 /*minpos*/ 0, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
325 if (!args) {
326 goto exit;
327 }
328 if (!noptargs) {
329 goto skip_optional_pos;
330 }
331 if (args[0]) {
332 {
333 Py_ssize_t ival = -1;
334 PyObject *iobj = _PyNumber_Index(args[0]);
335 if (iobj != NULL) {
336 ival = PyLong_AsSsize_t(iobj);
337 Py_DECREF(iobj);
338 }
339 if (ival == -1 && PyErr_Occurred()) {
340 goto exit;
341 }
342 length = ival;
343 }
344 if (!--noptargs) {
345 goto skip_optional_pos;
346 }
347 }
348 if (args[1]) {
349 if (!PyUnicode_Check(args[1])) {
350 _PyArg_BadArgument("to_bytes", "argument 'byteorder'", "str", args[1]);
351 goto exit;
352 }
353 byteorder = args[1];
354 if (!--noptargs) {
355 goto skip_optional_pos;
356 }
357 }
358 skip_optional_pos:
359 if (!noptargs) {
360 goto skip_optional_kwonly;
361 }
362 is_signed = PyObject_IsTrue(args[2]);
363 if (is_signed < 0) {
364 goto exit;
365 }
366 skip_optional_kwonly:
367 return_value = int_to_bytes_impl(self, length, byteorder, is_signed);
368
369 exit:
370 return return_value;
371 }
372
373 PyDoc_STRVAR(int_from_bytes__doc__,
374 "from_bytes($type, /, bytes, byteorder=\'big\', *, signed=False)\n"
375 "--\n"
376 "\n"
377 "Return the integer represented by the given array of bytes.\n"
378 "\n"
379 " bytes\n"
380 " Holds the array of bytes to convert. The argument must either\n"
381 " support the buffer protocol or be an iterable object producing bytes.\n"
382 " Bytes and bytearray are examples of built-in objects that support the\n"
383 " buffer protocol.\n"
384 " byteorder\n"
385 " The byte order used to represent the integer. If byteorder is \'big\',\n"
386 " the most significant byte is at the beginning of the byte array. If\n"
387 " byteorder is \'little\', the most significant byte is at the end of the\n"
388 " byte array. To request the native byte order of the host system, use\n"
389 " sys.byteorder as the byte order value. Default is to use \'big\'.\n"
390 " signed\n"
391 " Indicates whether two\'s complement is used to represent the integer.");
392
393 #define INT_FROM_BYTES_METHODDEF \
394 {"from_bytes", _PyCFunction_CAST(int_from_bytes), METH_FASTCALL|METH_KEYWORDS|METH_CLASS, int_from_bytes__doc__},
395
396 static PyObject *
397 int_from_bytes_impl(PyTypeObject *type, PyObject *bytes_obj,
398 PyObject *byteorder, int is_signed);
399
400 static PyObject *
401 int_from_bytes(PyObject *type, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
402 {
403 PyObject *return_value = NULL;
404 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
405
406 #define NUM_KEYWORDS 3
407 static struct {
408 PyGC_Head _this_is_not_used;
409 PyObject_VAR_HEAD
410 Py_hash_t ob_hash;
411 PyObject *ob_item[NUM_KEYWORDS];
412 } _kwtuple = {
413 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
414 .ob_hash = -1,
415 .ob_item = { &_Py_ID(bytes), &_Py_ID(byteorder), &_Py_ID(signed), },
416 };
417 #undef NUM_KEYWORDS
418 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
419
420 #else // !Py_BUILD_CORE
421 # define KWTUPLE NULL
422 #endif // !Py_BUILD_CORE
423
424 static const char * const _keywords[] = {"bytes", "byteorder", "signed", NULL};
425 static _PyArg_Parser _parser = {
426 .keywords = _keywords,
427 .fname = "from_bytes",
428 .kwtuple = KWTUPLE,
429 };
430 #undef KWTUPLE
431 PyObject *argsbuf[3];
432 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
433 PyObject *bytes_obj;
434 PyObject *byteorder = NULL;
435 int is_signed = 0;
436
437 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
438 /*minpos*/ 1, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
439 if (!args) {
440 goto exit;
441 }
442 bytes_obj = args[0];
443 if (!noptargs) {
444 goto skip_optional_pos;
445 }
446 if (args[1]) {
447 if (!PyUnicode_Check(args[1])) {
448 _PyArg_BadArgument("from_bytes", "argument 'byteorder'", "str", args[1]);
449 goto exit;
450 }
451 byteorder = args[1];
452 if (!--noptargs) {
453 goto skip_optional_pos;
454 }
455 }
456 skip_optional_pos:
457 if (!noptargs) {
458 goto skip_optional_kwonly;
459 }
460 is_signed = PyObject_IsTrue(args[2]);
461 if (is_signed < 0) {
462 goto exit;
463 }
464 skip_optional_kwonly:
465 return_value = int_from_bytes_impl((PyTypeObject *)type, bytes_obj, byteorder, is_signed);
466
467 exit:
468 return return_value;
469 }
470
471 PyDoc_STRVAR(int_is_integer__doc__,
472 "is_integer($self, /)\n"
473 "--\n"
474 "\n"
475 "Returns True. Exists for duck type compatibility with float.is_integer.");
476
477 #define INT_IS_INTEGER_METHODDEF \
478 {"is_integer", (PyCFunction)int_is_integer, METH_NOARGS, int_is_integer__doc__},
479
480 static PyObject *
481 int_is_integer_impl(PyObject *self);
482
483 static PyObject *
484 int_is_integer(PyObject *self, PyObject *Py_UNUSED(ignored))
485 {
486 return int_is_integer_impl(self);
487 }
488 /*[clinic end generated code: output=d23f8ce5bdf08a30 input=a9049054013a1b77]*/