blob: 9108fd431ac3da682a5389d1ef17cd367e3c5c66 [file] [log] [blame]
Guido van Rossumf70e43a1991-02-19 12:39:46 +00001
Guido van Rossum3f5da241990-12-20 15:06:42 +00002/* Generic object operations; and implementation of None (NoObject) */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00003
Guido van Rossumc0b618a1997-05-02 03:12:38 +00004#include "Python.h"
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00005
Anthony Baxterac6bd462006-04-13 02:06:09 +00006#ifdef __cplusplus
7extern "C" {
8#endif
9
Tim Peters34592512002-07-11 06:23:50 +000010#ifdef Py_REF_DEBUG
Neal Norwitz84632ee2006-03-04 20:00:59 +000011Py_ssize_t _Py_RefTotal;
Armin Rigoe1709372006-04-12 17:06:05 +000012
13Py_ssize_t
14_Py_GetRefTotal(void)
15{
16 PyObject *o;
17 Py_ssize_t total = _Py_RefTotal;
18 /* ignore the references to the dummy object of the dicts and sets
19 because they are not reliable and not useful (now that the
20 hash table code is well-tested) */
21 o = _PyDict_Dummy();
22 if (o != NULL)
23 total -= o->ob_refcnt;
24 o = _PySet_Dummy();
25 if (o != NULL)
26 total -= o->ob_refcnt;
27 return total;
28}
29#endif /* Py_REF_DEBUG */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000030
Mark Hammonda2905272002-07-29 13:42:14 +000031int Py_DivisionWarningFlag;
Neal Norwitz8b2bfbc2007-05-23 06:35:32 +000032int Py_Py3kWarningFlag;
Guido van Rossum393661d2001-08-31 17:40:15 +000033
Guido van Rossum3f5da241990-12-20 15:06:42 +000034/* Object allocation routines used by NEWOBJ and NEWVAROBJ macros.
35 These are used by the individual routines for object creation.
36 Do not call them otherwise, they do not initialize the object! */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000037
Tim Peters78be7992003-03-23 02:51:01 +000038#ifdef Py_TRACE_REFS
Tim Peters7571a0f2003-03-23 17:52:28 +000039/* Head of circular doubly-linked list of all objects. These are linked
40 * together via the _ob_prev and _ob_next members of a PyObject, which
41 * exist only in a Py_TRACE_REFS build.
42 */
Tim Peters78be7992003-03-23 02:51:01 +000043static PyObject refchain = {&refchain, &refchain};
Tim Peters36eb4df2003-03-23 03:33:13 +000044
Tim Peters7571a0f2003-03-23 17:52:28 +000045/* Insert op at the front of the list of all objects. If force is true,
46 * op is added even if _ob_prev and _ob_next are non-NULL already. If
47 * force is false amd _ob_prev or _ob_next are non-NULL, do nothing.
48 * force should be true if and only if op points to freshly allocated,
49 * uninitialized memory, or you've unlinked op from the list and are
Tim Peters51f8d382003-03-23 18:06:08 +000050 * relinking it into the front.
Tim Peters7571a0f2003-03-23 17:52:28 +000051 * Note that objects are normally added to the list via _Py_NewReference,
52 * which is called by PyObject_Init. Not all objects are initialized that
53 * way, though; exceptions include statically allocated type objects, and
54 * statically allocated singletons (like Py_True and Py_None).
55 */
Tim Peters36eb4df2003-03-23 03:33:13 +000056void
Tim Peters7571a0f2003-03-23 17:52:28 +000057_Py_AddToAllObjects(PyObject *op, int force)
Tim Peters36eb4df2003-03-23 03:33:13 +000058{
Tim Peters7571a0f2003-03-23 17:52:28 +000059#ifdef Py_DEBUG
60 if (!force) {
61 /* If it's initialized memory, op must be in or out of
62 * the list unambiguously.
63 */
64 assert((op->_ob_prev == NULL) == (op->_ob_next == NULL));
65 }
Tim Peters78be7992003-03-23 02:51:01 +000066#endif
Tim Peters7571a0f2003-03-23 17:52:28 +000067 if (force || op->_ob_prev == NULL) {
68 op->_ob_next = refchain._ob_next;
69 op->_ob_prev = &refchain;
70 refchain._ob_next->_ob_prev = op;
71 refchain._ob_next = op;
72 }
73}
74#endif /* Py_TRACE_REFS */
Tim Peters78be7992003-03-23 02:51:01 +000075
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +000076#ifdef COUNT_ALLOCS
Guido van Rossumc0b618a1997-05-02 03:12:38 +000077static PyTypeObject *type_list;
Andrew M. Kuchling2060d1b2006-04-18 11:49:53 +000078/* All types are added to type_list, at least when
Martin v. Löwis45294a92006-04-18 06:24:08 +000079 they get one object created. That makes them
80 immortal, which unfortunately contributes to
81 garbage itself. If unlist_types_without_objects
82 is set, they will be removed from the type_list
83 once the last object is deallocated. */
Martin v. Löwisb90304a2009-01-07 18:40:40 +000084static int unlist_types_without_objects;
85extern Py_ssize_t tuple_zero_allocs, fast_tuple_allocs;
86extern Py_ssize_t quick_int_allocs, quick_neg_int_allocs;
87extern Py_ssize_t null_strings, one_strings;
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +000088void
Martin v. Löwis45294a92006-04-18 06:24:08 +000089dump_counts(FILE* f)
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +000090{
Guido van Rossumc0b618a1997-05-02 03:12:38 +000091 PyTypeObject *tp;
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +000092
93 for (tp = type_list; tp; tp = tp->tp_next)
Martin v. Löwisb90304a2009-01-07 18:40:40 +000094 fprintf(f, "%s alloc'd: %" PY_FORMAT_SIZE_T "d, "
95 "freed: %" PY_FORMAT_SIZE_T "d, "
96 "max in use: %" PY_FORMAT_SIZE_T "d\n",
Tim Peters6d6c1a32001-08-02 04:15:00 +000097 tp->tp_name, tp->tp_allocs, tp->tp_frees,
Sjoerd Mullender52c1f511993-10-25 08:40:52 +000098 tp->tp_maxalloc);
Martin v. Löwisb90304a2009-01-07 18:40:40 +000099 fprintf(f, "fast tuple allocs: %" PY_FORMAT_SIZE_T "d, "
100 "empty: %" PY_FORMAT_SIZE_T "d\n",
Sjoerd Mullender52c1f511993-10-25 08:40:52 +0000101 fast_tuple_allocs, tuple_zero_allocs);
Martin v. Löwisb90304a2009-01-07 18:40:40 +0000102 fprintf(f, "fast int allocs: pos: %" PY_FORMAT_SIZE_T "d, "
103 "neg: %" PY_FORMAT_SIZE_T "d\n",
Sjoerd Mullender52c1f511993-10-25 08:40:52 +0000104 quick_int_allocs, quick_neg_int_allocs);
Martin v. Löwisb90304a2009-01-07 18:40:40 +0000105 fprintf(f, "null strings: %" PY_FORMAT_SIZE_T "d, "
106 "1-strings: %" PY_FORMAT_SIZE_T "d\n",
Sjoerd Mullender52c1f511993-10-25 08:40:52 +0000107 null_strings, one_strings);
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000108}
109
Sjoerd Mullender6ec3c651995-08-29 09:18:14 +0000110PyObject *
Fred Drake100814d2000-07-09 15:48:49 +0000111get_counts(void)
Sjoerd Mullender6ec3c651995-08-29 09:18:14 +0000112{
113 PyTypeObject *tp;
114 PyObject *result;
115 PyObject *v;
116
117 result = PyList_New(0);
118 if (result == NULL)
119 return NULL;
120 for (tp = type_list; tp; tp = tp->tp_next) {
Georg Brandl2cfaa342006-05-29 19:39:45 +0000121 v = Py_BuildValue("(snnn)", tp->tp_name, tp->tp_allocs,
Tim Peters6d6c1a32001-08-02 04:15:00 +0000122 tp->tp_frees, tp->tp_maxalloc);
Sjoerd Mullender6ec3c651995-08-29 09:18:14 +0000123 if (v == NULL) {
124 Py_DECREF(result);
125 return NULL;
126 }
127 if (PyList_Append(result, v) < 0) {
128 Py_DECREF(v);
129 Py_DECREF(result);
130 return NULL;
131 }
132 Py_DECREF(v);
133 }
134 return result;
135}
136
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000137void
Fred Drake100814d2000-07-09 15:48:49 +0000138inc_count(PyTypeObject *tp)
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000139{
Martin v. Löwis45294a92006-04-18 06:24:08 +0000140 if (tp->tp_next == NULL && tp->tp_prev == NULL) {
Guido van Rossumd8953cb1995-04-06 14:46:26 +0000141 /* first time; insert in linked list */
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000142 if (tp->tp_next != NULL) /* sanity check */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000143 Py_FatalError("XXX inc_count sanity check");
Martin v. Löwis45294a92006-04-18 06:24:08 +0000144 if (type_list)
145 type_list->tp_prev = tp;
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000146 tp->tp_next = type_list;
Tim Petersc6a3ff62002-07-08 22:11:52 +0000147 /* Note that as of Python 2.2, heap-allocated type objects
148 * can go away, but this code requires that they stay alive
149 * until program exit. That's why we're careful with
150 * refcounts here. type_list gets a new reference to tp,
151 * while ownership of the reference type_list used to hold
152 * (if any) was transferred to tp->tp_next in the line above.
153 * tp is thus effectively immortal after this.
154 */
155 Py_INCREF(tp);
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000156 type_list = tp;
Tim Peters3e40c7f2003-03-23 03:04:32 +0000157#ifdef Py_TRACE_REFS
Tim Peters7571a0f2003-03-23 17:52:28 +0000158 /* Also insert in the doubly-linked list of all objects,
159 * if not already there.
160 */
161 _Py_AddToAllObjects((PyObject *)tp, 0);
Tim Peters78be7992003-03-23 02:51:01 +0000162#endif
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000163 }
Tim Peters6d6c1a32001-08-02 04:15:00 +0000164 tp->tp_allocs++;
165 if (tp->tp_allocs - tp->tp_frees > tp->tp_maxalloc)
166 tp->tp_maxalloc = tp->tp_allocs - tp->tp_frees;
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000167}
Martin v. Löwis45294a92006-04-18 06:24:08 +0000168
169void dec_count(PyTypeObject *tp)
170{
171 tp->tp_frees++;
172 if (unlist_types_without_objects &&
173 tp->tp_allocs == tp->tp_frees) {
174 /* unlink the type from type_list */
175 if (tp->tp_prev)
176 tp->tp_prev->tp_next = tp->tp_next;
177 else
178 type_list = tp->tp_next;
179 if (tp->tp_next)
180 tp->tp_next->tp_prev = tp->tp_prev;
181 tp->tp_next = tp->tp_prev = NULL;
182 Py_DECREF(tp);
183 }
184}
185
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000186#endif
187
Tim Peters7c321a82002-07-09 02:57:01 +0000188#ifdef Py_REF_DEBUG
189/* Log a fatal error; doesn't return. */
190void
191_Py_NegativeRefcount(const char *fname, int lineno, PyObject *op)
192{
193 char buf[300];
194
195 PyOS_snprintf(buf, sizeof(buf),
Tim Peters4d073bb2006-03-23 05:38:33 +0000196 "%s:%i object at %p has negative ref count "
197 "%" PY_FORMAT_SIZE_T "d",
Tim Peters8af92d12006-03-23 05:41:24 +0000198 fname, lineno, op, op->ob_refcnt);
Tim Peters7c321a82002-07-09 02:57:01 +0000199 Py_FatalError(buf);
200}
201
202#endif /* Py_REF_DEBUG */
203
Thomas Heller1328b522004-04-22 17:23:49 +0000204void
205Py_IncRef(PyObject *o)
206{
207 Py_XINCREF(o);
208}
209
210void
211Py_DecRef(PyObject *o)
212{
213 Py_XDECREF(o);
214}
215
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000216PyObject *
Fred Drake100814d2000-07-09 15:48:49 +0000217PyObject_Init(PyObject *op, PyTypeObject *tp)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000218{
Guido van Rossum6e08c142002-10-11 20:37:24 +0000219 if (op == NULL)
220 return PyErr_NoMemory();
Guido van Rossumb18618d2000-05-03 23:44:39 +0000221 /* Any changes should be reflected in PyObject_INIT (objimpl.h) */
Christian Heimese93237d2007-12-19 02:37:44 +0000222 Py_TYPE(op) = tp;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000223 _Py_NewReference(op);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000224 return op;
225}
226
Guido van Rossumb18618d2000-05-03 23:44:39 +0000227PyVarObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000228PyObject_InitVar(PyVarObject *op, PyTypeObject *tp, Py_ssize_t size)
Guido van Rossumb18618d2000-05-03 23:44:39 +0000229{
Guido van Rossum6e08c142002-10-11 20:37:24 +0000230 if (op == NULL)
231 return (PyVarObject *) PyErr_NoMemory();
Guido van Rossumb18618d2000-05-03 23:44:39 +0000232 /* Any changes should be reflected in PyObject_INIT_VAR */
233 op->ob_size = size;
Christian Heimese93237d2007-12-19 02:37:44 +0000234 Py_TYPE(op) = tp;
Guido van Rossumb18618d2000-05-03 23:44:39 +0000235 _Py_NewReference((PyObject *)op);
236 return op;
237}
238
239PyObject *
Fred Drake100814d2000-07-09 15:48:49 +0000240_PyObject_New(PyTypeObject *tp)
Guido van Rossumb18618d2000-05-03 23:44:39 +0000241{
242 PyObject *op;
243 op = (PyObject *) PyObject_MALLOC(_PyObject_SIZE(tp));
244 if (op == NULL)
245 return PyErr_NoMemory();
246 return PyObject_INIT(op, tp);
247}
248
Guido van Rossumd0c87ee1997-05-15 21:31:03 +0000249PyVarObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000250_PyObject_NewVar(PyTypeObject *tp, Py_ssize_t nitems)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000251{
Guido van Rossumb18618d2000-05-03 23:44:39 +0000252 PyVarObject *op;
Tim Petersf2a67da2001-10-07 03:54:51 +0000253 const size_t size = _PyObject_VAR_SIZE(tp, nitems);
Tim Peters6d483d32001-10-06 21:27:34 +0000254 op = (PyVarObject *) PyObject_MALLOC(size);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000255 if (op == NULL)
Guido van Rossumd0c87ee1997-05-15 21:31:03 +0000256 return (PyVarObject *)PyErr_NoMemory();
Tim Peters6d483d32001-10-06 21:27:34 +0000257 return PyObject_INIT_VAR(op, tp, nitems);
Guido van Rossumb18618d2000-05-03 23:44:39 +0000258}
259
Neil Schemenauerbdf0eed2002-04-12 03:08:42 +0000260/* for binary compatibility with 2.2 */
261#undef _PyObject_Del
Guido van Rossumb18618d2000-05-03 23:44:39 +0000262void
Fred Drake100814d2000-07-09 15:48:49 +0000263_PyObject_Del(PyObject *op)
Guido van Rossumb18618d2000-05-03 23:44:39 +0000264{
Guido van Rossum4cc6ac72000-07-01 01:00:38 +0000265 PyObject_FREE(op);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000266}
267
Neal Norwitz1a997502003-01-13 20:13:12 +0000268/* Implementation of PyObject_Print with recursion checking */
269static int
270internal_print(PyObject *op, FILE *fp, int flags, int nesting)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000271{
Guido van Rossum278ef591991-07-27 21:40:24 +0000272 int ret = 0;
Neal Norwitz1a997502003-01-13 20:13:12 +0000273 if (nesting > 10) {
274 PyErr_SetString(PyExc_RuntimeError, "print recursion");
275 return -1;
276 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000277 if (PyErr_CheckSignals())
Guido van Rossum90933611991-06-07 16:10:43 +0000278 return -1;
Guido van Rossum9b00dfa1998-04-28 16:06:54 +0000279#ifdef USE_STACKCHECK
280 if (PyOS_CheckStack()) {
Fred Drake661ea262000-10-24 19:57:45 +0000281 PyErr_SetString(PyExc_MemoryError, "stack overflow");
Guido van Rossum9b00dfa1998-04-28 16:06:54 +0000282 return -1;
283 }
284#endif
Guido van Rossum687ef6e2000-01-12 16:28:58 +0000285 clearerr(fp); /* Clear any previous error condition */
Guido van Rossum90933611991-06-07 16:10:43 +0000286 if (op == NULL) {
Brett Cannon01531592007-09-17 03:28:34 +0000287 Py_BEGIN_ALLOW_THREADS
Guido van Rossum90933611991-06-07 16:10:43 +0000288 fprintf(fp, "<nil>");
Brett Cannon01531592007-09-17 03:28:34 +0000289 Py_END_ALLOW_THREADS
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000290 }
Guido van Rossum90933611991-06-07 16:10:43 +0000291 else {
292 if (op->ob_refcnt <= 0)
Thomas Wouters8b87a0b2006-03-01 05:41:20 +0000293 /* XXX(twouters) cast refcount to long until %zd is
294 universally available */
Brett Cannon01531592007-09-17 03:28:34 +0000295 Py_BEGIN_ALLOW_THREADS
Thomas Wouters8b87a0b2006-03-01 05:41:20 +0000296 fprintf(fp, "<refcnt %ld at %p>",
297 (long)op->ob_refcnt, op);
Brett Cannon01531592007-09-17 03:28:34 +0000298 Py_END_ALLOW_THREADS
Christian Heimese93237d2007-12-19 02:37:44 +0000299 else if (Py_TYPE(op)->tp_print == NULL) {
Guido van Rossum4f288ab2001-05-01 16:53:37 +0000300 PyObject *s;
301 if (flags & Py_PRINT_RAW)
302 s = PyObject_Str(op);
303 else
304 s = PyObject_Repr(op);
305 if (s == NULL)
306 ret = -1;
Guido van Rossum2e8f6141992-09-03 20:32:55 +0000307 else {
Neal Norwitz1a997502003-01-13 20:13:12 +0000308 ret = internal_print(s, fp, Py_PRINT_RAW,
309 nesting+1);
Guido van Rossum2e8f6141992-09-03 20:32:55 +0000310 }
Guido van Rossum4f288ab2001-05-01 16:53:37 +0000311 Py_XDECREF(s);
Guido van Rossum2e8f6141992-09-03 20:32:55 +0000312 }
Guido van Rossum90933611991-06-07 16:10:43 +0000313 else
Christian Heimese93237d2007-12-19 02:37:44 +0000314 ret = (*Py_TYPE(op)->tp_print)(op, fp, flags);
Guido van Rossum90933611991-06-07 16:10:43 +0000315 }
Guido van Rossum278ef591991-07-27 21:40:24 +0000316 if (ret == 0) {
317 if (ferror(fp)) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000318 PyErr_SetFromErrno(PyExc_IOError);
Guido van Rossum278ef591991-07-27 21:40:24 +0000319 clearerr(fp);
320 ret = -1;
321 }
322 }
323 return ret;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000324}
325
Neal Norwitz1a997502003-01-13 20:13:12 +0000326int
327PyObject_Print(PyObject *op, FILE *fp, int flags)
328{
329 return internal_print(op, fp, flags, 0);
330}
331
332
Barry Warsaw9bf16442001-01-23 16:24:35 +0000333/* For debugging convenience. See Misc/gdbinit for some useful gdb hooks */
Tim Peters803526b2002-07-07 05:13:56 +0000334void _PyObject_Dump(PyObject* op)
Barry Warsaw9bf16442001-01-23 16:24:35 +0000335{
Barry Warsaweefb1072001-02-22 22:39:18 +0000336 if (op == NULL)
337 fprintf(stderr, "NULL\n");
338 else {
Amaury Forgeot d'Arc3538a312008-12-15 22:29:14 +0000339 PyGILState_STATE gil;
Guido van Rossum5f5512d2001-09-14 15:50:08 +0000340 fprintf(stderr, "object : ");
Amaury Forgeot d'Arc3538a312008-12-15 22:29:14 +0000341 gil = PyGILState_Ensure();
Barry Warsaweefb1072001-02-22 22:39:18 +0000342 (void)PyObject_Print(op, stderr, 0);
Amaury Forgeot d'Arc3538a312008-12-15 22:29:14 +0000343 PyGILState_Release(gil);
Thomas Wouters8b87a0b2006-03-01 05:41:20 +0000344 /* XXX(twouters) cast refcount to long until %zd is
345 universally available */
Guido van Rossum5f5512d2001-09-14 15:50:08 +0000346 fprintf(stderr, "\n"
347 "type : %s\n"
Thomas Wouters8b87a0b2006-03-01 05:41:20 +0000348 "refcount: %ld\n"
Guido van Rossum5f5512d2001-09-14 15:50:08 +0000349 "address : %p\n",
Christian Heimese93237d2007-12-19 02:37:44 +0000350 Py_TYPE(op)==NULL ? "NULL" : Py_TYPE(op)->tp_name,
Thomas Wouters8b87a0b2006-03-01 05:41:20 +0000351 (long)op->ob_refcnt,
Guido van Rossum5f5512d2001-09-14 15:50:08 +0000352 op);
Barry Warsaweefb1072001-02-22 22:39:18 +0000353 }
Barry Warsaw9bf16442001-01-23 16:24:35 +0000354}
Barry Warsaw903138f2001-01-23 16:33:18 +0000355
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000356PyObject *
Fred Drake100814d2000-07-09 15:48:49 +0000357PyObject_Repr(PyObject *v)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000358{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000359 if (PyErr_CheckSignals())
Guido van Rossum90933611991-06-07 16:10:43 +0000360 return NULL;
Guido van Rossum9b00dfa1998-04-28 16:06:54 +0000361#ifdef USE_STACKCHECK
362 if (PyOS_CheckStack()) {
Fred Drake661ea262000-10-24 19:57:45 +0000363 PyErr_SetString(PyExc_MemoryError, "stack overflow");
Guido van Rossum9b00dfa1998-04-28 16:06:54 +0000364 return NULL;
365 }
366#endif
Guido van Rossum90933611991-06-07 16:10:43 +0000367 if (v == NULL)
Gregory P. Smithdd96db62008-06-09 04:58:54 +0000368 return PyString_FromString("<NULL>");
Christian Heimese93237d2007-12-19 02:37:44 +0000369 else if (Py_TYPE(v)->tp_repr == NULL)
Gregory P. Smithdd96db62008-06-09 04:58:54 +0000370 return PyString_FromFormat("<%s object at %p>",
Christian Heimese93237d2007-12-19 02:37:44 +0000371 Py_TYPE(v)->tp_name, v);
Guido van Rossum4c08d552000-03-10 22:55:18 +0000372 else {
373 PyObject *res;
Christian Heimese93237d2007-12-19 02:37:44 +0000374 res = (*Py_TYPE(v)->tp_repr)(v);
Guido van Rossum4c08d552000-03-10 22:55:18 +0000375 if (res == NULL)
376 return NULL;
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000377#ifdef Py_USING_UNICODE
Fredrik Lundhefecc7d2000-07-01 14:31:09 +0000378 if (PyUnicode_Check(res)) {
379 PyObject* str;
Anthony Baxter262c00a2006-03-30 10:53:17 +0000380 str = PyUnicode_AsEncodedString(res, NULL, NULL);
Marc-André Lemburg891bc652000-07-03 09:57:53 +0000381 Py_DECREF(res);
382 if (str)
Fredrik Lundhefecc7d2000-07-01 14:31:09 +0000383 res = str;
Marc-André Lemburg891bc652000-07-03 09:57:53 +0000384 else
385 return NULL;
Fredrik Lundhefecc7d2000-07-01 14:31:09 +0000386 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000387#endif
Gregory P. Smithdd96db62008-06-09 04:58:54 +0000388 if (!PyString_Check(res)) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000389 PyErr_Format(PyExc_TypeError,
Guido van Rossum5db862d2000-04-10 12:46:51 +0000390 "__repr__ returned non-string (type %.200s)",
Christian Heimese93237d2007-12-19 02:37:44 +0000391 Py_TYPE(res)->tp_name);
Guido van Rossum4c08d552000-03-10 22:55:18 +0000392 Py_DECREF(res);
393 return NULL;
394 }
395 return res;
396 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000397}
398
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000399PyObject *
Neil Schemenauercf52c072005-08-12 17:34:58 +0000400_PyObject_Str(PyObject *v)
Guido van Rossumc6004111993-11-05 10:22:19 +0000401{
Guido van Rossum4c08d552000-03-10 22:55:18 +0000402 PyObject *res;
Neil Schemenauercf52c072005-08-12 17:34:58 +0000403 int type_ok;
Guido van Rossumc6004111993-11-05 10:22:19 +0000404 if (v == NULL)
Gregory P. Smithdd96db62008-06-09 04:58:54 +0000405 return PyString_FromString("<NULL>");
406 if (PyString_CheckExact(v)) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000407 Py_INCREF(v);
Guido van Rossumc6004111993-11-05 10:22:19 +0000408 return v;
409 }
Neil Schemenauercf52c072005-08-12 17:34:58 +0000410#ifdef Py_USING_UNICODE
411 if (PyUnicode_CheckExact(v)) {
412 Py_INCREF(v);
413 return v;
414 }
415#endif
Christian Heimese93237d2007-12-19 02:37:44 +0000416 if (Py_TYPE(v)->tp_str == NULL)
Guido van Rossum4f288ab2001-05-01 16:53:37 +0000417 return PyObject_Repr(v);
418
Brett Cannon0b14f242007-09-30 19:45:10 +0000419 /* It is possible for a type to have a tp_str representation that loops
420 infinitely. */
421 if (Py_EnterRecursiveCall(" while getting the str of an object"))
422 return NULL;
Christian Heimese93237d2007-12-19 02:37:44 +0000423 res = (*Py_TYPE(v)->tp_str)(v);
Brett Cannon0b14f242007-09-30 19:45:10 +0000424 Py_LeaveRecursiveCall();
Guido van Rossum4c08d552000-03-10 22:55:18 +0000425 if (res == NULL)
426 return NULL;
Gregory P. Smithdd96db62008-06-09 04:58:54 +0000427 type_ok = PyString_Check(res);
Neil Schemenauercf52c072005-08-12 17:34:58 +0000428#ifdef Py_USING_UNICODE
429 type_ok = type_ok || PyUnicode_Check(res);
430#endif
431 if (!type_ok) {
432 PyErr_Format(PyExc_TypeError,
433 "__str__ returned non-string (type %.200s)",
Christian Heimese93237d2007-12-19 02:37:44 +0000434 Py_TYPE(res)->tp_name);
Neil Schemenauercf52c072005-08-12 17:34:58 +0000435 Py_DECREF(res);
436 return NULL;
437 }
438 return res;
439}
440
441PyObject *
442PyObject_Str(PyObject *v)
443{
444 PyObject *res = _PyObject_Str(v);
445 if (res == NULL)
446 return NULL;
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000447#ifdef Py_USING_UNICODE
Marc-André Lemburg891bc652000-07-03 09:57:53 +0000448 if (PyUnicode_Check(res)) {
449 PyObject* str;
450 str = PyUnicode_AsEncodedString(res, NULL, NULL);
451 Py_DECREF(res);
452 if (str)
453 res = str;
454 else
455 return NULL;
456 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000457#endif
Gregory P. Smithdd96db62008-06-09 04:58:54 +0000458 assert(PyString_Check(res));
Guido van Rossum4c08d552000-03-10 22:55:18 +0000459 return res;
Guido van Rossumc6004111993-11-05 10:22:19 +0000460}
461
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000462#ifdef Py_USING_UNICODE
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000463PyObject *
464PyObject_Unicode(PyObject *v)
465{
466 PyObject *res;
Brett Cannonc3647ac2005-04-26 03:45:26 +0000467 PyObject *func;
Neal Norwitz75801462006-03-14 06:02:16 +0000468 PyObject *str;
Nick Coghlan524b7772008-07-08 14:08:04 +0000469 int unicode_method_found = 0;
Brett Cannonc3647ac2005-04-26 03:45:26 +0000470 static PyObject *unicodestr;
Tim Peters803526b2002-07-07 05:13:56 +0000471
Georg Brandl3daf7582006-03-13 22:22:11 +0000472 if (v == NULL) {
Gregory P. Smithdd96db62008-06-09 04:58:54 +0000473 res = PyString_FromString("<NULL>");
Neal Norwitz75801462006-03-14 06:02:16 +0000474 if (res == NULL)
475 return NULL;
476 str = PyUnicode_FromEncodedObject(res, NULL, "strict");
477 Py_DECREF(res);
478 return str;
Georg Brandl3daf7582006-03-13 22:22:11 +0000479 } else if (PyUnicode_CheckExact(v)) {
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000480 Py_INCREF(v);
481 return v;
482 }
Nick Coghlan524b7772008-07-08 14:08:04 +0000483
484 /* Try the __unicode__ method */
Brett Cannonc3647ac2005-04-26 03:45:26 +0000485 if (unicodestr == NULL) {
Gregory P. Smithdd96db62008-06-09 04:58:54 +0000486 unicodestr= PyString_InternFromString("__unicode__");
Brett Cannonc3647ac2005-04-26 03:45:26 +0000487 if (unicodestr == NULL)
488 return NULL;
Guido van Rossumb8c65bc2001-10-19 02:01:31 +0000489 }
Nick Coghlan524b7772008-07-08 14:08:04 +0000490 if (PyInstance_Check(v)) {
491 /* We're an instance of a classic class */
492 /* Try __unicode__ from the instance -- alas we have no type */
493 func = PyObject_GetAttr(v, unicodestr);
494 if (func != NULL) {
495 unicode_method_found = 1;
496 res = PyObject_CallFunctionObjArgs(func, NULL);
497 Py_DECREF(func);
498 }
499 else {
500 PyErr_Clear();
501 }
Brett Cannonc3647ac2005-04-26 03:45:26 +0000502 }
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000503 else {
Nick Coghlan524b7772008-07-08 14:08:04 +0000504 /* Not a classic class instance, try __unicode__ from type */
505 /* _PyType_Lookup doesn't create a reference */
506 func = _PyType_Lookup(Py_TYPE(v), unicodestr);
507 if (func != NULL) {
508 unicode_method_found = 1;
509 res = PyObject_CallFunctionObjArgs(func, v, NULL);
510 }
511 else {
512 PyErr_Clear();
513 }
514 }
515
516 /* Didn't find __unicode__ */
517 if (!unicode_method_found) {
Brett Cannonc3647ac2005-04-26 03:45:26 +0000518 if (PyUnicode_Check(v)) {
519 /* For a Unicode subtype that's didn't overwrite __unicode__,
520 return a true Unicode object with the same data. */
521 return PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(v),
Nick Coghlan524b7772008-07-08 14:08:04 +0000522 PyUnicode_GET_SIZE(v));
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000523 }
Gregory P. Smithdd96db62008-06-09 04:58:54 +0000524 if (PyString_CheckExact(v)) {
Brett Cannonc3647ac2005-04-26 03:45:26 +0000525 Py_INCREF(v);
526 res = v;
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000527 }
Guido van Rossumb8c65bc2001-10-19 02:01:31 +0000528 else {
Christian Heimese93237d2007-12-19 02:37:44 +0000529 if (Py_TYPE(v)->tp_str != NULL)
530 res = (*Py_TYPE(v)->tp_str)(v);
Guido van Rossumb8c65bc2001-10-19 02:01:31 +0000531 else
532 res = PyObject_Repr(v);
533 }
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000534 }
Nick Coghlan524b7772008-07-08 14:08:04 +0000535
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000536 if (res == NULL)
537 return NULL;
538 if (!PyUnicode_Check(res)) {
Guido van Rossumb8c65bc2001-10-19 02:01:31 +0000539 str = PyUnicode_FromEncodedObject(res, NULL, "strict");
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000540 Py_DECREF(res);
Neal Norwitz75801462006-03-14 06:02:16 +0000541 res = str;
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000542 }
543 return res;
544}
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000545#endif
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000546
547
Guido van Rossuma4073002002-05-31 20:03:54 +0000548/* Helper to warn about deprecated tp_compare return values. Return:
549 -2 for an exception;
550 -1 if v < w;
551 0 if v == w;
552 1 if v > w.
553 (This function cannot return 2.)
554*/
555static int
556adjust_tp_compare(int c)
557{
558 if (PyErr_Occurred()) {
559 if (c != -1 && c != -2) {
560 PyObject *t, *v, *tb;
561 PyErr_Fetch(&t, &v, &tb);
562 if (PyErr_Warn(PyExc_RuntimeWarning,
563 "tp_compare didn't return -1 or -2 "
564 "for exception") < 0) {
565 Py_XDECREF(t);
566 Py_XDECREF(v);
567 Py_XDECREF(tb);
568 }
569 else
570 PyErr_Restore(t, v, tb);
571 }
572 return -2;
573 }
574 else if (c < -1 || c > 1) {
575 if (PyErr_Warn(PyExc_RuntimeWarning,
576 "tp_compare didn't return -1, 0 or 1") < 0)
577 return -2;
578 else
579 return c < -1 ? -1 : 1;
580 }
581 else {
582 assert(c >= -1 && c <= 1);
583 return c;
584 }
585}
586
587
Guido van Rossumd1f06b92001-01-24 22:14:43 +0000588/* Macro to get the tp_richcompare field of a type if defined */
589#define RICHCOMPARE(t) (PyType_HasFeature((t), Py_TPFLAGS_HAVE_RICHCOMPARE) \
590 ? (t)->tp_richcompare : NULL)
591
Guido van Rossume797ec12001-01-17 15:24:28 +0000592/* Map rich comparison operators to their swapped version, e.g. LT --> GT */
Brett Cannona5ca2e72004-09-25 01:37:24 +0000593int _Py_SwappedOp[] = {Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE};
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000594
Guido van Rossume797ec12001-01-17 15:24:28 +0000595/* Try a genuine rich comparison, returning an object. Return:
596 NULL for exception;
597 NotImplemented if this particular rich comparison is not implemented or
598 undefined;
599 some object not equal to NotImplemented if it is implemented
600 (this latter object may not be a Boolean).
601*/
602static PyObject *
603try_rich_compare(PyObject *v, PyObject *w, int op)
604{
605 richcmpfunc f;
606 PyObject *res;
607
Guido van Rossum2ed6bf82001-09-27 20:30:07 +0000608 if (v->ob_type != w->ob_type &&
609 PyType_IsSubtype(w->ob_type, v->ob_type) &&
610 (f = RICHCOMPARE(w->ob_type)) != NULL) {
Tim Petersf4aca752004-09-23 02:39:37 +0000611 res = (*f)(w, v, _Py_SwappedOp[op]);
Guido van Rossum2ed6bf82001-09-27 20:30:07 +0000612 if (res != Py_NotImplemented)
613 return res;
614 Py_DECREF(res);
615 }
Guido van Rossumd1f06b92001-01-24 22:14:43 +0000616 if ((f = RICHCOMPARE(v->ob_type)) != NULL) {
Guido van Rossume797ec12001-01-17 15:24:28 +0000617 res = (*f)(v, w, op);
618 if (res != Py_NotImplemented)
619 return res;
620 Py_DECREF(res);
621 }
Guido van Rossumd1f06b92001-01-24 22:14:43 +0000622 if ((f = RICHCOMPARE(w->ob_type)) != NULL) {
Tim Petersf4aca752004-09-23 02:39:37 +0000623 return (*f)(w, v, _Py_SwappedOp[op]);
Guido van Rossume797ec12001-01-17 15:24:28 +0000624 }
625 res = Py_NotImplemented;
626 Py_INCREF(res);
627 return res;
628}
629
630/* Try a genuine rich comparison, returning an int. Return:
631 -1 for exception (including the case where try_rich_compare() returns an
632 object that's not a Boolean);
Tim Petersc99213f2001-11-04 05:57:16 +0000633 0 if the outcome is false;
634 1 if the outcome is true;
635 2 if this particular rich comparison is not implemented or undefined.
Guido van Rossume797ec12001-01-17 15:24:28 +0000636*/
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000637static int
Guido van Rossume797ec12001-01-17 15:24:28 +0000638try_rich_compare_bool(PyObject *v, PyObject *w, int op)
639{
640 PyObject *res;
641 int ok;
642
Guido van Rossumd1f06b92001-01-24 22:14:43 +0000643 if (RICHCOMPARE(v->ob_type) == NULL && RICHCOMPARE(w->ob_type) == NULL)
Guido van Rossume797ec12001-01-17 15:24:28 +0000644 return 2; /* Shortcut, avoid INCREF+DECREF */
645 res = try_rich_compare(v, w, op);
646 if (res == NULL)
647 return -1;
648 if (res == Py_NotImplemented) {
649 Py_DECREF(res);
650 return 2;
651 }
652 ok = PyObject_IsTrue(res);
653 Py_DECREF(res);
654 return ok;
655}
656
657/* Try rich comparisons to determine a 3-way comparison. Return:
658 -2 for an exception;
Tim Petersc99213f2001-11-04 05:57:16 +0000659 -1 if v < w;
660 0 if v == w;
661 1 if v > w;
662 2 if this particular rich comparison is not implemented or undefined.
Guido van Rossume797ec12001-01-17 15:24:28 +0000663*/
664static int
665try_rich_to_3way_compare(PyObject *v, PyObject *w)
666{
Guido van Rossum2ffbf6b2001-01-17 21:27:02 +0000667 static struct { int op; int outcome; } tries[3] = {
668 /* Try this operator, and if it is true, use this outcome: */
669 {Py_EQ, 0},
670 {Py_LT, -1},
671 {Py_GT, 1},
672 };
673 int i;
674
Guido van Rossumd1f06b92001-01-24 22:14:43 +0000675 if (RICHCOMPARE(v->ob_type) == NULL && RICHCOMPARE(w->ob_type) == NULL)
Guido van Rossume797ec12001-01-17 15:24:28 +0000676 return 2; /* Shortcut */
Guido van Rossum2ffbf6b2001-01-17 21:27:02 +0000677
678 for (i = 0; i < 3; i++) {
679 switch (try_rich_compare_bool(v, w, tries[i].op)) {
680 case -1:
Tim Peters6d60b2e2001-05-07 20:53:51 +0000681 return -2;
Guido van Rossum2ffbf6b2001-01-17 21:27:02 +0000682 case 1:
683 return tries[i].outcome;
684 }
Guido van Rossume797ec12001-01-17 15:24:28 +0000685 }
Guido van Rossum2ffbf6b2001-01-17 21:27:02 +0000686
687 return 2;
Guido van Rossume797ec12001-01-17 15:24:28 +0000688}
689
690/* Try a 3-way comparison, returning an int. Return:
691 -2 for an exception;
Tim Petersc99213f2001-11-04 05:57:16 +0000692 -1 if v < w;
693 0 if v == w;
694 1 if v > w;
695 2 if this particular 3-way comparison is not implemented or undefined.
Guido van Rossume797ec12001-01-17 15:24:28 +0000696*/
697static int
698try_3way_compare(PyObject *v, PyObject *w)
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000699{
700 int c;
Guido van Rossume797ec12001-01-17 15:24:28 +0000701 cmpfunc f;
702
703 /* Comparisons involving instances are given to instance_compare,
704 which has the same return conventions as this function. */
705
Guido van Rossumab3b0342001-09-18 20:38:53 +0000706 f = v->ob_type->tp_compare;
Guido van Rossume797ec12001-01-17 15:24:28 +0000707 if (PyInstance_Check(v))
Guido van Rossumab3b0342001-09-18 20:38:53 +0000708 return (*f)(v, w);
Guido van Rossume797ec12001-01-17 15:24:28 +0000709 if (PyInstance_Check(w))
710 return (*w->ob_type->tp_compare)(v, w);
711
Guido van Rossumab3b0342001-09-18 20:38:53 +0000712 /* If both have the same (non-NULL) tp_compare, use it. */
713 if (f != NULL && f == w->ob_type->tp_compare) {
714 c = (*f)(v, w);
Guido van Rossuma4073002002-05-31 20:03:54 +0000715 return adjust_tp_compare(c);
Guido van Rossumab3b0342001-09-18 20:38:53 +0000716 }
717
718 /* If either tp_compare is _PyObject_SlotCompare, that's safe. */
719 if (f == _PyObject_SlotCompare ||
720 w->ob_type->tp_compare == _PyObject_SlotCompare)
721 return _PyObject_SlotCompare(v, w);
722
Armin Rigoa1748132004-12-23 22:13:13 +0000723 /* If we're here, v and w,
724 a) are not instances;
725 b) have different types or a type without tp_compare; and
726 c) don't have a user-defined tp_compare.
727 tp_compare implementations in C assume that both arguments
728 have their type, so we give up if the coercion fails or if
729 it yields types which are still incompatible (which can
730 happen with a user-defined nb_coerce).
731 */
Guido van Rossume797ec12001-01-17 15:24:28 +0000732 c = PyNumber_CoerceEx(&v, &w);
733 if (c < 0)
734 return -2;
735 if (c > 0)
736 return 2;
Armin Rigoa1748132004-12-23 22:13:13 +0000737 f = v->ob_type->tp_compare;
738 if (f != NULL && f == w->ob_type->tp_compare) {
Guido van Rossume797ec12001-01-17 15:24:28 +0000739 c = (*f)(v, w);
740 Py_DECREF(v);
741 Py_DECREF(w);
Guido van Rossuma4073002002-05-31 20:03:54 +0000742 return adjust_tp_compare(c);
Guido van Rossume797ec12001-01-17 15:24:28 +0000743 }
744
Guido van Rossume797ec12001-01-17 15:24:28 +0000745 /* No comparison defined */
746 Py_DECREF(v);
747 Py_DECREF(w);
748 return 2;
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000749}
750
Guido van Rossume797ec12001-01-17 15:24:28 +0000751/* Final fallback 3-way comparison, returning an int. Return:
752 -2 if an error occurred;
Tim Petersc99213f2001-11-04 05:57:16 +0000753 -1 if v < w;
754 0 if v == w;
755 1 if v > w.
Guido van Rossume797ec12001-01-17 15:24:28 +0000756*/
757static int
758default_3way_compare(PyObject *v, PyObject *w)
759{
760 int c;
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000761 const char *vname, *wname;
Guido van Rossume797ec12001-01-17 15:24:28 +0000762
763 if (v->ob_type == w->ob_type) {
Barry Warsawb0e754d2001-01-20 06:24:55 +0000764 /* When comparing these pointers, they must be cast to
765 * integer types (i.e. Py_uintptr_t, our spelling of C9X's
766 * uintptr_t). ANSI specifies that pointer compares other
767 * than == and != to non-related structures are undefined.
768 */
Barry Warsaw71ff8d52001-01-20 06:08:10 +0000769 Py_uintptr_t vv = (Py_uintptr_t)v;
770 Py_uintptr_t ww = (Py_uintptr_t)w;
Guido van Rossume797ec12001-01-17 15:24:28 +0000771 return (vv < ww) ? -1 : (vv > ww) ? 1 : 0;
772 }
773
Guido van Rossum0871e932001-01-22 19:28:09 +0000774 /* None is smaller than anything */
775 if (v == Py_None)
776 return -1;
777 if (w == Py_None)
778 return 1;
779
Guido van Rossumfb50d3f2003-02-18 16:40:09 +0000780 /* different type: compare type names; numbers are smaller */
781 if (PyNumber_Check(v))
Guido van Rossum8f9143d2001-01-22 15:59:32 +0000782 vname = "";
783 else
784 vname = v->ob_type->tp_name;
Guido van Rossumfb50d3f2003-02-18 16:40:09 +0000785 if (PyNumber_Check(w))
Guido van Rossum8f9143d2001-01-22 15:59:32 +0000786 wname = "";
787 else
788 wname = w->ob_type->tp_name;
789 c = strcmp(vname, wname);
790 if (c < 0)
791 return -1;
792 if (c > 0)
793 return 1;
794 /* Same type name, or (more likely) incomparable numeric types */
795 return ((Py_uintptr_t)(v->ob_type) < (
796 Py_uintptr_t)(w->ob_type)) ? -1 : 1;
Guido van Rossume797ec12001-01-17 15:24:28 +0000797}
798
Tim Peters6d60b2e2001-05-07 20:53:51 +0000799/* Do a 3-way comparison, by hook or by crook. Return:
Guido van Rossuma4073002002-05-31 20:03:54 +0000800 -2 for an exception (but see below);
Tim Petersc99213f2001-11-04 05:57:16 +0000801 -1 if v < w;
Tim Peters6d60b2e2001-05-07 20:53:51 +0000802 0 if v == w;
Tim Petersc99213f2001-11-04 05:57:16 +0000803 1 if v > w;
Guido van Rossuma4073002002-05-31 20:03:54 +0000804 BUT: if the object implements a tp_compare function, it returns
Martin v. Löwis0163d6d2001-06-09 07:34:05 +0000805 whatever this function returns (whether with an exception or not).
Tim Peters6d60b2e2001-05-07 20:53:51 +0000806*/
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000807static int
Fred Drake100814d2000-07-09 15:48:49 +0000808do_cmp(PyObject *v, PyObject *w)
Guido van Rossum20566841995-01-12 11:26:10 +0000809{
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000810 int c;
Martin v. Löwis0163d6d2001-06-09 07:34:05 +0000811 cmpfunc f;
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000812
Martin v. Löwis0163d6d2001-06-09 07:34:05 +0000813 if (v->ob_type == w->ob_type
Guido van Rossum82fc51c2001-08-16 08:02:45 +0000814 && (f = v->ob_type->tp_compare) != NULL) {
815 c = (*f)(v, w);
Guido van Rossuma4073002002-05-31 20:03:54 +0000816 if (PyInstance_Check(v)) {
817 /* Instance tp_compare has a different signature.
818 But if it returns undefined we fall through. */
819 if (c != 2)
820 return c;
Neal Norwitz3f8dae72002-05-31 20:23:33 +0000821 /* Else fall through to try_rich_to_3way_compare() */
Guido van Rossuma4073002002-05-31 20:03:54 +0000822 }
823 else
824 return adjust_tp_compare(c);
Guido van Rossum82fc51c2001-08-16 08:02:45 +0000825 }
Guido van Rossuma4073002002-05-31 20:03:54 +0000826 /* We only get here if one of the following is true:
827 a) v and w have different types
828 b) v and w have the same type, which doesn't have tp_compare
829 c) v and w are instances, and either __cmp__ is not defined or
830 __cmp__ returns NotImplemented
831 */
Guido van Rossume797ec12001-01-17 15:24:28 +0000832 c = try_rich_to_3way_compare(v, w);
833 if (c < 2)
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000834 return c;
Guido van Rossume797ec12001-01-17 15:24:28 +0000835 c = try_3way_compare(v, w);
836 if (c < 2)
837 return c;
838 return default_3way_compare(v, w);
Guido van Rossum20566841995-01-12 11:26:10 +0000839}
840
Tim Petersc99213f2001-11-04 05:57:16 +0000841/* Compare v to w. Return
842 -1 if v < w or exception (PyErr_Occurred() true in latter case).
843 0 if v == w.
844 1 if v > w.
845 XXX The docs (C API manual) say the return value is undefined in case
846 XXX of error.
847*/
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000848int
Fred Drake100814d2000-07-09 15:48:49 +0000849PyObject_Compare(PyObject *v, PyObject *w)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000850{
Jeremy Hylton4a3dd2d2000-04-14 19:13:24 +0000851 int result;
852
Guido van Rossumc8b6df91997-05-23 00:06:51 +0000853 if (v == NULL || w == NULL) {
854 PyErr_BadInternalCall();
855 return -1;
856 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000857 if (v == w)
858 return 0;
Armin Rigo2b3eb402003-10-28 12:05:48 +0000859 if (Py_EnterRecursiveCall(" in cmp"))
860 return -1;
861 result = do_cmp(v, w);
862 Py_LeaveRecursiveCall();
Guido van Rossume797ec12001-01-17 15:24:28 +0000863 return result < 0 ? -1 : result;
864}
865
Tim Petersc99213f2001-11-04 05:57:16 +0000866/* Return (new reference to) Py_True or Py_False. */
Guido van Rossume797ec12001-01-17 15:24:28 +0000867static PyObject *
Martin v. Löwis0163d6d2001-06-09 07:34:05 +0000868convert_3way_to_object(int op, int c)
Guido van Rossume797ec12001-01-17 15:24:28 +0000869{
Guido van Rossume797ec12001-01-17 15:24:28 +0000870 PyObject *result;
Guido van Rossume797ec12001-01-17 15:24:28 +0000871 switch (op) {
872 case Py_LT: c = c < 0; break;
873 case Py_LE: c = c <= 0; break;
874 case Py_EQ: c = c == 0; break;
875 case Py_NE: c = c != 0; break;
876 case Py_GT: c = c > 0; break;
877 case Py_GE: c = c >= 0; break;
878 }
879 result = c ? Py_True : Py_False;
880 Py_INCREF(result);
Jeremy Hylton4a3dd2d2000-04-14 19:13:24 +0000881 return result;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000882}
Tim Peters803526b2002-07-07 05:13:56 +0000883
Tim Petersc99213f2001-11-04 05:57:16 +0000884/* We want a rich comparison but don't have one. Try a 3-way cmp instead.
885 Return
886 NULL if error
887 Py_True if v op w
888 Py_False if not (v op w)
889*/
Martin v. Löwis0163d6d2001-06-09 07:34:05 +0000890static PyObject *
891try_3way_to_rich_compare(PyObject *v, PyObject *w, int op)
892{
893 int c;
894
895 c = try_3way_compare(v, w);
Steven Bethardae42f332008-03-18 17:26:10 +0000896 if (c >= 2) {
897
898 /* Py3K warning if types are not equal and comparison isn't == or != */
899 if (Py_Py3kWarningFlag &&
Georg Brandld5b635f2008-03-25 08:29:14 +0000900 v->ob_type != w->ob_type && op != Py_EQ && op != Py_NE &&
Benjamin Peterson9f4f4812008-04-27 03:01:45 +0000901 PyErr_WarnEx(PyExc_DeprecationWarning,
Georg Brandld5b635f2008-03-25 08:29:14 +0000902 "comparing unequal types not supported "
Benjamin Peterson9f4f4812008-04-27 03:01:45 +0000903 "in 3.x", 1) < 0) {
Steven Bethardae42f332008-03-18 17:26:10 +0000904 return NULL;
905 }
906
Martin v. Löwis0163d6d2001-06-09 07:34:05 +0000907 c = default_3way_compare(v, w);
Steven Bethardae42f332008-03-18 17:26:10 +0000908 }
Martin v. Löwis0163d6d2001-06-09 07:34:05 +0000909 if (c <= -2)
910 return NULL;
911 return convert_3way_to_object(op, c);
912}
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000913
Tim Petersc99213f2001-11-04 05:57:16 +0000914/* Do rich comparison on v and w. Return
915 NULL if error
916 Else a new reference to an object other than Py_NotImplemented, usually(?):
917 Py_True if v op w
918 Py_False if not (v op w)
919*/
Neil Schemenauerd38855c2001-01-21 16:25:18 +0000920static PyObject *
Guido van Rossume797ec12001-01-17 15:24:28 +0000921do_richcmp(PyObject *v, PyObject *w, int op)
922{
923 PyObject *res;
924
925 res = try_rich_compare(v, w, op);
926 if (res != Py_NotImplemented)
927 return res;
928 Py_DECREF(res);
929
930 return try_3way_to_rich_compare(v, w, op);
931}
932
Tim Petersc99213f2001-11-04 05:57:16 +0000933/* Return:
934 NULL for exception;
Tim Petersc99213f2001-11-04 05:57:16 +0000935 some object not equal to NotImplemented if it is implemented
936 (this latter object may not be a Boolean).
937*/
Guido van Rossume797ec12001-01-17 15:24:28 +0000938PyObject *
939PyObject_RichCompare(PyObject *v, PyObject *w, int op)
940{
941 PyObject *res;
942
943 assert(Py_LT <= op && op <= Py_GE);
Armin Rigo2b3eb402003-10-28 12:05:48 +0000944 if (Py_EnterRecursiveCall(" in cmp"))
945 return NULL;
Guido van Rossume797ec12001-01-17 15:24:28 +0000946
Armin Rigo2b3eb402003-10-28 12:05:48 +0000947 /* If the types are equal, and not old-style instances, try to
Tim Peters67754e92001-11-04 07:29:31 +0000948 get out cheap (don't bother with coercions etc.). */
949 if (v->ob_type == w->ob_type && !PyInstance_Check(v)) {
950 cmpfunc fcmp;
951 richcmpfunc frich = RICHCOMPARE(v->ob_type);
952 /* If the type has richcmp, try it first. try_rich_compare
953 tries it two-sided, which is not needed since we've a
954 single type only. */
955 if (frich != NULL) {
956 res = (*frich)(v, w, op);
957 if (res != Py_NotImplemented)
958 goto Done;
959 Py_DECREF(res);
960 }
961 /* No richcmp, or this particular richmp not implemented.
962 Try 3-way cmp. */
963 fcmp = v->ob_type->tp_compare;
964 if (fcmp != NULL) {
965 int c = (*fcmp)(v, w);
Guido van Rossuma4073002002-05-31 20:03:54 +0000966 c = adjust_tp_compare(c);
967 if (c == -2) {
Tim Peters67754e92001-11-04 07:29:31 +0000968 res = NULL;
969 goto Done;
970 }
971 res = convert_3way_to_object(op, c);
972 goto Done;
973 }
Guido van Rossum2ffbf6b2001-01-17 21:27:02 +0000974 }
Tim Peters67754e92001-11-04 07:29:31 +0000975
976 /* Fast path not taken, or couldn't deliver a useful result. */
977 res = do_richcmp(v, w, op);
978Done:
Armin Rigo2b3eb402003-10-28 12:05:48 +0000979 Py_LeaveRecursiveCall();
Guido van Rossume797ec12001-01-17 15:24:28 +0000980 return res;
981}
982
Tim Petersde9725f2001-05-05 10:06:17 +0000983/* Return -1 if error; 1 if v op w; 0 if not (v op w). */
Guido van Rossume797ec12001-01-17 15:24:28 +0000984int
985PyObject_RichCompareBool(PyObject *v, PyObject *w, int op)
986{
Raymond Hettinger93d44812004-03-21 17:01:44 +0000987 PyObject *res;
Guido van Rossume797ec12001-01-17 15:24:28 +0000988 int ok;
989
Raymond Hettinger93d44812004-03-21 17:01:44 +0000990 /* Quick result when objects are the same.
991 Guarantees that identity implies equality. */
992 if (v == w) {
993 if (op == Py_EQ)
994 return 1;
995 else if (op == Py_NE)
996 return 0;
997 }
998
999 res = PyObject_RichCompare(v, w, op);
Guido van Rossume797ec12001-01-17 15:24:28 +00001000 if (res == NULL)
1001 return -1;
Guido van Rossum81912d42002-08-24 05:33:28 +00001002 if (PyBool_Check(res))
1003 ok = (res == Py_True);
1004 else
1005 ok = PyObject_IsTrue(res);
Guido van Rossume797ec12001-01-17 15:24:28 +00001006 Py_DECREF(res);
1007 return ok;
1008}
Fred Drake13634cf2000-06-29 19:17:04 +00001009
1010/* Set of hash utility functions to help maintaining the invariant that
Raymond Hettinger8183fa42004-03-21 17:35:06 +00001011 if a==b then hash(a)==hash(b)
Fred Drake13634cf2000-06-29 19:17:04 +00001012
1013 All the utility functions (_Py_Hash*()) return "-1" to signify an error.
1014*/
1015
1016long
Fred Drake100814d2000-07-09 15:48:49 +00001017_Py_HashDouble(double v)
Fred Drake13634cf2000-06-29 19:17:04 +00001018{
Tim Peters39dce292000-08-15 03:34:48 +00001019 double intpart, fractpart;
1020 int expo;
1021 long hipart;
1022 long x; /* the final hash value */
1023 /* This is designed so that Python numbers of different types
1024 * that compare equal hash to the same value; otherwise comparisons
1025 * of mapping keys will turn out weird.
1026 */
1027
Tim Peters39dce292000-08-15 03:34:48 +00001028 fractpart = modf(v, &intpart);
Tim Peters39dce292000-08-15 03:34:48 +00001029 if (fractpart == 0.0) {
1030 /* This must return the same hash as an equal int or long. */
Mark Dickinson10fe8772009-02-08 14:42:28 +00001031 if (intpart > LONG_MAX/2 || -intpart > LONG_MAX/2) {
Tim Peters39dce292000-08-15 03:34:48 +00001032 /* Convert to long and use its hash. */
1033 PyObject *plong; /* converted to Python long */
1034 if (Py_IS_INFINITY(intpart))
1035 /* can't convert to long int -- arbitrary */
1036 v = v < 0 ? -271828.0 : 314159.0;
1037 plong = PyLong_FromDouble(v);
1038 if (plong == NULL)
1039 return -1;
1040 x = PyObject_Hash(plong);
1041 Py_DECREF(plong);
1042 return x;
1043 }
1044 /* Fits in a C long == a Python int, so is its own hash. */
1045 x = (long)intpart;
1046 if (x == -1)
1047 x = -2;
1048 return x;
1049 }
1050 /* The fractional part is non-zero, so we don't have to worry about
1051 * making this match the hash of some other type.
1052 * Use frexp to get at the bits in the double.
Fred Drake13634cf2000-06-29 19:17:04 +00001053 * Since the VAX D double format has 56 mantissa bits, which is the
1054 * most of any double format in use, each of these parts may have as
1055 * many as (but no more than) 56 significant bits.
Tim Peters39dce292000-08-15 03:34:48 +00001056 * So, assuming sizeof(long) >= 4, each part can be broken into two
1057 * longs; frexp and multiplication are used to do that.
1058 * Also, since the Cray double format has 15 exponent bits, which is
1059 * the most of any double format in use, shifting the exponent field
1060 * left by 15 won't overflow a long (again assuming sizeof(long) >= 4).
Fred Drake13634cf2000-06-29 19:17:04 +00001061 */
Tim Peters39dce292000-08-15 03:34:48 +00001062 v = frexp(v, &expo);
1063 v *= 2147483648.0; /* 2**31 */
1064 hipart = (long)v; /* take the top 32 bits */
1065 v = (v - (double)hipart) * 2147483648.0; /* get the next 32 bits */
1066 x = hipart + (long)v + (expo << 15);
1067 if (x == -1)
1068 x = -2;
1069 return x;
Fred Drake13634cf2000-06-29 19:17:04 +00001070}
1071
1072long
Fred Drake100814d2000-07-09 15:48:49 +00001073_Py_HashPointer(void *p)
Fred Drake13634cf2000-06-29 19:17:04 +00001074{
1075#if SIZEOF_LONG >= SIZEOF_VOID_P
1076 return (long)p;
1077#else
1078 /* convert to a Python long and hash that */
1079 PyObject* longobj;
1080 long x;
Tim Peters803526b2002-07-07 05:13:56 +00001081
Fred Drake13634cf2000-06-29 19:17:04 +00001082 if ((longobj = PyLong_FromVoidPtr(p)) == NULL) {
1083 x = -1;
1084 goto finally;
1085 }
1086 x = PyObject_Hash(longobj);
Tim Peters803526b2002-07-07 05:13:56 +00001087
Fred Drake13634cf2000-06-29 19:17:04 +00001088finally:
1089 Py_XDECREF(longobj);
1090 return x;
1091#endif
1092}
1093
Nick Coghlan53663a62008-07-15 14:27:37 +00001094long
1095PyObject_HashNotImplemented(PyObject *self)
1096{
1097 PyErr_Format(PyExc_TypeError, "unhashable type: '%.200s'",
1098 self->ob_type->tp_name);
1099 return -1;
1100}
Fred Drake13634cf2000-06-29 19:17:04 +00001101
Guido van Rossum9bfef441993-03-29 10:43:31 +00001102long
Fred Drake100814d2000-07-09 15:48:49 +00001103PyObject_Hash(PyObject *v)
Guido van Rossum9bfef441993-03-29 10:43:31 +00001104{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001105 PyTypeObject *tp = v->ob_type;
Guido van Rossum9bfef441993-03-29 10:43:31 +00001106 if (tp->tp_hash != NULL)
1107 return (*tp->tp_hash)(v);
Nick Coghlan180e4002008-12-30 01:18:48 +00001108 /* To keep to the general practice that inheriting
1109 * solely from object in C code should work without
1110 * an explicit call to PyType_Ready, we implicitly call
1111 * PyType_Ready here and then check the tp_hash slot again
1112 */
1113 if (tp->tp_dict == NULL) {
1114 if (PyType_Ready(tp) < 0)
1115 return -1;
1116 if (tp->tp_hash != NULL)
1117 return (*tp->tp_hash)(v);
1118 }
Guido van Rossumd1f06b92001-01-24 22:14:43 +00001119 if (tp->tp_compare == NULL && RICHCOMPARE(tp) == NULL) {
Fred Drake13634cf2000-06-29 19:17:04 +00001120 return _Py_HashPointer(v); /* Use address as hash value */
1121 }
Guido van Rossum9bfef441993-03-29 10:43:31 +00001122 /* If there's a cmp but no hash defined, the object can't be hashed */
Nick Coghlan53663a62008-07-15 14:27:37 +00001123 return PyObject_HashNotImplemented(v);
Guido van Rossum9bfef441993-03-29 10:43:31 +00001124}
1125
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001126PyObject *
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001127PyObject_GetAttrString(PyObject *v, const char *name)
Guido van Rossum3f5da241990-12-20 15:06:42 +00001128{
Tim Peters6d6c1a32001-08-02 04:15:00 +00001129 PyObject *w, *res;
Guido van Rossumd8eb1b31996-08-09 20:52:03 +00001130
Christian Heimese93237d2007-12-19 02:37:44 +00001131 if (Py_TYPE(v)->tp_getattr != NULL)
1132 return (*Py_TYPE(v)->tp_getattr)(v, (char*)name);
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001133 w = PyString_InternFromString(name);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001134 if (w == NULL)
1135 return NULL;
1136 res = PyObject_GetAttr(v, w);
1137 Py_XDECREF(w);
1138 return res;
Guido van Rossum3f5da241990-12-20 15:06:42 +00001139}
1140
1141int
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001142PyObject_HasAttrString(PyObject *v, const char *name)
Guido van Rossumed18fdc1993-07-11 19:55:34 +00001143{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001144 PyObject *res = PyObject_GetAttrString(v, name);
Guido van Rossumed18fdc1993-07-11 19:55:34 +00001145 if (res != NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001146 Py_DECREF(res);
Guido van Rossumed18fdc1993-07-11 19:55:34 +00001147 return 1;
1148 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001149 PyErr_Clear();
Guido van Rossumed18fdc1993-07-11 19:55:34 +00001150 return 0;
1151}
1152
1153int
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001154PyObject_SetAttrString(PyObject *v, const char *name, PyObject *w)
Guido van Rossum3f5da241990-12-20 15:06:42 +00001155{
Tim Peters6d6c1a32001-08-02 04:15:00 +00001156 PyObject *s;
1157 int res;
Guido van Rossumd8eb1b31996-08-09 20:52:03 +00001158
Christian Heimese93237d2007-12-19 02:37:44 +00001159 if (Py_TYPE(v)->tp_setattr != NULL)
1160 return (*Py_TYPE(v)->tp_setattr)(v, (char*)name, w);
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001161 s = PyString_InternFromString(name);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001162 if (s == NULL)
1163 return -1;
1164 res = PyObject_SetAttr(v, s, w);
1165 Py_XDECREF(s);
1166 return res;
Guido van Rossum3f5da241990-12-20 15:06:42 +00001167}
1168
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001169PyObject *
Fred Drake100814d2000-07-09 15:48:49 +00001170PyObject_GetAttr(PyObject *v, PyObject *name)
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001171{
Christian Heimese93237d2007-12-19 02:37:44 +00001172 PyTypeObject *tp = Py_TYPE(v);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001173
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001174 if (!PyString_Check(name)) {
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001175#ifdef Py_USING_UNICODE
1176 /* The Unicode to string conversion is done here because the
1177 existing tp_getattro slots expect a string object as name
1178 and we wouldn't want to break those. */
1179 if (PyUnicode_Check(name)) {
1180 name = _PyUnicode_AsDefaultEncodedString(name, NULL);
1181 if (name == NULL)
1182 return NULL;
1183 }
1184 else
1185#endif
1186 {
Georg Brandlccff7852006-06-18 22:17:29 +00001187 PyErr_Format(PyExc_TypeError,
1188 "attribute name must be string, not '%.200s'",
Christian Heimese93237d2007-12-19 02:37:44 +00001189 Py_TYPE(name)->tp_name);
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001190 return NULL;
1191 }
Jeremy Hylton99a8f902000-06-23 14:36:32 +00001192 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001193 if (tp->tp_getattro != NULL)
1194 return (*tp->tp_getattro)(v, name);
1195 if (tp->tp_getattr != NULL)
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001196 return (*tp->tp_getattr)(v, PyString_AS_STRING(name));
Tim Peters6d6c1a32001-08-02 04:15:00 +00001197 PyErr_Format(PyExc_AttributeError,
1198 "'%.50s' object has no attribute '%.400s'",
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001199 tp->tp_name, PyString_AS_STRING(name));
Tim Peters6d6c1a32001-08-02 04:15:00 +00001200 return NULL;
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001201}
1202
1203int
Fred Drake100814d2000-07-09 15:48:49 +00001204PyObject_HasAttr(PyObject *v, PyObject *name)
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001205{
1206 PyObject *res = PyObject_GetAttr(v, name);
1207 if (res != NULL) {
1208 Py_DECREF(res);
1209 return 1;
1210 }
1211 PyErr_Clear();
1212 return 0;
1213}
1214
1215int
Fred Drake100814d2000-07-09 15:48:49 +00001216PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value)
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001217{
Christian Heimese93237d2007-12-19 02:37:44 +00001218 PyTypeObject *tp = Py_TYPE(v);
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001219 int err;
Marc-André Lemburge44e5072000-09-18 16:20:57 +00001220
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001221 if (!PyString_Check(name)){
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001222#ifdef Py_USING_UNICODE
1223 /* The Unicode to string conversion is done here because the
1224 existing tp_setattro slots expect a string object as name
1225 and we wouldn't want to break those. */
1226 if (PyUnicode_Check(name)) {
1227 name = PyUnicode_AsEncodedString(name, NULL, NULL);
1228 if (name == NULL)
1229 return -1;
1230 }
Tim Peters803526b2002-07-07 05:13:56 +00001231 else
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001232#endif
1233 {
Georg Brandlccff7852006-06-18 22:17:29 +00001234 PyErr_Format(PyExc_TypeError,
1235 "attribute name must be string, not '%.200s'",
Christian Heimese93237d2007-12-19 02:37:44 +00001236 Py_TYPE(name)->tp_name);
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001237 return -1;
1238 }
Jeremy Hylton99a8f902000-06-23 14:36:32 +00001239 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001240 else
1241 Py_INCREF(name);
1242
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001243 PyString_InternInPlace(&name);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001244 if (tp->tp_setattro != NULL) {
1245 err = (*tp->tp_setattro)(v, name, value);
1246 Py_DECREF(name);
1247 return err;
Marc-André Lemburge44e5072000-09-18 16:20:57 +00001248 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001249 if (tp->tp_setattr != NULL) {
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001250 err = (*tp->tp_setattr)(v, PyString_AS_STRING(name), value);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001251 Py_DECREF(name);
1252 return err;
1253 }
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001254 Py_DECREF(name);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001255 if (tp->tp_getattr == NULL && tp->tp_getattro == NULL)
1256 PyErr_Format(PyExc_TypeError,
1257 "'%.100s' object has no attributes "
1258 "(%s .%.100s)",
1259 tp->tp_name,
1260 value==NULL ? "del" : "assign to",
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001261 PyString_AS_STRING(name));
Tim Peters6d6c1a32001-08-02 04:15:00 +00001262 else
1263 PyErr_Format(PyExc_TypeError,
1264 "'%.100s' object has only read-only attributes "
1265 "(%s .%.100s)",
1266 tp->tp_name,
1267 value==NULL ? "del" : "assign to",
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001268 PyString_AS_STRING(name));
Tim Peters6d6c1a32001-08-02 04:15:00 +00001269 return -1;
1270}
1271
1272/* Helper to get a pointer to an object's __dict__ slot, if any */
1273
1274PyObject **
1275_PyObject_GetDictPtr(PyObject *obj)
1276{
Martin v. Löwis725507b2006-03-07 12:08:51 +00001277 Py_ssize_t dictoffset;
Christian Heimese93237d2007-12-19 02:37:44 +00001278 PyTypeObject *tp = Py_TYPE(obj);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001279
1280 if (!(tp->tp_flags & Py_TPFLAGS_HAVE_CLASS))
1281 return NULL;
1282 dictoffset = tp->tp_dictoffset;
1283 if (dictoffset == 0)
1284 return NULL;
1285 if (dictoffset < 0) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001286 Py_ssize_t tsize;
Guido van Rossum2eb0b872002-03-01 22:24:49 +00001287 size_t size;
1288
1289 tsize = ((PyVarObject *)obj)->ob_size;
1290 if (tsize < 0)
1291 tsize = -tsize;
1292 size = _PyObject_VAR_SIZE(tp, tsize);
1293
Tim Peters6d483d32001-10-06 21:27:34 +00001294 dictoffset += (long)size;
1295 assert(dictoffset > 0);
1296 assert(dictoffset % SIZEOF_VOID_P == 0);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001297 }
1298 return (PyObject **) ((char *)obj + dictoffset);
1299}
1300
Tim Peters6d6c1a32001-08-02 04:15:00 +00001301PyObject *
Raymond Hettinger1da1dbf2003-03-17 19:46:11 +00001302PyObject_SelfIter(PyObject *obj)
Raymond Hettinger01538262003-03-17 08:24:35 +00001303{
1304 Py_INCREF(obj);
1305 return obj;
1306}
1307
Amaury Forgeot d'Arca40d5732009-01-12 23:36:55 +00001308/* Helper used when the __next__ method is removed from a type:
1309 tp_iternext is never NULL and can be safely called without checking
1310 on every iteration.
1311 */
1312
1313PyObject *
1314_PyObject_NextNotImplemented(PyObject *self)
1315{
1316 PyErr_Format(PyExc_TypeError,
1317 "'%.200s' object is not iterable",
1318 Py_TYPE(self)->tp_name);
1319 return NULL;
1320}
1321
Michael W. Hudson1593f502004-09-14 17:09:47 +00001322/* Generic GetAttr functions - put these in your tp_[gs]etattro slot */
1323
Raymond Hettinger01538262003-03-17 08:24:35 +00001324PyObject *
Tim Peters6d6c1a32001-08-02 04:15:00 +00001325PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
1326{
Christian Heimese93237d2007-12-19 02:37:44 +00001327 PyTypeObject *tp = Py_TYPE(obj);
Guido van Rossum056fbf42002-08-19 19:22:50 +00001328 PyObject *descr = NULL;
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001329 PyObject *res = NULL;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001330 descrgetfunc f;
Martin v. Löwis725507b2006-03-07 12:08:51 +00001331 Py_ssize_t dictoffset;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001332 PyObject **dictptr;
1333
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001334 if (!PyString_Check(name)){
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001335#ifdef Py_USING_UNICODE
1336 /* The Unicode to string conversion is done here because the
1337 existing tp_setattro slots expect a string object as name
1338 and we wouldn't want to break those. */
1339 if (PyUnicode_Check(name)) {
1340 name = PyUnicode_AsEncodedString(name, NULL, NULL);
1341 if (name == NULL)
1342 return NULL;
1343 }
Tim Peters803526b2002-07-07 05:13:56 +00001344 else
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001345#endif
1346 {
Georg Brandlccff7852006-06-18 22:17:29 +00001347 PyErr_Format(PyExc_TypeError,
1348 "attribute name must be string, not '%.200s'",
Christian Heimese93237d2007-12-19 02:37:44 +00001349 Py_TYPE(name)->tp_name);
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001350 return NULL;
1351 }
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001352 }
1353 else
1354 Py_INCREF(name);
1355
Tim Peters6d6c1a32001-08-02 04:15:00 +00001356 if (tp->tp_dict == NULL) {
Guido van Rossum528b7eb2001-08-07 17:24:28 +00001357 if (PyType_Ready(tp) < 0)
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001358 goto done;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001359 }
1360
Amaury Forgeot d'Arce4c270c2008-01-14 00:29:41 +00001361#if 0 /* XXX this is not quite _PyType_Lookup anymore */
Guido van Rossum056fbf42002-08-19 19:22:50 +00001362 /* Inline _PyType_Lookup */
1363 {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001364 Py_ssize_t i, n;
Guido van Rossum056fbf42002-08-19 19:22:50 +00001365 PyObject *mro, *base, *dict;
1366
1367 /* Look in tp_dict of types in MRO */
1368 mro = tp->tp_mro;
1369 assert(mro != NULL);
1370 assert(PyTuple_Check(mro));
1371 n = PyTuple_GET_SIZE(mro);
1372 for (i = 0; i < n; i++) {
1373 base = PyTuple_GET_ITEM(mro, i);
1374 if (PyClass_Check(base))
1375 dict = ((PyClassObject *)base)->cl_dict;
1376 else {
1377 assert(PyType_Check(base));
1378 dict = ((PyTypeObject *)base)->tp_dict;
1379 }
1380 assert(dict && PyDict_Check(dict));
1381 descr = PyDict_GetItem(dict, name);
1382 if (descr != NULL)
1383 break;
1384 }
1385 }
Amaury Forgeot d'Arce4c270c2008-01-14 00:29:41 +00001386#else
1387 descr = _PyType_Lookup(tp, name);
1388#endif
Guido van Rossum056fbf42002-08-19 19:22:50 +00001389
Michael W. Hudsonb2c7de42003-08-15 13:07:47 +00001390 Py_XINCREF(descr);
1391
Tim Peters6d6c1a32001-08-02 04:15:00 +00001392 f = NULL;
Guido van Rossum90195e22003-02-19 03:19:29 +00001393 if (descr != NULL &&
1394 PyType_HasFeature(descr->ob_type, Py_TPFLAGS_HAVE_CLASS)) {
Tim Peters6d6c1a32001-08-02 04:15:00 +00001395 f = descr->ob_type->tp_descr_get;
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001396 if (f != NULL && PyDescr_IsData(descr)) {
1397 res = f(descr, obj, (PyObject *)obj->ob_type);
Michael W. Hudsonb2c7de42003-08-15 13:07:47 +00001398 Py_DECREF(descr);
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001399 goto done;
1400 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001401 }
1402
Guido van Rossumc66ff442002-08-19 16:50:48 +00001403 /* Inline _PyObject_GetDictPtr */
1404 dictoffset = tp->tp_dictoffset;
1405 if (dictoffset != 0) {
1406 PyObject *dict;
1407 if (dictoffset < 0) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001408 Py_ssize_t tsize;
Guido van Rossumc66ff442002-08-19 16:50:48 +00001409 size_t size;
1410
1411 tsize = ((PyVarObject *)obj)->ob_size;
1412 if (tsize < 0)
1413 tsize = -tsize;
1414 size = _PyObject_VAR_SIZE(tp, tsize);
1415
1416 dictoffset += (long)size;
1417 assert(dictoffset > 0);
1418 assert(dictoffset % SIZEOF_VOID_P == 0);
1419 }
1420 dictptr = (PyObject **) ((char *)obj + dictoffset);
1421 dict = *dictptr;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001422 if (dict != NULL) {
Guido van Rossum37edeab2008-01-24 17:58:05 +00001423 Py_INCREF(dict);
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001424 res = PyDict_GetItem(dict, name);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001425 if (res != NULL) {
1426 Py_INCREF(res);
Michael W. Hudsonb2c7de42003-08-15 13:07:47 +00001427 Py_XDECREF(descr);
Guido van Rossum37edeab2008-01-24 17:58:05 +00001428 Py_DECREF(dict);
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001429 goto done;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001430 }
Guido van Rossum37edeab2008-01-24 17:58:05 +00001431 Py_DECREF(dict);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001432 }
1433 }
1434
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001435 if (f != NULL) {
Christian Heimese93237d2007-12-19 02:37:44 +00001436 res = f(descr, obj, (PyObject *)Py_TYPE(obj));
Michael W. Hudsonb2c7de42003-08-15 13:07:47 +00001437 Py_DECREF(descr);
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001438 goto done;
1439 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001440
1441 if (descr != NULL) {
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001442 res = descr;
Michael W. Hudsonb2c7de42003-08-15 13:07:47 +00001443 /* descr was already increfed above */
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001444 goto done;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001445 }
1446
1447 PyErr_Format(PyExc_AttributeError,
1448 "'%.50s' object has no attribute '%.400s'",
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001449 tp->tp_name, PyString_AS_STRING(name));
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001450 done:
1451 Py_DECREF(name);
1452 return res;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001453}
1454
1455int
1456PyObject_GenericSetAttr(PyObject *obj, PyObject *name, PyObject *value)
1457{
Christian Heimese93237d2007-12-19 02:37:44 +00001458 PyTypeObject *tp = Py_TYPE(obj);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001459 PyObject *descr;
1460 descrsetfunc f;
1461 PyObject **dictptr;
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001462 int res = -1;
1463
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001464 if (!PyString_Check(name)){
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001465#ifdef Py_USING_UNICODE
1466 /* The Unicode to string conversion is done here because the
1467 existing tp_setattro slots expect a string object as name
1468 and we wouldn't want to break those. */
1469 if (PyUnicode_Check(name)) {
1470 name = PyUnicode_AsEncodedString(name, NULL, NULL);
1471 if (name == NULL)
1472 return -1;
1473 }
Tim Peters803526b2002-07-07 05:13:56 +00001474 else
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001475#endif
1476 {
Georg Brandlccff7852006-06-18 22:17:29 +00001477 PyErr_Format(PyExc_TypeError,
1478 "attribute name must be string, not '%.200s'",
Christian Heimese93237d2007-12-19 02:37:44 +00001479 Py_TYPE(name)->tp_name);
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001480 return -1;
1481 }
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001482 }
1483 else
1484 Py_INCREF(name);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001485
1486 if (tp->tp_dict == NULL) {
Guido van Rossum528b7eb2001-08-07 17:24:28 +00001487 if (PyType_Ready(tp) < 0)
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001488 goto done;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001489 }
1490
1491 descr = _PyType_Lookup(tp, name);
1492 f = NULL;
Guido van Rossum90195e22003-02-19 03:19:29 +00001493 if (descr != NULL &&
1494 PyType_HasFeature(descr->ob_type, Py_TPFLAGS_HAVE_CLASS)) {
Tim Peters6d6c1a32001-08-02 04:15:00 +00001495 f = descr->ob_type->tp_descr_set;
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001496 if (f != NULL && PyDescr_IsData(descr)) {
1497 res = f(descr, obj, value);
1498 goto done;
1499 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001500 }
1501
1502 dictptr = _PyObject_GetDictPtr(obj);
1503 if (dictptr != NULL) {
1504 PyObject *dict = *dictptr;
1505 if (dict == NULL && value != NULL) {
1506 dict = PyDict_New();
1507 if (dict == NULL)
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001508 goto done;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001509 *dictptr = dict;
1510 }
1511 if (dict != NULL) {
Guido van Rossum37edeab2008-01-24 17:58:05 +00001512 Py_INCREF(dict);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001513 if (value == NULL)
1514 res = PyDict_DelItem(dict, name);
1515 else
1516 res = PyDict_SetItem(dict, name, value);
1517 if (res < 0 && PyErr_ExceptionMatches(PyExc_KeyError))
1518 PyErr_SetObject(PyExc_AttributeError, name);
Guido van Rossum37edeab2008-01-24 17:58:05 +00001519 Py_DECREF(dict);
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001520 goto done;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001521 }
1522 }
1523
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001524 if (f != NULL) {
1525 res = f(descr, obj, value);
1526 goto done;
1527 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001528
1529 if (descr == NULL) {
1530 PyErr_Format(PyExc_AttributeError,
Georg Brandlccff7852006-06-18 22:17:29 +00001531 "'%.100s' object has no attribute '%.200s'",
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001532 tp->tp_name, PyString_AS_STRING(name));
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001533 goto done;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001534 }
1535
1536 PyErr_Format(PyExc_AttributeError,
1537 "'%.50s' object attribute '%.400s' is read-only",
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001538 tp->tp_name, PyString_AS_STRING(name));
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001539 done:
1540 Py_DECREF(name);
1541 return res;
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001542}
1543
Guido van Rossum6ac258d1993-05-12 08:24:20 +00001544/* Test a value used as condition, e.g., in a for or if statement.
1545 Return -1 if an error occurred */
1546
1547int
Fred Drake100814d2000-07-09 15:48:49 +00001548PyObject_IsTrue(PyObject *v)
Guido van Rossum6ac258d1993-05-12 08:24:20 +00001549{
Martin v. Löwis18e16552006-02-15 17:27:45 +00001550 Py_ssize_t res;
Guido van Rossum6248f442002-08-24 06:31:34 +00001551 if (v == Py_True)
1552 return 1;
1553 if (v == Py_False)
1554 return 0;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001555 if (v == Py_None)
Neal Norwitz51290d32002-06-13 21:32:44 +00001556 return 0;
Guido van Rossum1c4f4581998-05-22 00:53:24 +00001557 else if (v->ob_type->tp_as_number != NULL &&
1558 v->ob_type->tp_as_number->nb_nonzero != NULL)
Guido van Rossum6ac258d1993-05-12 08:24:20 +00001559 res = (*v->ob_type->tp_as_number->nb_nonzero)(v);
Guido van Rossum1c4f4581998-05-22 00:53:24 +00001560 else if (v->ob_type->tp_as_mapping != NULL &&
1561 v->ob_type->tp_as_mapping->mp_length != NULL)
Guido van Rossum6ac258d1993-05-12 08:24:20 +00001562 res = (*v->ob_type->tp_as_mapping->mp_length)(v);
Guido van Rossum1c4f4581998-05-22 00:53:24 +00001563 else if (v->ob_type->tp_as_sequence != NULL &&
1564 v->ob_type->tp_as_sequence->sq_length != NULL)
Guido van Rossum6ac258d1993-05-12 08:24:20 +00001565 res = (*v->ob_type->tp_as_sequence->sq_length)(v);
1566 else
Neal Norwitz51290d32002-06-13 21:32:44 +00001567 return 1;
Martin v. Löwis18e16552006-02-15 17:27:45 +00001568 /* if it is negative, it should be either -1 or -2 */
1569 return (res > 0) ? 1 : Py_SAFE_DOWNCAST(res, Py_ssize_t, int);
Guido van Rossum6ac258d1993-05-12 08:24:20 +00001570}
1571
Tim Peters803526b2002-07-07 05:13:56 +00001572/* equivalent of 'not v'
Guido van Rossumc3d3f961998-04-09 17:53:59 +00001573 Return -1 if an error occurred */
1574
1575int
Fred Drake100814d2000-07-09 15:48:49 +00001576PyObject_Not(PyObject *v)
Guido van Rossumc3d3f961998-04-09 17:53:59 +00001577{
1578 int res;
1579 res = PyObject_IsTrue(v);
1580 if (res < 0)
1581 return res;
1582 return res == 0;
1583}
1584
Guido van Rossum5524a591995-01-10 15:26:20 +00001585/* Coerce two numeric types to the "larger" one.
1586 Increment the reference count on each argument.
Guido van Rossume797ec12001-01-17 15:24:28 +00001587 Return value:
1588 -1 if an error occurred;
1589 0 if the coercion succeeded (and then the reference counts are increased);
1590 1 if no coercion is possible (and no error is raised).
Guido van Rossum5524a591995-01-10 15:26:20 +00001591*/
Guido van Rossum5524a591995-01-10 15:26:20 +00001592int
Fred Drake100814d2000-07-09 15:48:49 +00001593PyNumber_CoerceEx(PyObject **pv, PyObject **pw)
Guido van Rossum5524a591995-01-10 15:26:20 +00001594{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001595 register PyObject *v = *pv;
1596 register PyObject *w = *pw;
Guido van Rossum5524a591995-01-10 15:26:20 +00001597 int res;
1598
Guido van Rossum517c7d42002-04-26 02:49:14 +00001599 /* Shortcut only for old-style types */
1600 if (v->ob_type == w->ob_type &&
1601 !PyType_HasFeature(v->ob_type, Py_TPFLAGS_CHECKTYPES))
1602 {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001603 Py_INCREF(v);
1604 Py_INCREF(w);
Guido van Rossum5524a591995-01-10 15:26:20 +00001605 return 0;
1606 }
1607 if (v->ob_type->tp_as_number && v->ob_type->tp_as_number->nb_coerce) {
1608 res = (*v->ob_type->tp_as_number->nb_coerce)(pv, pw);
1609 if (res <= 0)
1610 return res;
1611 }
1612 if (w->ob_type->tp_as_number && w->ob_type->tp_as_number->nb_coerce) {
1613 res = (*w->ob_type->tp_as_number->nb_coerce)(pw, pv);
1614 if (res <= 0)
1615 return res;
1616 }
Guido van Rossum242c6421997-11-19 16:03:17 +00001617 return 1;
1618}
1619
Guido van Rossume797ec12001-01-17 15:24:28 +00001620/* Coerce two numeric types to the "larger" one.
1621 Increment the reference count on each argument.
1622 Return -1 and raise an exception if no coercion is possible
1623 (and then no reference count is incremented).
1624*/
Guido van Rossum242c6421997-11-19 16:03:17 +00001625int
Fred Drake100814d2000-07-09 15:48:49 +00001626PyNumber_Coerce(PyObject **pv, PyObject **pw)
Guido van Rossum242c6421997-11-19 16:03:17 +00001627{
1628 int err = PyNumber_CoerceEx(pv, pw);
1629 if (err <= 0)
1630 return err;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001631 PyErr_SetString(PyExc_TypeError, "number coercion failed");
Guido van Rossum5524a591995-01-10 15:26:20 +00001632 return -1;
1633}
1634
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001635
Guido van Rossum49b11fe1995-01-26 00:38:22 +00001636/* Test whether an object can be called */
1637
1638int
Fred Drake100814d2000-07-09 15:48:49 +00001639PyCallable_Check(PyObject *x)
Guido van Rossum49b11fe1995-01-26 00:38:22 +00001640{
1641 if (x == NULL)
1642 return 0;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001643 if (PyInstance_Check(x)) {
1644 PyObject *call = PyObject_GetAttrString(x, "__call__");
Guido van Rossum49b11fe1995-01-26 00:38:22 +00001645 if (call == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001646 PyErr_Clear();
Guido van Rossum49b11fe1995-01-26 00:38:22 +00001647 return 0;
1648 }
1649 /* Could test recursively but don't, for fear of endless
1650 recursion if some joker sets self.__call__ = self */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001651 Py_DECREF(call);
Guido van Rossum49b11fe1995-01-26 00:38:22 +00001652 return 1;
1653 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001654 else {
1655 return x->ob_type->tp_call != NULL;
1656 }
Guido van Rossum49b11fe1995-01-26 00:38:22 +00001657}
1658
Georg Brandl871f1bc2007-03-12 13:17:36 +00001659/* ------------------------- PyObject_Dir() helpers ------------------------- */
1660
Tim Peters7eea37e2001-09-04 22:08:56 +00001661/* Helper for PyObject_Dir.
1662 Merge the __dict__ of aclass into dict, and recursively also all
1663 the __dict__s of aclass's base classes. The order of merging isn't
1664 defined, as it's expected that only the final set of dict keys is
1665 interesting.
1666 Return 0 on success, -1 on error.
1667*/
1668
1669static int
1670merge_class_dict(PyObject* dict, PyObject* aclass)
1671{
1672 PyObject *classdict;
1673 PyObject *bases;
1674
1675 assert(PyDict_Check(dict));
1676 assert(aclass);
1677
1678 /* Merge in the type's dict (if any). */
1679 classdict = PyObject_GetAttrString(aclass, "__dict__");
1680 if (classdict == NULL)
1681 PyErr_Clear();
1682 else {
1683 int status = PyDict_Update(dict, classdict);
1684 Py_DECREF(classdict);
1685 if (status < 0)
1686 return -1;
1687 }
1688
1689 /* Recursively merge in the base types' (if any) dicts. */
1690 bases = PyObject_GetAttrString(aclass, "__bases__");
Tim Petersbc7e8632001-09-16 20:33:22 +00001691 if (bases == NULL)
1692 PyErr_Clear();
1693 else {
Guido van Rossum44022412002-05-13 18:29:46 +00001694 /* We have no guarantee that bases is a real tuple */
Martin v. Löwis18e16552006-02-15 17:27:45 +00001695 Py_ssize_t i, n;
Guido van Rossum44022412002-05-13 18:29:46 +00001696 n = PySequence_Size(bases); /* This better be right */
1697 if (n < 0)
1698 PyErr_Clear();
1699 else {
1700 for (i = 0; i < n; i++) {
Tim Peters18e70832003-02-05 19:35:19 +00001701 int status;
Guido van Rossum44022412002-05-13 18:29:46 +00001702 PyObject *base = PySequence_GetItem(bases, i);
1703 if (base == NULL) {
1704 Py_DECREF(bases);
1705 return -1;
1706 }
Tim Peters18e70832003-02-05 19:35:19 +00001707 status = merge_class_dict(dict, base);
1708 Py_DECREF(base);
1709 if (status < 0) {
Guido van Rossum44022412002-05-13 18:29:46 +00001710 Py_DECREF(bases);
1711 return -1;
1712 }
Tim Peters7eea37e2001-09-04 22:08:56 +00001713 }
1714 }
1715 Py_DECREF(bases);
1716 }
1717 return 0;
1718}
1719
Tim Peters305b5852001-09-17 02:38:46 +00001720/* Helper for PyObject_Dir.
1721 If obj has an attr named attrname that's a list, merge its string
1722 elements into keys of dict.
1723 Return 0 on success, -1 on error. Errors due to not finding the attr,
1724 or the attr not being a list, are suppressed.
1725*/
1726
1727static int
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001728merge_list_attr(PyObject* dict, PyObject* obj, const char *attrname)
Tim Peters305b5852001-09-17 02:38:46 +00001729{
1730 PyObject *list;
1731 int result = 0;
1732
1733 assert(PyDict_Check(dict));
1734 assert(obj);
1735 assert(attrname);
1736
1737 list = PyObject_GetAttrString(obj, attrname);
1738 if (list == NULL)
1739 PyErr_Clear();
1740
1741 else if (PyList_Check(list)) {
1742 int i;
1743 for (i = 0; i < PyList_GET_SIZE(list); ++i) {
1744 PyObject *item = PyList_GET_ITEM(list, i);
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001745 if (PyString_Check(item)) {
Tim Peters305b5852001-09-17 02:38:46 +00001746 result = PyDict_SetItem(dict, item, Py_None);
1747 if (result < 0)
1748 break;
1749 }
1750 }
Georg Brandl07e56812008-03-21 20:21:46 +00001751 if (Py_Py3kWarningFlag &&
1752 (strcmp(attrname, "__members__") == 0 ||
1753 strcmp(attrname, "__methods__") == 0)) {
Benjamin Peterson9f4f4812008-04-27 03:01:45 +00001754 if (PyErr_WarnEx(PyExc_DeprecationWarning,
Georg Brandld5b635f2008-03-25 08:29:14 +00001755 "__members__ and __methods__ not "
Benjamin Peterson9f4f4812008-04-27 03:01:45 +00001756 "supported in 3.x", 1) < 0) {
Georg Brandl07e56812008-03-21 20:21:46 +00001757 Py_XDECREF(list);
1758 return -1;
1759 }
1760 }
Tim Peters305b5852001-09-17 02:38:46 +00001761 }
1762
1763 Py_XDECREF(list);
1764 return result;
1765}
1766
Georg Brandl871f1bc2007-03-12 13:17:36 +00001767/* Helper for PyObject_Dir without arguments: returns the local scope. */
1768static PyObject *
Jeremy Hylton26ca9252007-03-16 14:49:11 +00001769_dir_locals(void)
Tim Peters7eea37e2001-09-04 22:08:56 +00001770{
Georg Brandl871f1bc2007-03-12 13:17:36 +00001771 PyObject *names;
1772 PyObject *locals = PyEval_GetLocals();
Tim Peters7eea37e2001-09-04 22:08:56 +00001773
Georg Brandl871f1bc2007-03-12 13:17:36 +00001774 if (locals == NULL) {
1775 PyErr_SetString(PyExc_SystemError, "frame does not exist");
1776 return NULL;
Tim Peters7eea37e2001-09-04 22:08:56 +00001777 }
1778
Georg Brandl871f1bc2007-03-12 13:17:36 +00001779 names = PyMapping_Keys(locals);
1780 if (!names)
1781 return NULL;
1782 if (!PyList_Check(names)) {
Georg Brandlccff7852006-06-18 22:17:29 +00001783 PyErr_Format(PyExc_TypeError,
Georg Brandl871f1bc2007-03-12 13:17:36 +00001784 "dir(): expected keys() of locals to be a list, "
Christian Heimese93237d2007-12-19 02:37:44 +00001785 "not '%.200s'", Py_TYPE(names)->tp_name);
Georg Brandl871f1bc2007-03-12 13:17:36 +00001786 Py_DECREF(names);
1787 return NULL;
Raymond Hettinger2a7dede2004-08-07 04:55:30 +00001788 }
Georg Brandl871f1bc2007-03-12 13:17:36 +00001789 /* the locals don't need to be DECREF'd */
1790 return names;
1791}
Tim Peters7eea37e2001-09-04 22:08:56 +00001792
Georg Brandl871f1bc2007-03-12 13:17:36 +00001793/* Helper for PyObject_Dir of type objects: returns __dict__ and __bases__.
1794 We deliberately don't suck up its __class__, as methods belonging to the
1795 metaclass would probably be more confusing than helpful.
1796*/
1797static PyObject *
1798_specialized_dir_type(PyObject *obj)
1799{
1800 PyObject *result = NULL;
1801 PyObject *dict = PyDict_New();
1802
1803 if (dict != NULL && merge_class_dict(dict, obj) == 0)
1804 result = PyDict_Keys(dict);
1805
1806 Py_XDECREF(dict);
1807 return result;
1808}
1809
1810/* Helper for PyObject_Dir of module objects: returns the module's __dict__. */
1811static PyObject *
1812_specialized_dir_module(PyObject *obj)
1813{
1814 PyObject *result = NULL;
1815 PyObject *dict = PyObject_GetAttrString(obj, "__dict__");
1816
1817 if (dict != NULL) {
1818 if (PyDict_Check(dict))
1819 result = PyDict_Keys(dict);
1820 else {
1821 PyErr_Format(PyExc_TypeError,
1822 "%.200s.__dict__ is not a dictionary",
1823 PyModule_GetName(obj));
1824 }
1825 }
1826
1827 Py_XDECREF(dict);
1828 return result;
1829}
1830
1831/* Helper for PyObject_Dir of generic objects: returns __dict__, __class__,
1832 and recursively up the __class__.__bases__ chain.
1833*/
1834static PyObject *
1835_generic_dir(PyObject *obj)
1836{
1837 PyObject *result = NULL;
1838 PyObject *dict = NULL;
1839 PyObject *itsclass = NULL;
1840
1841 /* Get __dict__ (which may or may not be a real dict...) */
1842 dict = PyObject_GetAttrString(obj, "__dict__");
1843 if (dict == NULL) {
1844 PyErr_Clear();
1845 dict = PyDict_New();
1846 }
1847 else if (!PyDict_Check(dict)) {
1848 Py_DECREF(dict);
1849 dict = PyDict_New();
1850 }
1851 else {
1852 /* Copy __dict__ to avoid mutating it. */
1853 PyObject *temp = PyDict_Copy(dict);
1854 Py_DECREF(dict);
1855 dict = temp;
1856 }
1857
1858 if (dict == NULL)
1859 goto error;
1860
1861 /* Merge in __members__ and __methods__ (if any).
1862 * This is removed in Python 3000. */
1863 if (merge_list_attr(dict, obj, "__members__") < 0)
1864 goto error;
1865 if (merge_list_attr(dict, obj, "__methods__") < 0)
1866 goto error;
1867
1868 /* Merge in attrs reachable from its class. */
1869 itsclass = PyObject_GetAttrString(obj, "__class__");
1870 if (itsclass == NULL)
1871 /* XXX(tomer): Perhaps fall back to obj->ob_type if no
1872 __class__ exists? */
1873 PyErr_Clear();
1874 else {
1875 if (merge_class_dict(dict, itsclass) != 0)
1876 goto error;
1877 }
1878
1879 result = PyDict_Keys(dict);
Tim Peters7eea37e2001-09-04 22:08:56 +00001880 /* fall through */
Georg Brandl871f1bc2007-03-12 13:17:36 +00001881error:
1882 Py_XDECREF(itsclass);
1883 Py_XDECREF(dict);
1884 return result;
1885}
1886
1887/* Helper for PyObject_Dir: object introspection.
1888 This calls one of the above specialized versions if no __dir__ method
1889 exists. */
1890static PyObject *
1891_dir_object(PyObject *obj)
1892{
Georg Brandl3bb15672007-03-13 07:23:16 +00001893 PyObject *result = NULL;
1894 PyObject *dirfunc = PyObject_GetAttrString((PyObject *)obj->ob_type,
1895 "__dir__");
Georg Brandl871f1bc2007-03-12 13:17:36 +00001896
1897 assert(obj);
1898 if (dirfunc == NULL) {
1899 /* use default implementation */
1900 PyErr_Clear();
1901 if (PyModule_Check(obj))
1902 result = _specialized_dir_module(obj);
1903 else if (PyType_Check(obj) || PyClass_Check(obj))
1904 result = _specialized_dir_type(obj);
1905 else
1906 result = _generic_dir(obj);
1907 }
1908 else {
1909 /* use __dir__ */
1910 result = PyObject_CallFunctionObjArgs(dirfunc, obj, NULL);
1911 Py_DECREF(dirfunc);
1912 if (result == NULL)
1913 return NULL;
1914
1915 /* result must be a list */
1916 /* XXX(gbrandl): could also check if all items are strings */
1917 if (!PyList_Check(result)) {
1918 PyErr_Format(PyExc_TypeError,
1919 "__dir__() must return a list, not %.200s",
Christian Heimese93237d2007-12-19 02:37:44 +00001920 Py_TYPE(result)->tp_name);
Georg Brandl871f1bc2007-03-12 13:17:36 +00001921 Py_DECREF(result);
1922 result = NULL;
1923 }
1924 }
1925
1926 return result;
1927}
1928
1929/* Implementation of dir() -- if obj is NULL, returns the names in the current
1930 (local) scope. Otherwise, performs introspection of the object: returns a
1931 sorted list of attribute names (supposedly) accessible from the object
1932*/
1933PyObject *
1934PyObject_Dir(PyObject *obj)
1935{
1936 PyObject * result;
1937
1938 if (obj == NULL)
1939 /* no object -- introspect the locals */
1940 result = _dir_locals();
1941 else
1942 /* object -- introspect the object */
1943 result = _dir_object(obj);
1944
1945 assert(result == NULL || PyList_Check(result));
1946
1947 if (result != NULL && PyList_Sort(result) != 0) {
1948 /* sorting the list failed */
1949 Py_DECREF(result);
1950 result = NULL;
1951 }
1952
Tim Peters7eea37e2001-09-04 22:08:56 +00001953 return result;
1954}
Guido van Rossum49b11fe1995-01-26 00:38:22 +00001955
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001956/*
1957NoObject is usable as a non-NULL undefined value, used by the macro None.
1958There is (and should be!) no way to create other objects of this type,
Guido van Rossum3f5da241990-12-20 15:06:42 +00001959so there is exactly one (which is indestructible, by the way).
Guido van Rossumba21a492001-08-16 08:17:26 +00001960(XXX This type and the type of NotImplemented below should be unified.)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001961*/
1962
Guido van Rossum0c182a11992-03-27 17:26:13 +00001963/* ARGSUSED */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001964static PyObject *
Fred Drake100814d2000-07-09 15:48:49 +00001965none_repr(PyObject *op)
Guido van Rossum3f5da241990-12-20 15:06:42 +00001966{
Gregory P. Smithdd96db62008-06-09 04:58:54 +00001967 return PyString_FromString("None");
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001968}
1969
Barry Warsaw9bf16442001-01-23 16:24:35 +00001970/* ARGUSED */
1971static void
Tim Peters803526b2002-07-07 05:13:56 +00001972none_dealloc(PyObject* ignore)
Barry Warsaw9bf16442001-01-23 16:24:35 +00001973{
1974 /* This should never get called, but we also don't want to SEGV if
1975 * we accidently decref None out of existance.
1976 */
Martin v. Löwis3f19b102002-08-07 16:21:51 +00001977 Py_FatalError("deallocating None");
Barry Warsaw9bf16442001-01-23 16:24:35 +00001978}
1979
1980
Guido van Rossumba21a492001-08-16 08:17:26 +00001981static PyTypeObject PyNone_Type = {
Martin v. Löwis68192102007-07-21 06:55:02 +00001982 PyVarObject_HEAD_INIT(&PyType_Type, 0)
Guido van Rossumba21a492001-08-16 08:17:26 +00001983 "NoneType",
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001984 0,
1985 0,
Georg Brandl347b3002006-03-30 11:57:00 +00001986 none_dealloc, /*tp_dealloc*/ /*never called*/
Guido van Rossum7066dd71992-09-17 17:54:56 +00001987 0, /*tp_print*/
Guido van Rossum3f5da241990-12-20 15:06:42 +00001988 0, /*tp_getattr*/
1989 0, /*tp_setattr*/
1990 0, /*tp_compare*/
Georg Brandl347b3002006-03-30 11:57:00 +00001991 none_repr, /*tp_repr*/
Guido van Rossum3f5da241990-12-20 15:06:42 +00001992 0, /*tp_as_number*/
1993 0, /*tp_as_sequence*/
1994 0, /*tp_as_mapping*/
Guido van Rossum64c06e32007-11-22 00:55:51 +00001995 (hashfunc)_Py_HashPointer, /*tp_hash */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001996};
1997
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001998PyObject _Py_NoneStruct = {
Martin v. Löwis68192102007-07-21 06:55:02 +00001999 _PyObject_EXTRA_INIT
2000 1, &PyNone_Type
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002001};
2002
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +00002003/* NotImplemented is an object that can be used to signal that an
2004 operation is not implemented for the given type combination. */
2005
2006static PyObject *
2007NotImplemented_repr(PyObject *op)
2008{
Gregory P. Smithdd96db62008-06-09 04:58:54 +00002009 return PyString_FromString("NotImplemented");
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +00002010}
2011
2012static PyTypeObject PyNotImplemented_Type = {
Martin v. Löwis68192102007-07-21 06:55:02 +00002013 PyVarObject_HEAD_INIT(&PyType_Type, 0)
Guido van Rossumba21a492001-08-16 08:17:26 +00002014 "NotImplementedType",
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +00002015 0,
2016 0,
Georg Brandl347b3002006-03-30 11:57:00 +00002017 none_dealloc, /*tp_dealloc*/ /*never called*/
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +00002018 0, /*tp_print*/
2019 0, /*tp_getattr*/
2020 0, /*tp_setattr*/
2021 0, /*tp_compare*/
Georg Brandl347b3002006-03-30 11:57:00 +00002022 NotImplemented_repr, /*tp_repr*/
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +00002023 0, /*tp_as_number*/
2024 0, /*tp_as_sequence*/
2025 0, /*tp_as_mapping*/
2026 0, /*tp_hash */
2027};
2028
2029PyObject _Py_NotImplementedStruct = {
Martin v. Löwis68192102007-07-21 06:55:02 +00002030 _PyObject_EXTRA_INIT
2031 1, &PyNotImplemented_Type
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +00002032};
2033
Guido van Rossumba21a492001-08-16 08:17:26 +00002034void
2035_Py_ReadyTypes(void)
2036{
2037 if (PyType_Ready(&PyType_Type) < 0)
2038 Py_FatalError("Can't initialize 'type'");
2039
Fred Drake0a4dd392004-07-02 18:57:45 +00002040 if (PyType_Ready(&_PyWeakref_RefType) < 0)
2041 Py_FatalError("Can't initialize 'weakref'");
2042
Guido van Rossum77f6a652002-04-03 22:41:51 +00002043 if (PyType_Ready(&PyBool_Type) < 0)
2044 Py_FatalError("Can't initialize 'bool'");
2045
Gregory P. Smithdd96db62008-06-09 04:58:54 +00002046 if (PyType_Ready(&PyString_Type) < 0)
Guido van Rossumcacfc072002-05-24 19:01:59 +00002047 Py_FatalError("Can't initialize 'str'");
2048
Christian Heimes3497f942008-05-26 12:29:14 +00002049 if (PyType_Ready(&PyByteArray_Type) < 0)
Christian Heimes1a6387e2008-03-26 12:49:49 +00002050 Py_FatalError("Can't initialize 'bytes'");
2051
Guido van Rossumba21a492001-08-16 08:17:26 +00002052 if (PyType_Ready(&PyList_Type) < 0)
2053 Py_FatalError("Can't initialize 'list'");
2054
2055 if (PyType_Ready(&PyNone_Type) < 0)
2056 Py_FatalError("Can't initialize type(None)");
2057
2058 if (PyType_Ready(&PyNotImplemented_Type) < 0)
2059 Py_FatalError("Can't initialize type(NotImplemented)");
2060}
2061
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002062
Guido van Rossum84a90321996-05-22 16:34:47 +00002063#ifdef Py_TRACE_REFS
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002064
Guido van Rossumaacdc9d1996-08-12 21:32:12 +00002065void
Fred Drake100814d2000-07-09 15:48:49 +00002066_Py_NewReference(PyObject *op)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002067{
Tim Peters34592512002-07-11 06:23:50 +00002068 _Py_INC_REFTOTAL;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002069 op->ob_refcnt = 1;
Tim Peters7571a0f2003-03-23 17:52:28 +00002070 _Py_AddToAllObjects(op, 1);
Tim Peters34592512002-07-11 06:23:50 +00002071 _Py_INC_TPALLOCS(op);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002072}
2073
Guido van Rossumaacdc9d1996-08-12 21:32:12 +00002074void
Fred Drake100814d2000-07-09 15:48:49 +00002075_Py_ForgetReference(register PyObject *op)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002076{
Guido van Rossumbffd6832000-01-20 22:32:56 +00002077#ifdef SLOW_UNREF_CHECK
Guido van Rossum4c08d552000-03-10 22:55:18 +00002078 register PyObject *p;
Guido van Rossumbffd6832000-01-20 22:32:56 +00002079#endif
Guido van Rossumd7047b31995-01-02 19:07:15 +00002080 if (op->ob_refcnt < 0)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002081 Py_FatalError("UNREF negative refcnt");
Guido van Rossum2e8f6141992-09-03 20:32:55 +00002082 if (op == &refchain ||
Guido van Rossumd7047b31995-01-02 19:07:15 +00002083 op->_ob_prev->_ob_next != op || op->_ob_next->_ob_prev != op)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002084 Py_FatalError("UNREF invalid object");
Guido van Rossum2e8f6141992-09-03 20:32:55 +00002085#ifdef SLOW_UNREF_CHECK
Guido van Rossum3f5da241990-12-20 15:06:42 +00002086 for (p = refchain._ob_next; p != &refchain; p = p->_ob_next) {
2087 if (p == op)
2088 break;
2089 }
Guido van Rossumd7047b31995-01-02 19:07:15 +00002090 if (p == &refchain) /* Not found */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002091 Py_FatalError("UNREF unknown object");
Guido van Rossum2e8f6141992-09-03 20:32:55 +00002092#endif
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002093 op->_ob_next->_ob_prev = op->_ob_prev;
2094 op->_ob_prev->_ob_next = op->_ob_next;
Guido van Rossum2e8f6141992-09-03 20:32:55 +00002095 op->_ob_next = op->_ob_prev = NULL;
Tim Peters34592512002-07-11 06:23:50 +00002096 _Py_INC_TPFREES(op);
Guido van Rossum3f5da241990-12-20 15:06:42 +00002097}
2098
Guido van Rossumaacdc9d1996-08-12 21:32:12 +00002099void
Fred Drake100814d2000-07-09 15:48:49 +00002100_Py_Dealloc(PyObject *op)
Guido van Rossum3f5da241990-12-20 15:06:42 +00002101{
Christian Heimese93237d2007-12-19 02:37:44 +00002102 destructor dealloc = Py_TYPE(op)->tp_dealloc;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002103 _Py_ForgetReference(op);
Guido van Rossum9776adf1994-09-07 14:36:45 +00002104 (*dealloc)(op);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002105}
2106
Tim Peters269b2a62003-04-17 19:52:29 +00002107/* Print all live objects. Because PyObject_Print is called, the
2108 * interpreter must be in a healthy state.
2109 */
Guido van Rossumaacdc9d1996-08-12 21:32:12 +00002110void
Fred Drake100814d2000-07-09 15:48:49 +00002111_Py_PrintReferences(FILE *fp)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002112{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002113 PyObject *op;
Guido van Rossume09fb551997-08-05 02:04:34 +00002114 fprintf(fp, "Remaining objects:\n");
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002115 for (op = refchain._ob_next; op != &refchain; op = op->_ob_next) {
Tim Peterscbd6f182006-04-11 19:12:33 +00002116 fprintf(fp, "%p [%" PY_FORMAT_SIZE_T "d] ", op, op->ob_refcnt);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002117 if (PyObject_Print(op, fp, 0) != 0)
2118 PyErr_Clear();
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002119 putc('\n', fp);
2120 }
2121}
2122
Tim Peters269b2a62003-04-17 19:52:29 +00002123/* Print the addresses of all live objects. Unlike _Py_PrintReferences, this
2124 * doesn't make any calls to the Python C API, so is always safe to call.
2125 */
2126void
2127_Py_PrintReferenceAddresses(FILE *fp)
2128{
2129 PyObject *op;
2130 fprintf(fp, "Remaining object addresses:\n");
2131 for (op = refchain._ob_next; op != &refchain; op = op->_ob_next)
Tim Peterscbd6f182006-04-11 19:12:33 +00002132 fprintf(fp, "%p [%" PY_FORMAT_SIZE_T "d] %s\n", op,
Christian Heimese93237d2007-12-19 02:37:44 +00002133 op->ob_refcnt, Py_TYPE(op)->tp_name);
Tim Peters269b2a62003-04-17 19:52:29 +00002134}
2135
Sjoerd Mullender6ec3c651995-08-29 09:18:14 +00002136PyObject *
Fred Drake100814d2000-07-09 15:48:49 +00002137_Py_GetObjects(PyObject *self, PyObject *args)
Sjoerd Mullender6ec3c651995-08-29 09:18:14 +00002138{
2139 int i, n;
2140 PyObject *t = NULL;
2141 PyObject *res, *op;
2142
2143 if (!PyArg_ParseTuple(args, "i|O", &n, &t))
2144 return NULL;
2145 op = refchain._ob_next;
2146 res = PyList_New(0);
2147 if (res == NULL)
2148 return NULL;
2149 for (i = 0; (n == 0 || i < n) && op != &refchain; i++) {
2150 while (op == self || op == args || op == res || op == t ||
Christian Heimese93237d2007-12-19 02:37:44 +00002151 (t != NULL && Py_TYPE(op) != (PyTypeObject *) t)) {
Sjoerd Mullender6ec3c651995-08-29 09:18:14 +00002152 op = op->_ob_next;
2153 if (op == &refchain)
2154 return res;
2155 }
2156 if (PyList_Append(res, op) < 0) {
2157 Py_DECREF(res);
2158 return NULL;
2159 }
2160 op = op->_ob_next;
2161 }
2162 return res;
2163}
2164
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002165#endif
Guido van Rossum97ead3f1996-01-12 01:24:09 +00002166
2167
2168/* Hack to force loading of cobject.o */
Guido van Rossumda9c2711996-12-05 21:58:58 +00002169PyTypeObject *_Py_cobject_hack = &PyCObject_Type;
Guido van Rossum84a90321996-05-22 16:34:47 +00002170
2171
2172/* Hack to force loading of abstract.o */
Martin v. Löwis18e16552006-02-15 17:27:45 +00002173Py_ssize_t (*_Py_abstract_hack)(PyObject *) = PyObject_Size;
Guido van Rossume09fb551997-08-05 02:04:34 +00002174
2175
Andrew M. Kuchling1582a3a2000-08-16 12:27:23 +00002176/* Python's malloc wrappers (see pymem.h) */
Guido van Rossume09fb551997-08-05 02:04:34 +00002177
Thomas Wouters334fb892000-07-25 12:56:38 +00002178void *
Fred Drake100814d2000-07-09 15:48:49 +00002179PyMem_Malloc(size_t nbytes)
Guido van Rossume09fb551997-08-05 02:04:34 +00002180{
Guido van Rossumb18618d2000-05-03 23:44:39 +00002181 return PyMem_MALLOC(nbytes);
Guido van Rossume09fb551997-08-05 02:04:34 +00002182}
2183
Thomas Wouters334fb892000-07-25 12:56:38 +00002184void *
2185PyMem_Realloc(void *p, size_t nbytes)
Guido van Rossume09fb551997-08-05 02:04:34 +00002186{
Tim Petersaf3e8de2002-04-12 07:22:56 +00002187 return PyMem_REALLOC(p, nbytes);
Guido van Rossume09fb551997-08-05 02:04:34 +00002188}
2189
2190void
Thomas Wouters334fb892000-07-25 12:56:38 +00002191PyMem_Free(void *p)
Guido van Rossume09fb551997-08-05 02:04:34 +00002192{
Guido van Rossumb18618d2000-05-03 23:44:39 +00002193 PyMem_FREE(p);
2194}
2195
2196
Guido van Rossum86610361998-04-10 22:32:46 +00002197/* These methods are used to control infinite recursion in repr, str, print,
2198 etc. Container objects that may recursively contain themselves,
2199 e.g. builtin dictionaries and lists, should used Py_ReprEnter() and
2200 Py_ReprLeave() to avoid infinite recursion.
2201
2202 Py_ReprEnter() returns 0 the first time it is called for a particular
2203 object and 1 every time thereafter. It returns -1 if an exception
2204 occurred. Py_ReprLeave() has no return value.
2205
2206 See dictobject.c and listobject.c for examples of use.
2207*/
2208
2209#define KEY "Py_Repr"
2210
2211int
Fred Drake100814d2000-07-09 15:48:49 +00002212Py_ReprEnter(PyObject *obj)
Guido van Rossum86610361998-04-10 22:32:46 +00002213{
2214 PyObject *dict;
2215 PyObject *list;
Martin v. Löwis18e16552006-02-15 17:27:45 +00002216 Py_ssize_t i;
Guido van Rossum86610361998-04-10 22:32:46 +00002217
2218 dict = PyThreadState_GetDict();
2219 if (dict == NULL)
Guido van Rossum0fc8f002003-04-15 15:12:39 +00002220 return 0;
Guido van Rossum86610361998-04-10 22:32:46 +00002221 list = PyDict_GetItemString(dict, KEY);
2222 if (list == NULL) {
2223 list = PyList_New(0);
2224 if (list == NULL)
2225 return -1;
2226 if (PyDict_SetItemString(dict, KEY, list) < 0)
2227 return -1;
2228 Py_DECREF(list);
2229 }
2230 i = PyList_GET_SIZE(list);
2231 while (--i >= 0) {
2232 if (PyList_GET_ITEM(list, i) == obj)
2233 return 1;
2234 }
2235 PyList_Append(list, obj);
2236 return 0;
2237}
2238
2239void
Fred Drake100814d2000-07-09 15:48:49 +00002240Py_ReprLeave(PyObject *obj)
Guido van Rossum86610361998-04-10 22:32:46 +00002241{
2242 PyObject *dict;
2243 PyObject *list;
Martin v. Löwis18e16552006-02-15 17:27:45 +00002244 Py_ssize_t i;
Guido van Rossum86610361998-04-10 22:32:46 +00002245
2246 dict = PyThreadState_GetDict();
Guido van Rossumeb909461998-04-11 15:17:34 +00002247 if (dict == NULL)
2248 return;
Guido van Rossum86610361998-04-10 22:32:46 +00002249 list = PyDict_GetItemString(dict, KEY);
Guido van Rossumeb909461998-04-11 15:17:34 +00002250 if (list == NULL || !PyList_Check(list))
2251 return;
Guido van Rossum86610361998-04-10 22:32:46 +00002252 i = PyList_GET_SIZE(list);
2253 /* Count backwards because we always expect obj to be list[-1] */
2254 while (--i >= 0) {
2255 if (PyList_GET_ITEM(list, i) == obj) {
2256 PyList_SetSlice(list, i, i + 1, NULL);
2257 break;
2258 }
2259 }
2260}
Guido van Rossumd724b232000-03-13 16:01:29 +00002261
Tim Peters803526b2002-07-07 05:13:56 +00002262/* Trashcan support. */
Guido van Rossumd724b232000-03-13 16:01:29 +00002263
Tim Peters803526b2002-07-07 05:13:56 +00002264/* Current call-stack depth of tp_dealloc calls. */
Guido van Rossumd724b232000-03-13 16:01:29 +00002265int _PyTrash_delete_nesting = 0;
Guido van Rossume92e6102000-04-24 15:40:53 +00002266
Tim Peters803526b2002-07-07 05:13:56 +00002267/* List of objects that still need to be cleaned up, singly linked via their
2268 * gc headers' gc_prev pointers.
2269 */
2270PyObject *_PyTrash_delete_later = NULL;
Guido van Rossumd724b232000-03-13 16:01:29 +00002271
Tim Peters803526b2002-07-07 05:13:56 +00002272/* Add op to the _PyTrash_delete_later list. Called when the current
2273 * call-stack depth gets large. op must be a currently untracked gc'ed
2274 * object, with refcount 0. Py_DECREF must already have been called on it.
2275 */
Guido van Rossumd724b232000-03-13 16:01:29 +00002276void
Fred Drake100814d2000-07-09 15:48:49 +00002277_PyTrash_deposit_object(PyObject *op)
Guido van Rossumd724b232000-03-13 16:01:29 +00002278{
Tim Peters803526b2002-07-07 05:13:56 +00002279 assert(PyObject_IS_GC(op));
2280 assert(_Py_AS_GC(op)->gc.gc_refs == _PyGC_REFS_UNTRACKED);
2281 assert(op->ob_refcnt == 0);
Neil Schemenauerf589c052002-03-29 03:05:54 +00002282 _Py_AS_GC(op)->gc.gc_prev = (PyGC_Head *)_PyTrash_delete_later;
Guido van Rossume92e6102000-04-24 15:40:53 +00002283 _PyTrash_delete_later = op;
Guido van Rossumd724b232000-03-13 16:01:29 +00002284}
2285
Tim Peters803526b2002-07-07 05:13:56 +00002286/* Dealloccate all the objects in the _PyTrash_delete_later list. Called when
2287 * the call-stack unwinds again.
2288 */
Guido van Rossumd724b232000-03-13 16:01:29 +00002289void
Fred Drake100814d2000-07-09 15:48:49 +00002290_PyTrash_destroy_chain(void)
Guido van Rossumd724b232000-03-13 16:01:29 +00002291{
2292 while (_PyTrash_delete_later) {
Tim Peters803526b2002-07-07 05:13:56 +00002293 PyObject *op = _PyTrash_delete_later;
Christian Heimese93237d2007-12-19 02:37:44 +00002294 destructor dealloc = Py_TYPE(op)->tp_dealloc;
Neil Schemenauerf589c052002-03-29 03:05:54 +00002295
Neil Schemenauerf589c052002-03-29 03:05:54 +00002296 _PyTrash_delete_later =
Tim Peters803526b2002-07-07 05:13:56 +00002297 (PyObject*) _Py_AS_GC(op)->gc.gc_prev;
Neil Schemenauerf589c052002-03-29 03:05:54 +00002298
Tim Peters803526b2002-07-07 05:13:56 +00002299 /* Call the deallocator directly. This used to try to
2300 * fool Py_DECREF into calling it indirectly, but
2301 * Py_DECREF was already called on this object, and in
2302 * assorted non-release builds calling Py_DECREF again ends
2303 * up distorting allocation statistics.
2304 */
2305 assert(op->ob_refcnt == 0);
Guido van Rossumd724b232000-03-13 16:01:29 +00002306 ++_PyTrash_delete_nesting;
Tim Peters803526b2002-07-07 05:13:56 +00002307 (*dealloc)(op);
Guido van Rossumd724b232000-03-13 16:01:29 +00002308 --_PyTrash_delete_nesting;
2309 }
2310}
Anthony Baxterac6bd462006-04-13 02:06:09 +00002311
2312#ifdef __cplusplus
2313}
2314#endif