Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : static PyObject *
6 : : long_new_impl(PyTypeObject *type, PyObject *x, PyObject *obase);
7 : :
8 : : static PyObject *
9 : 4295628 : long_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10 : : {
11 : 4295628 : PyObject *return_value = NULL;
12 : : static const char * const _keywords[] = {"", "base", NULL};
13 : : static _PyArg_Parser _parser = {NULL, _keywords, "int", 0};
14 : : PyObject *argsbuf[2];
15 : : PyObject * const *fastargs;
16 : 4295628 : Py_ssize_t nargs = PyTuple_GET_SIZE(args);
17 [ + + ]: 4295628 : Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
18 : 4295628 : PyObject *x = NULL;
19 : 4295628 : PyObject *obase = NULL;
20 : :
21 [ + + + - : 4295628 : fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 2, 0, argsbuf);
+ - + - ]
22 [ + + ]: 4295628 : if (!fastargs) {
23 : 5 : goto exit;
24 : : }
25 [ + + ]: 4295623 : if (nargs < 1) {
26 : 23257 : goto skip_optional_posonly;
27 : : }
28 : 4272366 : noptargs--;
29 : 4272366 : x = fastargs[0];
30 : 4295623 : skip_optional_posonly:
31 [ + + ]: 4295623 : if (!noptargs) {
32 : 3362634 : goto skip_optional_pos;
33 : : }
34 : 932989 : obase = fastargs[1];
35 : 4295623 : skip_optional_pos:
36 : 4295623 : return_value = long_new_impl(type, x, obase);
37 : :
38 : 4295628 : exit:
39 : 4295628 : return return_value;
40 : : }
41 : :
42 : : PyDoc_STRVAR(int___getnewargs____doc__,
43 : : "__getnewargs__($self, /)\n"
44 : : "--\n"
45 : : "\n");
46 : :
47 : : #define INT___GETNEWARGS___METHODDEF \
48 : : {"__getnewargs__", (PyCFunction)int___getnewargs__, METH_NOARGS, int___getnewargs____doc__},
49 : :
50 : : static PyObject *
51 : : int___getnewargs___impl(PyObject *self);
52 : :
53 : : static PyObject *
54 : 102 : int___getnewargs__(PyObject *self, PyObject *Py_UNUSED(ignored))
55 : : {
56 : 102 : return int___getnewargs___impl(self);
57 : : }
58 : :
59 : : PyDoc_STRVAR(int___format____doc__,
60 : : "__format__($self, format_spec, /)\n"
61 : : "--\n"
62 : : "\n");
63 : :
64 : : #define INT___FORMAT___METHODDEF \
65 : : {"__format__", (PyCFunction)int___format__, METH_O, int___format____doc__},
66 : :
67 : : static PyObject *
68 : : int___format___impl(PyObject *self, PyObject *format_spec);
69 : :
70 : : static PyObject *
71 : 3643241 : int___format__(PyObject *self, PyObject *arg)
72 : : {
73 : 3643241 : PyObject *return_value = NULL;
74 : : PyObject *format_spec;
75 : :
76 [ + + ]: 3643241 : if (!PyUnicode_Check(arg)) {
77 : 2 : _PyArg_BadArgument("__format__", "argument", "str", arg);
78 : 2 : goto exit;
79 : : }
80 [ - + ]: 3643239 : if (PyUnicode_READY(arg) == -1) {
81 : 0 : goto exit;
82 : : }
83 : 3643239 : format_spec = arg;
84 : 3643239 : return_value = int___format___impl(self, format_spec);
85 : :
86 : 3643241 : exit:
87 : 3643241 : return return_value;
88 : : }
89 : :
90 : : PyDoc_STRVAR(int___round____doc__,
91 : : "__round__($self, ndigits=<unrepresentable>, /)\n"
92 : : "--\n"
93 : : "\n"
94 : : "Rounding an Integral returns itself.\n"
95 : : "\n"
96 : : "Rounding with an ndigits argument also returns an integer.");
97 : :
98 : : #define INT___ROUND___METHODDEF \
99 : : {"__round__", _PyCFunction_CAST(int___round__), METH_FASTCALL, int___round____doc__},
100 : :
101 : : static PyObject *
102 : : int___round___impl(PyObject *self, PyObject *o_ndigits);
103 : :
104 : : static PyObject *
105 : 1855 : int___round__(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
106 : : {
107 : 1855 : PyObject *return_value = NULL;
108 : 1855 : PyObject *o_ndigits = NULL;
109 : :
110 [ + - - + : 1855 : if (!_PyArg_CheckPositional("__round__", nargs, 0, 1)) {
- - ]
111 : 0 : goto exit;
112 : : }
113 [ + + ]: 1855 : if (nargs < 1) {
114 : 168 : goto skip_optional;
115 : : }
116 : 1687 : o_ndigits = args[0];
117 : 1855 : skip_optional:
118 : 1855 : return_value = int___round___impl(self, o_ndigits);
119 : :
120 : 1855 : exit:
121 : 1855 : return return_value;
122 : : }
123 : :
124 : : PyDoc_STRVAR(int___sizeof____doc__,
125 : : "__sizeof__($self, /)\n"
126 : : "--\n"
127 : : "\n"
128 : : "Returns size in memory, in bytes.");
129 : :
130 : : #define INT___SIZEOF___METHODDEF \
131 : : {"__sizeof__", (PyCFunction)int___sizeof__, METH_NOARGS, int___sizeof____doc__},
132 : :
133 : : static Py_ssize_t
134 : : int___sizeof___impl(PyObject *self);
135 : :
136 : : static PyObject *
137 : 12 : int___sizeof__(PyObject *self, PyObject *Py_UNUSED(ignored))
138 : : {
139 : 12 : PyObject *return_value = NULL;
140 : : Py_ssize_t _return_value;
141 : :
142 : 12 : _return_value = int___sizeof___impl(self);
143 [ - + - - ]: 12 : if ((_return_value == -1) && PyErr_Occurred()) {
144 : 0 : goto exit;
145 : : }
146 : 12 : return_value = PyLong_FromSsize_t(_return_value);
147 : :
148 : 12 : exit:
149 : 12 : return return_value;
150 : : }
151 : :
152 : : PyDoc_STRVAR(int_bit_length__doc__,
153 : : "bit_length($self, /)\n"
154 : : "--\n"
155 : : "\n"
156 : : "Number of bits necessary to represent self in binary.\n"
157 : : "\n"
158 : : ">>> bin(37)\n"
159 : : "\'0b100101\'\n"
160 : : ">>> (37).bit_length()\n"
161 : : "6");
162 : :
163 : : #define INT_BIT_LENGTH_METHODDEF \
164 : : {"bit_length", (PyCFunction)int_bit_length, METH_NOARGS, int_bit_length__doc__},
165 : :
166 : : static PyObject *
167 : : int_bit_length_impl(PyObject *self);
168 : :
169 : : static PyObject *
170 : 5015491 : int_bit_length(PyObject *self, PyObject *Py_UNUSED(ignored))
171 : : {
172 : 5015491 : return int_bit_length_impl(self);
173 : : }
174 : :
175 : : PyDoc_STRVAR(int_bit_count__doc__,
176 : : "bit_count($self, /)\n"
177 : : "--\n"
178 : : "\n"
179 : : "Number of ones in the binary representation of the absolute value of self.\n"
180 : : "\n"
181 : : "Also known as the population count.\n"
182 : : "\n"
183 : : ">>> bin(13)\n"
184 : : "\'0b1101\'\n"
185 : : ">>> (13).bit_count()\n"
186 : : "3");
187 : :
188 : : #define INT_BIT_COUNT_METHODDEF \
189 : : {"bit_count", (PyCFunction)int_bit_count, METH_NOARGS, int_bit_count__doc__},
190 : :
191 : : static PyObject *
192 : : int_bit_count_impl(PyObject *self);
193 : :
194 : : static PyObject *
195 : 2052 : int_bit_count(PyObject *self, PyObject *Py_UNUSED(ignored))
196 : : {
197 : 2052 : return int_bit_count_impl(self);
198 : : }
199 : :
200 : : PyDoc_STRVAR(int_as_integer_ratio__doc__,
201 : : "as_integer_ratio($self, /)\n"
202 : : "--\n"
203 : : "\n"
204 : : "Return integer ratio.\n"
205 : : "\n"
206 : : "Return a pair of integers, whose ratio is exactly equal to the original int\n"
207 : : "and with a positive denominator.\n"
208 : : "\n"
209 : : ">>> (10).as_integer_ratio()\n"
210 : : "(10, 1)\n"
211 : : ">>> (-10).as_integer_ratio()\n"
212 : : "(-10, 1)\n"
213 : : ">>> (0).as_integer_ratio()\n"
214 : : "(0, 1)");
215 : :
216 : : #define INT_AS_INTEGER_RATIO_METHODDEF \
217 : : {"as_integer_ratio", (PyCFunction)int_as_integer_ratio, METH_NOARGS, int_as_integer_ratio__doc__},
218 : :
219 : : static PyObject *
220 : : int_as_integer_ratio_impl(PyObject *self);
221 : :
222 : : static PyObject *
223 : 79995 : int_as_integer_ratio(PyObject *self, PyObject *Py_UNUSED(ignored))
224 : : {
225 : 79995 : return int_as_integer_ratio_impl(self);
226 : : }
227 : :
228 : : PyDoc_STRVAR(int_to_bytes__doc__,
229 : : "to_bytes($self, /, length=1, byteorder=\'big\', *, signed=False)\n"
230 : : "--\n"
231 : : "\n"
232 : : "Return an array of bytes representing an integer.\n"
233 : : "\n"
234 : : " length\n"
235 : : " Length of bytes object to use. An OverflowError is raised if the\n"
236 : : " integer is not representable with the given number of bytes. Default\n"
237 : : " is length 1.\n"
238 : : " byteorder\n"
239 : : " The byte order used to represent the integer. If byteorder is \'big\',\n"
240 : : " the most significant byte is at the beginning of the byte array. If\n"
241 : : " byteorder is \'little\', the most significant byte is at the end of the\n"
242 : : " byte array. To request the native byte order of the host system, use\n"
243 : : " `sys.byteorder\' as the byte order value. Default is to use \'big\'.\n"
244 : : " signed\n"
245 : : " Determines whether two\'s complement is used to represent the integer.\n"
246 : : " If signed is False and a negative integer is given, an OverflowError\n"
247 : : " is raised.");
248 : :
249 : : #define INT_TO_BYTES_METHODDEF \
250 : : {"to_bytes", _PyCFunction_CAST(int_to_bytes), METH_FASTCALL|METH_KEYWORDS, int_to_bytes__doc__},
251 : :
252 : : static PyObject *
253 : : int_to_bytes_impl(PyObject *self, Py_ssize_t length, PyObject *byteorder,
254 : : int is_signed);
255 : :
256 : : static PyObject *
257 : 230574 : int_to_bytes(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
258 : : {
259 : 230574 : PyObject *return_value = NULL;
260 : : static const char * const _keywords[] = {"length", "byteorder", "signed", NULL};
261 : : static _PyArg_Parser _parser = {NULL, _keywords, "to_bytes", 0};
262 : : PyObject *argsbuf[3];
263 [ + + ]: 230574 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
264 : 230574 : Py_ssize_t length = 1;
265 : 230574 : PyObject *byteorder = NULL;
266 : 230574 : int is_signed = 0;
267 : :
268 [ + + + - : 230574 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
+ - - + ]
269 [ - + ]: 230574 : if (!args) {
270 : 0 : goto exit;
271 : : }
272 [ + + ]: 230574 : if (!noptargs) {
273 : 5 : goto skip_optional_pos;
274 : : }
275 [ + - ]: 230569 : if (args[0]) {
276 : : {
277 : 230569 : Py_ssize_t ival = -1;
278 : 230569 : PyObject *iobj = _PyNumber_Index(args[0]);
279 [ + - ]: 230569 : if (iobj != NULL) {
280 : 230569 : ival = PyLong_AsSsize_t(iobj);
281 : 230569 : Py_DECREF(iobj);
282 : : }
283 [ - + - - ]: 230569 : if (ival == -1 && PyErr_Occurred()) {
284 : 0 : goto exit;
285 : : }
286 : 230569 : length = ival;
287 : : }
288 [ + + ]: 230569 : if (!--noptargs) {
289 : 700 : goto skip_optional_pos;
290 : : }
291 : : }
292 [ + + ]: 229869 : if (args[1]) {
293 [ - + ]: 229607 : if (!PyUnicode_Check(args[1])) {
294 : 0 : _PyArg_BadArgument("to_bytes", "argument 'byteorder'", "str", args[1]);
295 : 0 : goto exit;
296 : : }
297 [ - + ]: 229607 : if (PyUnicode_READY(args[1]) == -1) {
298 : 0 : goto exit;
299 : : }
300 : 229607 : byteorder = args[1];
301 [ + + ]: 229607 : if (!--noptargs) {
302 : 226071 : goto skip_optional_pos;
303 : : }
304 : : }
305 : 3798 : skip_optional_pos:
306 [ + + ]: 230574 : if (!noptargs) {
307 : 226776 : goto skip_optional_kwonly;
308 : : }
309 : 3798 : is_signed = PyObject_IsTrue(args[2]);
310 [ - + ]: 3798 : if (is_signed < 0) {
311 : 0 : goto exit;
312 : : }
313 : 3798 : skip_optional_kwonly:
314 : 230574 : return_value = int_to_bytes_impl(self, length, byteorder, is_signed);
315 : :
316 : 230574 : exit:
317 : 230574 : return return_value;
318 : : }
319 : :
320 : : PyDoc_STRVAR(int_from_bytes__doc__,
321 : : "from_bytes($type, /, bytes, byteorder=\'big\', *, signed=False)\n"
322 : : "--\n"
323 : : "\n"
324 : : "Return the integer represented by the given array of bytes.\n"
325 : : "\n"
326 : : " bytes\n"
327 : : " Holds the array of bytes to convert. The argument must either\n"
328 : : " support the buffer protocol or be an iterable object producing bytes.\n"
329 : : " Bytes and bytearray are examples of built-in objects that support the\n"
330 : : " buffer protocol.\n"
331 : : " byteorder\n"
332 : : " The byte order used to represent the integer. If byteorder is \'big\',\n"
333 : : " the most significant byte is at the beginning of the byte array. If\n"
334 : : " byteorder is \'little\', the most significant byte is at the end of the\n"
335 : : " byte array. To request the native byte order of the host system, use\n"
336 : : " `sys.byteorder\' as the byte order value. Default is to use \'big\'.\n"
337 : : " signed\n"
338 : : " Indicates whether two\'s complement is used to represent the integer.");
339 : :
340 : : #define INT_FROM_BYTES_METHODDEF \
341 : : {"from_bytes", _PyCFunction_CAST(int_from_bytes), METH_FASTCALL|METH_KEYWORDS|METH_CLASS, int_from_bytes__doc__},
342 : :
343 : : static PyObject *
344 : : int_from_bytes_impl(PyTypeObject *type, PyObject *bytes_obj,
345 : : PyObject *byteorder, int is_signed);
346 : :
347 : : static PyObject *
348 : 705023 : int_from_bytes(PyTypeObject *type, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
349 : : {
350 : 705023 : PyObject *return_value = NULL;
351 : : static const char * const _keywords[] = {"bytes", "byteorder", "signed", NULL};
352 : : static _PyArg_Parser _parser = {NULL, _keywords, "from_bytes", 0};
353 : : PyObject *argsbuf[3];
354 [ + + ]: 705023 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
355 : : PyObject *bytes_obj;
356 : 705023 : PyObject *byteorder = NULL;
357 : 705023 : int is_signed = 0;
358 : :
359 [ + + + - : 705023 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+ + - + ]
360 [ + + ]: 705023 : if (!args) {
361 : 3 : goto exit;
362 : : }
363 : 705020 : bytes_obj = args[0];
364 [ + + ]: 705020 : if (!noptargs) {
365 : 165581 : goto skip_optional_pos;
366 : : }
367 [ + + ]: 539439 : if (args[1]) {
368 [ - + ]: 539177 : if (!PyUnicode_Check(args[1])) {
369 : 0 : _PyArg_BadArgument("from_bytes", "argument 'byteorder'", "str", args[1]);
370 : 0 : goto exit;
371 : : }
372 [ - + ]: 539177 : if (PyUnicode_READY(args[1]) == -1) {
373 : 0 : goto exit;
374 : : }
375 : 539177 : byteorder = args[1];
376 [ + + ]: 539177 : if (!--noptargs) {
377 : 536708 : goto skip_optional_pos;
378 : : }
379 : : }
380 : 2731 : skip_optional_pos:
381 [ + + ]: 705020 : if (!noptargs) {
382 : 702289 : goto skip_optional_kwonly;
383 : : }
384 : 2731 : is_signed = PyObject_IsTrue(args[2]);
385 [ - + ]: 2731 : if (is_signed < 0) {
386 : 0 : goto exit;
387 : : }
388 : 2731 : skip_optional_kwonly:
389 : 705020 : return_value = int_from_bytes_impl(type, bytes_obj, byteorder, is_signed);
390 : :
391 : 705023 : exit:
392 : 705023 : return return_value;
393 : : }
394 : : /*[clinic end generated code: output=899e57c41861a8e9 input=a9049054013a1b77]*/
|
