blob: 28f760671078ee6699f3ee51e55f4a376cefdc26 [file] [log] [blame]
Guido van Rossumf70e43a1991-02-19 12:39:46 +00001
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002/* Integer object implementation */
3
Guido van Rossumc0b618a1997-05-02 03:12:38 +00004#include "Python.h"
Barry Warsaw226ae6c1999-10-12 19:54:53 +00005#include <ctype.h>
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00006
Guido van Rossum2e1d4331993-12-24 10:22:45 +00007long
Fred Drakea2f55112000-07-09 15:16:51 +00008PyInt_GetMax(void)
Guido van Rossum2e1d4331993-12-24 10:22:45 +00009{
10 return LONG_MAX; /* To initialize sys.maxint */
11}
12
Guido van Rossum3f5da241990-12-20 15:06:42 +000013/* Integers are quite normal objects, to make object handling uniform.
14 (Using odd pointers to represent integers would save much space
15 but require extra checks for this special case throughout the code.)
Tim Peters29c0afc2002-04-28 16:57:34 +000016 Since a typical Python program spends much of its time allocating
Guido van Rossum3f5da241990-12-20 15:06:42 +000017 and deallocating integers, these operations should be very fast.
18 Therefore we use a dedicated allocation scheme with a much lower
19 overhead (in space and time) than straight malloc(): a simple
20 dedicated free list, filled when necessary with memory from malloc().
Tim Peters29c0afc2002-04-28 16:57:34 +000021
22 block_list is a singly-linked list of all PyIntBlocks ever allocated,
23 linked via their next members. PyIntBlocks are never returned to the
24 system before shutdown (PyInt_Fini).
25
26 free_list is a singly-linked list of available PyIntObjects, linked
27 via abuse of their ob_type members.
Guido van Rossum3f5da241990-12-20 15:06:42 +000028*/
29
30#define BLOCK_SIZE 1000 /* 1K less typical malloc overhead */
Guido van Rossum3fce8831999-03-12 19:43:17 +000031#define BHEAD_SIZE 8 /* Enough for a 64-bit pointer */
32#define N_INTOBJECTS ((BLOCK_SIZE - BHEAD_SIZE) / sizeof(PyIntObject))
Guido van Rossumda084ed1999-03-10 22:55:24 +000033
Guido van Rossum3fce8831999-03-12 19:43:17 +000034struct _intblock {
35 struct _intblock *next;
36 PyIntObject objects[N_INTOBJECTS];
37};
38
39typedef struct _intblock PyIntBlock;
40
41static PyIntBlock *block_list = NULL;
42static PyIntObject *free_list = NULL;
Guido van Rossum3f5da241990-12-20 15:06:42 +000043
Guido van Rossumc0b618a1997-05-02 03:12:38 +000044static PyIntObject *
Fred Drakea2f55112000-07-09 15:16:51 +000045fill_free_list(void)
Guido van Rossum3f5da241990-12-20 15:06:42 +000046{
Guido van Rossumc0b618a1997-05-02 03:12:38 +000047 PyIntObject *p, *q;
Tim Peters29c0afc2002-04-28 16:57:34 +000048 /* Python's object allocator isn't appropriate for large blocks. */
Guido van Rossumb18618d2000-05-03 23:44:39 +000049 p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
Guido van Rossum3f5da241990-12-20 15:06:42 +000050 if (p == NULL)
Guido van Rossumb18618d2000-05-03 23:44:39 +000051 return (PyIntObject *) PyErr_NoMemory();
Guido van Rossum3fce8831999-03-12 19:43:17 +000052 ((PyIntBlock *)p)->next = block_list;
53 block_list = (PyIntBlock *)p;
Tim Peters29c0afc2002-04-28 16:57:34 +000054 /* Link the int objects together, from rear to front, then return
55 the address of the last int object in the block. */
Guido van Rossum3fce8831999-03-12 19:43:17 +000056 p = &((PyIntBlock *)p)->objects[0];
Guido van Rossum3f5da241990-12-20 15:06:42 +000057 q = p + N_INTOBJECTS;
58 while (--q > p)
Guido van Rossumda084ed1999-03-10 22:55:24 +000059 q->ob_type = (struct _typeobject *)(q-1);
60 q->ob_type = NULL;
Guido van Rossum3f5da241990-12-20 15:06:42 +000061 return p + N_INTOBJECTS - 1;
62}
63
Sjoerd Mullender842d2cc1993-10-15 16:18:48 +000064#ifndef NSMALLPOSINTS
Georg Brandl418a1ef2006-02-22 11:30:06 +000065#define NSMALLPOSINTS 257
Sjoerd Mullender842d2cc1993-10-15 16:18:48 +000066#endif
67#ifndef NSMALLNEGINTS
Neal Norwitzc91ed402002-12-30 22:29:22 +000068#define NSMALLNEGINTS 5
Sjoerd Mullender842d2cc1993-10-15 16:18:48 +000069#endif
70#if NSMALLNEGINTS + NSMALLPOSINTS > 0
71/* References to small integers are saved in this array so that they
72 can be shared.
73 The integers that are saved are those in the range
74 -NSMALLNEGINTS (inclusive) to NSMALLPOSINTS (not inclusive).
75*/
Guido van Rossumc0b618a1997-05-02 03:12:38 +000076static PyIntObject *small_ints[NSMALLNEGINTS + NSMALLPOSINTS];
Sjoerd Mullender842d2cc1993-10-15 16:18:48 +000077#endif
78#ifdef COUNT_ALLOCS
79int quick_int_allocs, quick_neg_int_allocs;
80#endif
Guido van Rossum3f5da241990-12-20 15:06:42 +000081
Guido van Rossumc0b618a1997-05-02 03:12:38 +000082PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +000083PyInt_FromLong(long ival)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000084{
Guido van Rossumc0b618a1997-05-02 03:12:38 +000085 register PyIntObject *v;
Sjoerd Mullender842d2cc1993-10-15 16:18:48 +000086#if NSMALLNEGINTS + NSMALLPOSINTS > 0
Neal Norwitzc91ed402002-12-30 22:29:22 +000087 if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) {
88 v = small_ints[ival + NSMALLNEGINTS];
Guido van Rossumc0b618a1997-05-02 03:12:38 +000089 Py_INCREF(v);
Sjoerd Mullender842d2cc1993-10-15 16:18:48 +000090#ifdef COUNT_ALLOCS
91 if (ival >= 0)
92 quick_int_allocs++;
93 else
94 quick_neg_int_allocs++;
95#endif
Guido van Rossumc0b618a1997-05-02 03:12:38 +000096 return (PyObject *) v;
Sjoerd Mullender842d2cc1993-10-15 16:18:48 +000097 }
98#endif
Guido van Rossum3f5da241990-12-20 15:06:42 +000099 if (free_list == NULL) {
100 if ((free_list = fill_free_list()) == NULL)
101 return NULL;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000102 }
Guido van Rossume3a8e7e2002-08-19 19:26:42 +0000103 /* Inline PyObject_New */
Guido van Rossum3f5da241990-12-20 15:06:42 +0000104 v = free_list;
Guido van Rossumda084ed1999-03-10 22:55:24 +0000105 free_list = (PyIntObject *)v->ob_type;
Guido van Rossumb18618d2000-05-03 23:44:39 +0000106 PyObject_INIT(v, &PyInt_Type);
Guido van Rossum3f5da241990-12-20 15:06:42 +0000107 v->ob_ival = ival;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000108 return (PyObject *) v;
Guido van Rossum3f5da241990-12-20 15:06:42 +0000109}
110
Martin v. Löwis18e16552006-02-15 17:27:45 +0000111PyObject *
112PyInt_FromSize_t(size_t ival)
113{
114 if (ival <= LONG_MAX)
115 return PyInt_FromLong((long)ival);
116 return _PyLong_FromSize_t(ival);
117}
118
119PyObject *
120PyInt_FromSsize_t(Py_ssize_t ival)
121{
122 if (ival >= LONG_MIN && ival <= LONG_MAX)
123 return PyInt_FromLong((long)ival);
124 return _PyLong_FromSsize_t(ival);
125}
126
Guido van Rossum3f5da241990-12-20 15:06:42 +0000127static void
Fred Drakea2f55112000-07-09 15:16:51 +0000128int_dealloc(PyIntObject *v)
Guido van Rossum3f5da241990-12-20 15:06:42 +0000129{
Guido van Rossumdea6ef92001-09-11 16:13:52 +0000130 if (PyInt_CheckExact(v)) {
Guido van Rossumbef14172001-08-29 15:47:46 +0000131 v->ob_type = (struct _typeobject *)free_list;
132 free_list = v;
133 }
134 else
135 v->ob_type->tp_free((PyObject *)v);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000136}
137
Guido van Rossum93646982002-04-26 00:53:34 +0000138static void
139int_free(PyIntObject *v)
140{
141 v->ob_type = (struct _typeobject *)free_list;
142 free_list = v;
143}
144
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000145long
Fred Drakea2f55112000-07-09 15:16:51 +0000146PyInt_AsLong(register PyObject *op)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000147{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000148 PyNumberMethods *nb;
149 PyIntObject *io;
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000150 long val;
Tim Petersa3c01ce2001-12-04 23:05:10 +0000151
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000152 if (op && PyInt_Check(op))
153 return PyInt_AS_LONG((PyIntObject*) op);
Tim Petersa3c01ce2001-12-04 23:05:10 +0000154
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000155 if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
156 nb->nb_int == NULL) {
Guido van Rossumc18a6f42000-05-09 14:27:48 +0000157 PyErr_SetString(PyExc_TypeError, "an integer is required");
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000158 return -1;
159 }
Tim Petersa3c01ce2001-12-04 23:05:10 +0000160
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000161 io = (PyIntObject*) (*nb->nb_int) (op);
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000162 if (io == NULL)
163 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000164 if (!PyInt_Check(io)) {
Walter Dörwaldf1715402002-11-19 20:49:15 +0000165 if (PyLong_Check(io)) {
166 /* got a long? => retry int conversion */
167 val = PyLong_AsLong((PyObject *)io);
Thomas Heller850566b2003-02-20 20:32:11 +0000168 Py_DECREF(io);
169 if ((val == -1) && PyErr_Occurred())
Walter Dörwaldf1715402002-11-19 20:49:15 +0000170 return -1;
Thomas Heller850566b2003-02-20 20:32:11 +0000171 return val;
Walter Dörwaldf1715402002-11-19 20:49:15 +0000172 }
173 else
174 {
Thomas Hellera4ea6032003-04-17 18:55:45 +0000175 Py_DECREF(io);
Walter Dörwaldf1715402002-11-19 20:49:15 +0000176 PyErr_SetString(PyExc_TypeError,
177 "nb_int should return int object");
178 return -1;
179 }
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000180 }
Tim Petersa3c01ce2001-12-04 23:05:10 +0000181
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000182 val = PyInt_AS_LONG(io);
183 Py_DECREF(io);
Tim Petersa3c01ce2001-12-04 23:05:10 +0000184
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000185 return val;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000186}
187
Martin v. Löwis18e16552006-02-15 17:27:45 +0000188Py_ssize_t
189PyInt_AsSsize_t(register PyObject *op)
190{
Thomas Woutersb1410fb2006-02-15 23:08:56 +0000191#if SIZEOF_SIZE_T != SIZEOF_LONG
Martin v. Löwis18e16552006-02-15 17:27:45 +0000192 PyNumberMethods *nb;
193 PyIntObject *io;
194 Py_ssize_t val;
Thomas Woutersb1410fb2006-02-15 23:08:56 +0000195#endif
Neal Norwitz8a87f5d2006-08-12 17:03:09 +0000196
197 if (op == NULL) {
198 PyErr_SetString(PyExc_TypeError, "an integer is required");
199 return -1;
200 }
201
202 if (PyInt_Check(op))
203 return PyInt_AS_LONG((PyIntObject*) op);
204 if (PyLong_Check(op))
Martin v. Löwis18e16552006-02-15 17:27:45 +0000205 return _PyLong_AsSsize_t(op);
Thomas Woutersb1410fb2006-02-15 23:08:56 +0000206#if SIZEOF_SIZE_T == SIZEOF_LONG
Martin v. Löwis18e16552006-02-15 17:27:45 +0000207 return PyInt_AsLong(op);
208#else
209
Neal Norwitz8a87f5d2006-08-12 17:03:09 +0000210 if ((nb = op->ob_type->tp_as_number) == NULL ||
Martin v. Löwis18e16552006-02-15 17:27:45 +0000211 (nb->nb_int == NULL && nb->nb_long == 0)) {
212 PyErr_SetString(PyExc_TypeError, "an integer is required");
213 return -1;
214 }
215
216 if (nb->nb_long != 0) {
217 io = (PyIntObject*) (*nb->nb_long) (op);
218 } else {
219 io = (PyIntObject*) (*nb->nb_int) (op);
220 }
221 if (io == NULL)
222 return -1;
223 if (!PyInt_Check(io)) {
224 if (PyLong_Check(io)) {
225 /* got a long? => retry int conversion */
226 val = _PyLong_AsSsize_t((PyObject *)io);
227 Py_DECREF(io);
228 if ((val == -1) && PyErr_Occurred())
229 return -1;
230 return val;
231 }
232 else
233 {
234 Py_DECREF(io);
235 PyErr_SetString(PyExc_TypeError,
236 "nb_int should return int object");
237 return -1;
238 }
239 }
240
241 val = PyInt_AS_LONG(io);
242 Py_DECREF(io);
243
244 return val;
245#endif
246}
247
Thomas Hellera4ea6032003-04-17 18:55:45 +0000248unsigned long
249PyInt_AsUnsignedLongMask(register PyObject *op)
250{
251 PyNumberMethods *nb;
252 PyIntObject *io;
253 unsigned long val;
254
255 if (op && PyInt_Check(op))
256 return PyInt_AS_LONG((PyIntObject*) op);
257 if (op && PyLong_Check(op))
258 return PyLong_AsUnsignedLongMask(op);
259
260 if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
261 nb->nb_int == NULL) {
262 PyErr_SetString(PyExc_TypeError, "an integer is required");
Skip Montanaro429433b2006-04-18 00:35:43 +0000263 return (unsigned long)-1;
Thomas Hellera4ea6032003-04-17 18:55:45 +0000264 }
265
266 io = (PyIntObject*) (*nb->nb_int) (op);
267 if (io == NULL)
Skip Montanaro429433b2006-04-18 00:35:43 +0000268 return (unsigned long)-1;
Thomas Hellera4ea6032003-04-17 18:55:45 +0000269 if (!PyInt_Check(io)) {
270 if (PyLong_Check(io)) {
271 val = PyLong_AsUnsignedLongMask((PyObject *)io);
272 Py_DECREF(io);
273 if (PyErr_Occurred())
Skip Montanaro429433b2006-04-18 00:35:43 +0000274 return (unsigned long)-1;
Thomas Hellera4ea6032003-04-17 18:55:45 +0000275 return val;
276 }
277 else
278 {
279 Py_DECREF(io);
280 PyErr_SetString(PyExc_TypeError,
281 "nb_int should return int object");
Skip Montanaro429433b2006-04-18 00:35:43 +0000282 return (unsigned long)-1;
Thomas Hellera4ea6032003-04-17 18:55:45 +0000283 }
284 }
285
286 val = PyInt_AS_LONG(io);
287 Py_DECREF(io);
288
289 return val;
290}
291
292#ifdef HAVE_LONG_LONG
293unsigned PY_LONG_LONG
294PyInt_AsUnsignedLongLongMask(register PyObject *op)
295{
296 PyNumberMethods *nb;
297 PyIntObject *io;
298 unsigned PY_LONG_LONG val;
299
300 if (op && PyInt_Check(op))
301 return PyInt_AS_LONG((PyIntObject*) op);
302 if (op && PyLong_Check(op))
303 return PyLong_AsUnsignedLongLongMask(op);
304
305 if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
306 nb->nb_int == NULL) {
307 PyErr_SetString(PyExc_TypeError, "an integer is required");
Skip Montanaro429433b2006-04-18 00:35:43 +0000308 return (unsigned PY_LONG_LONG)-1;
Thomas Hellera4ea6032003-04-17 18:55:45 +0000309 }
310
311 io = (PyIntObject*) (*nb->nb_int) (op);
312 if (io == NULL)
Skip Montanaro429433b2006-04-18 00:35:43 +0000313 return (unsigned PY_LONG_LONG)-1;
Thomas Hellera4ea6032003-04-17 18:55:45 +0000314 if (!PyInt_Check(io)) {
315 if (PyLong_Check(io)) {
316 val = PyLong_AsUnsignedLongLongMask((PyObject *)io);
317 Py_DECREF(io);
318 if (PyErr_Occurred())
Skip Montanaro429433b2006-04-18 00:35:43 +0000319 return (unsigned PY_LONG_LONG)-1;
Thomas Hellera4ea6032003-04-17 18:55:45 +0000320 return val;
321 }
322 else
323 {
324 Py_DECREF(io);
325 PyErr_SetString(PyExc_TypeError,
326 "nb_int should return int object");
Skip Montanaro429433b2006-04-18 00:35:43 +0000327 return (unsigned PY_LONG_LONG)-1;
Thomas Hellera4ea6032003-04-17 18:55:45 +0000328 }
329 }
330
331 val = PyInt_AS_LONG(io);
332 Py_DECREF(io);
333
334 return val;
335}
336#endif
337
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000338PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000339PyInt_FromString(char *s, char **pend, int base)
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000340{
341 char *end;
342 long x;
Thomas Wouters9cb28bea2006-04-11 23:50:33 +0000343 Py_ssize_t slen;
344 PyObject *sobj, *srepr;
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000345
346 if ((base != 0 && base < 2) || base > 36) {
Guido van Rossum47710652003-02-12 20:48:22 +0000347 PyErr_SetString(PyExc_ValueError,
348 "int() base must be >= 2 and <= 36");
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000349 return NULL;
350 }
351
352 while (*s && isspace(Py_CHARMASK(*s)))
353 s++;
354 errno = 0;
Guido van Rossum47710652003-02-12 20:48:22 +0000355 if (base == 0 && s[0] == '0') {
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000356 x = (long) PyOS_strtoul(s, &end, base);
Guido van Rossum47710652003-02-12 20:48:22 +0000357 if (x < 0)
Guido van Rossum6c9e1302003-11-29 23:52:13 +0000358 return PyLong_FromString(s, pend, base);
Guido van Rossum47710652003-02-12 20:48:22 +0000359 }
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000360 else
361 x = PyOS_strtol(s, &end, base);
Martin v. Löwis2b6727b2001-03-06 12:12:02 +0000362 if (end == s || !isalnum(Py_CHARMASK(end[-1])))
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000363 goto bad;
364 while (*end && isspace(Py_CHARMASK(*end)))
365 end++;
366 if (*end != '\0') {
367 bad:
Thomas Wouters9cb28bea2006-04-11 23:50:33 +0000368 slen = strlen(s) < 200 ? strlen(s) : 200;
369 sobj = PyString_FromStringAndSize(s, slen);
370 if (sobj == NULL)
371 return NULL;
372 srepr = PyObject_Repr(sobj);
373 Py_DECREF(sobj);
374 if (srepr == NULL)
375 return NULL;
376 PyErr_Format(PyExc_ValueError,
377 "invalid literal for int() with base %d: %s",
378 base, PyString_AS_STRING(srepr));
379 Py_DECREF(srepr);
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000380 return NULL;
381 }
Tim Petersc8854432004-08-25 02:14:08 +0000382 else if (errno != 0)
Walter Dörwald07e14762002-11-06 16:15:14 +0000383 return PyLong_FromString(s, pend, base);
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000384 if (pend)
385 *pend = end;
386 return PyInt_FromLong(x);
387}
388
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000389#ifdef Py_USING_UNICODE
Guido van Rossum9e896b32000-04-05 20:11:21 +0000390PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000391PyInt_FromUnicode(Py_UNICODE *s, Py_ssize_t length, int base)
Guido van Rossum9e896b32000-04-05 20:11:21 +0000392{
Walter Dörwald07e14762002-11-06 16:15:14 +0000393 PyObject *result;
Anthony Baxter377be112006-04-11 06:54:30 +0000394 char *buffer = (char *)PyMem_MALLOC(length+1);
Tim Petersa3c01ce2001-12-04 23:05:10 +0000395
Walter Dörwald07e14762002-11-06 16:15:14 +0000396 if (buffer == NULL)
397 return NULL;
398
399 if (PyUnicode_EncodeDecimal(s, length, buffer, NULL)) {
400 PyMem_FREE(buffer);
Guido van Rossum9e896b32000-04-05 20:11:21 +0000401 return NULL;
402 }
Walter Dörwald07e14762002-11-06 16:15:14 +0000403 result = PyInt_FromString(buffer, NULL, base);
404 PyMem_FREE(buffer);
405 return result;
Guido van Rossum9e896b32000-04-05 20:11:21 +0000406}
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000407#endif
Guido van Rossum9e896b32000-04-05 20:11:21 +0000408
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000409/* Methods */
410
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000411/* Integers are seen as the "smallest" of all numeric types and thus
412 don't have any knowledge about conversion of other types to
413 integers. */
414
415#define CONVERT_TO_LONG(obj, lng) \
416 if (PyInt_Check(obj)) { \
417 lng = PyInt_AS_LONG(obj); \
418 } \
419 else { \
420 Py_INCREF(Py_NotImplemented); \
421 return Py_NotImplemented; \
422 }
423
Guido van Rossum719f5fa1992-03-27 17:31:02 +0000424/* ARGSUSED */
Guido van Rossum90933611991-06-07 16:10:43 +0000425static int
Fred Drakea2f55112000-07-09 15:16:51 +0000426int_print(PyIntObject *v, FILE *fp, int flags)
427 /* flags -- not used but required by interface */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000428{
429 fprintf(fp, "%ld", v->ob_ival);
Guido van Rossum90933611991-06-07 16:10:43 +0000430 return 0;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000431}
432
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000433static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000434int_repr(PyIntObject *v)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000435{
Tim Peters42221042001-12-01 02:52:56 +0000436 char buf[64];
Barry Warsaw61975092001-11-28 20:55:34 +0000437 PyOS_snprintf(buf, sizeof(buf), "%ld", v->ob_ival);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000438 return PyString_FromString(buf);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000439}
440
441static int
Fred Drakea2f55112000-07-09 15:16:51 +0000442int_compare(PyIntObject *v, PyIntObject *w)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000443{
444 register long i = v->ob_ival;
445 register long j = w->ob_ival;
446 return (i < j) ? -1 : (i > j) ? 1 : 0;
447}
448
Guido van Rossum9bfef441993-03-29 10:43:31 +0000449static long
Fred Drakea2f55112000-07-09 15:16:51 +0000450int_hash(PyIntObject *v)
Guido van Rossum9bfef441993-03-29 10:43:31 +0000451{
Guido van Rossum541cdd81997-01-06 22:53:20 +0000452 /* XXX If this is changed, you also need to change the way
453 Python's long, float and complex types are hashed. */
Guido van Rossum9bfef441993-03-29 10:43:31 +0000454 long x = v -> ob_ival;
455 if (x == -1)
456 x = -2;
457 return x;
458}
459
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000460static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000461int_add(PyIntObject *v, PyIntObject *w)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000462{
463 register long a, b, x;
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000464 CONVERT_TO_LONG(v, a);
465 CONVERT_TO_LONG(w, b);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000466 x = a + b;
Guido van Rossume27f7952001-08-23 02:59:04 +0000467 if ((x^a) >= 0 || (x^b) >= 0)
468 return PyInt_FromLong(x);
Guido van Rossume27f7952001-08-23 02:59:04 +0000469 return PyLong_Type.tp_as_number->nb_add((PyObject *)v, (PyObject *)w);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000470}
471
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000472static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000473int_sub(PyIntObject *v, PyIntObject *w)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000474{
475 register long a, b, x;
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000476 CONVERT_TO_LONG(v, a);
477 CONVERT_TO_LONG(w, b);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000478 x = a - b;
Guido van Rossume27f7952001-08-23 02:59:04 +0000479 if ((x^a) >= 0 || (x^~b) >= 0)
480 return PyInt_FromLong(x);
Guido van Rossume27f7952001-08-23 02:59:04 +0000481 return PyLong_Type.tp_as_number->nb_subtract((PyObject *)v,
482 (PyObject *)w);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000483}
484
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000485/*
Tim Petersa3c01ce2001-12-04 23:05:10 +0000486Integer overflow checking for * is painful: Python tried a couple ways, but
487they didn't work on all platforms, or failed in endcases (a product of
488-sys.maxint-1 has been a particular pain).
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000489
Tim Petersa3c01ce2001-12-04 23:05:10 +0000490Here's another way:
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000491
Tim Petersa3c01ce2001-12-04 23:05:10 +0000492The native long product x*y is either exactly right or *way* off, being
493just the last n bits of the true product, where n is the number of bits
494in a long (the delivered product is the true product plus i*2**n for
495some integer i).
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000496
Tim Petersa3c01ce2001-12-04 23:05:10 +0000497The native double product (double)x * (double)y is subject to three
498rounding errors: on a sizeof(long)==8 box, each cast to double can lose
499info, and even on a sizeof(long)==4 box, the multiplication can lose info.
500But, unlike the native long product, it's not in *range* trouble: even
501if sizeof(long)==32 (256-bit longs), the product easily fits in the
502dynamic range of a double. So the leading 50 (or so) bits of the double
503product are correct.
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000504
Tim Petersa3c01ce2001-12-04 23:05:10 +0000505We check these two ways against each other, and declare victory if they're
506approximately the same. Else, because the native long product is the only
507one that can lose catastrophic amounts of information, it's the native long
508product that must have overflowed.
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000509*/
510
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000511static PyObject *
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000512int_mul(PyObject *v, PyObject *w)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000513{
Tim Petersa3c01ce2001-12-04 23:05:10 +0000514 long a, b;
515 long longprod; /* a*b in native long arithmetic */
516 double doubled_longprod; /* (double)longprod */
517 double doubleprod; /* (double)a * (double)b */
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000518
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000519 CONVERT_TO_LONG(v, a);
520 CONVERT_TO_LONG(w, b);
Tim Petersa3c01ce2001-12-04 23:05:10 +0000521 longprod = a * b;
522 doubleprod = (double)a * (double)b;
523 doubled_longprod = (double)longprod;
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000524
Tim Petersa3c01ce2001-12-04 23:05:10 +0000525 /* Fast path for normal case: small multiplicands, and no info
526 is lost in either method. */
527 if (doubled_longprod == doubleprod)
528 return PyInt_FromLong(longprod);
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000529
Tim Petersa3c01ce2001-12-04 23:05:10 +0000530 /* Somebody somewhere lost info. Close enough, or way off? Note
531 that a != 0 and b != 0 (else doubled_longprod == doubleprod == 0).
532 The difference either is or isn't significant compared to the
533 true value (of which doubleprod is a good approximation).
534 */
535 {
536 const double diff = doubled_longprod - doubleprod;
537 const double absdiff = diff >= 0.0 ? diff : -diff;
538 const double absprod = doubleprod >= 0.0 ? doubleprod :
539 -doubleprod;
540 /* absdiff/absprod <= 1/32 iff
541 32 * absdiff <= absprod -- 5 good bits is "close enough" */
542 if (32.0 * absdiff <= absprod)
543 return PyInt_FromLong(longprod);
Tim Petersa3c01ce2001-12-04 23:05:10 +0000544 else
545 return PyLong_Type.tp_as_number->nb_multiply(v, w);
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000546 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000547}
548
Guido van Rossume27f7952001-08-23 02:59:04 +0000549/* Return type of i_divmod */
550enum divmod_result {
551 DIVMOD_OK, /* Correct result */
552 DIVMOD_OVERFLOW, /* Overflow, try again using longs */
553 DIVMOD_ERROR /* Exception raised */
554};
555
556static enum divmod_result
Tim Peters1dad6a82001-06-18 19:21:11 +0000557i_divmod(register long x, register long y,
Fred Drakea2f55112000-07-09 15:16:51 +0000558 long *p_xdivy, long *p_xmody)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000559{
Guido van Rossum2b16a6f1992-01-19 16:28:51 +0000560 long xdivy, xmody;
Tim Petersa3c01ce2001-12-04 23:05:10 +0000561
Tim Peters1dad6a82001-06-18 19:21:11 +0000562 if (y == 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000563 PyErr_SetString(PyExc_ZeroDivisionError,
Fred Drake661ea262000-10-24 19:57:45 +0000564 "integer division or modulo by zero");
Guido van Rossume27f7952001-08-23 02:59:04 +0000565 return DIVMOD_ERROR;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000566 }
Tim Peterscbdd3502006-09-05 01:47:53 +0000567 /* (-sys.maxint-1)/-1 is the only overflow case. x is the most
568 * negative long iff x < 0 and, on a 2's-complement box, x == -x.
569 * However, -x is undefined (by C) if x /is/ the most negative long
570 * (it's a signed overflow case), and some compilers care. So we cast
571 * x to unsigned long first. However, then other compilers warn about
572 * applying unary minus to an unsigned operand. Hence the weird "0-".
573 */
574 if (y == -1 && x < 0 && (unsigned long)x == 0-(unsigned long)x)
Guido van Rossume27f7952001-08-23 02:59:04 +0000575 return DIVMOD_OVERFLOW;
Tim Peters1dad6a82001-06-18 19:21:11 +0000576 xdivy = x / y;
577 xmody = x - xdivy * y;
578 /* If the signs of x and y differ, and the remainder is non-0,
579 * C89 doesn't define whether xdivy is now the floor or the
580 * ceiling of the infinitely precise quotient. We want the floor,
581 * and we have it iff the remainder's sign matches y's.
582 */
583 if (xmody && ((y ^ xmody) < 0) /* i.e. and signs differ */) {
584 xmody += y;
585 --xdivy;
586 assert(xmody && ((y ^ xmody) >= 0));
Guido van Rossum00466951991-05-05 20:08:27 +0000587 }
Guido van Rossum2b16a6f1992-01-19 16:28:51 +0000588 *p_xdivy = xdivy;
589 *p_xmody = xmody;
Guido van Rossume27f7952001-08-23 02:59:04 +0000590 return DIVMOD_OK;
Guido van Rossum2b16a6f1992-01-19 16:28:51 +0000591}
592
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000593static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000594int_div(PyIntObject *x, PyIntObject *y)
Guido van Rossum2b16a6f1992-01-19 16:28:51 +0000595{
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000596 long xi, yi;
Guido van Rossum2b16a6f1992-01-19 16:28:51 +0000597 long d, m;
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000598 CONVERT_TO_LONG(x, xi);
599 CONVERT_TO_LONG(y, yi);
Guido van Rossume27f7952001-08-23 02:59:04 +0000600 switch (i_divmod(xi, yi, &d, &m)) {
601 case DIVMOD_OK:
602 return PyInt_FromLong(d);
603 case DIVMOD_OVERFLOW:
604 return PyLong_Type.tp_as_number->nb_divide((PyObject *)x,
605 (PyObject *)y);
606 default:
Guido van Rossum2b16a6f1992-01-19 16:28:51 +0000607 return NULL;
Guido van Rossume27f7952001-08-23 02:59:04 +0000608 }
Guido van Rossum2b16a6f1992-01-19 16:28:51 +0000609}
610
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000611static PyObject *
Guido van Rossum393661d2001-08-31 17:40:15 +0000612int_classic_div(PyIntObject *x, PyIntObject *y)
613{
614 long xi, yi;
615 long d, m;
616 CONVERT_TO_LONG(x, xi);
617 CONVERT_TO_LONG(y, yi);
618 if (Py_DivisionWarningFlag &&
619 PyErr_Warn(PyExc_DeprecationWarning, "classic int division") < 0)
620 return NULL;
621 switch (i_divmod(xi, yi, &d, &m)) {
622 case DIVMOD_OK:
623 return PyInt_FromLong(d);
624 case DIVMOD_OVERFLOW:
625 return PyLong_Type.tp_as_number->nb_divide((PyObject *)x,
626 (PyObject *)y);
627 default:
628 return NULL;
629 }
630}
631
632static PyObject *
Tim Peters9c1d7fd2001-09-04 05:52:47 +0000633int_true_divide(PyObject *v, PyObject *w)
634{
Tim Peterse2a60002001-09-04 06:17:36 +0000635 /* If they aren't both ints, give someone else a chance. In
636 particular, this lets int/long get handled by longs, which
637 underflows to 0 gracefully if the long is too big to convert
638 to float. */
639 if (PyInt_Check(v) && PyInt_Check(w))
640 return PyFloat_Type.tp_as_number->nb_true_divide(v, w);
641 Py_INCREF(Py_NotImplemented);
642 return Py_NotImplemented;
Tim Peters9c1d7fd2001-09-04 05:52:47 +0000643}
644
645static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000646int_mod(PyIntObject *x, PyIntObject *y)
Guido van Rossum2b16a6f1992-01-19 16:28:51 +0000647{
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000648 long xi, yi;
Guido van Rossum2b16a6f1992-01-19 16:28:51 +0000649 long d, m;
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000650 CONVERT_TO_LONG(x, xi);
651 CONVERT_TO_LONG(y, yi);
Guido van Rossume27f7952001-08-23 02:59:04 +0000652 switch (i_divmod(xi, yi, &d, &m)) {
653 case DIVMOD_OK:
654 return PyInt_FromLong(m);
655 case DIVMOD_OVERFLOW:
656 return PyLong_Type.tp_as_number->nb_remainder((PyObject *)x,
657 (PyObject *)y);
658 default:
Guido van Rossum2b16a6f1992-01-19 16:28:51 +0000659 return NULL;
Guido van Rossume27f7952001-08-23 02:59:04 +0000660 }
Guido van Rossum2b16a6f1992-01-19 16:28:51 +0000661}
662
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000663static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000664int_divmod(PyIntObject *x, PyIntObject *y)
Guido van Rossum2b16a6f1992-01-19 16:28:51 +0000665{
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000666 long xi, yi;
Guido van Rossum2b16a6f1992-01-19 16:28:51 +0000667 long d, m;
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000668 CONVERT_TO_LONG(x, xi);
669 CONVERT_TO_LONG(y, yi);
Guido van Rossume27f7952001-08-23 02:59:04 +0000670 switch (i_divmod(xi, yi, &d, &m)) {
671 case DIVMOD_OK:
672 return Py_BuildValue("(ll)", d, m);
673 case DIVMOD_OVERFLOW:
674 return PyLong_Type.tp_as_number->nb_divmod((PyObject *)x,
675 (PyObject *)y);
676 default:
Guido van Rossum2b16a6f1992-01-19 16:28:51 +0000677 return NULL;
Guido van Rossume27f7952001-08-23 02:59:04 +0000678 }
Guido van Rossum00466951991-05-05 20:08:27 +0000679}
680
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000681static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000682int_pow(PyIntObject *v, PyIntObject *w, PyIntObject *z)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000683{
Guido van Rossum9478dd41996-12-06 20:14:43 +0000684 register long iv, iw, iz=0, ix, temp, prev;
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000685 CONVERT_TO_LONG(v, iv);
686 CONVERT_TO_LONG(w, iw);
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000687 if (iw < 0) {
Tim Peters32f453e2001-09-03 08:35:41 +0000688 if ((PyObject *)z != Py_None) {
Tim Peters4c483c42001-09-05 06:24:58 +0000689 PyErr_SetString(PyExc_TypeError, "pow() 2nd argument "
690 "cannot be negative when 3rd argument specified");
Tim Peters32f453e2001-09-03 08:35:41 +0000691 return NULL;
692 }
Guido van Rossumb82fedc2001-07-12 11:19:45 +0000693 /* Return a float. This works because we know that
694 this calls float_pow() which converts its
695 arguments to double. */
696 return PyFloat_Type.tp_as_number->nb_power(
697 (PyObject *)v, (PyObject *)w, (PyObject *)z);
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000698 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000699 if ((PyObject *)z != Py_None) {
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000700 CONVERT_TO_LONG(z, iz);
Guido van Rossum9478dd41996-12-06 20:14:43 +0000701 if (iz == 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000702 PyErr_SetString(PyExc_ValueError,
Tim Peters4c483c42001-09-05 06:24:58 +0000703 "pow() 3rd argument cannot be 0");
Guido van Rossum9478dd41996-12-06 20:14:43 +0000704 return NULL;
705 }
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000706 }
707 /*
708 * XXX: The original exponentiation code stopped looping
709 * when temp hit zero; this code will continue onwards
710 * unnecessarily, but at least it won't cause any errors.
711 * Hopefully the speed improvement from the fast exponentiation
712 * will compensate for the slight inefficiency.
713 * XXX: Better handling of overflows is desperately needed.
714 */
715 temp = iv;
716 ix = 1;
717 while (iw > 0) {
718 prev = ix; /* Save value for overflow check */
Tim Petersa3c01ce2001-12-04 23:05:10 +0000719 if (iw & 1) {
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000720 ix = ix*temp;
721 if (temp == 0)
722 break; /* Avoid ix / 0 */
Guido van Rossume27f7952001-08-23 02:59:04 +0000723 if (ix / temp != prev) {
Guido van Rossume27f7952001-08-23 02:59:04 +0000724 return PyLong_Type.tp_as_number->nb_power(
725 (PyObject *)v,
726 (PyObject *)w,
Tim Peters31960db2001-08-23 21:28:33 +0000727 (PyObject *)z);
Guido van Rossume27f7952001-08-23 02:59:04 +0000728 }
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000729 }
730 iw >>= 1; /* Shift exponent down by 1 bit */
731 if (iw==0) break;
732 prev = temp;
733 temp *= temp; /* Square the value of temp */
Tim Petersc8854432004-08-25 02:14:08 +0000734 if (prev != 0 && temp / prev != prev) {
Guido van Rossume27f7952001-08-23 02:59:04 +0000735 return PyLong_Type.tp_as_number->nb_power(
736 (PyObject *)v, (PyObject *)w, (PyObject *)z);
737 }
Guido van Rossum9478dd41996-12-06 20:14:43 +0000738 if (iz) {
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000739 /* If we did a multiplication, perform a modulo */
740 ix = ix % iz;
741 temp = temp % iz;
742 }
743 }
Guido van Rossum9478dd41996-12-06 20:14:43 +0000744 if (iz) {
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000745 long div, mod;
Guido van Rossume27f7952001-08-23 02:59:04 +0000746 switch (i_divmod(ix, iz, &div, &mod)) {
747 case DIVMOD_OK:
748 ix = mod;
749 break;
750 case DIVMOD_OVERFLOW:
751 return PyLong_Type.tp_as_number->nb_power(
752 (PyObject *)v, (PyObject *)w, (PyObject *)z);
753 default:
754 return NULL;
755 }
Guido van Rossumbf8c0e31994-08-29 12:48:32 +0000756 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000757 return PyInt_FromLong(ix);
Tim Petersa3c01ce2001-12-04 23:05:10 +0000758}
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000759
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000760static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000761int_neg(PyIntObject *v)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000762{
Martin v. Löwis10525ad2006-10-04 05:47:47 +0000763 register long a;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000764 a = v->ob_ival;
Martin v. Löwis10525ad2006-10-04 05:47:47 +0000765 if (a < 0 && (unsigned long)a == 0-(unsigned long)a) {
Tim Petersc8854432004-08-25 02:14:08 +0000766 PyObject *o = PyLong_FromLong(a);
Neal Norwitzfa56e2d2003-01-19 15:40:09 +0000767 if (o != NULL) {
768 PyObject *result = PyNumber_Negative(o);
769 Py_DECREF(o);
770 return result;
771 }
772 return NULL;
Guido van Rossume27f7952001-08-23 02:59:04 +0000773 }
Martin v. Löwis10525ad2006-10-04 05:47:47 +0000774 return PyInt_FromLong(-a);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000775}
776
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000777static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000778int_pos(PyIntObject *v)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000779{
Tim Peters73a1dfe2001-09-11 21:44:14 +0000780 if (PyInt_CheckExact(v)) {
781 Py_INCREF(v);
782 return (PyObject *)v;
783 }
784 else
785 return PyInt_FromLong(v->ob_ival);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000786}
787
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000788static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000789int_abs(PyIntObject *v)
Guido van Rossum00466951991-05-05 20:08:27 +0000790{
791 if (v->ob_ival >= 0)
792 return int_pos(v);
793 else
794 return int_neg(v);
795}
796
Guido van Rossum0bff0151991-05-14 12:05:32 +0000797static int
Fred Drakea2f55112000-07-09 15:16:51 +0000798int_nonzero(PyIntObject *v)
Guido van Rossum0bff0151991-05-14 12:05:32 +0000799{
800 return v->ob_ival != 0;
801}
802
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000803static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000804int_invert(PyIntObject *v)
Guido van Rossum7928cd71991-10-24 14:59:31 +0000805{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000806 return PyInt_FromLong(~v->ob_ival);
Guido van Rossum7928cd71991-10-24 14:59:31 +0000807}
808
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000809static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000810int_lshift(PyIntObject *v, PyIntObject *w)
Guido van Rossum7928cd71991-10-24 14:59:31 +0000811{
Guido van Rossum078151d2002-08-11 04:24:12 +0000812 long a, b, c;
Raymond Hettingera006c372004-06-26 23:22:57 +0000813 PyObject *vv, *ww, *result;
814
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000815 CONVERT_TO_LONG(v, a);
816 CONVERT_TO_LONG(w, b);
Guido van Rossumf3b351f1992-01-14 18:33:22 +0000817 if (b < 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000818 PyErr_SetString(PyExc_ValueError, "negative shift count");
Guido van Rossumf3b351f1992-01-14 18:33:22 +0000819 return NULL;
820 }
Tim Peters73a1dfe2001-09-11 21:44:14 +0000821 if (a == 0 || b == 0)
822 return int_pos(v);
Guido van Rossum72481a31993-10-26 15:21:51 +0000823 if (b >= LONG_BIT) {
Raymond Hettingera006c372004-06-26 23:22:57 +0000824 vv = PyLong_FromLong(PyInt_AS_LONG(v));
825 if (vv == NULL)
826 return NULL;
827 ww = PyLong_FromLong(PyInt_AS_LONG(w));
828 if (ww == NULL) {
829 Py_DECREF(vv);
830 return NULL;
831 }
832 result = PyNumber_Lshift(vv, ww);
833 Py_DECREF(vv);
834 Py_DECREF(ww);
835 return result;
Guido van Rossumf3b351f1992-01-14 18:33:22 +0000836 }
Tim Petersda1a2212002-08-11 17:54:42 +0000837 c = a << b;
838 if (a != Py_ARITHMETIC_RIGHT_SHIFT(long, c, b)) {
Raymond Hettingera006c372004-06-26 23:22:57 +0000839 vv = PyLong_FromLong(PyInt_AS_LONG(v));
840 if (vv == NULL)
841 return NULL;
842 ww = PyLong_FromLong(PyInt_AS_LONG(w));
843 if (ww == NULL) {
844 Py_DECREF(vv);
845 return NULL;
846 }
847 result = PyNumber_Lshift(vv, ww);
848 Py_DECREF(vv);
849 Py_DECREF(ww);
850 return result;
Guido van Rossum078151d2002-08-11 04:24:12 +0000851 }
852 return PyInt_FromLong(c);
Guido van Rossum7928cd71991-10-24 14:59:31 +0000853}
854
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000855static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000856int_rshift(PyIntObject *v, PyIntObject *w)
Guido van Rossum7928cd71991-10-24 14:59:31 +0000857{
858 register long a, b;
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000859 CONVERT_TO_LONG(v, a);
860 CONVERT_TO_LONG(w, b);
Guido van Rossumf3b351f1992-01-14 18:33:22 +0000861 if (b < 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000862 PyErr_SetString(PyExc_ValueError, "negative shift count");
Guido van Rossumf3b351f1992-01-14 18:33:22 +0000863 return NULL;
864 }
Tim Peters73a1dfe2001-09-11 21:44:14 +0000865 if (a == 0 || b == 0)
866 return int_pos(v);
Guido van Rossum72481a31993-10-26 15:21:51 +0000867 if (b >= LONG_BIT) {
Guido van Rossumf3b351f1992-01-14 18:33:22 +0000868 if (a < 0)
869 a = -1;
870 else
871 a = 0;
872 }
873 else {
Tim Peters7d3a5112000-07-08 04:17:21 +0000874 a = Py_ARITHMETIC_RIGHT_SHIFT(long, a, b);
Guido van Rossumf3b351f1992-01-14 18:33:22 +0000875 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000876 return PyInt_FromLong(a);
Guido van Rossum7928cd71991-10-24 14:59:31 +0000877}
878
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000879static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000880int_and(PyIntObject *v, PyIntObject *w)
Guido van Rossum7928cd71991-10-24 14:59:31 +0000881{
882 register long a, b;
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000883 CONVERT_TO_LONG(v, a);
884 CONVERT_TO_LONG(w, b);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000885 return PyInt_FromLong(a & b);
Guido van Rossum7928cd71991-10-24 14:59:31 +0000886}
887
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000888static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000889int_xor(PyIntObject *v, PyIntObject *w)
Guido van Rossum7928cd71991-10-24 14:59:31 +0000890{
891 register long a, b;
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000892 CONVERT_TO_LONG(v, a);
893 CONVERT_TO_LONG(w, b);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000894 return PyInt_FromLong(a ^ b);
Guido van Rossum7928cd71991-10-24 14:59:31 +0000895}
896
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000897static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000898int_or(PyIntObject *v, PyIntObject *w)
Guido van Rossum7928cd71991-10-24 14:59:31 +0000899{
900 register long a, b;
Neil Schemenauer139e72a2001-01-04 01:45:33 +0000901 CONVERT_TO_LONG(v, a);
902 CONVERT_TO_LONG(w, b);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000903 return PyInt_FromLong(a | b);
Guido van Rossum7928cd71991-10-24 14:59:31 +0000904}
905
Guido van Rossum1952e382001-09-19 01:25:16 +0000906static int
907int_coerce(PyObject **pv, PyObject **pw)
908{
909 if (PyInt_Check(*pw)) {
910 Py_INCREF(*pv);
911 Py_INCREF(*pw);
912 return 0;
913 }
914 return 1; /* Can't do it */
915}
916
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000917static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000918int_int(PyIntObject *v)
Guido van Rossum1899c2e1992-09-12 11:09:23 +0000919{
Brett Cannonc3647ac2005-04-26 03:45:26 +0000920 if (PyInt_CheckExact(v))
921 Py_INCREF(v);
922 else
923 v = (PyIntObject *)PyInt_FromLong(v->ob_ival);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000924 return (PyObject *)v;
Guido van Rossum1899c2e1992-09-12 11:09:23 +0000925}
926
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000927static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000928int_long(PyIntObject *v)
Guido van Rossum1899c2e1992-09-12 11:09:23 +0000929{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000930 return PyLong_FromLong((v -> ob_ival));
Guido van Rossum1899c2e1992-09-12 11:09:23 +0000931}
932
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000933static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000934int_float(PyIntObject *v)
Guido van Rossum1899c2e1992-09-12 11:09:23 +0000935{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000936 return PyFloat_FromDouble((double)(v -> ob_ival));
Guido van Rossum1899c2e1992-09-12 11:09:23 +0000937}
938
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000939static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000940int_oct(PyIntObject *v)
Guido van Rossum1899c2e1992-09-12 11:09:23 +0000941{
Guido van Rossum6f72f971997-01-14 15:43:41 +0000942 char buf[100];
Guido van Rossum9bfef441993-03-29 10:43:31 +0000943 long x = v -> ob_ival;
Guido van Rossum6c9e1302003-11-29 23:52:13 +0000944 if (x < 0)
945 PyOS_snprintf(buf, sizeof(buf), "-0%lo", -x);
946 else if (x == 0)
Guido van Rossum1899c2e1992-09-12 11:09:23 +0000947 strcpy(buf, "0");
Guido van Rossum1899c2e1992-09-12 11:09:23 +0000948 else
Barry Warsaw61975092001-11-28 20:55:34 +0000949 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000950 return PyString_FromString(buf);
Guido van Rossum1899c2e1992-09-12 11:09:23 +0000951}
952
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000953static PyObject *
Fred Drakea2f55112000-07-09 15:16:51 +0000954int_hex(PyIntObject *v)
Guido van Rossum1899c2e1992-09-12 11:09:23 +0000955{
Guido van Rossum6f72f971997-01-14 15:43:41 +0000956 char buf[100];
Guido van Rossum9bfef441993-03-29 10:43:31 +0000957 long x = v -> ob_ival;
Guido van Rossum6c9e1302003-11-29 23:52:13 +0000958 if (x < 0)
959 PyOS_snprintf(buf, sizeof(buf), "-0x%lx", -x);
960 else
961 PyOS_snprintf(buf, sizeof(buf), "0x%lx", x);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000962 return PyString_FromString(buf);
Guido van Rossum1899c2e1992-09-12 11:09:23 +0000963}
964
Jeremy Hylton938ace62002-07-17 16:30:39 +0000965static PyObject *
Guido van Rossumbef14172001-08-29 15:47:46 +0000966int_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
967
Tim Peters6d6c1a32001-08-02 04:15:00 +0000968static PyObject *
969int_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
970{
971 PyObject *x = NULL;
972 int base = -909;
Martin v. Löwis15e62742006-02-27 16:46:16 +0000973 static char *kwlist[] = {"x", "base", 0};
Tim Peters6d6c1a32001-08-02 04:15:00 +0000974
Guido van Rossumbef14172001-08-29 15:47:46 +0000975 if (type != &PyInt_Type)
976 return int_subtype_new(type, args, kwds); /* Wimp out */
Tim Peters6d6c1a32001-08-02 04:15:00 +0000977 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:int", kwlist,
978 &x, &base))
979 return NULL;
980 if (x == NULL)
981 return PyInt_FromLong(0L);
982 if (base == -909)
983 return PyNumber_Int(x);
984 if (PyString_Check(x))
985 return PyInt_FromString(PyString_AS_STRING(x), NULL, base);
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000986#ifdef Py_USING_UNICODE
Tim Peters6d6c1a32001-08-02 04:15:00 +0000987 if (PyUnicode_Check(x))
988 return PyInt_FromUnicode(PyUnicode_AS_UNICODE(x),
989 PyUnicode_GET_SIZE(x),
990 base);
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000991#endif
Tim Peters6d6c1a32001-08-02 04:15:00 +0000992 PyErr_SetString(PyExc_TypeError,
993 "int() can't convert non-string with explicit base");
994 return NULL;
995}
996
Guido van Rossumbef14172001-08-29 15:47:46 +0000997/* Wimpy, slow approach to tp_new calls for subtypes of int:
998 first create a regular int from whatever arguments we got,
999 then allocate a subtype instance and initialize its ob_ival
1000 from the regular int. The regular int is then thrown away.
1001*/
1002static PyObject *
1003int_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1004{
Anthony Baxter377be112006-04-11 06:54:30 +00001005 PyObject *tmp, *newobj;
Neal Norwitzde8b94c2003-02-10 02:12:43 +00001006 long ival;
Guido van Rossumbef14172001-08-29 15:47:46 +00001007
1008 assert(PyType_IsSubtype(type, &PyInt_Type));
1009 tmp = int_new(&PyInt_Type, args, kwds);
1010 if (tmp == NULL)
1011 return NULL;
Neal Norwitzde8b94c2003-02-10 02:12:43 +00001012 if (!PyInt_Check(tmp)) {
Neal Norwitzde8b94c2003-02-10 02:12:43 +00001013 ival = PyLong_AsLong(tmp);
Michael W. Hudson71665dc2003-08-11 17:32:02 +00001014 if (ival == -1 && PyErr_Occurred()) {
1015 Py_DECREF(tmp);
Neal Norwitzde8b94c2003-02-10 02:12:43 +00001016 return NULL;
Michael W. Hudson71665dc2003-08-11 17:32:02 +00001017 }
Neal Norwitzde8b94c2003-02-10 02:12:43 +00001018 } else {
1019 ival = ((PyIntObject *)tmp)->ob_ival;
1020 }
1021
Anthony Baxter377be112006-04-11 06:54:30 +00001022 newobj = type->tp_alloc(type, 0);
1023 if (newobj == NULL) {
Raymond Hettingerf4667932003-06-28 20:04:25 +00001024 Py_DECREF(tmp);
Guido van Rossumbef14172001-08-29 15:47:46 +00001025 return NULL;
Raymond Hettingerf4667932003-06-28 20:04:25 +00001026 }
Anthony Baxter377be112006-04-11 06:54:30 +00001027 ((PyIntObject *)newobj)->ob_ival = ival;
Guido van Rossumbef14172001-08-29 15:47:46 +00001028 Py_DECREF(tmp);
Anthony Baxter377be112006-04-11 06:54:30 +00001029 return newobj;
Guido van Rossumbef14172001-08-29 15:47:46 +00001030}
1031
Guido van Rossum5d9113d2003-01-29 17:58:45 +00001032static PyObject *
1033int_getnewargs(PyIntObject *v)
1034{
1035 return Py_BuildValue("(l)", v->ob_ival);
1036}
1037
1038static PyMethodDef int_methods[] = {
1039 {"__getnewargs__", (PyCFunction)int_getnewargs, METH_NOARGS},
1040 {NULL, NULL} /* sentinel */
1041};
1042
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001043PyDoc_STRVAR(int_doc,
Tim Peters6d6c1a32001-08-02 04:15:00 +00001044"int(x[, base]) -> integer\n\
1045\n\
1046Convert a string or number to an integer, if possible. A floating point\n\
1047argument will be truncated towards zero (this does not include a string\n\
1048representation of a floating point number!) When converting a string, use\n\
1049the optional base. It is an error to supply a base when converting a\n\
Walter Dörwaldf1715402002-11-19 20:49:15 +00001050non-string. If the argument is outside the integer range a long object\n\
1051will be returned instead.");
Tim Peters6d6c1a32001-08-02 04:15:00 +00001052
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001053static PyNumberMethods int_as_number = {
Neil Schemenauer139e72a2001-01-04 01:45:33 +00001054 (binaryfunc)int_add, /*nb_add*/
1055 (binaryfunc)int_sub, /*nb_subtract*/
1056 (binaryfunc)int_mul, /*nb_multiply*/
Guido van Rossum393661d2001-08-31 17:40:15 +00001057 (binaryfunc)int_classic_div, /*nb_divide*/
Neil Schemenauer139e72a2001-01-04 01:45:33 +00001058 (binaryfunc)int_mod, /*nb_remainder*/
1059 (binaryfunc)int_divmod, /*nb_divmod*/
1060 (ternaryfunc)int_pow, /*nb_power*/
1061 (unaryfunc)int_neg, /*nb_negative*/
1062 (unaryfunc)int_pos, /*nb_positive*/
1063 (unaryfunc)int_abs, /*nb_absolute*/
1064 (inquiry)int_nonzero, /*nb_nonzero*/
1065 (unaryfunc)int_invert, /*nb_invert*/
1066 (binaryfunc)int_lshift, /*nb_lshift*/
1067 (binaryfunc)int_rshift, /*nb_rshift*/
1068 (binaryfunc)int_and, /*nb_and*/
1069 (binaryfunc)int_xor, /*nb_xor*/
1070 (binaryfunc)int_or, /*nb_or*/
Guido van Rossum1952e382001-09-19 01:25:16 +00001071 int_coerce, /*nb_coerce*/
Neil Schemenauer139e72a2001-01-04 01:45:33 +00001072 (unaryfunc)int_int, /*nb_int*/
1073 (unaryfunc)int_long, /*nb_long*/
1074 (unaryfunc)int_float, /*nb_float*/
1075 (unaryfunc)int_oct, /*nb_oct*/
1076 (unaryfunc)int_hex, /*nb_hex*/
1077 0, /*nb_inplace_add*/
1078 0, /*nb_inplace_subtract*/
1079 0, /*nb_inplace_multiply*/
1080 0, /*nb_inplace_divide*/
1081 0, /*nb_inplace_remainder*/
1082 0, /*nb_inplace_power*/
1083 0, /*nb_inplace_lshift*/
1084 0, /*nb_inplace_rshift*/
1085 0, /*nb_inplace_and*/
1086 0, /*nb_inplace_xor*/
1087 0, /*nb_inplace_or*/
Guido van Rossum4668b002001-08-08 05:00:18 +00001088 (binaryfunc)int_div, /* nb_floor_divide */
1089 int_true_divide, /* nb_true_divide */
1090 0, /* nb_inplace_floor_divide */
1091 0, /* nb_inplace_true_divide */
Neal Norwitz8a87f5d2006-08-12 17:03:09 +00001092 (unaryfunc)int_int, /* nb_index */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001093};
1094
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001095PyTypeObject PyInt_Type = {
1096 PyObject_HEAD_INIT(&PyType_Type)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001097 0,
1098 "int",
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001099 sizeof(PyIntObject),
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001100 0,
Tim Peters6d6c1a32001-08-02 04:15:00 +00001101 (destructor)int_dealloc, /* tp_dealloc */
1102 (printfunc)int_print, /* tp_print */
1103 0, /* tp_getattr */
1104 0, /* tp_setattr */
1105 (cmpfunc)int_compare, /* tp_compare */
1106 (reprfunc)int_repr, /* tp_repr */
1107 &int_as_number, /* tp_as_number */
1108 0, /* tp_as_sequence */
1109 0, /* tp_as_mapping */
1110 (hashfunc)int_hash, /* tp_hash */
1111 0, /* tp_call */
Guido van Rossume75bfde2002-02-01 15:34:10 +00001112 (reprfunc)int_repr, /* tp_str */
Tim Peters6d6c1a32001-08-02 04:15:00 +00001113 PyObject_GenericGetAttr, /* tp_getattro */
1114 0, /* tp_setattro */
1115 0, /* tp_as_buffer */
Guido van Rossumbef14172001-08-29 15:47:46 +00001116 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES |
1117 Py_TPFLAGS_BASETYPE, /* tp_flags */
Tim Peters6d6c1a32001-08-02 04:15:00 +00001118 int_doc, /* tp_doc */
1119 0, /* tp_traverse */
1120 0, /* tp_clear */
1121 0, /* tp_richcompare */
1122 0, /* tp_weaklistoffset */
1123 0, /* tp_iter */
1124 0, /* tp_iternext */
Guido van Rossum5d9113d2003-01-29 17:58:45 +00001125 int_methods, /* tp_methods */
Tim Peters6d6c1a32001-08-02 04:15:00 +00001126 0, /* tp_members */
1127 0, /* tp_getset */
1128 0, /* tp_base */
1129 0, /* tp_dict */
1130 0, /* tp_descr_get */
1131 0, /* tp_descr_set */
1132 0, /* tp_dictoffset */
1133 0, /* tp_init */
1134 0, /* tp_alloc */
1135 int_new, /* tp_new */
Guido van Rossum93646982002-04-26 00:53:34 +00001136 (freefunc)int_free, /* tp_free */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001137};
Guido van Rossumfbbd57e1997-08-05 02:16:08 +00001138
Neal Norwitzc91ed402002-12-30 22:29:22 +00001139int
Neal Norwitzb2501f42002-12-31 03:42:13 +00001140_PyInt_Init(void)
Neal Norwitzc91ed402002-12-30 22:29:22 +00001141{
1142 PyIntObject *v;
1143 int ival;
1144#if NSMALLNEGINTS + NSMALLPOSINTS > 0
1145 for (ival = -NSMALLNEGINTS; ival < NSMALLPOSINTS; ival++) {
Raymond Hettingerb32e6402004-02-08 18:54:37 +00001146 if (!free_list && (free_list = fill_free_list()) == NULL)
Neal Norwitzc91ed402002-12-30 22:29:22 +00001147 return 0;
1148 /* PyObject_New is inlined */
1149 v = free_list;
1150 free_list = (PyIntObject *)v->ob_type;
1151 PyObject_INIT(v, &PyInt_Type);
1152 v->ob_ival = ival;
1153 small_ints[ival + NSMALLNEGINTS] = v;
1154 }
1155#endif
1156 return 1;
1157}
1158
Guido van Rossumfbbd57e1997-08-05 02:16:08 +00001159void
Fred Drakea2f55112000-07-09 15:16:51 +00001160PyInt_Fini(void)
Guido van Rossumfbbd57e1997-08-05 02:16:08 +00001161{
Guido van Rossum3fce8831999-03-12 19:43:17 +00001162 PyIntObject *p;
1163 PyIntBlock *list, *next;
Guido van Rossumfbbd57e1997-08-05 02:16:08 +00001164 int i;
Skip Montanaro429433b2006-04-18 00:35:43 +00001165 unsigned int ctr;
Guido van Rossumda084ed1999-03-10 22:55:24 +00001166 int bc, bf; /* block count, number of freed blocks */
1167 int irem, isum; /* remaining unfreed ints per block, total */
Guido van Rossumfbbd57e1997-08-05 02:16:08 +00001168
Guido van Rossumda084ed1999-03-10 22:55:24 +00001169#if NSMALLNEGINTS + NSMALLPOSINTS > 0
1170 PyIntObject **q;
1171
1172 i = NSMALLNEGINTS + NSMALLPOSINTS;
1173 q = small_ints;
1174 while (--i >= 0) {
1175 Py_XDECREF(*q);
1176 *q++ = NULL;
1177 }
Guido van Rossumfbbd57e1997-08-05 02:16:08 +00001178#endif
Guido van Rossumda084ed1999-03-10 22:55:24 +00001179 bc = 0;
1180 bf = 0;
1181 isum = 0;
1182 list = block_list;
1183 block_list = NULL;
Guido van Rossum51288bc1999-03-19 20:30:39 +00001184 free_list = NULL;
Guido van Rossumda084ed1999-03-10 22:55:24 +00001185 while (list != NULL) {
Guido van Rossumda084ed1999-03-10 22:55:24 +00001186 bc++;
1187 irem = 0;
Skip Montanaro429433b2006-04-18 00:35:43 +00001188 for (ctr = 0, p = &list->objects[0];
1189 ctr < N_INTOBJECTS;
1190 ctr++, p++) {
Guido van Rossumdea6ef92001-09-11 16:13:52 +00001191 if (PyInt_CheckExact(p) && p->ob_refcnt != 0)
Guido van Rossumda084ed1999-03-10 22:55:24 +00001192 irem++;
1193 }
Guido van Rossum3fce8831999-03-12 19:43:17 +00001194 next = list->next;
Guido van Rossumda084ed1999-03-10 22:55:24 +00001195 if (irem) {
Guido van Rossum3fce8831999-03-12 19:43:17 +00001196 list->next = block_list;
1197 block_list = list;
Skip Montanaro429433b2006-04-18 00:35:43 +00001198 for (ctr = 0, p = &list->objects[0];
1199 ctr < N_INTOBJECTS;
1200 ctr++, p++) {
Guido van Rossumdea6ef92001-09-11 16:13:52 +00001201 if (!PyInt_CheckExact(p) ||
Guido van Rossumbef14172001-08-29 15:47:46 +00001202 p->ob_refcnt == 0) {
Guido van Rossum51288bc1999-03-19 20:30:39 +00001203 p->ob_type = (struct _typeobject *)
1204 free_list;
1205 free_list = p;
1206 }
1207#if NSMALLNEGINTS + NSMALLPOSINTS > 0
1208 else if (-NSMALLNEGINTS <= p->ob_ival &&
1209 p->ob_ival < NSMALLPOSINTS &&
1210 small_ints[p->ob_ival +
1211 NSMALLNEGINTS] == NULL) {
1212 Py_INCREF(p);
1213 small_ints[p->ob_ival +
1214 NSMALLNEGINTS] = p;
1215 }
1216#endif
1217 }
Guido van Rossumda084ed1999-03-10 22:55:24 +00001218 }
1219 else {
Tim Peters29c0afc2002-04-28 16:57:34 +00001220 PyMem_FREE(list);
Guido van Rossumda084ed1999-03-10 22:55:24 +00001221 bf++;
1222 }
1223 isum += irem;
Guido van Rossum3fce8831999-03-12 19:43:17 +00001224 list = next;
Guido van Rossumda084ed1999-03-10 22:55:24 +00001225 }
Guido van Rossum3fce8831999-03-12 19:43:17 +00001226 if (!Py_VerboseFlag)
1227 return;
1228 fprintf(stderr, "# cleanup ints");
1229 if (!isum) {
1230 fprintf(stderr, "\n");
1231 }
1232 else {
1233 fprintf(stderr,
1234 ": %d unfreed int%s in %d out of %d block%s\n",
1235 isum, isum == 1 ? "" : "s",
1236 bc - bf, bc, bc == 1 ? "" : "s");
1237 }
1238 if (Py_VerboseFlag > 1) {
1239 list = block_list;
1240 while (list != NULL) {
Skip Montanaro429433b2006-04-18 00:35:43 +00001241 for (ctr = 0, p = &list->objects[0];
1242 ctr < N_INTOBJECTS;
1243 ctr++, p++) {
Guido van Rossumdea6ef92001-09-11 16:13:52 +00001244 if (PyInt_CheckExact(p) && p->ob_refcnt != 0)
Thomas Wouters8b87a0b2006-03-01 05:41:20 +00001245 /* XXX(twouters) cast refcount to
1246 long until %zd is universally
1247 available
1248 */
Guido van Rossum3fce8831999-03-12 19:43:17 +00001249 fprintf(stderr,
Thomas Wouters8b87a0b2006-03-01 05:41:20 +00001250 "# <int at %p, refcnt=%ld, val=%ld>\n",
1251 p, (long)p->ob_refcnt,
1252 p->ob_ival);
Guido van Rossum3fce8831999-03-12 19:43:17 +00001253 }
1254 list = list->next;
Guido van Rossumda084ed1999-03-10 22:55:24 +00001255 }
1256 }
Guido van Rossumfbbd57e1997-08-05 02:16:08 +00001257}