blob: 9a451d2d2804a6cd801e015cbad49982dfd4e33c [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
Thomas Wouters49fd7fa2006-04-21 10:40:58 +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;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +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;
Guido van Rossum393661d2001-08-31 17:40:15 +000032
Guido van Rossum3f5da241990-12-20 15:06:42 +000033/* Object allocation routines used by NEWOBJ and NEWVAROBJ macros.
34 These are used by the individual routines for object creation.
35 Do not call them otherwise, they do not initialize the object! */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000036
Tim Peters78be7992003-03-23 02:51:01 +000037#ifdef Py_TRACE_REFS
Tim Peters7571a0f2003-03-23 17:52:28 +000038/* Head of circular doubly-linked list of all objects. These are linked
39 * together via the _ob_prev and _ob_next members of a PyObject, which
40 * exist only in a Py_TRACE_REFS build.
41 */
Tim Peters78be7992003-03-23 02:51:01 +000042static PyObject refchain = {&refchain, &refchain};
Tim Peters36eb4df2003-03-23 03:33:13 +000043
Tim Peters7571a0f2003-03-23 17:52:28 +000044/* Insert op at the front of the list of all objects. If force is true,
45 * op is added even if _ob_prev and _ob_next are non-NULL already. If
46 * force is false amd _ob_prev or _ob_next are non-NULL, do nothing.
47 * force should be true if and only if op points to freshly allocated,
48 * uninitialized memory, or you've unlinked op from the list and are
Tim Peters51f8d382003-03-23 18:06:08 +000049 * relinking it into the front.
Tim Peters7571a0f2003-03-23 17:52:28 +000050 * Note that objects are normally added to the list via _Py_NewReference,
51 * which is called by PyObject_Init. Not all objects are initialized that
52 * way, though; exceptions include statically allocated type objects, and
53 * statically allocated singletons (like Py_True and Py_None).
54 */
Tim Peters36eb4df2003-03-23 03:33:13 +000055void
Tim Peters7571a0f2003-03-23 17:52:28 +000056_Py_AddToAllObjects(PyObject *op, int force)
Tim Peters36eb4df2003-03-23 03:33:13 +000057{
Tim Peters7571a0f2003-03-23 17:52:28 +000058#ifdef Py_DEBUG
59 if (!force) {
60 /* If it's initialized memory, op must be in or out of
61 * the list unambiguously.
62 */
63 assert((op->_ob_prev == NULL) == (op->_ob_next == NULL));
64 }
Tim Peters78be7992003-03-23 02:51:01 +000065#endif
Tim Peters7571a0f2003-03-23 17:52:28 +000066 if (force || op->_ob_prev == NULL) {
67 op->_ob_next = refchain._ob_next;
68 op->_ob_prev = &refchain;
69 refchain._ob_next->_ob_prev = op;
70 refchain._ob_next = op;
71 }
72}
73#endif /* Py_TRACE_REFS */
Tim Peters78be7992003-03-23 02:51:01 +000074
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +000075#ifdef COUNT_ALLOCS
Guido van Rossumc0b618a1997-05-02 03:12:38 +000076static PyTypeObject *type_list;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000077/* All types are added to type_list, at least when
78 they get one object created. That makes them
79 immortal, which unfortunately contributes to
80 garbage itself. If unlist_types_without_objects
81 is set, they will be removed from the type_list
82 once the last object is deallocated. */
83int unlist_types_without_objects;
Sjoerd Mullender842d2cc1993-10-15 16:18:48 +000084extern int tuple_zero_allocs, fast_tuple_allocs;
85extern int quick_int_allocs, quick_neg_int_allocs;
Sjoerd Mullender3bb8a051993-10-22 12:04:32 +000086extern int null_strings, one_strings;
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +000087void
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000088dump_counts(FILE* f)
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +000089{
Guido van Rossumc0b618a1997-05-02 03:12:38 +000090 PyTypeObject *tp;
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +000091
92 for (tp = type_list; tp; tp = tp->tp_next)
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000093 fprintf(f, "%s alloc'd: %d, freed: %d, max in use: %d\n",
Tim Peters6d6c1a32001-08-02 04:15:00 +000094 tp->tp_name, tp->tp_allocs, tp->tp_frees,
Sjoerd Mullender52c1f511993-10-25 08:40:52 +000095 tp->tp_maxalloc);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000096 fprintf(f, "fast tuple allocs: %d, empty: %d\n",
Sjoerd Mullender52c1f511993-10-25 08:40:52 +000097 fast_tuple_allocs, tuple_zero_allocs);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000098 fprintf(f, "fast int allocs: pos: %d, neg: %d\n",
Sjoerd Mullender52c1f511993-10-25 08:40:52 +000099 quick_int_allocs, quick_neg_int_allocs);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000100 fprintf(f, "null strings: %d, 1-strings: %d\n",
Sjoerd Mullender52c1f511993-10-25 08:40:52 +0000101 null_strings, one_strings);
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000102}
103
Sjoerd Mullender6ec3c651995-08-29 09:18:14 +0000104PyObject *
Fred Drake100814d2000-07-09 15:48:49 +0000105get_counts(void)
Sjoerd Mullender6ec3c651995-08-29 09:18:14 +0000106{
107 PyTypeObject *tp;
108 PyObject *result;
109 PyObject *v;
110
111 result = PyList_New(0);
112 if (result == NULL)
113 return NULL;
114 for (tp = type_list; tp; tp = tp->tp_next) {
Tim Peters6d6c1a32001-08-02 04:15:00 +0000115 v = Py_BuildValue("(siii)", tp->tp_name, tp->tp_allocs,
116 tp->tp_frees, tp->tp_maxalloc);
Sjoerd Mullender6ec3c651995-08-29 09:18:14 +0000117 if (v == NULL) {
118 Py_DECREF(result);
119 return NULL;
120 }
121 if (PyList_Append(result, v) < 0) {
122 Py_DECREF(v);
123 Py_DECREF(result);
124 return NULL;
125 }
126 Py_DECREF(v);
127 }
128 return result;
129}
130
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000131void
Fred Drake100814d2000-07-09 15:48:49 +0000132inc_count(PyTypeObject *tp)
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000133{
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000134 if (tp->tp_next == NULL && tp->tp_prev == NULL) {
Guido van Rossumd8953cb1995-04-06 14:46:26 +0000135 /* first time; insert in linked list */
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000136 if (tp->tp_next != NULL) /* sanity check */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000137 Py_FatalError("XXX inc_count sanity check");
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000138 if (type_list)
139 type_list->tp_prev = tp;
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000140 tp->tp_next = type_list;
Tim Petersc6a3ff62002-07-08 22:11:52 +0000141 /* Note that as of Python 2.2, heap-allocated type objects
142 * can go away, but this code requires that they stay alive
143 * until program exit. That's why we're careful with
144 * refcounts here. type_list gets a new reference to tp,
145 * while ownership of the reference type_list used to hold
146 * (if any) was transferred to tp->tp_next in the line above.
147 * tp is thus effectively immortal after this.
148 */
149 Py_INCREF(tp);
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000150 type_list = tp;
Tim Peters3e40c7f2003-03-23 03:04:32 +0000151#ifdef Py_TRACE_REFS
Tim Peters7571a0f2003-03-23 17:52:28 +0000152 /* Also insert in the doubly-linked list of all objects,
153 * if not already there.
154 */
155 _Py_AddToAllObjects((PyObject *)tp, 0);
Tim Peters78be7992003-03-23 02:51:01 +0000156#endif
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000157 }
Tim Peters6d6c1a32001-08-02 04:15:00 +0000158 tp->tp_allocs++;
159 if (tp->tp_allocs - tp->tp_frees > tp->tp_maxalloc)
160 tp->tp_maxalloc = tp->tp_allocs - tp->tp_frees;
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000161}
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000162
163void dec_count(PyTypeObject *tp)
164{
165 tp->tp_frees++;
166 if (unlist_types_without_objects &&
167 tp->tp_allocs == tp->tp_frees) {
168 /* unlink the type from type_list */
169 if (tp->tp_prev)
170 tp->tp_prev->tp_next = tp->tp_next;
171 else
172 type_list = tp->tp_next;
173 if (tp->tp_next)
174 tp->tp_next->tp_prev = tp->tp_prev;
175 tp->tp_next = tp->tp_prev = NULL;
176 Py_DECREF(tp);
177 }
178}
179
Sjoerd Mullendera9c3c221993-10-11 12:54:31 +0000180#endif
181
Tim Peters7c321a82002-07-09 02:57:01 +0000182#ifdef Py_REF_DEBUG
183/* Log a fatal error; doesn't return. */
184void
185_Py_NegativeRefcount(const char *fname, int lineno, PyObject *op)
186{
187 char buf[300];
188
189 PyOS_snprintf(buf, sizeof(buf),
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000190 "%s:%i object at %p has negative ref count "
191 "%" PY_FORMAT_SIZE_T "d",
192 fname, lineno, op, op->ob_refcnt);
Tim Peters7c321a82002-07-09 02:57:01 +0000193 Py_FatalError(buf);
194}
195
196#endif /* Py_REF_DEBUG */
197
Thomas Heller1328b522004-04-22 17:23:49 +0000198void
199Py_IncRef(PyObject *o)
200{
201 Py_XINCREF(o);
202}
203
204void
205Py_DecRef(PyObject *o)
206{
207 Py_XDECREF(o);
208}
209
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000210PyObject *
Fred Drake100814d2000-07-09 15:48:49 +0000211PyObject_Init(PyObject *op, PyTypeObject *tp)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000212{
Guido van Rossum6e08c142002-10-11 20:37:24 +0000213 if (op == NULL)
214 return PyErr_NoMemory();
Guido van Rossumb18618d2000-05-03 23:44:39 +0000215 /* Any changes should be reflected in PyObject_INIT (objimpl.h) */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000216 op->ob_type = tp;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000217 _Py_NewReference(op);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000218 return op;
219}
220
Guido van Rossumb18618d2000-05-03 23:44:39 +0000221PyVarObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000222PyObject_InitVar(PyVarObject *op, PyTypeObject *tp, Py_ssize_t size)
Guido van Rossumb18618d2000-05-03 23:44:39 +0000223{
Guido van Rossum6e08c142002-10-11 20:37:24 +0000224 if (op == NULL)
225 return (PyVarObject *) PyErr_NoMemory();
Guido van Rossumb18618d2000-05-03 23:44:39 +0000226 /* Any changes should be reflected in PyObject_INIT_VAR */
227 op->ob_size = size;
228 op->ob_type = tp;
229 _Py_NewReference((PyObject *)op);
230 return op;
231}
232
233PyObject *
Fred Drake100814d2000-07-09 15:48:49 +0000234_PyObject_New(PyTypeObject *tp)
Guido van Rossumb18618d2000-05-03 23:44:39 +0000235{
236 PyObject *op;
237 op = (PyObject *) PyObject_MALLOC(_PyObject_SIZE(tp));
238 if (op == NULL)
239 return PyErr_NoMemory();
240 return PyObject_INIT(op, tp);
241}
242
Guido van Rossumd0c87ee1997-05-15 21:31:03 +0000243PyVarObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000244_PyObject_NewVar(PyTypeObject *tp, Py_ssize_t nitems)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000245{
Guido van Rossumb18618d2000-05-03 23:44:39 +0000246 PyVarObject *op;
Tim Petersf2a67da2001-10-07 03:54:51 +0000247 const size_t size = _PyObject_VAR_SIZE(tp, nitems);
Tim Peters6d483d32001-10-06 21:27:34 +0000248 op = (PyVarObject *) PyObject_MALLOC(size);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000249 if (op == NULL)
Guido van Rossumd0c87ee1997-05-15 21:31:03 +0000250 return (PyVarObject *)PyErr_NoMemory();
Tim Peters6d483d32001-10-06 21:27:34 +0000251 return PyObject_INIT_VAR(op, tp, nitems);
Guido van Rossumb18618d2000-05-03 23:44:39 +0000252}
253
Neil Schemenauerbdf0eed2002-04-12 03:08:42 +0000254/* for binary compatibility with 2.2 */
255#undef _PyObject_Del
Guido van Rossumb18618d2000-05-03 23:44:39 +0000256void
Fred Drake100814d2000-07-09 15:48:49 +0000257_PyObject_Del(PyObject *op)
Guido van Rossumb18618d2000-05-03 23:44:39 +0000258{
Guido van Rossum4cc6ac72000-07-01 01:00:38 +0000259 PyObject_FREE(op);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000260}
261
Neal Norwitz1a997502003-01-13 20:13:12 +0000262/* Implementation of PyObject_Print with recursion checking */
263static int
264internal_print(PyObject *op, FILE *fp, int flags, int nesting)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000265{
Guido van Rossum278ef591991-07-27 21:40:24 +0000266 int ret = 0;
Neal Norwitz1a997502003-01-13 20:13:12 +0000267 if (nesting > 10) {
268 PyErr_SetString(PyExc_RuntimeError, "print recursion");
269 return -1;
270 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000271 if (PyErr_CheckSignals())
Guido van Rossum90933611991-06-07 16:10:43 +0000272 return -1;
Guido van Rossum9b00dfa1998-04-28 16:06:54 +0000273#ifdef USE_STACKCHECK
274 if (PyOS_CheckStack()) {
Fred Drake661ea262000-10-24 19:57:45 +0000275 PyErr_SetString(PyExc_MemoryError, "stack overflow");
Guido van Rossum9b00dfa1998-04-28 16:06:54 +0000276 return -1;
277 }
278#endif
Guido van Rossum687ef6e2000-01-12 16:28:58 +0000279 clearerr(fp); /* Clear any previous error condition */
Guido van Rossum90933611991-06-07 16:10:43 +0000280 if (op == NULL) {
281 fprintf(fp, "<nil>");
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000282 }
Guido van Rossum90933611991-06-07 16:10:43 +0000283 else {
284 if (op->ob_refcnt <= 0)
Thomas Wouters8b87a0b2006-03-01 05:41:20 +0000285 /* XXX(twouters) cast refcount to long until %zd is
286 universally available */
287 fprintf(fp, "<refcnt %ld at %p>",
288 (long)op->ob_refcnt, op);
Guido van Rossum2e8f6141992-09-03 20:32:55 +0000289 else if (op->ob_type->tp_print == NULL) {
Guido van Rossum4f288ab2001-05-01 16:53:37 +0000290 PyObject *s;
291 if (flags & Py_PRINT_RAW)
292 s = PyObject_Str(op);
293 else
294 s = PyObject_Repr(op);
295 if (s == NULL)
296 ret = -1;
Guido van Rossum2e8f6141992-09-03 20:32:55 +0000297 else {
Neal Norwitz1a997502003-01-13 20:13:12 +0000298 ret = internal_print(s, fp, Py_PRINT_RAW,
299 nesting+1);
Guido van Rossum2e8f6141992-09-03 20:32:55 +0000300 }
Guido van Rossum4f288ab2001-05-01 16:53:37 +0000301 Py_XDECREF(s);
Guido van Rossum2e8f6141992-09-03 20:32:55 +0000302 }
Guido van Rossum90933611991-06-07 16:10:43 +0000303 else
Guido van Rossum278ef591991-07-27 21:40:24 +0000304 ret = (*op->ob_type->tp_print)(op, fp, flags);
Guido van Rossum90933611991-06-07 16:10:43 +0000305 }
Guido van Rossum278ef591991-07-27 21:40:24 +0000306 if (ret == 0) {
307 if (ferror(fp)) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000308 PyErr_SetFromErrno(PyExc_IOError);
Guido van Rossum278ef591991-07-27 21:40:24 +0000309 clearerr(fp);
310 ret = -1;
311 }
312 }
313 return ret;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000314}
315
Neal Norwitz1a997502003-01-13 20:13:12 +0000316int
317PyObject_Print(PyObject *op, FILE *fp, int flags)
318{
319 return internal_print(op, fp, flags, 0);
320}
321
322
Barry Warsaw9bf16442001-01-23 16:24:35 +0000323/* For debugging convenience. See Misc/gdbinit for some useful gdb hooks */
Tim Peters803526b2002-07-07 05:13:56 +0000324void _PyObject_Dump(PyObject* op)
Barry Warsaw9bf16442001-01-23 16:24:35 +0000325{
Barry Warsaweefb1072001-02-22 22:39:18 +0000326 if (op == NULL)
327 fprintf(stderr, "NULL\n");
328 else {
Guido van Rossum5f5512d2001-09-14 15:50:08 +0000329 fprintf(stderr, "object : ");
Barry Warsaweefb1072001-02-22 22:39:18 +0000330 (void)PyObject_Print(op, stderr, 0);
Thomas Wouters8b87a0b2006-03-01 05:41:20 +0000331 /* XXX(twouters) cast refcount to long until %zd is
332 universally available */
Guido van Rossum5f5512d2001-09-14 15:50:08 +0000333 fprintf(stderr, "\n"
334 "type : %s\n"
Thomas Wouters8b87a0b2006-03-01 05:41:20 +0000335 "refcount: %ld\n"
Guido van Rossum5f5512d2001-09-14 15:50:08 +0000336 "address : %p\n",
337 op->ob_type==NULL ? "NULL" : op->ob_type->tp_name,
Thomas Wouters8b87a0b2006-03-01 05:41:20 +0000338 (long)op->ob_refcnt,
Guido van Rossum5f5512d2001-09-14 15:50:08 +0000339 op);
Barry Warsaweefb1072001-02-22 22:39:18 +0000340 }
Barry Warsaw9bf16442001-01-23 16:24:35 +0000341}
Barry Warsaw903138f2001-01-23 16:33:18 +0000342
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000343PyObject *
Fred Drake100814d2000-07-09 15:48:49 +0000344PyObject_Repr(PyObject *v)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000345{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000346 if (PyErr_CheckSignals())
Guido van Rossum90933611991-06-07 16:10:43 +0000347 return NULL;
Guido van Rossum9b00dfa1998-04-28 16:06:54 +0000348#ifdef USE_STACKCHECK
349 if (PyOS_CheckStack()) {
Fred Drake661ea262000-10-24 19:57:45 +0000350 PyErr_SetString(PyExc_MemoryError, "stack overflow");
Guido van Rossum9b00dfa1998-04-28 16:06:54 +0000351 return NULL;
352 }
353#endif
Guido van Rossum90933611991-06-07 16:10:43 +0000354 if (v == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000355 return PyString_FromString("<NULL>");
Barry Warsaw7ce36942001-08-24 18:34:26 +0000356 else if (v->ob_type->tp_repr == NULL)
Guido van Rossum21922aa2001-08-30 20:26:05 +0000357 return PyString_FromFormat("<%s object at %p>",
Barry Warsaw7ce36942001-08-24 18:34:26 +0000358 v->ob_type->tp_name, v);
Guido van Rossum4c08d552000-03-10 22:55:18 +0000359 else {
360 PyObject *res;
361 res = (*v->ob_type->tp_repr)(v);
362 if (res == NULL)
363 return NULL;
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000364#ifdef Py_USING_UNICODE
Fredrik Lundhefecc7d2000-07-01 14:31:09 +0000365 if (PyUnicode_Check(res)) {
366 PyObject* str;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000367 str = PyUnicode_AsEncodedString(res, NULL, NULL);
Marc-André Lemburg891bc652000-07-03 09:57:53 +0000368 Py_DECREF(res);
369 if (str)
Fredrik Lundhefecc7d2000-07-01 14:31:09 +0000370 res = str;
Marc-André Lemburg891bc652000-07-03 09:57:53 +0000371 else
372 return NULL;
Fredrik Lundhefecc7d2000-07-01 14:31:09 +0000373 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000374#endif
Guido van Rossum4c08d552000-03-10 22:55:18 +0000375 if (!PyString_Check(res)) {
376 PyErr_Format(PyExc_TypeError,
Guido van Rossum5db862d2000-04-10 12:46:51 +0000377 "__repr__ returned non-string (type %.200s)",
Guido van Rossum4c08d552000-03-10 22:55:18 +0000378 res->ob_type->tp_name);
379 Py_DECREF(res);
380 return NULL;
381 }
382 return res;
383 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000384}
385
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000386PyObject *
Neil Schemenauercf52c072005-08-12 17:34:58 +0000387_PyObject_Str(PyObject *v)
Guido van Rossumc6004111993-11-05 10:22:19 +0000388{
Guido van Rossum4c08d552000-03-10 22:55:18 +0000389 PyObject *res;
Neil Schemenauercf52c072005-08-12 17:34:58 +0000390 int type_ok;
Guido van Rossumc6004111993-11-05 10:22:19 +0000391 if (v == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000392 return PyString_FromString("<NULL>");
Tim Peters5a49ade2001-09-11 01:41:59 +0000393 if (PyString_CheckExact(v)) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000394 Py_INCREF(v);
Guido van Rossumc6004111993-11-05 10:22:19 +0000395 return v;
396 }
Neil Schemenauercf52c072005-08-12 17:34:58 +0000397#ifdef Py_USING_UNICODE
398 if (PyUnicode_CheckExact(v)) {
399 Py_INCREF(v);
400 return v;
401 }
402#endif
Guido van Rossum4f288ab2001-05-01 16:53:37 +0000403 if (v->ob_type->tp_str == NULL)
404 return PyObject_Repr(v);
405
406 res = (*v->ob_type->tp_str)(v);
Guido van Rossum4c08d552000-03-10 22:55:18 +0000407 if (res == NULL)
408 return NULL;
Neil Schemenauercf52c072005-08-12 17:34:58 +0000409 type_ok = PyString_Check(res);
410#ifdef Py_USING_UNICODE
411 type_ok = type_ok || PyUnicode_Check(res);
412#endif
413 if (!type_ok) {
414 PyErr_Format(PyExc_TypeError,
415 "__str__ returned non-string (type %.200s)",
416 res->ob_type->tp_name);
417 Py_DECREF(res);
418 return NULL;
419 }
420 return res;
421}
422
423PyObject *
424PyObject_Str(PyObject *v)
425{
426 PyObject *res = _PyObject_Str(v);
427 if (res == NULL)
428 return NULL;
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000429#ifdef Py_USING_UNICODE
Marc-André Lemburg891bc652000-07-03 09:57:53 +0000430 if (PyUnicode_Check(res)) {
431 PyObject* str;
432 str = PyUnicode_AsEncodedString(res, NULL, NULL);
433 Py_DECREF(res);
434 if (str)
435 res = str;
436 else
437 return NULL;
438 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000439#endif
Neil Schemenauercf52c072005-08-12 17:34:58 +0000440 assert(PyString_Check(res));
Guido van Rossum4c08d552000-03-10 22:55:18 +0000441 return res;
Guido van Rossumc6004111993-11-05 10:22:19 +0000442}
443
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000444#ifdef Py_USING_UNICODE
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000445PyObject *
446PyObject_Unicode(PyObject *v)
447{
448 PyObject *res;
Brett Cannonc3647ac2005-04-26 03:45:26 +0000449 PyObject *func;
Neal Norwitz75801462006-03-14 06:02:16 +0000450 PyObject *str;
Brett Cannonc3647ac2005-04-26 03:45:26 +0000451 static PyObject *unicodestr;
Tim Peters803526b2002-07-07 05:13:56 +0000452
Georg Brandl3daf7582006-03-13 22:22:11 +0000453 if (v == NULL) {
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000454 res = PyString_FromString("<NULL>");
Neal Norwitz75801462006-03-14 06:02:16 +0000455 if (res == NULL)
456 return NULL;
457 str = PyUnicode_FromEncodedObject(res, NULL, "strict");
458 Py_DECREF(res);
459 return str;
Georg Brandl3daf7582006-03-13 22:22:11 +0000460 } else if (PyUnicode_CheckExact(v)) {
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000461 Py_INCREF(v);
462 return v;
463 }
Brett Cannonc3647ac2005-04-26 03:45:26 +0000464 /* XXX As soon as we have a tp_unicode slot, we should
465 check this before trying the __unicode__
466 method. */
467 if (unicodestr == NULL) {
468 unicodestr= PyString_InternFromString("__unicode__");
469 if (unicodestr == NULL)
470 return NULL;
Guido van Rossumb8c65bc2001-10-19 02:01:31 +0000471 }
Brett Cannonc3647ac2005-04-26 03:45:26 +0000472 func = PyObject_GetAttr(v, unicodestr);
473 if (func != NULL) {
474 res = PyEval_CallObject(func, (PyObject *)NULL);
475 Py_DECREF(func);
476 }
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000477 else {
Brett Cannonc3647ac2005-04-26 03:45:26 +0000478 PyErr_Clear();
479 if (PyUnicode_Check(v)) {
480 /* For a Unicode subtype that's didn't overwrite __unicode__,
481 return a true Unicode object with the same data. */
482 return PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(v),
483 PyUnicode_GET_SIZE(v));
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000484 }
Brett Cannonc3647ac2005-04-26 03:45:26 +0000485 if (PyString_CheckExact(v)) {
486 Py_INCREF(v);
487 res = v;
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000488 }
Guido van Rossumb8c65bc2001-10-19 02:01:31 +0000489 else {
Guido van Rossumb8c65bc2001-10-19 02:01:31 +0000490 if (v->ob_type->tp_str != NULL)
491 res = (*v->ob_type->tp_str)(v);
492 else
493 res = PyObject_Repr(v);
494 }
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000495 }
496 if (res == NULL)
497 return NULL;
498 if (!PyUnicode_Check(res)) {
Guido van Rossumb8c65bc2001-10-19 02:01:31 +0000499 str = PyUnicode_FromEncodedObject(res, NULL, "strict");
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000500 Py_DECREF(res);
Neal Norwitz75801462006-03-14 06:02:16 +0000501 res = str;
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000502 }
503 return res;
504}
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000505#endif
Guido van Rossuma3af41d2001-01-18 22:07:06 +0000506
507
Guido van Rossuma4073002002-05-31 20:03:54 +0000508/* Helper to warn about deprecated tp_compare return values. Return:
509 -2 for an exception;
510 -1 if v < w;
511 0 if v == w;
512 1 if v > w.
513 (This function cannot return 2.)
514*/
515static int
516adjust_tp_compare(int c)
517{
518 if (PyErr_Occurred()) {
519 if (c != -1 && c != -2) {
520 PyObject *t, *v, *tb;
521 PyErr_Fetch(&t, &v, &tb);
522 if (PyErr_Warn(PyExc_RuntimeWarning,
523 "tp_compare didn't return -1 or -2 "
524 "for exception") < 0) {
525 Py_XDECREF(t);
526 Py_XDECREF(v);
527 Py_XDECREF(tb);
528 }
529 else
530 PyErr_Restore(t, v, tb);
531 }
532 return -2;
533 }
534 else if (c < -1 || c > 1) {
535 if (PyErr_Warn(PyExc_RuntimeWarning,
536 "tp_compare didn't return -1, 0 or 1") < 0)
537 return -2;
538 else
539 return c < -1 ? -1 : 1;
540 }
541 else {
542 assert(c >= -1 && c <= 1);
543 return c;
544 }
545}
546
547
Guido van Rossumd1f06b92001-01-24 22:14:43 +0000548/* Macro to get the tp_richcompare field of a type if defined */
549#define RICHCOMPARE(t) (PyType_HasFeature((t), Py_TPFLAGS_HAVE_RICHCOMPARE) \
550 ? (t)->tp_richcompare : NULL)
551
Guido van Rossume797ec12001-01-17 15:24:28 +0000552/* Map rich comparison operators to their swapped version, e.g. LT --> GT */
Brett Cannona5ca2e72004-09-25 01:37:24 +0000553int _Py_SwappedOp[] = {Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE};
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000554
Guido van Rossume797ec12001-01-17 15:24:28 +0000555/* Try a genuine rich comparison, returning an object. Return:
556 NULL for exception;
557 NotImplemented if this particular rich comparison is not implemented or
558 undefined;
559 some object not equal to NotImplemented if it is implemented
560 (this latter object may not be a Boolean).
561*/
562static PyObject *
563try_rich_compare(PyObject *v, PyObject *w, int op)
564{
565 richcmpfunc f;
566 PyObject *res;
567
Guido van Rossum2ed6bf82001-09-27 20:30:07 +0000568 if (v->ob_type != w->ob_type &&
569 PyType_IsSubtype(w->ob_type, v->ob_type) &&
570 (f = RICHCOMPARE(w->ob_type)) != NULL) {
Tim Petersf4aca752004-09-23 02:39:37 +0000571 res = (*f)(w, v, _Py_SwappedOp[op]);
Guido van Rossum2ed6bf82001-09-27 20:30:07 +0000572 if (res != Py_NotImplemented)
573 return res;
574 Py_DECREF(res);
575 }
Guido van Rossumd1f06b92001-01-24 22:14:43 +0000576 if ((f = RICHCOMPARE(v->ob_type)) != NULL) {
Guido van Rossume797ec12001-01-17 15:24:28 +0000577 res = (*f)(v, w, op);
578 if (res != Py_NotImplemented)
579 return res;
580 Py_DECREF(res);
581 }
Guido van Rossumd1f06b92001-01-24 22:14:43 +0000582 if ((f = RICHCOMPARE(w->ob_type)) != NULL) {
Tim Petersf4aca752004-09-23 02:39:37 +0000583 return (*f)(w, v, _Py_SwappedOp[op]);
Guido van Rossume797ec12001-01-17 15:24:28 +0000584 }
585 res = Py_NotImplemented;
586 Py_INCREF(res);
587 return res;
588}
589
590/* Try a genuine rich comparison, returning an int. Return:
591 -1 for exception (including the case where try_rich_compare() returns an
592 object that's not a Boolean);
Tim Petersc99213f2001-11-04 05:57:16 +0000593 0 if the outcome is false;
594 1 if the outcome is true;
595 2 if this particular rich comparison is not implemented or undefined.
Guido van Rossume797ec12001-01-17 15:24:28 +0000596*/
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000597static int
Guido van Rossume797ec12001-01-17 15:24:28 +0000598try_rich_compare_bool(PyObject *v, PyObject *w, int op)
599{
600 PyObject *res;
601 int ok;
602
Guido van Rossumd1f06b92001-01-24 22:14:43 +0000603 if (RICHCOMPARE(v->ob_type) == NULL && RICHCOMPARE(w->ob_type) == NULL)
Guido van Rossume797ec12001-01-17 15:24:28 +0000604 return 2; /* Shortcut, avoid INCREF+DECREF */
605 res = try_rich_compare(v, w, op);
606 if (res == NULL)
607 return -1;
608 if (res == Py_NotImplemented) {
609 Py_DECREF(res);
610 return 2;
611 }
612 ok = PyObject_IsTrue(res);
613 Py_DECREF(res);
614 return ok;
615}
616
617/* Try rich comparisons to determine a 3-way comparison. Return:
618 -2 for an exception;
Tim Petersc99213f2001-11-04 05:57:16 +0000619 -1 if v < w;
620 0 if v == w;
621 1 if v > w;
622 2 if this particular rich comparison is not implemented or undefined.
Guido van Rossume797ec12001-01-17 15:24:28 +0000623*/
624static int
625try_rich_to_3way_compare(PyObject *v, PyObject *w)
626{
Guido van Rossum2ffbf6b2001-01-17 21:27:02 +0000627 static struct { int op; int outcome; } tries[3] = {
628 /* Try this operator, and if it is true, use this outcome: */
629 {Py_EQ, 0},
630 {Py_LT, -1},
631 {Py_GT, 1},
632 };
633 int i;
634
Guido van Rossumd1f06b92001-01-24 22:14:43 +0000635 if (RICHCOMPARE(v->ob_type) == NULL && RICHCOMPARE(w->ob_type) == NULL)
Guido van Rossume797ec12001-01-17 15:24:28 +0000636 return 2; /* Shortcut */
Guido van Rossum2ffbf6b2001-01-17 21:27:02 +0000637
638 for (i = 0; i < 3; i++) {
639 switch (try_rich_compare_bool(v, w, tries[i].op)) {
640 case -1:
Tim Peters6d60b2e2001-05-07 20:53:51 +0000641 return -2;
Guido van Rossum2ffbf6b2001-01-17 21:27:02 +0000642 case 1:
643 return tries[i].outcome;
644 }
Guido van Rossume797ec12001-01-17 15:24:28 +0000645 }
Guido van Rossum2ffbf6b2001-01-17 21:27:02 +0000646
647 return 2;
Guido van Rossume797ec12001-01-17 15:24:28 +0000648}
649
650/* Try a 3-way comparison, returning an int. Return:
651 -2 for an exception;
Tim Petersc99213f2001-11-04 05:57:16 +0000652 -1 if v < w;
653 0 if v == w;
654 1 if v > w;
655 2 if this particular 3-way comparison is not implemented or undefined.
Guido van Rossume797ec12001-01-17 15:24:28 +0000656*/
657static int
658try_3way_compare(PyObject *v, PyObject *w)
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000659{
660 int c;
Guido van Rossume797ec12001-01-17 15:24:28 +0000661 cmpfunc f;
662
663 /* Comparisons involving instances are given to instance_compare,
664 which has the same return conventions as this function. */
665
Guido van Rossumab3b0342001-09-18 20:38:53 +0000666 f = v->ob_type->tp_compare;
Guido van Rossume797ec12001-01-17 15:24:28 +0000667 if (PyInstance_Check(v))
Guido van Rossumab3b0342001-09-18 20:38:53 +0000668 return (*f)(v, w);
Guido van Rossume797ec12001-01-17 15:24:28 +0000669 if (PyInstance_Check(w))
670 return (*w->ob_type->tp_compare)(v, w);
671
Guido van Rossumab3b0342001-09-18 20:38:53 +0000672 /* If both have the same (non-NULL) tp_compare, use it. */
673 if (f != NULL && f == w->ob_type->tp_compare) {
674 c = (*f)(v, w);
Guido van Rossuma4073002002-05-31 20:03:54 +0000675 return adjust_tp_compare(c);
Guido van Rossumab3b0342001-09-18 20:38:53 +0000676 }
677
678 /* If either tp_compare is _PyObject_SlotCompare, that's safe. */
679 if (f == _PyObject_SlotCompare ||
680 w->ob_type->tp_compare == _PyObject_SlotCompare)
681 return _PyObject_SlotCompare(v, w);
682
Armin Rigoa1748132004-12-23 22:13:13 +0000683 /* If we're here, v and w,
684 a) are not instances;
685 b) have different types or a type without tp_compare; and
686 c) don't have a user-defined tp_compare.
687 tp_compare implementations in C assume that both arguments
688 have their type, so we give up if the coercion fails or if
689 it yields types which are still incompatible (which can
690 happen with a user-defined nb_coerce).
691 */
Guido van Rossume797ec12001-01-17 15:24:28 +0000692 c = PyNumber_CoerceEx(&v, &w);
693 if (c < 0)
694 return -2;
695 if (c > 0)
696 return 2;
Armin Rigoa1748132004-12-23 22:13:13 +0000697 f = v->ob_type->tp_compare;
698 if (f != NULL && f == w->ob_type->tp_compare) {
Guido van Rossume797ec12001-01-17 15:24:28 +0000699 c = (*f)(v, w);
700 Py_DECREF(v);
701 Py_DECREF(w);
Guido van Rossuma4073002002-05-31 20:03:54 +0000702 return adjust_tp_compare(c);
Guido van Rossume797ec12001-01-17 15:24:28 +0000703 }
704
Guido van Rossume797ec12001-01-17 15:24:28 +0000705 /* No comparison defined */
706 Py_DECREF(v);
707 Py_DECREF(w);
708 return 2;
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000709}
710
Guido van Rossume797ec12001-01-17 15:24:28 +0000711/* Final fallback 3-way comparison, returning an int. Return:
712 -2 if an error occurred;
Tim Petersc99213f2001-11-04 05:57:16 +0000713 -1 if v < w;
714 0 if v == w;
715 1 if v > w.
Guido van Rossume797ec12001-01-17 15:24:28 +0000716*/
717static int
718default_3way_compare(PyObject *v, PyObject *w)
719{
720 int c;
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000721 const char *vname, *wname;
Guido van Rossume797ec12001-01-17 15:24:28 +0000722
723 if (v->ob_type == w->ob_type) {
Barry Warsawb0e754d2001-01-20 06:24:55 +0000724 /* When comparing these pointers, they must be cast to
725 * integer types (i.e. Py_uintptr_t, our spelling of C9X's
726 * uintptr_t). ANSI specifies that pointer compares other
727 * than == and != to non-related structures are undefined.
728 */
Barry Warsaw71ff8d52001-01-20 06:08:10 +0000729 Py_uintptr_t vv = (Py_uintptr_t)v;
730 Py_uintptr_t ww = (Py_uintptr_t)w;
Guido van Rossume797ec12001-01-17 15:24:28 +0000731 return (vv < ww) ? -1 : (vv > ww) ? 1 : 0;
732 }
733
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000734#ifdef Py_USING_UNICODE
Guido van Rossume797ec12001-01-17 15:24:28 +0000735 /* Special case for Unicode */
736 if (PyUnicode_Check(v) || PyUnicode_Check(w)) {
737 c = PyUnicode_Compare(v, w);
738 if (!PyErr_Occurred())
739 return c;
740 /* TypeErrors are ignored: if Unicode coercion fails due
741 to one of the arguments not having the right type, we
742 continue as defined by the coercion protocol (see
743 above). Luckily, decoding errors are reported as
744 ValueErrors and are not masked by this technique. */
745 if (!PyErr_ExceptionMatches(PyExc_TypeError))
746 return -2;
747 PyErr_Clear();
748 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000749#endif
Guido van Rossume797ec12001-01-17 15:24:28 +0000750
Guido van Rossum0871e932001-01-22 19:28:09 +0000751 /* None is smaller than anything */
752 if (v == Py_None)
753 return -1;
754 if (w == Py_None)
755 return 1;
756
Guido van Rossumfb50d3f2003-02-18 16:40:09 +0000757 /* different type: compare type names; numbers are smaller */
758 if (PyNumber_Check(v))
Guido van Rossum8f9143d2001-01-22 15:59:32 +0000759 vname = "";
760 else
761 vname = v->ob_type->tp_name;
Guido van Rossumfb50d3f2003-02-18 16:40:09 +0000762 if (PyNumber_Check(w))
Guido van Rossum8f9143d2001-01-22 15:59:32 +0000763 wname = "";
764 else
765 wname = w->ob_type->tp_name;
766 c = strcmp(vname, wname);
767 if (c < 0)
768 return -1;
769 if (c > 0)
770 return 1;
771 /* Same type name, or (more likely) incomparable numeric types */
772 return ((Py_uintptr_t)(v->ob_type) < (
773 Py_uintptr_t)(w->ob_type)) ? -1 : 1;
Guido van Rossume797ec12001-01-17 15:24:28 +0000774}
775
Tim Peters6d60b2e2001-05-07 20:53:51 +0000776/* Do a 3-way comparison, by hook or by crook. Return:
Guido van Rossuma4073002002-05-31 20:03:54 +0000777 -2 for an exception (but see below);
Tim Petersc99213f2001-11-04 05:57:16 +0000778 -1 if v < w;
Tim Peters6d60b2e2001-05-07 20:53:51 +0000779 0 if v == w;
Tim Petersc99213f2001-11-04 05:57:16 +0000780 1 if v > w;
Guido van Rossuma4073002002-05-31 20:03:54 +0000781 BUT: if the object implements a tp_compare function, it returns
Martin v. Löwis0163d6d2001-06-09 07:34:05 +0000782 whatever this function returns (whether with an exception or not).
Tim Peters6d60b2e2001-05-07 20:53:51 +0000783*/
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000784static int
Fred Drake100814d2000-07-09 15:48:49 +0000785do_cmp(PyObject *v, PyObject *w)
Guido van Rossum20566841995-01-12 11:26:10 +0000786{
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000787 int c;
Martin v. Löwis0163d6d2001-06-09 07:34:05 +0000788 cmpfunc f;
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000789
Martin v. Löwis0163d6d2001-06-09 07:34:05 +0000790 if (v->ob_type == w->ob_type
Guido van Rossum82fc51c12001-08-16 08:02:45 +0000791 && (f = v->ob_type->tp_compare) != NULL) {
792 c = (*f)(v, w);
Guido van Rossuma4073002002-05-31 20:03:54 +0000793 if (PyInstance_Check(v)) {
794 /* Instance tp_compare has a different signature.
795 But if it returns undefined we fall through. */
796 if (c != 2)
797 return c;
Neal Norwitz3f8dae72002-05-31 20:23:33 +0000798 /* Else fall through to try_rich_to_3way_compare() */
Guido van Rossuma4073002002-05-31 20:03:54 +0000799 }
800 else
801 return adjust_tp_compare(c);
Guido van Rossum82fc51c12001-08-16 08:02:45 +0000802 }
Guido van Rossuma4073002002-05-31 20:03:54 +0000803 /* We only get here if one of the following is true:
804 a) v and w have different types
805 b) v and w have the same type, which doesn't have tp_compare
806 c) v and w are instances, and either __cmp__ is not defined or
807 __cmp__ returns NotImplemented
808 */
Guido van Rossume797ec12001-01-17 15:24:28 +0000809 c = try_rich_to_3way_compare(v, w);
810 if (c < 2)
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +0000811 return c;
Guido van Rossume797ec12001-01-17 15:24:28 +0000812 c = try_3way_compare(v, w);
813 if (c < 2)
814 return c;
815 return default_3way_compare(v, w);
Guido van Rossum20566841995-01-12 11:26:10 +0000816}
817
Tim Petersc99213f2001-11-04 05:57:16 +0000818/* Compare v to w. Return
819 -1 if v < w or exception (PyErr_Occurred() true in latter case).
820 0 if v == w.
821 1 if v > w.
822 XXX The docs (C API manual) say the return value is undefined in case
823 XXX of error.
824*/
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000825int
Fred Drake100814d2000-07-09 15:48:49 +0000826PyObject_Compare(PyObject *v, PyObject *w)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000827{
Jeremy Hylton4a3dd2d2000-04-14 19:13:24 +0000828 int result;
829
Guido van Rossumc8b6df91997-05-23 00:06:51 +0000830 if (v == NULL || w == NULL) {
831 PyErr_BadInternalCall();
832 return -1;
833 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000834 if (v == w)
835 return 0;
Armin Rigo2b3eb402003-10-28 12:05:48 +0000836 if (Py_EnterRecursiveCall(" in cmp"))
837 return -1;
838 result = do_cmp(v, w);
839 Py_LeaveRecursiveCall();
Guido van Rossume797ec12001-01-17 15:24:28 +0000840 return result < 0 ? -1 : result;
841}
842
Tim Petersc99213f2001-11-04 05:57:16 +0000843/* Return (new reference to) Py_True or Py_False. */
Guido van Rossume797ec12001-01-17 15:24:28 +0000844static PyObject *
Martin v. Löwis0163d6d2001-06-09 07:34:05 +0000845convert_3way_to_object(int op, int c)
Guido van Rossume797ec12001-01-17 15:24:28 +0000846{
Guido van Rossume797ec12001-01-17 15:24:28 +0000847 PyObject *result;
Guido van Rossume797ec12001-01-17 15:24:28 +0000848 switch (op) {
849 case Py_LT: c = c < 0; break;
850 case Py_LE: c = c <= 0; break;
851 case Py_EQ: c = c == 0; break;
852 case Py_NE: c = c != 0; break;
853 case Py_GT: c = c > 0; break;
854 case Py_GE: c = c >= 0; break;
855 }
856 result = c ? Py_True : Py_False;
857 Py_INCREF(result);
Jeremy Hylton4a3dd2d2000-04-14 19:13:24 +0000858 return result;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000859}
Tim Peters803526b2002-07-07 05:13:56 +0000860
Tim Petersc99213f2001-11-04 05:57:16 +0000861/* We want a rich comparison but don't have one. Try a 3-way cmp instead.
862 Return
863 NULL if error
864 Py_True if v op w
865 Py_False if not (v op w)
866*/
Martin v. Löwis0163d6d2001-06-09 07:34:05 +0000867static PyObject *
868try_3way_to_rich_compare(PyObject *v, PyObject *w, int op)
869{
870 int c;
871
872 c = try_3way_compare(v, w);
873 if (c >= 2)
874 c = default_3way_compare(v, w);
875 if (c <= -2)
876 return NULL;
877 return convert_3way_to_object(op, c);
878}
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000879
Tim Petersc99213f2001-11-04 05:57:16 +0000880/* Do rich comparison on v and w. Return
881 NULL if error
882 Else a new reference to an object other than Py_NotImplemented, usually(?):
883 Py_True if v op w
884 Py_False if not (v op w)
885*/
Neil Schemenauerd38855c2001-01-21 16:25:18 +0000886static PyObject *
Guido van Rossume797ec12001-01-17 15:24:28 +0000887do_richcmp(PyObject *v, PyObject *w, int op)
888{
889 PyObject *res;
890
891 res = try_rich_compare(v, w, op);
892 if (res != Py_NotImplemented)
893 return res;
894 Py_DECREF(res);
895
896 return try_3way_to_rich_compare(v, w, op);
897}
898
Tim Petersc99213f2001-11-04 05:57:16 +0000899/* Return:
900 NULL for exception;
Tim Petersc99213f2001-11-04 05:57:16 +0000901 some object not equal to NotImplemented if it is implemented
902 (this latter object may not be a Boolean).
903*/
Guido van Rossume797ec12001-01-17 15:24:28 +0000904PyObject *
905PyObject_RichCompare(PyObject *v, PyObject *w, int op)
906{
907 PyObject *res;
908
909 assert(Py_LT <= op && op <= Py_GE);
Armin Rigo2b3eb402003-10-28 12:05:48 +0000910 if (Py_EnterRecursiveCall(" in cmp"))
911 return NULL;
Guido van Rossume797ec12001-01-17 15:24:28 +0000912
Armin Rigo2b3eb402003-10-28 12:05:48 +0000913 /* If the types are equal, and not old-style instances, try to
Tim Peters67754e92001-11-04 07:29:31 +0000914 get out cheap (don't bother with coercions etc.). */
915 if (v->ob_type == w->ob_type && !PyInstance_Check(v)) {
916 cmpfunc fcmp;
917 richcmpfunc frich = RICHCOMPARE(v->ob_type);
918 /* If the type has richcmp, try it first. try_rich_compare
919 tries it two-sided, which is not needed since we've a
920 single type only. */
921 if (frich != NULL) {
922 res = (*frich)(v, w, op);
923 if (res != Py_NotImplemented)
924 goto Done;
925 Py_DECREF(res);
926 }
927 /* No richcmp, or this particular richmp not implemented.
928 Try 3-way cmp. */
929 fcmp = v->ob_type->tp_compare;
930 if (fcmp != NULL) {
931 int c = (*fcmp)(v, w);
Guido van Rossuma4073002002-05-31 20:03:54 +0000932 c = adjust_tp_compare(c);
933 if (c == -2) {
Tim Peters67754e92001-11-04 07:29:31 +0000934 res = NULL;
935 goto Done;
936 }
937 res = convert_3way_to_object(op, c);
938 goto Done;
939 }
Guido van Rossum2ffbf6b2001-01-17 21:27:02 +0000940 }
Tim Peters67754e92001-11-04 07:29:31 +0000941
942 /* Fast path not taken, or couldn't deliver a useful result. */
943 res = do_richcmp(v, w, op);
944Done:
Armin Rigo2b3eb402003-10-28 12:05:48 +0000945 Py_LeaveRecursiveCall();
Guido van Rossume797ec12001-01-17 15:24:28 +0000946 return res;
947}
948
Tim Petersde9725f2001-05-05 10:06:17 +0000949/* Return -1 if error; 1 if v op w; 0 if not (v op w). */
Guido van Rossume797ec12001-01-17 15:24:28 +0000950int
951PyObject_RichCompareBool(PyObject *v, PyObject *w, int op)
952{
Raymond Hettinger93d44812004-03-21 17:01:44 +0000953 PyObject *res;
Guido van Rossume797ec12001-01-17 15:24:28 +0000954 int ok;
955
Raymond Hettinger93d44812004-03-21 17:01:44 +0000956 /* Quick result when objects are the same.
957 Guarantees that identity implies equality. */
958 if (v == w) {
959 if (op == Py_EQ)
960 return 1;
961 else if (op == Py_NE)
962 return 0;
963 }
964
965 res = PyObject_RichCompare(v, w, op);
Guido van Rossume797ec12001-01-17 15:24:28 +0000966 if (res == NULL)
967 return -1;
Guido van Rossum81912d42002-08-24 05:33:28 +0000968 if (PyBool_Check(res))
969 ok = (res == Py_True);
970 else
971 ok = PyObject_IsTrue(res);
Guido van Rossume797ec12001-01-17 15:24:28 +0000972 Py_DECREF(res);
973 return ok;
974}
Fred Drake13634cf2000-06-29 19:17:04 +0000975
976/* Set of hash utility functions to help maintaining the invariant that
Raymond Hettinger8183fa42004-03-21 17:35:06 +0000977 if a==b then hash(a)==hash(b)
Fred Drake13634cf2000-06-29 19:17:04 +0000978
979 All the utility functions (_Py_Hash*()) return "-1" to signify an error.
980*/
981
982long
Fred Drake100814d2000-07-09 15:48:49 +0000983_Py_HashDouble(double v)
Fred Drake13634cf2000-06-29 19:17:04 +0000984{
Tim Peters39dce292000-08-15 03:34:48 +0000985 double intpart, fractpart;
986 int expo;
987 long hipart;
988 long x; /* the final hash value */
989 /* This is designed so that Python numbers of different types
990 * that compare equal hash to the same value; otherwise comparisons
991 * of mapping keys will turn out weird.
992 */
993
Tim Peters39dce292000-08-15 03:34:48 +0000994 fractpart = modf(v, &intpart);
Tim Peters39dce292000-08-15 03:34:48 +0000995 if (fractpart == 0.0) {
996 /* This must return the same hash as an equal int or long. */
997 if (intpart > LONG_MAX || -intpart > LONG_MAX) {
998 /* Convert to long and use its hash. */
999 PyObject *plong; /* converted to Python long */
1000 if (Py_IS_INFINITY(intpart))
1001 /* can't convert to long int -- arbitrary */
1002 v = v < 0 ? -271828.0 : 314159.0;
1003 plong = PyLong_FromDouble(v);
1004 if (plong == NULL)
1005 return -1;
1006 x = PyObject_Hash(plong);
1007 Py_DECREF(plong);
1008 return x;
1009 }
1010 /* Fits in a C long == a Python int, so is its own hash. */
1011 x = (long)intpart;
1012 if (x == -1)
1013 x = -2;
1014 return x;
1015 }
1016 /* The fractional part is non-zero, so we don't have to worry about
1017 * making this match the hash of some other type.
1018 * Use frexp to get at the bits in the double.
Fred Drake13634cf2000-06-29 19:17:04 +00001019 * Since the VAX D double format has 56 mantissa bits, which is the
1020 * most of any double format in use, each of these parts may have as
1021 * many as (but no more than) 56 significant bits.
Tim Peters39dce292000-08-15 03:34:48 +00001022 * So, assuming sizeof(long) >= 4, each part can be broken into two
1023 * longs; frexp and multiplication are used to do that.
1024 * Also, since the Cray double format has 15 exponent bits, which is
1025 * the most of any double format in use, shifting the exponent field
1026 * left by 15 won't overflow a long (again assuming sizeof(long) >= 4).
Fred Drake13634cf2000-06-29 19:17:04 +00001027 */
Tim Peters39dce292000-08-15 03:34:48 +00001028 v = frexp(v, &expo);
1029 v *= 2147483648.0; /* 2**31 */
1030 hipart = (long)v; /* take the top 32 bits */
1031 v = (v - (double)hipart) * 2147483648.0; /* get the next 32 bits */
1032 x = hipart + (long)v + (expo << 15);
1033 if (x == -1)
1034 x = -2;
1035 return x;
Fred Drake13634cf2000-06-29 19:17:04 +00001036}
1037
1038long
Fred Drake100814d2000-07-09 15:48:49 +00001039_Py_HashPointer(void *p)
Fred Drake13634cf2000-06-29 19:17:04 +00001040{
1041#if SIZEOF_LONG >= SIZEOF_VOID_P
1042 return (long)p;
1043#else
1044 /* convert to a Python long and hash that */
1045 PyObject* longobj;
1046 long x;
Tim Peters803526b2002-07-07 05:13:56 +00001047
Fred Drake13634cf2000-06-29 19:17:04 +00001048 if ((longobj = PyLong_FromVoidPtr(p)) == NULL) {
1049 x = -1;
1050 goto finally;
1051 }
1052 x = PyObject_Hash(longobj);
Tim Peters803526b2002-07-07 05:13:56 +00001053
Fred Drake13634cf2000-06-29 19:17:04 +00001054finally:
1055 Py_XDECREF(longobj);
1056 return x;
1057#endif
1058}
1059
1060
Guido van Rossum9bfef441993-03-29 10:43:31 +00001061long
Fred Drake100814d2000-07-09 15:48:49 +00001062PyObject_Hash(PyObject *v)
Guido van Rossum9bfef441993-03-29 10:43:31 +00001063{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001064 PyTypeObject *tp = v->ob_type;
Guido van Rossum9bfef441993-03-29 10:43:31 +00001065 if (tp->tp_hash != NULL)
1066 return (*tp->tp_hash)(v);
Guido van Rossumd1f06b92001-01-24 22:14:43 +00001067 if (tp->tp_compare == NULL && RICHCOMPARE(tp) == NULL) {
Fred Drake13634cf2000-06-29 19:17:04 +00001068 return _Py_HashPointer(v); /* Use address as hash value */
1069 }
Guido van Rossum9bfef441993-03-29 10:43:31 +00001070 /* If there's a cmp but no hash defined, the object can't be hashed */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001071 PyErr_SetString(PyExc_TypeError, "unhashable type");
Guido van Rossum9bfef441993-03-29 10:43:31 +00001072 return -1;
1073}
1074
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001075PyObject *
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001076PyObject_GetAttrString(PyObject *v, const char *name)
Guido van Rossum3f5da241990-12-20 15:06:42 +00001077{
Tim Peters6d6c1a32001-08-02 04:15:00 +00001078 PyObject *w, *res;
Guido van Rossumd8eb1b31996-08-09 20:52:03 +00001079
Tim Peters6d6c1a32001-08-02 04:15:00 +00001080 if (v->ob_type->tp_getattr != NULL)
Martin v. Löwis15e62742006-02-27 16:46:16 +00001081 return (*v->ob_type->tp_getattr)(v, (char*)name);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001082 w = PyString_InternFromString(name);
1083 if (w == NULL)
1084 return NULL;
1085 res = PyObject_GetAttr(v, w);
1086 Py_XDECREF(w);
1087 return res;
Guido van Rossum3f5da241990-12-20 15:06:42 +00001088}
1089
1090int
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001091PyObject_HasAttrString(PyObject *v, const char *name)
Guido van Rossumed18fdc1993-07-11 19:55:34 +00001092{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001093 PyObject *res = PyObject_GetAttrString(v, name);
Guido van Rossumed18fdc1993-07-11 19:55:34 +00001094 if (res != NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001095 Py_DECREF(res);
Guido van Rossumed18fdc1993-07-11 19:55:34 +00001096 return 1;
1097 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001098 PyErr_Clear();
Guido van Rossumed18fdc1993-07-11 19:55:34 +00001099 return 0;
1100}
1101
1102int
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001103PyObject_SetAttrString(PyObject *v, const char *name, PyObject *w)
Guido van Rossum3f5da241990-12-20 15:06:42 +00001104{
Tim Peters6d6c1a32001-08-02 04:15:00 +00001105 PyObject *s;
1106 int res;
Guido van Rossumd8eb1b31996-08-09 20:52:03 +00001107
Tim Peters6d6c1a32001-08-02 04:15:00 +00001108 if (v->ob_type->tp_setattr != NULL)
Martin v. Löwis15e62742006-02-27 16:46:16 +00001109 return (*v->ob_type->tp_setattr)(v, (char*)name, w);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001110 s = PyString_InternFromString(name);
1111 if (s == NULL)
1112 return -1;
1113 res = PyObject_SetAttr(v, s, w);
1114 Py_XDECREF(s);
1115 return res;
Guido van Rossum3f5da241990-12-20 15:06:42 +00001116}
1117
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001118PyObject *
Fred Drake100814d2000-07-09 15:48:49 +00001119PyObject_GetAttr(PyObject *v, PyObject *name)
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001120{
Tim Peters6d6c1a32001-08-02 04:15:00 +00001121 PyTypeObject *tp = v->ob_type;
1122
Jeremy Hylton99a8f902000-06-23 14:36:32 +00001123 if (!PyString_Check(name)) {
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001124#ifdef Py_USING_UNICODE
1125 /* The Unicode to string conversion is done here because the
1126 existing tp_getattro slots expect a string object as name
1127 and we wouldn't want to break those. */
1128 if (PyUnicode_Check(name)) {
1129 name = _PyUnicode_AsDefaultEncodedString(name, NULL);
1130 if (name == NULL)
1131 return NULL;
1132 }
1133 else
1134#endif
1135 {
1136 PyErr_SetString(PyExc_TypeError,
1137 "attribute name must be string");
1138 return NULL;
1139 }
Jeremy Hylton99a8f902000-06-23 14:36:32 +00001140 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001141 if (tp->tp_getattro != NULL)
1142 return (*tp->tp_getattro)(v, name);
1143 if (tp->tp_getattr != NULL)
1144 return (*tp->tp_getattr)(v, PyString_AS_STRING(name));
1145 PyErr_Format(PyExc_AttributeError,
1146 "'%.50s' object has no attribute '%.400s'",
1147 tp->tp_name, PyString_AS_STRING(name));
1148 return NULL;
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001149}
1150
1151int
Fred Drake100814d2000-07-09 15:48:49 +00001152PyObject_HasAttr(PyObject *v, PyObject *name)
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001153{
1154 PyObject *res = PyObject_GetAttr(v, name);
1155 if (res != NULL) {
1156 Py_DECREF(res);
1157 return 1;
1158 }
1159 PyErr_Clear();
1160 return 0;
1161}
1162
1163int
Fred Drake100814d2000-07-09 15:48:49 +00001164PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value)
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001165{
Tim Peters6d6c1a32001-08-02 04:15:00 +00001166 PyTypeObject *tp = v->ob_type;
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001167 int err;
Marc-André Lemburge44e5072000-09-18 16:20:57 +00001168
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001169 if (!PyString_Check(name)){
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001170#ifdef Py_USING_UNICODE
1171 /* The Unicode to string conversion is done here because the
1172 existing tp_setattro slots expect a string object as name
1173 and we wouldn't want to break those. */
1174 if (PyUnicode_Check(name)) {
1175 name = PyUnicode_AsEncodedString(name, NULL, NULL);
1176 if (name == NULL)
1177 return -1;
1178 }
Tim Peters803526b2002-07-07 05:13:56 +00001179 else
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001180#endif
1181 {
1182 PyErr_SetString(PyExc_TypeError,
1183 "attribute name must be string");
1184 return -1;
1185 }
Jeremy Hylton99a8f902000-06-23 14:36:32 +00001186 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001187 else
1188 Py_INCREF(name);
1189
1190 PyString_InternInPlace(&name);
1191 if (tp->tp_setattro != NULL) {
1192 err = (*tp->tp_setattro)(v, name, value);
1193 Py_DECREF(name);
1194 return err;
Marc-André Lemburge44e5072000-09-18 16:20:57 +00001195 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001196 if (tp->tp_setattr != NULL) {
1197 err = (*tp->tp_setattr)(v, PyString_AS_STRING(name), value);
1198 Py_DECREF(name);
1199 return err;
1200 }
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001201 Py_DECREF(name);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001202 if (tp->tp_getattr == NULL && tp->tp_getattro == NULL)
1203 PyErr_Format(PyExc_TypeError,
1204 "'%.100s' object has no attributes "
1205 "(%s .%.100s)",
1206 tp->tp_name,
1207 value==NULL ? "del" : "assign to",
1208 PyString_AS_STRING(name));
1209 else
1210 PyErr_Format(PyExc_TypeError,
1211 "'%.100s' object has only read-only attributes "
1212 "(%s .%.100s)",
1213 tp->tp_name,
1214 value==NULL ? "del" : "assign to",
1215 PyString_AS_STRING(name));
1216 return -1;
1217}
1218
1219/* Helper to get a pointer to an object's __dict__ slot, if any */
1220
1221PyObject **
1222_PyObject_GetDictPtr(PyObject *obj)
1223{
Martin v. Löwis725507b2006-03-07 12:08:51 +00001224 Py_ssize_t dictoffset;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001225 PyTypeObject *tp = obj->ob_type;
1226
1227 if (!(tp->tp_flags & Py_TPFLAGS_HAVE_CLASS))
1228 return NULL;
1229 dictoffset = tp->tp_dictoffset;
1230 if (dictoffset == 0)
1231 return NULL;
1232 if (dictoffset < 0) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001233 Py_ssize_t tsize;
Guido van Rossum2eb0b872002-03-01 22:24:49 +00001234 size_t size;
1235
1236 tsize = ((PyVarObject *)obj)->ob_size;
1237 if (tsize < 0)
1238 tsize = -tsize;
1239 size = _PyObject_VAR_SIZE(tp, tsize);
1240
Tim Peters6d483d32001-10-06 21:27:34 +00001241 dictoffset += (long)size;
1242 assert(dictoffset > 0);
1243 assert(dictoffset % SIZEOF_VOID_P == 0);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001244 }
1245 return (PyObject **) ((char *)obj + dictoffset);
1246}
1247
Tim Peters6d6c1a32001-08-02 04:15:00 +00001248PyObject *
Raymond Hettinger1da1dbf2003-03-17 19:46:11 +00001249PyObject_SelfIter(PyObject *obj)
Raymond Hettinger01538262003-03-17 08:24:35 +00001250{
1251 Py_INCREF(obj);
1252 return obj;
1253}
1254
Michael W. Hudson1593f502004-09-14 17:09:47 +00001255/* Generic GetAttr functions - put these in your tp_[gs]etattro slot */
1256
Raymond Hettinger01538262003-03-17 08:24:35 +00001257PyObject *
Tim Peters6d6c1a32001-08-02 04:15:00 +00001258PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
1259{
1260 PyTypeObject *tp = obj->ob_type;
Guido van Rossum056fbf42002-08-19 19:22:50 +00001261 PyObject *descr = NULL;
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001262 PyObject *res = NULL;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001263 descrgetfunc f;
Martin v. Löwis725507b2006-03-07 12:08:51 +00001264 Py_ssize_t dictoffset;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001265 PyObject **dictptr;
1266
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001267 if (!PyString_Check(name)){
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001268#ifdef Py_USING_UNICODE
1269 /* The Unicode to string conversion is done here because the
1270 existing tp_setattro slots expect a string object as name
1271 and we wouldn't want to break those. */
1272 if (PyUnicode_Check(name)) {
1273 name = PyUnicode_AsEncodedString(name, NULL, NULL);
1274 if (name == NULL)
1275 return NULL;
1276 }
Tim Peters803526b2002-07-07 05:13:56 +00001277 else
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001278#endif
1279 {
1280 PyErr_SetString(PyExc_TypeError,
1281 "attribute name must be string");
1282 return NULL;
1283 }
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001284 }
1285 else
1286 Py_INCREF(name);
1287
Tim Peters6d6c1a32001-08-02 04:15:00 +00001288 if (tp->tp_dict == NULL) {
Guido van Rossum528b7eb2001-08-07 17:24:28 +00001289 if (PyType_Ready(tp) < 0)
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001290 goto done;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001291 }
1292
Guido van Rossum056fbf42002-08-19 19:22:50 +00001293 /* Inline _PyType_Lookup */
1294 {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001295 Py_ssize_t i, n;
Guido van Rossum056fbf42002-08-19 19:22:50 +00001296 PyObject *mro, *base, *dict;
1297
1298 /* Look in tp_dict of types in MRO */
1299 mro = tp->tp_mro;
1300 assert(mro != NULL);
1301 assert(PyTuple_Check(mro));
1302 n = PyTuple_GET_SIZE(mro);
1303 for (i = 0; i < n; i++) {
1304 base = PyTuple_GET_ITEM(mro, i);
1305 if (PyClass_Check(base))
1306 dict = ((PyClassObject *)base)->cl_dict;
1307 else {
1308 assert(PyType_Check(base));
1309 dict = ((PyTypeObject *)base)->tp_dict;
1310 }
1311 assert(dict && PyDict_Check(dict));
1312 descr = PyDict_GetItem(dict, name);
1313 if (descr != NULL)
1314 break;
1315 }
1316 }
1317
Michael W. Hudsonb2c7de42003-08-15 13:07:47 +00001318 Py_XINCREF(descr);
1319
Tim Peters6d6c1a32001-08-02 04:15:00 +00001320 f = NULL;
Guido van Rossum90195e22003-02-19 03:19:29 +00001321 if (descr != NULL &&
1322 PyType_HasFeature(descr->ob_type, Py_TPFLAGS_HAVE_CLASS)) {
Tim Peters6d6c1a32001-08-02 04:15:00 +00001323 f = descr->ob_type->tp_descr_get;
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001324 if (f != NULL && PyDescr_IsData(descr)) {
1325 res = f(descr, obj, (PyObject *)obj->ob_type);
Michael W. Hudsonb2c7de42003-08-15 13:07:47 +00001326 Py_DECREF(descr);
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001327 goto done;
1328 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001329 }
1330
Guido van Rossumc66ff442002-08-19 16:50:48 +00001331 /* Inline _PyObject_GetDictPtr */
1332 dictoffset = tp->tp_dictoffset;
1333 if (dictoffset != 0) {
1334 PyObject *dict;
1335 if (dictoffset < 0) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001336 Py_ssize_t tsize;
Guido van Rossumc66ff442002-08-19 16:50:48 +00001337 size_t size;
1338
1339 tsize = ((PyVarObject *)obj)->ob_size;
1340 if (tsize < 0)
1341 tsize = -tsize;
1342 size = _PyObject_VAR_SIZE(tp, tsize);
1343
1344 dictoffset += (long)size;
1345 assert(dictoffset > 0);
1346 assert(dictoffset % SIZEOF_VOID_P == 0);
1347 }
1348 dictptr = (PyObject **) ((char *)obj + dictoffset);
1349 dict = *dictptr;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001350 if (dict != NULL) {
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001351 res = PyDict_GetItem(dict, name);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001352 if (res != NULL) {
1353 Py_INCREF(res);
Michael W. Hudsonb2c7de42003-08-15 13:07:47 +00001354 Py_XDECREF(descr);
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001355 goto done;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001356 }
1357 }
1358 }
1359
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001360 if (f != NULL) {
1361 res = f(descr, obj, (PyObject *)obj->ob_type);
Michael W. Hudsonb2c7de42003-08-15 13:07:47 +00001362 Py_DECREF(descr);
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001363 goto done;
1364 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001365
1366 if (descr != NULL) {
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001367 res = descr;
Michael W. Hudsonb2c7de42003-08-15 13:07:47 +00001368 /* descr was already increfed above */
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001369 goto done;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001370 }
1371
1372 PyErr_Format(PyExc_AttributeError,
1373 "'%.50s' object has no attribute '%.400s'",
1374 tp->tp_name, PyString_AS_STRING(name));
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001375 done:
1376 Py_DECREF(name);
1377 return res;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001378}
1379
1380int
1381PyObject_GenericSetAttr(PyObject *obj, PyObject *name, PyObject *value)
1382{
1383 PyTypeObject *tp = obj->ob_type;
1384 PyObject *descr;
1385 descrsetfunc f;
1386 PyObject **dictptr;
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001387 int res = -1;
1388
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001389 if (!PyString_Check(name)){
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001390#ifdef Py_USING_UNICODE
1391 /* The Unicode to string conversion is done here because the
1392 existing tp_setattro slots expect a string object as name
1393 and we wouldn't want to break those. */
1394 if (PyUnicode_Check(name)) {
1395 name = PyUnicode_AsEncodedString(name, NULL, NULL);
1396 if (name == NULL)
1397 return -1;
1398 }
Tim Peters803526b2002-07-07 05:13:56 +00001399 else
Martin v. Löwis0c160a02002-03-15 13:40:30 +00001400#endif
1401 {
1402 PyErr_SetString(PyExc_TypeError,
1403 "attribute name must be string");
1404 return -1;
1405 }
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001406 }
1407 else
1408 Py_INCREF(name);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001409
1410 if (tp->tp_dict == NULL) {
Guido van Rossum528b7eb2001-08-07 17:24:28 +00001411 if (PyType_Ready(tp) < 0)
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001412 goto done;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001413 }
1414
1415 descr = _PyType_Lookup(tp, name);
1416 f = NULL;
Guido van Rossum90195e22003-02-19 03:19:29 +00001417 if (descr != NULL &&
1418 PyType_HasFeature(descr->ob_type, Py_TPFLAGS_HAVE_CLASS)) {
Tim Peters6d6c1a32001-08-02 04:15:00 +00001419 f = descr->ob_type->tp_descr_set;
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001420 if (f != NULL && PyDescr_IsData(descr)) {
1421 res = f(descr, obj, value);
1422 goto done;
1423 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001424 }
1425
1426 dictptr = _PyObject_GetDictPtr(obj);
1427 if (dictptr != NULL) {
1428 PyObject *dict = *dictptr;
1429 if (dict == NULL && value != NULL) {
1430 dict = PyDict_New();
1431 if (dict == NULL)
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001432 goto done;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001433 *dictptr = dict;
1434 }
1435 if (dict != NULL) {
Tim Peters6d6c1a32001-08-02 04:15:00 +00001436 if (value == NULL)
1437 res = PyDict_DelItem(dict, name);
1438 else
1439 res = PyDict_SetItem(dict, name, value);
1440 if (res < 0 && PyErr_ExceptionMatches(PyExc_KeyError))
1441 PyErr_SetObject(PyExc_AttributeError, name);
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001442 goto done;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001443 }
1444 }
1445
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001446 if (f != NULL) {
1447 res = f(descr, obj, value);
1448 goto done;
1449 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001450
1451 if (descr == NULL) {
1452 PyErr_Format(PyExc_AttributeError,
1453 "'%.50s' object has no attribute '%.400s'",
1454 tp->tp_name, PyString_AS_STRING(name));
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001455 goto done;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001456 }
1457
1458 PyErr_Format(PyExc_AttributeError,
1459 "'%.50s' object attribute '%.400s' is read-only",
1460 tp->tp_name, PyString_AS_STRING(name));
Guido van Rossumebca9fc2001-12-04 15:54:53 +00001461 done:
1462 Py_DECREF(name);
1463 return res;
Guido van Rossum98ff96a1997-05-20 18:34:44 +00001464}
1465
Guido van Rossum6ac258d1993-05-12 08:24:20 +00001466/* Test a value used as condition, e.g., in a for or if statement.
1467 Return -1 if an error occurred */
1468
1469int
Fred Drake100814d2000-07-09 15:48:49 +00001470PyObject_IsTrue(PyObject *v)
Guido van Rossum6ac258d1993-05-12 08:24:20 +00001471{
Martin v. Löwis18e16552006-02-15 17:27:45 +00001472 Py_ssize_t res;
Guido van Rossum6248f442002-08-24 06:31:34 +00001473 if (v == Py_True)
1474 return 1;
1475 if (v == Py_False)
1476 return 0;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001477 if (v == Py_None)
Neal Norwitz51290d32002-06-13 21:32:44 +00001478 return 0;
Guido van Rossum1c4f4581998-05-22 00:53:24 +00001479 else if (v->ob_type->tp_as_number != NULL &&
1480 v->ob_type->tp_as_number->nb_nonzero != NULL)
Guido van Rossum6ac258d1993-05-12 08:24:20 +00001481 res = (*v->ob_type->tp_as_number->nb_nonzero)(v);
Guido van Rossum1c4f4581998-05-22 00:53:24 +00001482 else if (v->ob_type->tp_as_mapping != NULL &&
1483 v->ob_type->tp_as_mapping->mp_length != NULL)
Guido van Rossum6ac258d1993-05-12 08:24:20 +00001484 res = (*v->ob_type->tp_as_mapping->mp_length)(v);
Guido van Rossum1c4f4581998-05-22 00:53:24 +00001485 else if (v->ob_type->tp_as_sequence != NULL &&
1486 v->ob_type->tp_as_sequence->sq_length != NULL)
Guido van Rossum6ac258d1993-05-12 08:24:20 +00001487 res = (*v->ob_type->tp_as_sequence->sq_length)(v);
1488 else
Neal Norwitz51290d32002-06-13 21:32:44 +00001489 return 1;
Martin v. Löwis18e16552006-02-15 17:27:45 +00001490 /* if it is negative, it should be either -1 or -2 */
1491 return (res > 0) ? 1 : Py_SAFE_DOWNCAST(res, Py_ssize_t, int);
Guido van Rossum6ac258d1993-05-12 08:24:20 +00001492}
1493
Tim Peters803526b2002-07-07 05:13:56 +00001494/* equivalent of 'not v'
Guido van Rossumc3d3f961998-04-09 17:53:59 +00001495 Return -1 if an error occurred */
1496
1497int
Fred Drake100814d2000-07-09 15:48:49 +00001498PyObject_Not(PyObject *v)
Guido van Rossumc3d3f961998-04-09 17:53:59 +00001499{
1500 int res;
1501 res = PyObject_IsTrue(v);
1502 if (res < 0)
1503 return res;
1504 return res == 0;
1505}
1506
Guido van Rossum5524a591995-01-10 15:26:20 +00001507/* Coerce two numeric types to the "larger" one.
1508 Increment the reference count on each argument.
Guido van Rossume797ec12001-01-17 15:24:28 +00001509 Return value:
1510 -1 if an error occurred;
1511 0 if the coercion succeeded (and then the reference counts are increased);
1512 1 if no coercion is possible (and no error is raised).
Guido van Rossum5524a591995-01-10 15:26:20 +00001513*/
Guido van Rossum5524a591995-01-10 15:26:20 +00001514int
Fred Drake100814d2000-07-09 15:48:49 +00001515PyNumber_CoerceEx(PyObject **pv, PyObject **pw)
Guido van Rossum5524a591995-01-10 15:26:20 +00001516{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001517 register PyObject *v = *pv;
1518 register PyObject *w = *pw;
Guido van Rossum5524a591995-01-10 15:26:20 +00001519 int res;
1520
Guido van Rossum517c7d42002-04-26 02:49:14 +00001521 /* Shortcut only for old-style types */
1522 if (v->ob_type == w->ob_type &&
1523 !PyType_HasFeature(v->ob_type, Py_TPFLAGS_CHECKTYPES))
1524 {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001525 Py_INCREF(v);
1526 Py_INCREF(w);
Guido van Rossum5524a591995-01-10 15:26:20 +00001527 return 0;
1528 }
1529 if (v->ob_type->tp_as_number && v->ob_type->tp_as_number->nb_coerce) {
1530 res = (*v->ob_type->tp_as_number->nb_coerce)(pv, pw);
1531 if (res <= 0)
1532 return res;
1533 }
1534 if (w->ob_type->tp_as_number && w->ob_type->tp_as_number->nb_coerce) {
1535 res = (*w->ob_type->tp_as_number->nb_coerce)(pw, pv);
1536 if (res <= 0)
1537 return res;
1538 }
Guido van Rossum242c6421997-11-19 16:03:17 +00001539 return 1;
1540}
1541
Guido van Rossume797ec12001-01-17 15:24:28 +00001542/* Coerce two numeric types to the "larger" one.
1543 Increment the reference count on each argument.
1544 Return -1 and raise an exception if no coercion is possible
1545 (and then no reference count is incremented).
1546*/
Guido van Rossum242c6421997-11-19 16:03:17 +00001547int
Fred Drake100814d2000-07-09 15:48:49 +00001548PyNumber_Coerce(PyObject **pv, PyObject **pw)
Guido van Rossum242c6421997-11-19 16:03:17 +00001549{
1550 int err = PyNumber_CoerceEx(pv, pw);
1551 if (err <= 0)
1552 return err;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001553 PyErr_SetString(PyExc_TypeError, "number coercion failed");
Guido van Rossum5524a591995-01-10 15:26:20 +00001554 return -1;
1555}
1556
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001557
Guido van Rossum49b11fe1995-01-26 00:38:22 +00001558/* Test whether an object can be called */
1559
1560int
Fred Drake100814d2000-07-09 15:48:49 +00001561PyCallable_Check(PyObject *x)
Guido van Rossum49b11fe1995-01-26 00:38:22 +00001562{
1563 if (x == NULL)
1564 return 0;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001565 if (PyInstance_Check(x)) {
1566 PyObject *call = PyObject_GetAttrString(x, "__call__");
Guido van Rossum49b11fe1995-01-26 00:38:22 +00001567 if (call == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001568 PyErr_Clear();
Guido van Rossum49b11fe1995-01-26 00:38:22 +00001569 return 0;
1570 }
1571 /* Could test recursively but don't, for fear of endless
1572 recursion if some joker sets self.__call__ = self */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001573 Py_DECREF(call);
Guido van Rossum49b11fe1995-01-26 00:38:22 +00001574 return 1;
1575 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00001576 else {
1577 return x->ob_type->tp_call != NULL;
1578 }
Guido van Rossum49b11fe1995-01-26 00:38:22 +00001579}
1580
Tim Peters7eea37e2001-09-04 22:08:56 +00001581/* Helper for PyObject_Dir.
1582 Merge the __dict__ of aclass into dict, and recursively also all
1583 the __dict__s of aclass's base classes. The order of merging isn't
1584 defined, as it's expected that only the final set of dict keys is
1585 interesting.
1586 Return 0 on success, -1 on error.
1587*/
1588
1589static int
1590merge_class_dict(PyObject* dict, PyObject* aclass)
1591{
1592 PyObject *classdict;
1593 PyObject *bases;
1594
1595 assert(PyDict_Check(dict));
1596 assert(aclass);
1597
1598 /* Merge in the type's dict (if any). */
1599 classdict = PyObject_GetAttrString(aclass, "__dict__");
1600 if (classdict == NULL)
1601 PyErr_Clear();
1602 else {
1603 int status = PyDict_Update(dict, classdict);
1604 Py_DECREF(classdict);
1605 if (status < 0)
1606 return -1;
1607 }
1608
1609 /* Recursively merge in the base types' (if any) dicts. */
1610 bases = PyObject_GetAttrString(aclass, "__bases__");
Tim Petersbc7e8632001-09-16 20:33:22 +00001611 if (bases == NULL)
1612 PyErr_Clear();
1613 else {
Guido van Rossum44022412002-05-13 18:29:46 +00001614 /* We have no guarantee that bases is a real tuple */
Martin v. Löwis18e16552006-02-15 17:27:45 +00001615 Py_ssize_t i, n;
Guido van Rossum44022412002-05-13 18:29:46 +00001616 n = PySequence_Size(bases); /* This better be right */
1617 if (n < 0)
1618 PyErr_Clear();
1619 else {
1620 for (i = 0; i < n; i++) {
Tim Peters18e70832003-02-05 19:35:19 +00001621 int status;
Guido van Rossum44022412002-05-13 18:29:46 +00001622 PyObject *base = PySequence_GetItem(bases, i);
1623 if (base == NULL) {
1624 Py_DECREF(bases);
1625 return -1;
1626 }
Tim Peters18e70832003-02-05 19:35:19 +00001627 status = merge_class_dict(dict, base);
1628 Py_DECREF(base);
1629 if (status < 0) {
Guido van Rossum44022412002-05-13 18:29:46 +00001630 Py_DECREF(bases);
1631 return -1;
1632 }
Tim Peters7eea37e2001-09-04 22:08:56 +00001633 }
1634 }
1635 Py_DECREF(bases);
1636 }
1637 return 0;
1638}
1639
Tim Peters305b5852001-09-17 02:38:46 +00001640/* Helper for PyObject_Dir.
1641 If obj has an attr named attrname that's a list, merge its string
1642 elements into keys of dict.
1643 Return 0 on success, -1 on error. Errors due to not finding the attr,
1644 or the attr not being a list, are suppressed.
1645*/
1646
1647static int
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001648merge_list_attr(PyObject* dict, PyObject* obj, const char *attrname)
Tim Peters305b5852001-09-17 02:38:46 +00001649{
1650 PyObject *list;
1651 int result = 0;
1652
1653 assert(PyDict_Check(dict));
1654 assert(obj);
1655 assert(attrname);
1656
1657 list = PyObject_GetAttrString(obj, attrname);
1658 if (list == NULL)
1659 PyErr_Clear();
1660
1661 else if (PyList_Check(list)) {
1662 int i;
1663 for (i = 0; i < PyList_GET_SIZE(list); ++i) {
1664 PyObject *item = PyList_GET_ITEM(list, i);
1665 if (PyString_Check(item)) {
1666 result = PyDict_SetItem(dict, item, Py_None);
1667 if (result < 0)
1668 break;
1669 }
1670 }
1671 }
1672
1673 Py_XDECREF(list);
1674 return result;
1675}
1676
Tim Peters7eea37e2001-09-04 22:08:56 +00001677/* Like __builtin__.dir(arg). See bltinmodule.c's builtin_dir for the
1678 docstring, which should be kept in synch with this implementation. */
1679
1680PyObject *
1681PyObject_Dir(PyObject *arg)
1682{
1683 /* Set exactly one of these non-NULL before the end. */
1684 PyObject *result = NULL; /* result list */
1685 PyObject *masterdict = NULL; /* result is masterdict.keys() */
1686
1687 /* If NULL arg, return the locals. */
1688 if (arg == NULL) {
1689 PyObject *locals = PyEval_GetLocals();
1690 if (locals == NULL)
1691 goto error;
Raymond Hettinger214b1c32004-07-02 06:41:07 +00001692 result = PyMapping_Keys(locals);
Tim Peters7eea37e2001-09-04 22:08:56 +00001693 if (result == NULL)
1694 goto error;
1695 }
1696
1697 /* Elif this is some form of module, we only want its dict. */
Guido van Rossum8dbd3d82001-09-10 18:27:43 +00001698 else if (PyModule_Check(arg)) {
Tim Peters7eea37e2001-09-04 22:08:56 +00001699 masterdict = PyObject_GetAttrString(arg, "__dict__");
1700 if (masterdict == NULL)
1701 goto error;
Guido van Rossum8dbd3d82001-09-10 18:27:43 +00001702 if (!PyDict_Check(masterdict)) {
1703 PyErr_SetString(PyExc_TypeError,
1704 "module.__dict__ is not a dictionary");
1705 goto error;
1706 }
Tim Peters7eea37e2001-09-04 22:08:56 +00001707 }
1708
1709 /* Elif some form of type or class, grab its dict and its bases.
1710 We deliberately don't suck up its __class__, as methods belonging
1711 to the metaclass would probably be more confusing than helpful. */
1712 else if (PyType_Check(arg) || PyClass_Check(arg)) {
1713 masterdict = PyDict_New();
1714 if (masterdict == NULL)
1715 goto error;
1716 if (merge_class_dict(masterdict, arg) < 0)
1717 goto error;
1718 }
1719
1720 /* Else look at its dict, and the attrs reachable from its class. */
1721 else {
1722 PyObject *itsclass;
1723 /* Create a dict to start with. CAUTION: Not everything
1724 responding to __dict__ returns a dict! */
1725 masterdict = PyObject_GetAttrString(arg, "__dict__");
1726 if (masterdict == NULL) {
1727 PyErr_Clear();
1728 masterdict = PyDict_New();
1729 }
1730 else if (!PyDict_Check(masterdict)) {
1731 Py_DECREF(masterdict);
1732 masterdict = PyDict_New();
1733 }
1734 else {
1735 /* The object may have returned a reference to its
1736 dict, so copy it to avoid mutating it. */
1737 PyObject *temp = PyDict_Copy(masterdict);
1738 Py_DECREF(masterdict);
1739 masterdict = temp;
1740 }
1741 if (masterdict == NULL)
1742 goto error;
1743
Tim Peters305b5852001-09-17 02:38:46 +00001744 /* Merge in __members__ and __methods__ (if any).
1745 XXX Would like this to go away someday; for now, it's
1746 XXX needed to get at im_self etc of method objects. */
1747 if (merge_list_attr(masterdict, arg, "__members__") < 0)
1748 goto error;
1749 if (merge_list_attr(masterdict, arg, "__methods__") < 0)
1750 goto error;
1751
Tim Peters7eea37e2001-09-04 22:08:56 +00001752 /* Merge in attrs reachable from its class.
1753 CAUTION: Not all objects have a __class__ attr. */
1754 itsclass = PyObject_GetAttrString(arg, "__class__");
1755 if (itsclass == NULL)
1756 PyErr_Clear();
1757 else {
1758 int status = merge_class_dict(masterdict, itsclass);
1759 Py_DECREF(itsclass);
1760 if (status < 0)
1761 goto error;
1762 }
1763 }
1764
1765 assert((result == NULL) ^ (masterdict == NULL));
1766 if (masterdict != NULL) {
1767 /* The result comes from its keys. */
1768 assert(result == NULL);
1769 result = PyDict_Keys(masterdict);
1770 if (result == NULL)
1771 goto error;
1772 }
1773
1774 assert(result);
Raymond Hettinger2a7dede2004-08-07 04:55:30 +00001775 if (!PyList_Check(result)) {
Tim Petersf4aca752004-09-23 02:39:37 +00001776 PyErr_SetString(PyExc_TypeError,
Raymond Hettinger2a7dede2004-08-07 04:55:30 +00001777 "Expected keys() to be a list.");
1778 goto error;
1779 }
Tim Peters7eea37e2001-09-04 22:08:56 +00001780 if (PyList_Sort(result) != 0)
1781 goto error;
1782 else
1783 goto normal_return;
1784
1785 error:
1786 Py_XDECREF(result);
1787 result = NULL;
1788 /* fall through */
1789 normal_return:
1790 Py_XDECREF(masterdict);
1791 return result;
1792}
Guido van Rossum49b11fe1995-01-26 00:38:22 +00001793
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001794/*
1795NoObject is usable as a non-NULL undefined value, used by the macro None.
1796There is (and should be!) no way to create other objects of this type,
Guido van Rossum3f5da241990-12-20 15:06:42 +00001797so there is exactly one (which is indestructible, by the way).
Guido van Rossumba21a492001-08-16 08:17:26 +00001798(XXX This type and the type of NotImplemented below should be unified.)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001799*/
1800
Guido van Rossum0c182a11992-03-27 17:26:13 +00001801/* ARGSUSED */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001802static PyObject *
Fred Drake100814d2000-07-09 15:48:49 +00001803none_repr(PyObject *op)
Guido van Rossum3f5da241990-12-20 15:06:42 +00001804{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001805 return PyString_FromString("None");
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001806}
1807
Barry Warsaw9bf16442001-01-23 16:24:35 +00001808/* ARGUSED */
1809static void
Tim Peters803526b2002-07-07 05:13:56 +00001810none_dealloc(PyObject* ignore)
Barry Warsaw9bf16442001-01-23 16:24:35 +00001811{
1812 /* This should never get called, but we also don't want to SEGV if
1813 * we accidently decref None out of existance.
1814 */
Martin v. Löwis3f19b102002-08-07 16:21:51 +00001815 Py_FatalError("deallocating None");
Barry Warsaw9bf16442001-01-23 16:24:35 +00001816}
1817
1818
Guido van Rossumba21a492001-08-16 08:17:26 +00001819static PyTypeObject PyNone_Type = {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001820 PyObject_HEAD_INIT(&PyType_Type)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001821 0,
Guido van Rossumba21a492001-08-16 08:17:26 +00001822 "NoneType",
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001823 0,
1824 0,
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001825 none_dealloc, /*tp_dealloc*/ /*never called*/
Guido van Rossum7066dd71992-09-17 17:54:56 +00001826 0, /*tp_print*/
Guido van Rossum3f5da241990-12-20 15:06:42 +00001827 0, /*tp_getattr*/
1828 0, /*tp_setattr*/
1829 0, /*tp_compare*/
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001830 none_repr, /*tp_repr*/
Guido van Rossum3f5da241990-12-20 15:06:42 +00001831 0, /*tp_as_number*/
1832 0, /*tp_as_sequence*/
1833 0, /*tp_as_mapping*/
Guido van Rossum9bfef441993-03-29 10:43:31 +00001834 0, /*tp_hash */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001835};
1836
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001837PyObject _Py_NoneStruct = {
Guido van Rossumba21a492001-08-16 08:17:26 +00001838 PyObject_HEAD_INIT(&PyNone_Type)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001839};
1840
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +00001841/* NotImplemented is an object that can be used to signal that an
1842 operation is not implemented for the given type combination. */
1843
1844static PyObject *
1845NotImplemented_repr(PyObject *op)
1846{
1847 return PyString_FromString("NotImplemented");
1848}
1849
1850static PyTypeObject PyNotImplemented_Type = {
1851 PyObject_HEAD_INIT(&PyType_Type)
1852 0,
Guido van Rossumba21a492001-08-16 08:17:26 +00001853 "NotImplementedType",
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +00001854 0,
1855 0,
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001856 none_dealloc, /*tp_dealloc*/ /*never called*/
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +00001857 0, /*tp_print*/
1858 0, /*tp_getattr*/
1859 0, /*tp_setattr*/
1860 0, /*tp_compare*/
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001861 NotImplemented_repr, /*tp_repr*/
Neil Schemenauer5ed85ec2001-01-04 01:48:10 +00001862 0, /*tp_as_number*/
1863 0, /*tp_as_sequence*/
1864 0, /*tp_as_mapping*/
1865 0, /*tp_hash */
1866};
1867
1868PyObject _Py_NotImplementedStruct = {
1869 PyObject_HEAD_INIT(&PyNotImplemented_Type)
1870};
1871
Guido van Rossumba21a492001-08-16 08:17:26 +00001872void
1873_Py_ReadyTypes(void)
1874{
1875 if (PyType_Ready(&PyType_Type) < 0)
1876 Py_FatalError("Can't initialize 'type'");
1877
Fred Drake0a4dd392004-07-02 18:57:45 +00001878 if (PyType_Ready(&_PyWeakref_RefType) < 0)
1879 Py_FatalError("Can't initialize 'weakref'");
1880
Guido van Rossum77f6a652002-04-03 22:41:51 +00001881 if (PyType_Ready(&PyBool_Type) < 0)
1882 Py_FatalError("Can't initialize 'bool'");
1883
Guido van Rossum4dfe8a12006-04-22 23:28:04 +00001884 if (PyType_Ready(&PyBytes_Type) < 0)
1885 Py_FatalError("Can't initialize 'bytes'");
1886
Guido van Rossumcacfc072002-05-24 19:01:59 +00001887 if (PyType_Ready(&PyString_Type) < 0)
1888 Py_FatalError("Can't initialize 'str'");
1889
Guido van Rossumba21a492001-08-16 08:17:26 +00001890 if (PyType_Ready(&PyList_Type) < 0)
1891 Py_FatalError("Can't initialize 'list'");
1892
1893 if (PyType_Ready(&PyNone_Type) < 0)
1894 Py_FatalError("Can't initialize type(None)");
1895
1896 if (PyType_Ready(&PyNotImplemented_Type) < 0)
1897 Py_FatalError("Can't initialize type(NotImplemented)");
1898}
1899
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001900
Guido van Rossum84a90321996-05-22 16:34:47 +00001901#ifdef Py_TRACE_REFS
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001902
Guido van Rossumaacdc9d1996-08-12 21:32:12 +00001903void
Fred Drake100814d2000-07-09 15:48:49 +00001904_Py_NewReference(PyObject *op)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001905{
Tim Peters34592512002-07-11 06:23:50 +00001906 _Py_INC_REFTOTAL;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001907 op->ob_refcnt = 1;
Tim Peters7571a0f2003-03-23 17:52:28 +00001908 _Py_AddToAllObjects(op, 1);
Tim Peters34592512002-07-11 06:23:50 +00001909 _Py_INC_TPALLOCS(op);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001910}
1911
Guido van Rossumaacdc9d1996-08-12 21:32:12 +00001912void
Fred Drake100814d2000-07-09 15:48:49 +00001913_Py_ForgetReference(register PyObject *op)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001914{
Guido van Rossumbffd6832000-01-20 22:32:56 +00001915#ifdef SLOW_UNREF_CHECK
Guido van Rossum4c08d552000-03-10 22:55:18 +00001916 register PyObject *p;
Guido van Rossumbffd6832000-01-20 22:32:56 +00001917#endif
Guido van Rossumd7047b31995-01-02 19:07:15 +00001918 if (op->ob_refcnt < 0)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001919 Py_FatalError("UNREF negative refcnt");
Guido van Rossum2e8f6141992-09-03 20:32:55 +00001920 if (op == &refchain ||
Guido van Rossumd7047b31995-01-02 19:07:15 +00001921 op->_ob_prev->_ob_next != op || op->_ob_next->_ob_prev != op)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001922 Py_FatalError("UNREF invalid object");
Guido van Rossum2e8f6141992-09-03 20:32:55 +00001923#ifdef SLOW_UNREF_CHECK
Guido van Rossum3f5da241990-12-20 15:06:42 +00001924 for (p = refchain._ob_next; p != &refchain; p = p->_ob_next) {
1925 if (p == op)
1926 break;
1927 }
Guido van Rossumd7047b31995-01-02 19:07:15 +00001928 if (p == &refchain) /* Not found */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001929 Py_FatalError("UNREF unknown object");
Guido van Rossum2e8f6141992-09-03 20:32:55 +00001930#endif
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001931 op->_ob_next->_ob_prev = op->_ob_prev;
1932 op->_ob_prev->_ob_next = op->_ob_next;
Guido van Rossum2e8f6141992-09-03 20:32:55 +00001933 op->_ob_next = op->_ob_prev = NULL;
Tim Peters34592512002-07-11 06:23:50 +00001934 _Py_INC_TPFREES(op);
Guido van Rossum3f5da241990-12-20 15:06:42 +00001935}
1936
Guido van Rossumaacdc9d1996-08-12 21:32:12 +00001937void
Fred Drake100814d2000-07-09 15:48:49 +00001938_Py_Dealloc(PyObject *op)
Guido van Rossum3f5da241990-12-20 15:06:42 +00001939{
Guido van Rossum9776adf1994-09-07 14:36:45 +00001940 destructor dealloc = op->ob_type->tp_dealloc;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001941 _Py_ForgetReference(op);
Guido van Rossum9776adf1994-09-07 14:36:45 +00001942 (*dealloc)(op);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001943}
1944
Tim Peters269b2a62003-04-17 19:52:29 +00001945/* Print all live objects. Because PyObject_Print is called, the
1946 * interpreter must be in a healthy state.
1947 */
Guido van Rossumaacdc9d1996-08-12 21:32:12 +00001948void
Fred Drake100814d2000-07-09 15:48:49 +00001949_Py_PrintReferences(FILE *fp)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001950{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001951 PyObject *op;
Guido van Rossume09fb551997-08-05 02:04:34 +00001952 fprintf(fp, "Remaining objects:\n");
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001953 for (op = refchain._ob_next; op != &refchain; op = op->_ob_next) {
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001954 fprintf(fp, "%p [%" PY_FORMAT_SIZE_T "d] ", op, op->ob_refcnt);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001955 if (PyObject_Print(op, fp, 0) != 0)
1956 PyErr_Clear();
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001957 putc('\n', fp);
1958 }
1959}
1960
Tim Peters269b2a62003-04-17 19:52:29 +00001961/* Print the addresses of all live objects. Unlike _Py_PrintReferences, this
1962 * doesn't make any calls to the Python C API, so is always safe to call.
1963 */
1964void
1965_Py_PrintReferenceAddresses(FILE *fp)
1966{
1967 PyObject *op;
1968 fprintf(fp, "Remaining object addresses:\n");
1969 for (op = refchain._ob_next; op != &refchain; op = op->_ob_next)
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001970 fprintf(fp, "%p [%" PY_FORMAT_SIZE_T "d] %s\n", op,
1971 op->ob_refcnt, op->ob_type->tp_name);
Tim Peters269b2a62003-04-17 19:52:29 +00001972}
1973
Sjoerd Mullender6ec3c651995-08-29 09:18:14 +00001974PyObject *
Fred Drake100814d2000-07-09 15:48:49 +00001975_Py_GetObjects(PyObject *self, PyObject *args)
Sjoerd Mullender6ec3c651995-08-29 09:18:14 +00001976{
1977 int i, n;
1978 PyObject *t = NULL;
1979 PyObject *res, *op;
1980
1981 if (!PyArg_ParseTuple(args, "i|O", &n, &t))
1982 return NULL;
1983 op = refchain._ob_next;
1984 res = PyList_New(0);
1985 if (res == NULL)
1986 return NULL;
1987 for (i = 0; (n == 0 || i < n) && op != &refchain; i++) {
1988 while (op == self || op == args || op == res || op == t ||
Guido van Rossum3c296022001-07-14 17:58:00 +00001989 (t != NULL && op->ob_type != (PyTypeObject *) t)) {
Sjoerd Mullender6ec3c651995-08-29 09:18:14 +00001990 op = op->_ob_next;
1991 if (op == &refchain)
1992 return res;
1993 }
1994 if (PyList_Append(res, op) < 0) {
1995 Py_DECREF(res);
1996 return NULL;
1997 }
1998 op = op->_ob_next;
1999 }
2000 return res;
2001}
2002
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002003#endif
Guido van Rossum97ead3f1996-01-12 01:24:09 +00002004
2005
2006/* Hack to force loading of cobject.o */
Guido van Rossumda9c2711996-12-05 21:58:58 +00002007PyTypeObject *_Py_cobject_hack = &PyCObject_Type;
Guido van Rossum84a90321996-05-22 16:34:47 +00002008
2009
2010/* Hack to force loading of abstract.o */
Martin v. Löwis18e16552006-02-15 17:27:45 +00002011Py_ssize_t (*_Py_abstract_hack)(PyObject *) = PyObject_Size;
Guido van Rossume09fb551997-08-05 02:04:34 +00002012
2013
Andrew M. Kuchling1582a3a2000-08-16 12:27:23 +00002014/* Python's malloc wrappers (see pymem.h) */
Guido van Rossume09fb551997-08-05 02:04:34 +00002015
Thomas Wouters334fb892000-07-25 12:56:38 +00002016void *
Fred Drake100814d2000-07-09 15:48:49 +00002017PyMem_Malloc(size_t nbytes)
Guido van Rossume09fb551997-08-05 02:04:34 +00002018{
Guido van Rossumb18618d2000-05-03 23:44:39 +00002019 return PyMem_MALLOC(nbytes);
Guido van Rossume09fb551997-08-05 02:04:34 +00002020}
2021
Thomas Wouters334fb892000-07-25 12:56:38 +00002022void *
2023PyMem_Realloc(void *p, size_t nbytes)
Guido van Rossume09fb551997-08-05 02:04:34 +00002024{
Tim Petersaf3e8de2002-04-12 07:22:56 +00002025 return PyMem_REALLOC(p, nbytes);
Guido van Rossume09fb551997-08-05 02:04:34 +00002026}
2027
2028void
Thomas Wouters334fb892000-07-25 12:56:38 +00002029PyMem_Free(void *p)
Guido van Rossume09fb551997-08-05 02:04:34 +00002030{
Guido van Rossumb18618d2000-05-03 23:44:39 +00002031 PyMem_FREE(p);
2032}
2033
2034
Guido van Rossum86610361998-04-10 22:32:46 +00002035/* These methods are used to control infinite recursion in repr, str, print,
2036 etc. Container objects that may recursively contain themselves,
2037 e.g. builtin dictionaries and lists, should used Py_ReprEnter() and
2038 Py_ReprLeave() to avoid infinite recursion.
2039
2040 Py_ReprEnter() returns 0 the first time it is called for a particular
2041 object and 1 every time thereafter. It returns -1 if an exception
2042 occurred. Py_ReprLeave() has no return value.
2043
2044 See dictobject.c and listobject.c for examples of use.
2045*/
2046
2047#define KEY "Py_Repr"
2048
2049int
Fred Drake100814d2000-07-09 15:48:49 +00002050Py_ReprEnter(PyObject *obj)
Guido van Rossum86610361998-04-10 22:32:46 +00002051{
2052 PyObject *dict;
2053 PyObject *list;
Martin v. Löwis18e16552006-02-15 17:27:45 +00002054 Py_ssize_t i;
Guido van Rossum86610361998-04-10 22:32:46 +00002055
2056 dict = PyThreadState_GetDict();
2057 if (dict == NULL)
Guido van Rossum0fc8f002003-04-15 15:12:39 +00002058 return 0;
Guido van Rossum86610361998-04-10 22:32:46 +00002059 list = PyDict_GetItemString(dict, KEY);
2060 if (list == NULL) {
2061 list = PyList_New(0);
2062 if (list == NULL)
2063 return -1;
2064 if (PyDict_SetItemString(dict, KEY, list) < 0)
2065 return -1;
2066 Py_DECREF(list);
2067 }
2068 i = PyList_GET_SIZE(list);
2069 while (--i >= 0) {
2070 if (PyList_GET_ITEM(list, i) == obj)
2071 return 1;
2072 }
2073 PyList_Append(list, obj);
2074 return 0;
2075}
2076
2077void
Fred Drake100814d2000-07-09 15:48:49 +00002078Py_ReprLeave(PyObject *obj)
Guido van Rossum86610361998-04-10 22:32:46 +00002079{
2080 PyObject *dict;
2081 PyObject *list;
Martin v. Löwis18e16552006-02-15 17:27:45 +00002082 Py_ssize_t i;
Guido van Rossum86610361998-04-10 22:32:46 +00002083
2084 dict = PyThreadState_GetDict();
Guido van Rossumeb909461998-04-11 15:17:34 +00002085 if (dict == NULL)
2086 return;
Guido van Rossum86610361998-04-10 22:32:46 +00002087 list = PyDict_GetItemString(dict, KEY);
Guido van Rossumeb909461998-04-11 15:17:34 +00002088 if (list == NULL || !PyList_Check(list))
2089 return;
Guido van Rossum86610361998-04-10 22:32:46 +00002090 i = PyList_GET_SIZE(list);
2091 /* Count backwards because we always expect obj to be list[-1] */
2092 while (--i >= 0) {
2093 if (PyList_GET_ITEM(list, i) == obj) {
2094 PyList_SetSlice(list, i, i + 1, NULL);
2095 break;
2096 }
2097 }
2098}
Guido van Rossumd724b232000-03-13 16:01:29 +00002099
Tim Peters803526b2002-07-07 05:13:56 +00002100/* Trashcan support. */
Guido van Rossumd724b232000-03-13 16:01:29 +00002101
Tim Peters803526b2002-07-07 05:13:56 +00002102/* Current call-stack depth of tp_dealloc calls. */
Guido van Rossumd724b232000-03-13 16:01:29 +00002103int _PyTrash_delete_nesting = 0;
Guido van Rossume92e6102000-04-24 15:40:53 +00002104
Tim Peters803526b2002-07-07 05:13:56 +00002105/* List of objects that still need to be cleaned up, singly linked via their
2106 * gc headers' gc_prev pointers.
2107 */
2108PyObject *_PyTrash_delete_later = NULL;
Guido van Rossumd724b232000-03-13 16:01:29 +00002109
Tim Peters803526b2002-07-07 05:13:56 +00002110/* Add op to the _PyTrash_delete_later list. Called when the current
2111 * call-stack depth gets large. op must be a currently untracked gc'ed
2112 * object, with refcount 0. Py_DECREF must already have been called on it.
2113 */
Guido van Rossumd724b232000-03-13 16:01:29 +00002114void
Fred Drake100814d2000-07-09 15:48:49 +00002115_PyTrash_deposit_object(PyObject *op)
Guido van Rossumd724b232000-03-13 16:01:29 +00002116{
Tim Peters803526b2002-07-07 05:13:56 +00002117 assert(PyObject_IS_GC(op));
2118 assert(_Py_AS_GC(op)->gc.gc_refs == _PyGC_REFS_UNTRACKED);
2119 assert(op->ob_refcnt == 0);
Neil Schemenauerf589c052002-03-29 03:05:54 +00002120 _Py_AS_GC(op)->gc.gc_prev = (PyGC_Head *)_PyTrash_delete_later;
Guido van Rossume92e6102000-04-24 15:40:53 +00002121 _PyTrash_delete_later = op;
Guido van Rossumd724b232000-03-13 16:01:29 +00002122}
2123
Tim Peters803526b2002-07-07 05:13:56 +00002124/* Dealloccate all the objects in the _PyTrash_delete_later list. Called when
2125 * the call-stack unwinds again.
2126 */
Guido van Rossumd724b232000-03-13 16:01:29 +00002127void
Fred Drake100814d2000-07-09 15:48:49 +00002128_PyTrash_destroy_chain(void)
Guido van Rossumd724b232000-03-13 16:01:29 +00002129{
2130 while (_PyTrash_delete_later) {
Tim Peters803526b2002-07-07 05:13:56 +00002131 PyObject *op = _PyTrash_delete_later;
2132 destructor dealloc = op->ob_type->tp_dealloc;
Neil Schemenauerf589c052002-03-29 03:05:54 +00002133
Neil Schemenauerf589c052002-03-29 03:05:54 +00002134 _PyTrash_delete_later =
Tim Peters803526b2002-07-07 05:13:56 +00002135 (PyObject*) _Py_AS_GC(op)->gc.gc_prev;
Neil Schemenauerf589c052002-03-29 03:05:54 +00002136
Tim Peters803526b2002-07-07 05:13:56 +00002137 /* Call the deallocator directly. This used to try to
2138 * fool Py_DECREF into calling it indirectly, but
2139 * Py_DECREF was already called on this object, and in
2140 * assorted non-release builds calling Py_DECREF again ends
2141 * up distorting allocation statistics.
2142 */
2143 assert(op->ob_refcnt == 0);
Guido van Rossumd724b232000-03-13 16:01:29 +00002144 ++_PyTrash_delete_nesting;
Tim Peters803526b2002-07-07 05:13:56 +00002145 (*dealloc)(op);
Guido van Rossumd724b232000-03-13 16:01:29 +00002146 --_PyTrash_delete_nesting;
2147 }
2148}
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002149
2150#ifdef __cplusplus
2151}
2152#endif
2153