blob: 60214a44226608bda984286d57e987fc8096f358 [file] [log] [blame]
Guido van Rossumf70e43a1991-02-19 12:39:46 +00001
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002/* Class object implementation */
3
Guido van Rossumc0b618a1997-05-02 03:12:38 +00004#include "Python.h"
Guido van Rossum3f5da241990-12-20 15:06:42 +00005#include "structmember.h"
Guido van Rossum04691fc1992-08-12 15:35:34 +00006
Neil Schemenauer29bfc072001-01-04 01:43:46 +00007
Guido van Rossum52ca98a1994-09-05 07:32:29 +00008/* Forward */
Tim Petersdbd9ba62000-07-09 03:09:57 +00009static PyObject *class_lookup(PyClassObject *, PyObject *,
10 PyClassObject **);
11static PyObject *instance_getattr1(PyInstanceObject *, PyObject *);
12static PyObject *instance_getattr2(PyInstanceObject *, PyObject *);
Guido van Rossum52ca98a1994-09-05 07:32:29 +000013
Guido van Rossuma63eff61998-05-29 21:37:21 +000014static PyObject *getattrstr, *setattrstr, *delattrstr;
15
Fred Drake79912472000-07-09 04:06:11 +000016
Guido van Rossumc0b618a1997-05-02 03:12:38 +000017PyObject *
Fred Drake79912472000-07-09 04:06:11 +000018PyClass_New(PyObject *bases, PyObject *dict, PyObject *name)
19 /* bases is NULL or tuple of classobjects! */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000020{
Guido van Rossumc0b618a1997-05-02 03:12:38 +000021 PyClassObject *op, *dummy;
Guido van Rossum7cc56eb1997-09-12 20:04:46 +000022 static PyObject *docstr, *modstr, *namestr;
Guido van Rossum019f4241996-08-21 14:54:28 +000023 if (docstr == NULL) {
Guido van Rossuma412d241997-01-18 07:59:12 +000024 docstr= PyString_InternFromString("__doc__");
Guido van Rossum019f4241996-08-21 14:54:28 +000025 if (docstr == NULL)
26 return NULL;
27 }
Guido van Rossum7cc56eb1997-09-12 20:04:46 +000028 if (modstr == NULL) {
29 modstr= PyString_InternFromString("__module__");
30 if (modstr == NULL)
31 return NULL;
32 }
33 if (namestr == NULL) {
34 namestr= PyString_InternFromString("__name__");
35 if (namestr == NULL)
36 return NULL;
37 }
Guido van Rossum04d73c41997-10-07 14:54:11 +000038 if (name == NULL || !PyString_Check(name)) {
39 PyErr_SetString(PyExc_SystemError,
40 "PyClass_New: name must be a string");
41 return NULL;
42 }
43 if (dict == NULL || !PyDict_Check(dict)) {
44 PyErr_SetString(PyExc_SystemError,
45 "PyClass_New: dict must be a dictionary");
46 return NULL;
47 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +000048 if (PyDict_GetItem(dict, docstr) == NULL) {
49 if (PyDict_SetItem(dict, docstr, Py_None) < 0)
Guido van Rossume7d444f1995-01-07 12:35:18 +000050 return NULL;
51 }
Guido van Rossum7cc56eb1997-09-12 20:04:46 +000052 if (PyDict_GetItem(dict, modstr) == NULL) {
53 PyObject *globals = PyEval_GetGlobals();
54 if (globals != NULL) {
Guido van Rossum04d73c41997-10-07 14:54:11 +000055 PyObject *modname = PyDict_GetItem(globals, namestr);
56 if (modname != NULL) {
57 if (PyDict_SetItem(dict, modstr, modname) < 0)
Guido van Rossum7cc56eb1997-09-12 20:04:46 +000058 return NULL;
59 }
60 }
61 }
Guido van Rossume2966a61991-12-10 13:53:23 +000062 if (bases == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +000063 bases = PyTuple_New(0);
Guido van Rossume2966a61991-12-10 13:53:23 +000064 if (bases == NULL)
Guido van Rossume5372401993-03-16 12:15:04 +000065 return NULL;
Guido van Rossume2966a61991-12-10 13:53:23 +000066 }
Guido van Rossum04d73c41997-10-07 14:54:11 +000067 else {
68 int i;
69 if (!PyTuple_Check(bases)) {
70 PyErr_SetString(PyExc_SystemError,
71 "PyClass_New: bases must be a tuple");
72 return NULL;
73 }
74 i = PyTuple_Size(bases);
75 while (--i >= 0) {
76 if (!PyClass_Check(PyTuple_GetItem(bases, i))) {
77 PyErr_SetString(PyExc_SystemError,
78 "PyClass_New: base must be a class");
79 return NULL;
80 }
81 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +000082 Py_INCREF(bases);
Guido van Rossum04d73c41997-10-07 14:54:11 +000083 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +000084 op = PyObject_NEW(PyClassObject, &PyClass_Type);
Guido van Rossume2966a61991-12-10 13:53:23 +000085 if (op == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +000086 Py_DECREF(bases);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000087 return NULL;
Guido van Rossume2966a61991-12-10 13:53:23 +000088 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000089 op->cl_bases = bases;
Guido van Rossumc0b618a1997-05-02 03:12:38 +000090 Py_INCREF(dict);
Guido van Rossum81daa321993-05-20 14:24:46 +000091 op->cl_dict = dict;
Guido van Rossumc0b618a1997-05-02 03:12:38 +000092 Py_XINCREF(name);
Guido van Rossum94308391991-10-20 20:11:48 +000093 op->cl_name = name;
Guido van Rossum2878a691996-08-09 20:53:24 +000094 if (getattrstr == NULL) {
Guido van Rossuma412d241997-01-18 07:59:12 +000095 getattrstr = PyString_InternFromString("__getattr__");
96 setattrstr = PyString_InternFromString("__setattr__");
97 delattrstr = PyString_InternFromString("__delattr__");
Guido van Rossum2878a691996-08-09 20:53:24 +000098 }
99 op->cl_getattr = class_lookup(op, getattrstr, &dummy);
100 op->cl_setattr = class_lookup(op, setattrstr, &dummy);
101 op->cl_delattr = class_lookup(op, delattrstr, &dummy);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000102 Py_XINCREF(op->cl_getattr);
103 Py_XINCREF(op->cl_setattr);
104 Py_XINCREF(op->cl_delattr);
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000105 PyObject_GC_Init(op);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000106 return (PyObject *) op;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000107}
108
109/* Class methods */
110
111static void
Fred Drake79912472000-07-09 04:06:11 +0000112class_dealloc(PyClassObject *op)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000113{
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000114 PyObject_GC_Fini(op);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000115 Py_DECREF(op->cl_bases);
116 Py_DECREF(op->cl_dict);
117 Py_XDECREF(op->cl_name);
Guido van Rossum152d8171998-08-04 14:59:16 +0000118 Py_XDECREF(op->cl_getattr);
119 Py_XDECREF(op->cl_setattr);
120 Py_XDECREF(op->cl_delattr);
Guido van Rossum4cc6ac72000-07-01 01:00:38 +0000121 op = (PyClassObject *) PyObject_AS_GC(op);
Guido van Rossumb18618d2000-05-03 23:44:39 +0000122 PyObject_DEL(op);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000123}
124
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000125static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000126class_lookup(PyClassObject *cp, PyObject *name, PyClassObject **pclass)
Guido van Rossum81daa321993-05-20 14:24:46 +0000127{
128 int i, n;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000129 PyObject *value = PyDict_GetItem(cp->cl_dict, name);
Guido van Rossum81daa321993-05-20 14:24:46 +0000130 if (value != NULL) {
131 *pclass = cp;
132 return value;
133 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000134 n = PyTuple_Size(cp->cl_bases);
Guido van Rossum81daa321993-05-20 14:24:46 +0000135 for (i = 0; i < n; i++) {
Guido van Rossum7cc56eb1997-09-12 20:04:46 +0000136 /* XXX What if one of the bases is not a class? */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000137 PyObject *v = class_lookup(
138 (PyClassObject *)
139 PyTuple_GetItem(cp->cl_bases, i), name, pclass);
Guido van Rossum81daa321993-05-20 14:24:46 +0000140 if (v != NULL)
141 return v;
142 }
143 return NULL;
144}
145
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000146static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000147class_getattr(register PyClassObject *op, PyObject *name)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000148{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000149 register PyObject *v;
150 register char *sname = PyString_AsString(name);
151 PyClassObject *class;
Guido van Rossum2878a691996-08-09 20:53:24 +0000152 if (sname[0] == '_' && sname[1] == '_') {
153 if (strcmp(sname, "__dict__") == 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000154 if (PyEval_GetRestricted()) {
155 PyErr_SetString(PyExc_RuntimeError,
156 "class.__dict__ not accessible in restricted mode");
Guido van Rossum10393b11995-01-10 10:39:49 +0000157 return NULL;
158 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000159 Py_INCREF(op->cl_dict);
Guido van Rossum10393b11995-01-10 10:39:49 +0000160 return op->cl_dict;
161 }
Guido van Rossum2878a691996-08-09 20:53:24 +0000162 if (strcmp(sname, "__bases__") == 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000163 Py_INCREF(op->cl_bases);
Guido van Rossum10393b11995-01-10 10:39:49 +0000164 return op->cl_bases;
165 }
Guido van Rossum2878a691996-08-09 20:53:24 +0000166 if (strcmp(sname, "__name__") == 0) {
Guido van Rossum10393b11995-01-10 10:39:49 +0000167 if (op->cl_name == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000168 v = Py_None;
Guido van Rossum10393b11995-01-10 10:39:49 +0000169 else
170 v = op->cl_name;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000171 Py_INCREF(v);
Guido van Rossum10393b11995-01-10 10:39:49 +0000172 return v;
173 }
Guido van Rossum94308391991-10-20 20:11:48 +0000174 }
Guido van Rossum81daa321993-05-20 14:24:46 +0000175 v = class_lookup(op, name, &class);
Guido van Rossumb3f72581993-05-21 19:56:10 +0000176 if (v == NULL) {
Fred Drake661ea262000-10-24 19:57:45 +0000177 PyErr_Format(PyExc_AttributeError,
178 "class %.50s has no attribute '%.400s'",
179 PyString_AS_STRING(op->cl_name), sname);
Guido van Rossumb3f72581993-05-21 19:56:10 +0000180 return NULL;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000181 }
Guido van Rossum0add15f1997-05-09 01:07:15 +0000182 Py_INCREF(v);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000183 if (PyFunction_Check(v)) {
184 PyObject *w = PyMethod_New(v, (PyObject *)NULL,
185 (PyObject *)class);
186 Py_DECREF(v);
Guido van Rossumb3f72581993-05-21 19:56:10 +0000187 v = w;
188 }
189 return v;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000190}
191
Guido van Rossuma63eff61998-05-29 21:37:21 +0000192static void
Fred Drake79912472000-07-09 04:06:11 +0000193set_slot(PyObject **slot, PyObject *v)
Guido van Rossuma63eff61998-05-29 21:37:21 +0000194{
195 PyObject *temp = *slot;
196 Py_XINCREF(v);
197 *slot = v;
198 Py_XDECREF(temp);
199}
200
Guido van Rossum7ba30431998-07-08 13:34:48 +0000201static void
Fred Drake79912472000-07-09 04:06:11 +0000202set_attr_slots(PyClassObject *c)
Guido van Rossum7ba30431998-07-08 13:34:48 +0000203{
204 PyClassObject *dummy;
205
206 set_slot(&c->cl_getattr, class_lookup(c, getattrstr, &dummy));
207 set_slot(&c->cl_setattr, class_lookup(c, setattrstr, &dummy));
208 set_slot(&c->cl_delattr, class_lookup(c, delattrstr, &dummy));
209}
210
Guido van Rossuma63eff61998-05-29 21:37:21 +0000211static char *
Fred Drake79912472000-07-09 04:06:11 +0000212set_dict(PyClassObject *c, PyObject *v)
Guido van Rossuma63eff61998-05-29 21:37:21 +0000213{
Guido van Rossuma63eff61998-05-29 21:37:21 +0000214 if (v == NULL || !PyDict_Check(v))
215 return "__dict__ must be a dictionary object";
216 set_slot(&c->cl_dict, v);
Guido van Rossum7ba30431998-07-08 13:34:48 +0000217 set_attr_slots(c);
Guido van Rossuma63eff61998-05-29 21:37:21 +0000218 return "";
219}
220
221static char *
Fred Drake79912472000-07-09 04:06:11 +0000222set_bases(PyClassObject *c, PyObject *v)
Guido van Rossuma63eff61998-05-29 21:37:21 +0000223{
Guido van Rossuma63eff61998-05-29 21:37:21 +0000224 int i, n;
225
226 if (v == NULL || !PyTuple_Check(v))
227 return "__bases__ must be a tuple object";
228 n = PyTuple_Size(v);
229 for (i = 0; i < n; i++) {
230 PyObject *x = PyTuple_GET_ITEM(v, i);
231 if (!PyClass_Check(x))
232 return "__bases__ items must be classes";
233 if (PyClass_IsSubclass(x, (PyObject *)c))
234 return "a __bases__ item causes an inheritance cycle";
235 }
236 set_slot(&c->cl_bases, v);
Guido van Rossum7ba30431998-07-08 13:34:48 +0000237 set_attr_slots(c);
Guido van Rossuma63eff61998-05-29 21:37:21 +0000238 return "";
239}
240
241static char *
Fred Drake79912472000-07-09 04:06:11 +0000242set_name(PyClassObject *c, PyObject *v)
Guido van Rossuma63eff61998-05-29 21:37:21 +0000243{
Guido van Rossuma63eff61998-05-29 21:37:21 +0000244 if (v == NULL || !PyString_Check(v))
245 return "__name__ must be a string object";
Guido van Rossumad89bbc2000-06-28 21:57:18 +0000246 if (strlen(PyString_AS_STRING(v)) != (size_t)PyString_GET_SIZE(v))
Guido van Rossuma63eff61998-05-29 21:37:21 +0000247 return "__name__ must not contain null bytes";
248 set_slot(&c->cl_name, v);
249 return "";
250}
251
Guido van Rossum94308391991-10-20 20:11:48 +0000252static int
Fred Drake79912472000-07-09 04:06:11 +0000253class_setattr(PyClassObject *op, PyObject *name, PyObject *v)
Guido van Rossum94308391991-10-20 20:11:48 +0000254{
Guido van Rossumb2173c31997-08-25 21:23:56 +0000255 char *sname;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000256 if (PyEval_GetRestricted()) {
257 PyErr_SetString(PyExc_RuntimeError,
Guido van Rossumac21f6a1995-08-04 04:05:31 +0000258 "classes are read-only in restricted mode");
259 return -1;
260 }
Guido van Rossumb2173c31997-08-25 21:23:56 +0000261 sname = PyString_AsString(name);
262 if (sname[0] == '_' && sname[1] == '_') {
263 int n = PyString_Size(name);
264 if (sname[n-1] == '_' && sname[n-2] == '_') {
Guido van Rossuma63eff61998-05-29 21:37:21 +0000265 char *err = NULL;
266 if (strcmp(sname, "__dict__") == 0)
267 err = set_dict(op, v);
268 else if (strcmp(sname, "__bases__") == 0)
269 err = set_bases(op, v);
270 else if (strcmp(sname, "__name__") == 0)
271 err = set_name(op, v);
272 else if (strcmp(sname, "__getattr__") == 0)
273 set_slot(&op->cl_getattr, v);
274 else if (strcmp(sname, "__setattr__") == 0)
275 set_slot(&op->cl_setattr, v);
276 else if (strcmp(sname, "__delattr__") == 0)
277 set_slot(&op->cl_delattr, v);
278 /* For the last three, we fall through to update the
279 dictionary as well. */
280 if (err != NULL) {
281 if (*err == '\0')
282 return 0;
283 PyErr_SetString(PyExc_TypeError, err);
Guido van Rossumb2173c31997-08-25 21:23:56 +0000284 return -1;
285 }
286 }
287 }
Guido van Rossum94472a01992-09-04 09:45:18 +0000288 if (v == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000289 int rv = PyDict_DelItem(op->cl_dict, name);
Guido van Rossum94472a01992-09-04 09:45:18 +0000290 if (rv < 0)
Fred Drake661ea262000-10-24 19:57:45 +0000291 PyErr_Format(PyExc_AttributeError,
292 "class %.50s has no attribute '%.400s'",
293 PyString_AS_STRING(op->cl_name), sname);
Guido van Rossum94472a01992-09-04 09:45:18 +0000294 return rv;
295 }
Guido van Rossum94308391991-10-20 20:11:48 +0000296 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000297 return PyDict_SetItem(op->cl_dict, name, v);
Guido van Rossum94308391991-10-20 20:11:48 +0000298}
299
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000300static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000301class_repr(PyClassObject *op)
Guido van Rossum25831651993-05-19 14:50:45 +0000302{
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000303 PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
Guido van Rossum25831651993-05-19 14:50:45 +0000304 char buf[140];
305 char *name;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000306 if (op->cl_name == NULL || !PyString_Check(op->cl_name))
Guido van Rossum25831651993-05-19 14:50:45 +0000307 name = "?";
308 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000309 name = PyString_AsString(op->cl_name);
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000310 if (mod == NULL || !PyString_Check(mod))
Fred Drakea44d3532000-06-30 15:01:00 +0000311 sprintf(buf, "<class ?.%.100s at %p>", name, op);
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000312 else
Fred Drakea44d3532000-06-30 15:01:00 +0000313 sprintf(buf, "<class %.50s.%.50s at %p>",
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000314 PyString_AsString(mod),
Fred Drakea44d3532000-06-30 15:01:00 +0000315 name, op);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000316 return PyString_FromString(buf);
Guido van Rossum25831651993-05-19 14:50:45 +0000317}
318
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000319static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000320class_str(PyClassObject *op)
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000321{
322 PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
323 PyObject *name = op->cl_name;
324 PyObject *res;
325 int m, n;
326
327 if (name == NULL || !PyString_Check(name))
328 return class_repr(op);
329 if (mod == NULL || !PyString_Check(mod)) {
330 Py_INCREF(name);
331 return name;
332 }
333 m = PyString_Size(mod);
334 n = PyString_Size(name);
335 res = PyString_FromStringAndSize((char *)NULL, m+1+n);
336 if (res != NULL) {
337 char *s = PyString_AsString(res);
338 memcpy(s, PyString_AsString(mod), m);
339 s += m;
340 *s++ = '.';
341 memcpy(s, PyString_AsString(name), n);
342 }
343 return res;
344}
345
Jeremy Hylton8caad492000-06-23 14:18:11 +0000346static int
347class_traverse(PyClassObject *o, visitproc visit, void *arg)
348{
349 int err;
350 if (o->cl_bases) {
351 err = visit(o->cl_bases, arg);
352 if (err)
353 return err;
354 }
355 if (o->cl_dict) {
356 err = visit(o->cl_dict, arg);
357 if (err)
358 return err;
359 }
360 if (o->cl_name) {
361 err = visit(o->cl_name, arg);
362 if (err)
363 return err;
364 }
365 if (o->cl_getattr) {
366 err = visit(o->cl_getattr, arg);
367 if (err)
368 return err;
369 }
370 if (o->cl_setattr) {
371 err = visit(o->cl_setattr, arg);
372 if (err)
373 return err;
374 }
375 if (o->cl_delattr) {
376 err = visit(o->cl_delattr, arg);
377 if (err)
378 return err;
379 }
380 return 0;
381}
382
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000383PyTypeObject PyClass_Type = {
384 PyObject_HEAD_INIT(&PyType_Type)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000385 0,
386 "class",
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000387 sizeof(PyClassObject) + PyGC_HEAD_SIZE,
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000388 0,
Guido van Rossum8998b4f2001-01-17 15:28:20 +0000389 (destructor)class_dealloc, /* tp_dealloc */
390 0, /* tp_print */
391 0, /* tp_getattr */
392 0, /* tp_setattr */
393 0, /* tp_compare */
394 (reprfunc)class_repr, /* tp_repr */
395 0, /* tp_as_number */
396 0, /* tp_as_sequence */
397 0, /* tp_as_mapping */
398 0, /* tp_hash */
399 0, /* tp_call */
400 (reprfunc)class_str, /* tp_str */
401 (getattrofunc)class_getattr, /* tp_getattro */
402 (setattrofunc)class_setattr, /* tp_setattro */
403 0, /* tp_as_buffer */
404 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_GC, /* tp_flags */
405 0, /* tp_doc */
406 (traverseproc)class_traverse, /* tp_traverse */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000407};
408
Guido van Rossum81daa321993-05-20 14:24:46 +0000409int
Fred Drake79912472000-07-09 04:06:11 +0000410PyClass_IsSubclass(PyObject *class, PyObject *base)
Guido van Rossum81daa321993-05-20 14:24:46 +0000411{
412 int i, n;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000413 PyClassObject *cp;
Guido van Rossum81daa321993-05-20 14:24:46 +0000414 if (class == base)
415 return 1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000416 if (class == NULL || !PyClass_Check(class))
Guido van Rossumeb6b33a1993-05-25 09:38:27 +0000417 return 0;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000418 cp = (PyClassObject *)class;
419 n = PyTuple_Size(cp->cl_bases);
Guido van Rossum81daa321993-05-20 14:24:46 +0000420 for (i = 0; i < n; i++) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000421 if (PyClass_IsSubclass(PyTuple_GetItem(cp->cl_bases, i), base))
Guido van Rossum81daa321993-05-20 14:24:46 +0000422 return 1;
423 }
424 return 0;
425}
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000426
Guido van Rossum81daa321993-05-20 14:24:46 +0000427
428/* Instance objects */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000429
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000430PyObject *
Fred Drake5cc2c8c2001-01-28 03:53:08 +0000431PyInstance_NewRaw(PyObject *klass, PyObject *dict)
432{
433 PyInstanceObject *inst;
434
435 if (!PyClass_Check(klass)) {
436 PyErr_BadInternalCall();
437 return NULL;
438 }
439 if (dict == NULL) {
440 dict = PyDict_New();
441 if (dict == NULL)
442 return NULL;
443 }
444 else {
445 if (!PyDict_Check(dict)) {
446 PyErr_BadInternalCall();
447 return NULL;
448 }
449 Py_INCREF(dict);
450 }
451 inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
452 if (inst == NULL) {
453 Py_DECREF(dict);
454 return NULL;
455 }
456 Py_INCREF(klass);
457 inst->in_class = (PyClassObject *)klass;
458 inst->in_dict = dict;
459 PyObject_GC_Init(inst);
460 return (PyObject *)inst;
461}
462
463PyObject *
464PyInstance_New(PyObject *klass, PyObject *arg, PyObject *kw)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000465{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000466 register PyInstanceObject *inst;
467 PyObject *init;
468 static PyObject *initstr;
Fred Drake5cc2c8c2001-01-28 03:53:08 +0000469
470 inst = (PyInstanceObject *) PyInstance_NewRaw(klass, NULL);
Guido van Rossume8122f11991-05-05 20:03:07 +0000471 if (inst == NULL)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000472 return NULL;
Guido van Rossum2878a691996-08-09 20:53:24 +0000473 if (initstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000474 initstr = PyString_InternFromString("__init__");
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000475 init = instance_getattr2(inst, initstr);
Guido van Rossum25831651993-05-19 14:50:45 +0000476 if (init == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000477 if ((arg != NULL && (!PyTuple_Check(arg) ||
478 PyTuple_Size(arg) != 0))
479 || (kw != NULL && (!PyDict_Check(kw) ||
480 PyDict_Size(kw) != 0))) {
481 PyErr_SetString(PyExc_TypeError,
Guido van Rossuma83f2701995-07-26 18:07:32 +0000482 "this constructor takes no arguments");
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000483 Py_DECREF(inst);
Guido van Rossum25831651993-05-19 14:50:45 +0000484 inst = NULL;
485 }
486 }
487 else {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000488 PyObject *res = PyEval_CallObjectWithKeywords(init, arg, kw);
489 Py_DECREF(init);
Guido van Rossum25831651993-05-19 14:50:45 +0000490 if (res == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000491 Py_DECREF(inst);
Guido van Rossum25831651993-05-19 14:50:45 +0000492 inst = NULL;
493 }
494 else {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000495 if (res != Py_None) {
496 PyErr_SetString(PyExc_TypeError,
Guido van Rossum25831651993-05-19 14:50:45 +0000497 "__init__() should return None");
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000498 Py_DECREF(inst);
Guido van Rossum25831651993-05-19 14:50:45 +0000499 inst = NULL;
500 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000501 Py_DECREF(res);
Guido van Rossum25831651993-05-19 14:50:45 +0000502 }
503 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000504 return (PyObject *)inst;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000505}
506
Guido van Rossum21ed88c1991-04-04 10:42:10 +0000507/* Instance methods */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000508
509static void
Fred Drake79912472000-07-09 04:06:11 +0000510instance_dealloc(register PyInstanceObject *inst)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000511{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000512 PyObject *error_type, *error_value, *error_traceback;
513 PyObject *del;
514 static PyObject *delstr;
Tim Peters6b184912000-09-17 14:40:17 +0000515#ifdef Py_REF_DEBUG
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000516 extern long _Py_RefTotal;
Skip Montanaro4ca150b2000-07-08 12:04:57 +0000517#endif
Tim Peters6b184912000-09-17 14:40:17 +0000518 /* Temporarily resurrect the object. */
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000519#ifdef Py_TRACE_REFS
Tim Peters6b184912000-09-17 14:40:17 +0000520#ifndef Py_REF_DEBUG
521# error "Py_TRACE_REFS defined but Py_REF_DEBUG not."
522#endif
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000523 /* much too complicated if Py_TRACE_REFS defined */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000524 inst->ob_type = &PyInstance_Type;
Guido van Rossumbffd6832000-01-20 22:32:56 +0000525 _Py_NewReference((PyObject *)inst);
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000526#ifdef COUNT_ALLOCS
Tim Peters6b184912000-09-17 14:40:17 +0000527 /* compensate for boost in _Py_NewReference; note that
528 * _Py_RefTotal was also boosted; we'll knock that down later.
529 */
530 inst->ob_type->tp_alloc--;
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000531#endif
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000532#else /* !Py_TRACE_REFS */
Tim Peters6b184912000-09-17 14:40:17 +0000533 /* Py_INCREF boosts _Py_RefTotal if Py_REF_DEBUG is defined */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000534 Py_INCREF(inst);
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000535#endif /* !Py_TRACE_REFS */
Tim Peters6b184912000-09-17 14:40:17 +0000536
537 /* Save the current exception, if any. */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000538 PyErr_Fetch(&error_type, &error_value, &error_traceback);
Tim Peters6b184912000-09-17 14:40:17 +0000539 /* Execute __del__ method, if any. */
Guido van Rossum2878a691996-08-09 20:53:24 +0000540 if (delstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000541 delstr = PyString_InternFromString("__del__");
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000542 if ((del = instance_getattr2(inst, delstr)) != NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000543 PyObject *res = PyEval_CallObject(del, (PyObject *)NULL);
Tim Peters6b184912000-09-17 14:40:17 +0000544 if (res == NULL)
Jeremy Hyltonb709df32000-09-01 02:47:25 +0000545 PyErr_WriteUnraisable(del);
Guido van Rossum0dfcf751996-08-12 22:00:53 +0000546 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000547 Py_DECREF(res);
548 Py_DECREF(del);
Guido van Rossum25831651993-05-19 14:50:45 +0000549 }
Tim Peters6b184912000-09-17 14:40:17 +0000550 /* Restore the saved exception. */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000551 PyErr_Restore(error_type, error_value, error_traceback);
Tim Peters6b184912000-09-17 14:40:17 +0000552 /* Undo the temporary resurrection; can't use DECREF here, it would
553 * cause a recursive call.
554 */
555#ifdef Py_REF_DEBUG
556 /* _Py_RefTotal was boosted either by _Py_NewReference or
557 * Py_INCREF above.
558 */
559 _Py_RefTotal--;
560#endif
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000561 if (--inst->ob_refcnt > 0) {
562#ifdef COUNT_ALLOCS
563 inst->ob_type->tp_free--;
564#endif
Guido van Rossum25831651993-05-19 14:50:45 +0000565 return; /* __del__ added a reference; don't delete now */
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000566 }
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000567#ifdef Py_TRACE_REFS
Guido van Rossumbffd6832000-01-20 22:32:56 +0000568 _Py_ForgetReference((PyObject *)inst);
Tim Peters6b184912000-09-17 14:40:17 +0000569#ifdef COUNT_ALLOCS
570 /* compensate for increment in _Py_ForgetReference */
571 inst->ob_type->tp_free--;
572#endif
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000573#ifndef WITH_CYCLE_GC
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000574 inst->ob_type = NULL;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000575#endif
Tim Peters6b184912000-09-17 14:40:17 +0000576#endif
Neil Schemenauerce209672000-09-15 18:57:21 +0000577 PyObject_GC_Fini(inst);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000578 Py_DECREF(inst->in_class);
579 Py_XDECREF(inst->in_dict);
Guido van Rossum4cc6ac72000-07-01 01:00:38 +0000580 inst = (PyInstanceObject *) PyObject_AS_GC(inst);
Guido van Rossumb18618d2000-05-03 23:44:39 +0000581 PyObject_DEL(inst);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000582}
583
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000584static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000585instance_getattr1(register PyInstanceObject *inst, PyObject *name)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000586{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000587 register PyObject *v;
588 register char *sname = PyString_AsString(name);
Guido van Rossum2878a691996-08-09 20:53:24 +0000589 if (sname[0] == '_' && sname[1] == '_') {
590 if (strcmp(sname, "__dict__") == 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000591 if (PyEval_GetRestricted()) {
592 PyErr_SetString(PyExc_RuntimeError,
593 "instance.__dict__ not accessible in restricted mode");
Guido van Rossum10393b11995-01-10 10:39:49 +0000594 return NULL;
595 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000596 Py_INCREF(inst->in_dict);
Sjoerd Mullender3bb8a051993-10-22 12:04:32 +0000597 return inst->in_dict;
598 }
Guido van Rossum2878a691996-08-09 20:53:24 +0000599 if (strcmp(sname, "__class__") == 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000600 Py_INCREF(inst->in_class);
601 return (PyObject *)inst->in_class;
Sjoerd Mullender3bb8a051993-10-22 12:04:32 +0000602 }
Guido van Rossum94308391991-10-20 20:11:48 +0000603 }
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000604 v = instance_getattr2(inst, name);
605 if (v == NULL) {
Fred Drake661ea262000-10-24 19:57:45 +0000606 PyErr_Format(PyExc_AttributeError,
607 "%.50s instance has no attribute '%.400s'",
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000608 PyString_AS_STRING(inst->in_class->cl_name), sname);
609 }
610 return v;
611}
612
613static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000614instance_getattr2(register PyInstanceObject *inst, PyObject *name)
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000615{
616 register PyObject *v;
617 PyClassObject *class;
Guido van Rossumeb6b33a1993-05-25 09:38:27 +0000618 class = NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000619 v = PyDict_GetItem(inst->in_dict, name);
Guido van Rossumb3f72581993-05-21 19:56:10 +0000620 if (v == NULL) {
621 v = class_lookup(inst->in_class, name, &class);
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000622 if (v == NULL)
623 return v;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000624 }
Guido van Rossum0add15f1997-05-09 01:07:15 +0000625 Py_INCREF(v);
Guido van Rossum21d335e1993-10-15 13:01:11 +0000626 if (class != NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000627 if (PyFunction_Check(v)) {
628 PyObject *w = PyMethod_New(v, (PyObject *)inst,
629 (PyObject *)class);
630 Py_DECREF(v);
Guido van Rossum21d335e1993-10-15 13:01:11 +0000631 v = w;
632 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000633 else if (PyMethod_Check(v)) {
634 PyObject *im_class = PyMethod_Class(v);
Guido van Rossum21d335e1993-10-15 13:01:11 +0000635 /* Only if classes are compatible */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000636 if (PyClass_IsSubclass((PyObject *)class, im_class)) {
637 PyObject *im_func = PyMethod_Function(v);
638 PyObject *w = PyMethod_New(im_func,
639 (PyObject *)inst, im_class);
640 Py_DECREF(v);
Guido van Rossum21d335e1993-10-15 13:01:11 +0000641 v = w;
642 }
643 }
Guido van Rossumb3f72581993-05-21 19:56:10 +0000644 }
645 return v;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000646}
647
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000648static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000649instance_getattr(register PyInstanceObject *inst, PyObject *name)
Guido van Rossume7737541994-09-05 07:31:41 +0000650{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000651 register PyObject *func, *res;
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000652 res = instance_getattr1(inst, name);
653 if (res == NULL && (func = inst->in_class->cl_getattr) != NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000654 PyObject *args;
655 PyErr_Clear();
656 args = Py_BuildValue("(OO)", inst, name);
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000657 if (args == NULL)
Guido van Rossume7737541994-09-05 07:31:41 +0000658 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000659 res = PyEval_CallObject(func, args);
660 Py_DECREF(args);
Guido van Rossume7737541994-09-05 07:31:41 +0000661 }
662 return res;
663}
664
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000665static int
Fred Drake79912472000-07-09 04:06:11 +0000666instance_setattr1(PyInstanceObject *inst, PyObject *name, PyObject *v)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000667{
Guido van Rossum94472a01992-09-04 09:45:18 +0000668 if (v == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000669 int rv = PyDict_DelItem(inst->in_dict, name);
Guido van Rossum94472a01992-09-04 09:45:18 +0000670 if (rv < 0)
Fred Drake661ea262000-10-24 19:57:45 +0000671 PyErr_Format(PyExc_AttributeError,
672 "%.50s instance has no attribute '%.400s'",
673 PyString_AS_STRING(inst->in_class->cl_name),
674 PyString_AS_STRING(name));
Guido van Rossum94472a01992-09-04 09:45:18 +0000675 return rv;
676 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000677 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000678 return PyDict_SetItem(inst->in_dict, name, v);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000679}
680
Guido van Rossume7737541994-09-05 07:31:41 +0000681static int
Fred Drake79912472000-07-09 04:06:11 +0000682instance_setattr(PyInstanceObject *inst, PyObject *name, PyObject *v)
Guido van Rossume7737541994-09-05 07:31:41 +0000683{
Guido van Rossumb2173c31997-08-25 21:23:56 +0000684 PyObject *func, *args, *res, *tmp;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000685 char *sname = PyString_AsString(name);
Guido van Rossumb2173c31997-08-25 21:23:56 +0000686 if (sname[0] == '_' && sname[1] == '_') {
687 int n = PyString_Size(name);
Guido van Rossum2878a691996-08-09 20:53:24 +0000688 if (sname[n-1] == '_' && sname[n-2] == '_') {
Guido van Rossumb2173c31997-08-25 21:23:56 +0000689 if (strcmp(sname, "__dict__") == 0) {
690 if (PyEval_GetRestricted()) {
691 PyErr_SetString(PyExc_RuntimeError,
692 "__dict__ not accessible in restricted mode");
693 return -1;
694 }
695 if (v == NULL || !PyDict_Check(v)) {
696 PyErr_SetString(PyExc_TypeError,
697 "__dict__ must be set to a dictionary");
698 return -1;
699 }
700 tmp = inst->in_dict;
701 Py_INCREF(v);
702 inst->in_dict = v;
703 Py_DECREF(tmp);
704 return 0;
705 }
706 if (strcmp(sname, "__class__") == 0) {
707 if (PyEval_GetRestricted()) {
708 PyErr_SetString(PyExc_RuntimeError,
709 "__class__ not accessible in restricted mode");
710 return -1;
711 }
712 if (v == NULL || !PyClass_Check(v)) {
713 PyErr_SetString(PyExc_TypeError,
714 "__class__ must be set to a class");
715 return -1;
716 }
717 tmp = (PyObject *)(inst->in_class);
718 Py_INCREF(v);
719 inst->in_class = (PyClassObject *)v;
720 Py_DECREF(tmp);
721 return 0;
722 }
Guido van Rossume7737541994-09-05 07:31:41 +0000723 }
Guido van Rossume7737541994-09-05 07:31:41 +0000724 }
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000725 if (v == NULL)
726 func = inst->in_class->cl_delattr;
727 else
728 func = inst->in_class->cl_setattr;
729 if (func == NULL)
730 return instance_setattr1(inst, name, v);
731 if (v == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000732 args = Py_BuildValue("(OO)", inst, name);
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000733 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000734 args = Py_BuildValue("(OOO)", inst, name, v);
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000735 if (args == NULL)
736 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000737 res = PyEval_CallObject(func, args);
738 Py_DECREF(args);
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000739 if (res == NULL)
740 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000741 Py_DECREF(res);
Guido van Rossume7737541994-09-05 07:31:41 +0000742 return 0;
743}
744
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000745static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000746instance_repr(PyInstanceObject *inst)
Guido van Rossum04691fc1992-08-12 15:35:34 +0000747{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000748 PyObject *func;
749 PyObject *res;
750 static PyObject *reprstr;
Guido van Rossum04691fc1992-08-12 15:35:34 +0000751
Guido van Rossum2878a691996-08-09 20:53:24 +0000752 if (reprstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000753 reprstr = PyString_InternFromString("__repr__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000754 func = instance_getattr(inst, reprstr);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000755 if (func == NULL) {
Guido van Rossum25831651993-05-19 14:50:45 +0000756 char buf[140];
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000757 PyObject *classname = inst->in_class->cl_name;
Guido van Rossumb7f1afe1997-12-03 00:06:02 +0000758 PyObject *mod = PyDict_GetItemString(
759 inst->in_class->cl_dict, "__module__");
Guido van Rossum25831651993-05-19 14:50:45 +0000760 char *cname;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000761 if (classname != NULL && PyString_Check(classname))
762 cname = PyString_AsString(classname);
Guido van Rossum25831651993-05-19 14:50:45 +0000763 else
764 cname = "?";
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000765 PyErr_Clear();
Guido van Rossumb7f1afe1997-12-03 00:06:02 +0000766 if (mod == NULL || !PyString_Check(mod))
Fred Drakea44d3532000-06-30 15:01:00 +0000767 sprintf(buf, "<?.%.100s instance at %p>",
768 cname, inst);
Guido van Rossumb7f1afe1997-12-03 00:06:02 +0000769 else
Fred Drakea44d3532000-06-30 15:01:00 +0000770 sprintf(buf, "<%.50s.%.50s instance at %p>",
Guido van Rossumb7f1afe1997-12-03 00:06:02 +0000771 PyString_AsString(mod),
Fred Drakea44d3532000-06-30 15:01:00 +0000772 cname, inst);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000773 return PyString_FromString(buf);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000774 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000775 res = PyEval_CallObject(func, (PyObject *)NULL);
776 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000777 return res;
778}
779
Guido van Rossum9bfef441993-03-29 10:43:31 +0000780static long
Fred Drake79912472000-07-09 04:06:11 +0000781instance_hash(PyInstanceObject *inst)
Guido van Rossum9bfef441993-03-29 10:43:31 +0000782{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000783 PyObject *func;
784 PyObject *res;
Guido van Rossum8a0c3451993-04-08 12:56:19 +0000785 long outcome;
Guido van Rossum65e8bd72001-01-18 23:46:31 +0000786 static PyObject *hashstr, *eqstr, *cmpstr;
Guido van Rossum9bfef441993-03-29 10:43:31 +0000787
Guido van Rossum2878a691996-08-09 20:53:24 +0000788 if (hashstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000789 hashstr = PyString_InternFromString("__hash__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000790 func = instance_getattr(inst, hashstr);
Guido van Rossum9bfef441993-03-29 10:43:31 +0000791 if (func == NULL) {
Guido van Rossum65e8bd72001-01-18 23:46:31 +0000792 /* If there is no __eq__ and no __cmp__ method, we hash on the
793 address. If an __eq__ or __cmp__ method exists, there must
794 be a __hash__. */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000795 PyErr_Clear();
Guido van Rossum65e8bd72001-01-18 23:46:31 +0000796 if (eqstr == NULL)
797 eqstr = PyString_InternFromString("__eq__");
798 func = instance_getattr(inst, eqstr);
Guido van Rossum8a0c3451993-04-08 12:56:19 +0000799 if (func == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000800 PyErr_Clear();
Guido van Rossum65e8bd72001-01-18 23:46:31 +0000801 if (cmpstr == NULL)
802 cmpstr = PyString_InternFromString("__cmp__");
803 func = instance_getattr(inst, cmpstr);
804 if (func == NULL) {
805 PyErr_Clear();
806 return _Py_HashPointer(inst);
807 }
Guido van Rossum8a0c3451993-04-08 12:56:19 +0000808 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000809 PyErr_SetString(PyExc_TypeError, "unhashable instance");
Guido van Rossum9bfef441993-03-29 10:43:31 +0000810 return -1;
811 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000812 res = PyEval_CallObject(func, (PyObject *)NULL);
813 Py_DECREF(func);
Guido van Rossum9bfef441993-03-29 10:43:31 +0000814 if (res == NULL)
815 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000816 if (PyInt_Check(res)) {
817 outcome = PyInt_AsLong(res);
Guido van Rossum9bfef441993-03-29 10:43:31 +0000818 if (outcome == -1)
819 outcome = -2;
820 }
821 else {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000822 PyErr_SetString(PyExc_TypeError,
823 "__hash__() should return an int");
Guido van Rossum9bfef441993-03-29 10:43:31 +0000824 outcome = -1;
825 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000826 Py_DECREF(res);
Guido van Rossum9bfef441993-03-29 10:43:31 +0000827 return outcome;
828}
829
Jeremy Hylton8caad492000-06-23 14:18:11 +0000830static int
831instance_traverse(PyInstanceObject *o, visitproc visit, void *arg)
832{
833 int err;
834 if (o->in_class) {
835 err = visit((PyObject *)(o->in_class), arg);
836 if (err)
837 return err;
838 }
839 if (o->in_dict) {
840 err = visit(o->in_dict, arg);
841 if (err)
842 return err;
843 }
Jeremy Hyltond22162b2000-06-23 17:14:56 +0000844 return 0;
Jeremy Hylton8caad492000-06-23 14:18:11 +0000845}
846
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000847static PyObject *getitemstr, *setitemstr, *delitemstr, *lenstr;
Guido van Rossum2878a691996-08-09 20:53:24 +0000848
Guido van Rossum9bfef441993-03-29 10:43:31 +0000849static int
Fred Drake79912472000-07-09 04:06:11 +0000850instance_length(PyInstanceObject *inst)
Guido van Rossum04691fc1992-08-12 15:35:34 +0000851{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000852 PyObject *func;
853 PyObject *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +0000854 int outcome;
855
Guido van Rossum2878a691996-08-09 20:53:24 +0000856 if (lenstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000857 lenstr = PyString_InternFromString("__len__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000858 func = instance_getattr(inst, lenstr);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000859 if (func == NULL)
860 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000861 res = PyEval_CallObject(func, (PyObject *)NULL);
862 Py_DECREF(func);
Guido van Rossumd014ea61992-11-26 10:30:26 +0000863 if (res == NULL)
864 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000865 if (PyInt_Check(res)) {
866 outcome = PyInt_AsLong(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000867 if (outcome < 0)
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000868 PyErr_SetString(PyExc_ValueError,
869 "__len__() should return >= 0");
Guido van Rossum04691fc1992-08-12 15:35:34 +0000870 }
871 else {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000872 PyErr_SetString(PyExc_TypeError,
873 "__len__() should return an int");
Guido van Rossum04691fc1992-08-12 15:35:34 +0000874 outcome = -1;
875 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000876 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000877 return outcome;
878}
879
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000880static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000881instance_subscript(PyInstanceObject *inst, PyObject *key)
Guido van Rossum04691fc1992-08-12 15:35:34 +0000882{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000883 PyObject *func;
884 PyObject *arg;
885 PyObject *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +0000886
Guido van Rossum2878a691996-08-09 20:53:24 +0000887 if (getitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000888 getitemstr = PyString_InternFromString("__getitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000889 func = instance_getattr(inst, getitemstr);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000890 if (func == NULL)
891 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000892 arg = Py_BuildValue("(O)", key);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000893 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000894 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000895 return NULL;
896 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000897 res = PyEval_CallObject(func, arg);
898 Py_DECREF(func);
899 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000900 return res;
901}
902
Guido van Rossum9bfef441993-03-29 10:43:31 +0000903static int
Fred Drake79912472000-07-09 04:06:11 +0000904instance_ass_subscript(PyInstanceObject *inst, PyObject *key, PyObject *value)
Guido van Rossum04691fc1992-08-12 15:35:34 +0000905{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000906 PyObject *func;
907 PyObject *arg;
908 PyObject *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +0000909
Guido van Rossum2878a691996-08-09 20:53:24 +0000910 if (value == NULL) {
911 if (delitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000912 delitemstr = PyString_InternFromString("__delitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000913 func = instance_getattr(inst, delitemstr);
914 }
915 else {
916 if (setitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000917 setitemstr = PyString_InternFromString("__setitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000918 func = instance_getattr(inst, setitemstr);
919 }
Guido van Rossum04691fc1992-08-12 15:35:34 +0000920 if (func == NULL)
921 return -1;
922 if (value == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000923 arg = Py_BuildValue("(O)", key);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000924 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000925 arg = Py_BuildValue("(OO)", key, value);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000926 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000927 Py_DECREF(func);
Guido van Rossum6d946f91992-08-14 13:49:30 +0000928 return -1;
Guido van Rossum04691fc1992-08-12 15:35:34 +0000929 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000930 res = PyEval_CallObject(func, arg);
931 Py_DECREF(func);
932 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000933 if (res == NULL)
934 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000935 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000936 return 0;
937}
938
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000939static PyMappingMethods instance_as_mapping = {
Guido van Rossum8998b4f2001-01-17 15:28:20 +0000940 (inquiry)instance_length, /* mp_length */
941 (binaryfunc)instance_subscript, /* mp_subscript */
942 (objobjargproc)instance_ass_subscript, /* mp_ass_subscript */
Guido van Rossum04691fc1992-08-12 15:35:34 +0000943};
944
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000945static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000946instance_item(PyInstanceObject *inst, int i)
Guido van Rossum04691fc1992-08-12 15:35:34 +0000947{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000948 PyObject *func, *arg, *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +0000949
Guido van Rossum2878a691996-08-09 20:53:24 +0000950 if (getitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000951 getitemstr = PyString_InternFromString("__getitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000952 func = instance_getattr(inst, getitemstr);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000953 if (func == NULL)
954 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000955 arg = Py_BuildValue("(i)", i);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000956 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000957 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000958 return NULL;
959 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000960 res = PyEval_CallObject(func, arg);
961 Py_DECREF(func);
962 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000963 return res;
964}
965
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000966static PyObject *
Thomas Wouters1d75a792000-08-17 22:37:32 +0000967sliceobj_from_intint(int i, int j)
968{
969 PyObject *start, *end, *res;
970
971 start = PyInt_FromLong((long)i);
972 if (!start)
973 return NULL;
974
975 end = PyInt_FromLong((long)j);
976 if (!end) {
977 Py_DECREF(start);
978 return NULL;
979 }
980 res = PySlice_New(start, end, NULL);
981 Py_DECREF(start);
982 Py_DECREF(end);
983 return res;
984}
985
986
987static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000988instance_slice(PyInstanceObject *inst, int i, int j)
Guido van Rossum04691fc1992-08-12 15:35:34 +0000989{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000990 PyObject *func, *arg, *res;
991 static PyObject *getslicestr;
Guido van Rossum04691fc1992-08-12 15:35:34 +0000992
Guido van Rossum2878a691996-08-09 20:53:24 +0000993 if (getslicestr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000994 getslicestr = PyString_InternFromString("__getslice__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000995 func = instance_getattr(inst, getslicestr);
Thomas Wouters1d75a792000-08-17 22:37:32 +0000996
997 if (func == NULL) {
998 PyErr_Clear();
999
1000 if (getitemstr == NULL)
1001 getitemstr = PyString_InternFromString("__getitem__");
1002 func = instance_getattr(inst, getitemstr);
1003 if (func == NULL)
1004 return NULL;
1005 arg = Py_BuildValue("(N)", sliceobj_from_intint(i, j));
1006 } else
1007 arg = Py_BuildValue("(ii)", i, j);
1008
Guido van Rossum04691fc1992-08-12 15:35:34 +00001009 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001010 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001011 return NULL;
1012 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001013 res = PyEval_CallObject(func, arg);
1014 Py_DECREF(func);
1015 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001016 return res;
1017}
1018
1019static int
Fred Drake79912472000-07-09 04:06:11 +00001020instance_ass_item(PyInstanceObject *inst, int i, PyObject *item)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001021{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001022 PyObject *func, *arg, *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001023
Guido van Rossum2878a691996-08-09 20:53:24 +00001024 if (item == NULL) {
1025 if (delitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001026 delitemstr = PyString_InternFromString("__delitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001027 func = instance_getattr(inst, delitemstr);
1028 }
1029 else {
1030 if (setitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001031 setitemstr = PyString_InternFromString("__setitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001032 func = instance_getattr(inst, setitemstr);
1033 }
Guido van Rossum04691fc1992-08-12 15:35:34 +00001034 if (func == NULL)
Guido van Rossum6d946f91992-08-14 13:49:30 +00001035 return -1;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001036 if (item == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001037 arg = Py_BuildValue("i", i);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001038 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001039 arg = Py_BuildValue("(iO)", i, item);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001040 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001041 Py_DECREF(func);
Guido van Rossum6d946f91992-08-14 13:49:30 +00001042 return -1;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001043 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001044 res = PyEval_CallObject(func, arg);
1045 Py_DECREF(func);
1046 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001047 if (res == NULL)
1048 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001049 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001050 return 0;
1051}
1052
1053static int
Fred Drake79912472000-07-09 04:06:11 +00001054instance_ass_slice(PyInstanceObject *inst, int i, int j, PyObject *value)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001055{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001056 PyObject *func, *arg, *res;
1057 static PyObject *setslicestr, *delslicestr;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001058
Guido van Rossum2878a691996-08-09 20:53:24 +00001059 if (value == NULL) {
1060 if (delslicestr == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001061 delslicestr =
1062 PyString_InternFromString("__delslice__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001063 func = instance_getattr(inst, delslicestr);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001064 if (func == NULL) {
1065 PyErr_Clear();
1066 if (delitemstr == NULL)
1067 delitemstr =
1068 PyString_InternFromString("__delitem__");
1069 func = instance_getattr(inst, delitemstr);
1070 if (func == NULL)
1071 return -1;
1072
1073 arg = Py_BuildValue("(N)",
1074 sliceobj_from_intint(i, j));
1075 } else
1076 arg = Py_BuildValue("(ii)", i, j);
Guido van Rossum2878a691996-08-09 20:53:24 +00001077 }
1078 else {
1079 if (setslicestr == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001080 setslicestr =
1081 PyString_InternFromString("__setslice__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001082 func = instance_getattr(inst, setslicestr);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001083 if (func == NULL) {
1084 PyErr_Clear();
1085 if (setitemstr == NULL)
1086 setitemstr =
1087 PyString_InternFromString("__setitem__");
1088 func = instance_getattr(inst, setitemstr);
1089 if (func == NULL)
1090 return -1;
1091
1092 arg = Py_BuildValue("(NO)",
1093 sliceobj_from_intint(i, j), value);
1094 } else
1095 arg = Py_BuildValue("(iiO)", i, j, value);
Guido van Rossum2878a691996-08-09 20:53:24 +00001096 }
Guido van Rossum04691fc1992-08-12 15:35:34 +00001097 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001098 Py_DECREF(func);
Guido van Rossum6d946f91992-08-14 13:49:30 +00001099 return -1;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001100 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001101 res = PyEval_CallObject(func, arg);
1102 Py_DECREF(func);
1103 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001104 if (res == NULL)
1105 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001106 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001107 return 0;
1108}
1109
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001110static int instance_contains(PyInstanceObject *inst, PyObject *member)
1111{
1112 static PyObject *__contains__;
1113 PyObject *func, *arg, *res;
1114 int ret;
1115
1116 if(__contains__ == NULL) {
1117 __contains__ = PyString_InternFromString("__contains__");
1118 if(__contains__ == NULL)
1119 return -1;
1120 }
1121 func = instance_getattr(inst, __contains__);
1122 if(func == NULL) {
Thomas Wouters7e474022000-07-16 12:04:32 +00001123 /* fall back to previous behavior */
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001124 int i, cmp_res;
1125
1126 if(!PyErr_ExceptionMatches(PyExc_AttributeError))
1127 return -1;
1128 PyErr_Clear();
1129 for(i=0;;i++) {
1130 PyObject *obj = instance_item(inst, i);
1131 int ret = 0;
1132
1133 if(obj == NULL) {
1134 if(!PyErr_ExceptionMatches(PyExc_IndexError))
1135 return -1;
1136 PyErr_Clear();
1137 return 0;
1138 }
1139 if(PyObject_Cmp(obj, member, &cmp_res) == -1)
1140 ret = -1;
1141 if(cmp_res == 0)
1142 ret = 1;
1143 Py_DECREF(obj);
1144 if(ret)
1145 return ret;
1146 }
1147 }
1148 arg = Py_BuildValue("(O)", member);
1149 if(arg == NULL) {
1150 Py_DECREF(func);
1151 return -1;
1152 }
1153 res = PyEval_CallObject(func, arg);
1154 Py_DECREF(func);
1155 Py_DECREF(arg);
1156 if(res == NULL)
1157 return -1;
1158 ret = PyObject_IsTrue(res);
1159 Py_DECREF(res);
1160 return ret;
1161}
1162
Fred Drake79912472000-07-09 04:06:11 +00001163static PySequenceMethods
1164instance_as_sequence = {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001165 (inquiry)instance_length, /* sq_length */
1166 0, /* sq_concat */
1167 0, /* sq_repeat */
1168 (intargfunc)instance_item, /* sq_item */
1169 (intintargfunc)instance_slice, /* sq_slice */
1170 (intobjargproc)instance_ass_item, /* sq_ass_item */
1171 (intintobjargproc)instance_ass_slice, /* sq_ass_slice */
1172 (objobjproc)instance_contains, /* sq_contains */
Guido van Rossum04691fc1992-08-12 15:35:34 +00001173};
1174
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001175static PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001176generic_unary_op(PyInstanceObject *self, PyObject *methodname)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001177{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001178 PyObject *func, *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001179
1180 if ((func = instance_getattr(self, methodname)) == NULL)
1181 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001182 res = PyEval_CallObject(func, (PyObject *)NULL);
1183 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001184 return res;
1185}
1186
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001187static PyObject *
1188generic_binary_op(PyObject *v, PyObject *w, char *opname)
Guido van Rossum03093a21994-09-28 15:51:32 +00001189{
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001190 PyObject *result;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001191 PyObject *args;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001192 PyObject *func = PyObject_GetAttrString(v, opname);
Guido van Rossume7d444f1995-01-07 12:35:18 +00001193 if (func == NULL) {
Guido van Rossum617c1b01998-05-28 19:50:02 +00001194 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001195 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001196 PyErr_Clear();
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001197 Py_INCREF(Py_NotImplemented);
1198 return Py_NotImplemented;
Guido van Rossume7d444f1995-01-07 12:35:18 +00001199 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001200 args = Py_BuildValue("(O)", w);
Guido van Rossum03093a21994-09-28 15:51:32 +00001201 if (args == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001202 Py_DECREF(func);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001203 return NULL;
Guido van Rossum03093a21994-09-28 15:51:32 +00001204 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001205 result = PyEval_CallObject(func, args);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001206 Py_DECREF(args);
1207 Py_DECREF(func);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001208 return result;
1209}
1210
1211
1212static PyObject *coerce_obj;
1213
1214/* Try one half of a binary operator involving a class instance. */
1215static PyObject *
1216half_binop(PyObject *v, PyObject *w, char *opname, binaryfunc thisfunc,
1217 int swapped)
1218{
1219 PyObject *args;
1220 PyObject *coercefunc;
1221 PyObject *coerced = NULL;
1222 PyObject *v1;
1223 PyObject *result;
1224
1225 if (!PyInstance_Check(v)) {
1226 Py_INCREF(Py_NotImplemented);
1227 return Py_NotImplemented;
1228 }
1229
1230 if (coerce_obj == NULL) {
1231 coerce_obj = PyString_InternFromString("__coerce__");
1232 if (coerce_obj == NULL)
1233 return NULL;
1234 }
1235 coercefunc = PyObject_GetAttr(v, coerce_obj);
1236 if (coercefunc == NULL) {
1237 PyErr_Clear();
1238 return generic_binary_op(v, w, opname);
1239 }
1240
1241 args = Py_BuildValue("(O)", w);
1242 if (args == NULL) {
1243 return NULL;
1244 }
1245 coerced = PyEval_CallObject(coercefunc, args);
1246 Py_DECREF(args);
1247 Py_DECREF(coercefunc);
1248 if (coerced == NULL) {
1249 return NULL;
1250 }
1251 if (coerced == Py_None || coerced == Py_NotImplemented) {
1252 Py_DECREF(coerced);
1253 return generic_binary_op(v, w, opname);
1254 }
1255 if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
1256 Py_DECREF(coerced);
1257 PyErr_SetString(PyExc_TypeError,
1258 "coercion should return None or 2-tuple");
1259 return NULL;
1260 }
1261 v1 = PyTuple_GetItem(coerced, 0);
1262 w = PyTuple_GetItem(coerced, 1);
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001263 if (v1->ob_type == v->ob_type && PyInstance_Check(v)) {
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001264 /* prevent recursion if __coerce__ returns self as the first
1265 * argument */
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001266 result = generic_binary_op(v1, w, opname);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001267 } else {
1268 if (swapped)
1269 result = (thisfunc)(w, v1);
1270 else
1271 result = (thisfunc)(v1, w);
1272 }
1273 Py_DECREF(coerced);
1274 return result;
1275}
1276
1277/* Implement a binary operator involving at least one class instance. */
1278static PyObject *
1279do_binop(PyObject *v, PyObject *w, char *opname, char *ropname,
1280 binaryfunc thisfunc)
1281{
1282 PyObject *result = half_binop(v, w, opname, thisfunc, 0);
1283 if (result == Py_NotImplemented) {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001284 Py_DECREF(result);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001285 result = half_binop(w, v, ropname, thisfunc, 1);
1286 }
1287 return result;
1288}
1289
1290static PyObject *
1291do_binop_inplace(PyObject *v, PyObject *w, char *iopname, char *opname,
1292 char *ropname, binaryfunc thisfunc)
1293{
1294 PyObject *result = half_binop(v, w, iopname, thisfunc, 0);
1295 if (result == Py_NotImplemented) {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001296 Py_DECREF(result);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001297 result = do_binop(v, w, opname, ropname, thisfunc);
1298 }
1299 return result;
Guido van Rossum03093a21994-09-28 15:51:32 +00001300}
1301
Guido van Rossum879c5811995-01-10 15:24:06 +00001302static int
Fred Drake79912472000-07-09 04:06:11 +00001303instance_coerce(PyObject **pv, PyObject **pw)
Guido van Rossum879c5811995-01-10 15:24:06 +00001304{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001305 PyObject *v = *pv;
1306 PyObject *w = *pw;
Guido van Rossum3931df91997-11-18 19:23:07 +00001307 PyObject *coercefunc;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001308 PyObject *args;
1309 PyObject *coerced;
Guido van Rossum879c5811995-01-10 15:24:06 +00001310
Guido van Rossum2878a691996-08-09 20:53:24 +00001311 if (coerce_obj == NULL) {
Guido van Rossuma412d241997-01-18 07:59:12 +00001312 coerce_obj = PyString_InternFromString("__coerce__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001313 if (coerce_obj == NULL)
1314 return -1;
1315 }
Guido van Rossum3931df91997-11-18 19:23:07 +00001316 coercefunc = PyObject_GetAttr(v, coerce_obj);
1317 if (coercefunc == NULL) {
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001318 /* No __coerce__ method */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001319 PyErr_Clear();
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001320 return 1;
Guido van Rossum879c5811995-01-10 15:24:06 +00001321 }
1322 /* Has __coerce__ method: call it */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001323 args = Py_BuildValue("(O)", w);
Guido van Rossum879c5811995-01-10 15:24:06 +00001324 if (args == NULL) {
1325 return -1;
1326 }
Guido van Rossum3931df91997-11-18 19:23:07 +00001327 coerced = PyEval_CallObject(coercefunc, args);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001328 Py_DECREF(args);
Guido van Rossum3931df91997-11-18 19:23:07 +00001329 Py_DECREF(coercefunc);
Guido van Rossum879c5811995-01-10 15:24:06 +00001330 if (coerced == NULL) {
1331 /* __coerce__ call raised an exception */
1332 return -1;
1333 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001334 if (coerced == Py_None || coerced == Py_NotImplemented) {
Guido van Rossum879c5811995-01-10 15:24:06 +00001335 /* __coerce__ says "I can't do it" */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001336 Py_DECREF(coerced);
Guido van Rossum879c5811995-01-10 15:24:06 +00001337 return 1;
1338 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001339 if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
Guido van Rossum879c5811995-01-10 15:24:06 +00001340 /* __coerce__ return value is malformed */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001341 Py_DECREF(coerced);
1342 PyErr_SetString(PyExc_TypeError,
Guido van Rossum879c5811995-01-10 15:24:06 +00001343 "coercion should return None or 2-tuple");
1344 return -1;
1345 }
1346 /* __coerce__ returned two new values */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001347 *pv = PyTuple_GetItem(coerced, 0);
1348 *pw = PyTuple_GetItem(coerced, 1);
1349 Py_INCREF(*pv);
1350 Py_INCREF(*pw);
1351 Py_DECREF(coerced);
Guido van Rossum879c5811995-01-10 15:24:06 +00001352 return 0;
1353}
1354
Guido van Rossum04691fc1992-08-12 15:35:34 +00001355#define UNARY(funcname, methodname) \
Thomas Woutersc3073522000-07-23 22:09:59 +00001356static PyObject *funcname(PyInstanceObject *self) { \
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001357 static PyObject *o; \
Guido van Rossuma412d241997-01-18 07:59:12 +00001358 if (o == NULL) o = PyString_InternFromString(methodname); \
Guido van Rossum2878a691996-08-09 20:53:24 +00001359 return generic_unary_op(self, o); \
Guido van Rossum04691fc1992-08-12 15:35:34 +00001360}
1361
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001362#define BINARY(f, m, n) \
1363static PyObject *f(PyObject *v, PyObject *w) { \
1364 return do_binop(v, w, "__" m "__", "__r" m "__", n); \
1365}
1366
1367#define BINARY_INPLACE(f, m, n) \
1368static PyObject *f(PyObject *v, PyObject *w) { \
1369 return do_binop_inplace(v, w, "__i" m "__", "__" m "__", \
1370 "__r" m "__", n); \
1371}
1372
Guido van Rossum04691fc1992-08-12 15:35:34 +00001373UNARY(instance_neg, "__neg__")
1374UNARY(instance_pos, "__pos__")
1375UNARY(instance_abs, "__abs__")
1376
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001377BINARY(instance_or, "or", PyNumber_Or)
1378BINARY(instance_and, "and", PyNumber_And)
1379BINARY(instance_xor, "xor", PyNumber_Xor)
1380BINARY(instance_lshift, "lshift", PyNumber_Lshift)
1381BINARY(instance_rshift, "rshift", PyNumber_Rshift)
1382BINARY(instance_add, "add", PyNumber_Add)
1383BINARY(instance_sub, "sub", PyNumber_Subtract)
1384BINARY(instance_mul, "mul", PyNumber_Multiply)
1385BINARY(instance_div, "div", PyNumber_Divide)
1386BINARY(instance_mod, "mod", PyNumber_Remainder)
1387BINARY(instance_divmod, "divmod", PyNumber_Divmod)
1388
1389BINARY_INPLACE(instance_ior, "or", PyNumber_InPlaceOr)
1390BINARY_INPLACE(instance_ixor, "xor", PyNumber_InPlaceXor)
1391BINARY_INPLACE(instance_iand, "and", PyNumber_InPlaceAnd)
1392BINARY_INPLACE(instance_ilshift, "lshift", PyNumber_InPlaceLshift)
1393BINARY_INPLACE(instance_irshift, "rshift", PyNumber_InPlaceRshift)
1394BINARY_INPLACE(instance_iadd, "add", PyNumber_InPlaceAdd)
1395BINARY_INPLACE(instance_isub, "sub", PyNumber_InPlaceSubtract)
1396BINARY_INPLACE(instance_imul, "mul", PyNumber_InPlaceMultiply)
1397BINARY_INPLACE(instance_idiv, "div", PyNumber_InPlaceDivide)
1398BINARY_INPLACE(instance_imod, "mod", PyNumber_InPlaceRemainder)
1399
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001400/* Try a 3-way comparison, returning an int; v is an instance. Return:
1401 -2 for an exception;
1402 -1 if v < w;
1403 0 if v == w;
1404 1 if v > w;
1405 2 if this particular 3-way comparison is not implemented or undefined.
1406*/
1407static int
1408half_cmp(PyObject *v, PyObject *w)
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001409{
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001410 static PyObject *cmp_obj;
1411 PyObject *args;
1412 PyObject *cmpfunc;
1413 PyObject *result;
1414 long l;
1415
1416 assert(PyInstance_Check(v));
1417
1418 if (cmp_obj == NULL) {
1419 cmp_obj = PyString_InternFromString("__cmp__");
1420 if (cmp_obj == NULL)
1421 return -2;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001422 }
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001423
1424 cmpfunc = PyObject_GetAttr(v, cmp_obj);
1425 if (cmpfunc == NULL) {
1426 PyErr_Clear();
1427 return 2;
1428 }
1429
1430 args = Py_BuildValue("(O)", w);
1431 if (args == NULL)
1432 return -2;
1433
1434 result = PyEval_CallObject(cmpfunc, args);
1435 Py_DECREF(args);
1436 Py_DECREF(cmpfunc);
1437
1438 if (result == NULL)
1439 return -2;
1440
1441 if (result == Py_NotImplemented) {
1442 Py_DECREF(result);
1443 return 2;
1444 }
1445
1446 l = PyInt_AsLong(result);
1447 Py_DECREF(result);
1448 if (l == -1 && PyErr_Occurred()) {
1449 PyErr_SetString(PyExc_TypeError,
1450 "comparison did not return an int");
1451 return -2;
1452 }
1453
1454 return l < 0 ? -1 : l > 0 ? 1 : 0;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001455}
1456
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001457/* Try a 3-way comparison, returning an int; either v or w is an instance.
1458 We first try a coercion. Return:
1459 -2 for an exception;
1460 -1 if v < w;
1461 0 if v == w;
1462 1 if v > w;
1463 2 if this particular 3-way comparison is not implemented or undefined.
1464 THIS IS ONLY CALLED FROM object.c!
1465*/
1466static int
1467instance_compare(PyObject *v, PyObject *w)
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001468{
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001469 int c;
1470
1471 c = PyNumber_CoerceEx(&v, &w);
1472 if (c < 0)
1473 return -2;
1474 if (c == 0) {
1475 /* If neither is now an instance, use regular comparison */
1476 if (!PyInstance_Check(v) && !PyInstance_Check(w)) {
1477 c = PyObject_Compare(v, w);
1478 Py_DECREF(v);
1479 Py_DECREF(w);
1480 if (PyErr_Occurred())
1481 return -2;
1482 return c < 0 ? -1 : c > 0 ? 1 : 0;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001483 }
1484 }
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001485 else {
1486 /* The coercion didn't do anything.
1487 Treat this the same as returning v and w unchanged. */
1488 Py_INCREF(v);
1489 Py_INCREF(w);
1490 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001491
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001492 if (PyInstance_Check(v)) {
1493 c = half_cmp(v, w);
1494 if (c <= 1) {
1495 Py_DECREF(v);
1496 Py_DECREF(w);
1497 return c;
1498 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001499 }
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001500 if (PyInstance_Check(w)) {
1501 c = half_cmp(w, v);
1502 if (c <= 1) {
1503 Py_DECREF(v);
1504 Py_DECREF(w);
1505 if (c >= -1)
1506 c = -c;
1507 return c;
1508 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001509 }
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001510 Py_DECREF(v);
1511 Py_DECREF(w);
1512 return 2;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001513}
1514
Guido van Rossum9bfef441993-03-29 10:43:31 +00001515static int
Fred Drake79912472000-07-09 04:06:11 +00001516instance_nonzero(PyInstanceObject *self)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001517{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001518 PyObject *func, *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001519 long outcome;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001520 static PyObject *nonzerostr;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001521
Guido van Rossum2878a691996-08-09 20:53:24 +00001522 if (nonzerostr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001523 nonzerostr = PyString_InternFromString("__nonzero__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001524 if ((func = instance_getattr(self, nonzerostr)) == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001525 PyErr_Clear();
Guido van Rossum2878a691996-08-09 20:53:24 +00001526 if (lenstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001527 lenstr = PyString_InternFromString("__len__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001528 if ((func = instance_getattr(self, lenstr)) == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001529 PyErr_Clear();
Guido van Rossum04691fc1992-08-12 15:35:34 +00001530 /* Fall back to the default behavior:
1531 all instances are nonzero */
1532 return 1;
1533 }
1534 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001535 res = PyEval_CallObject(func, (PyObject *)NULL);
1536 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001537 if (res == NULL)
1538 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001539 if (!PyInt_Check(res)) {
1540 Py_DECREF(res);
1541 PyErr_SetString(PyExc_TypeError,
1542 "__nonzero__ should return an int");
Guido van Rossum04691fc1992-08-12 15:35:34 +00001543 return -1;
1544 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001545 outcome = PyInt_AsLong(res);
1546 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001547 if (outcome < 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001548 PyErr_SetString(PyExc_ValueError,
1549 "__nonzero__ should return >= 0");
Guido van Rossum04691fc1992-08-12 15:35:34 +00001550 return -1;
1551 }
1552 return outcome > 0;
1553}
1554
1555UNARY(instance_invert, "__invert__")
Guido van Rossum1899c2e1992-09-12 11:09:23 +00001556UNARY(instance_int, "__int__")
1557UNARY(instance_long, "__long__")
1558UNARY(instance_float, "__float__")
1559UNARY(instance_oct, "__oct__")
1560UNARY(instance_hex, "__hex__")
1561
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001562static PyObject *
1563bin_power(PyObject *v, PyObject *w)
1564{
1565 return PyNumber_Power(v, w, Py_None);
1566}
1567
Guido van Rossum03093a21994-09-28 15:51:32 +00001568/* This version is for ternary calls only (z != None) */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001569static PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001570instance_pow(PyObject *v, PyObject *w, PyObject *z)
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001571{
1572 if (z == Py_None) {
1573 return do_binop(v, w, "__pow__", "__rpow__", bin_power);
Guido van Rossum03093a21994-09-28 15:51:32 +00001574 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001575 else {
1576 PyObject *func;
1577 PyObject *args;
1578 PyObject *result;
1579
1580 /* XXX Doesn't do coercions... */
1581 func = PyObject_GetAttrString(v, "__pow__");
1582 if (func == NULL)
1583 return NULL;
1584 args = Py_BuildValue("(OO)", w, z);
1585 if (args == NULL) {
1586 Py_DECREF(func);
1587 return NULL;
1588 }
1589 result = PyEval_CallObject(func, args);
1590 Py_DECREF(func);
1591 Py_DECREF(args);
1592 return result;
1593 }
Guido van Rossum03093a21994-09-28 15:51:32 +00001594}
1595
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001596static PyObject *
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001597bin_inplace_power(PyObject *v, PyObject *w)
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001598{
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001599 return PyNumber_InPlacePower(v, w, Py_None);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001600}
1601
1602
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001603static PyObject *
1604instance_ipow(PyObject *v, PyObject *w, PyObject *z)
1605{
1606 if (z == Py_None) {
1607 return do_binop_inplace(v, w, "__ipow__", "__pow__",
1608 "__rpow__", bin_inplace_power);
1609 }
1610 else {
1611 /* XXX Doesn't do coercions... */
1612 PyObject *func;
1613 PyObject *args;
1614 PyObject *result;
1615
1616 func = PyObject_GetAttrString(v, "__ipow__");
1617 if (func == NULL) {
1618 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1619 return NULL;
1620 PyErr_Clear();
1621 return instance_pow(v, w, z);
1622 }
1623 args = Py_BuildValue("(OO)", w, z);
1624 if (args == NULL) {
1625 Py_DECREF(func);
1626 return NULL;
1627 }
1628 result = PyEval_CallObject(func, args);
1629 Py_DECREF(func);
1630 Py_DECREF(args);
1631 return result;
1632 }
1633}
1634
1635
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001636/* Map rich comparison operators to their __xx__ namesakes */
1637static char *name_op[] = {
1638 "__lt__",
1639 "__le__",
1640 "__eq__",
1641 "__ne__",
1642 "__gt__",
1643 "__ge__",
1644};
1645
1646static PyObject *
1647half_richcompare(PyObject *v, PyObject *w, int op)
1648{
1649 PyObject *name;
1650 PyObject *method;
1651 PyObject *args;
1652 PyObject *res;
1653
1654 assert(PyInstance_Check(v));
1655
1656 name = PyString_InternFromString(name_op[op]);
1657 if (name == NULL)
1658 return NULL;
1659
1660 method = PyObject_GetAttr(v, name);
1661 Py_DECREF(name);
1662 if (method == NULL) {
1663 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1664 return NULL;
1665 PyErr_Clear();
1666 res = Py_NotImplemented;
1667 Py_INCREF(res);
1668 return res;
1669 }
1670
1671 args = Py_BuildValue("(O)", w);
1672 if (args == NULL) {
1673 Py_DECREF(method);
1674 return NULL;
1675 }
1676
1677 res = PyEval_CallObject(method, args);
1678 Py_DECREF(args);
1679 Py_DECREF(method);
1680
1681 return res;
1682}
1683
1684/* Map rich comparison operators to their swapped version, e.g. LT --> GT */
1685static int swapped_op[] = {Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE};
1686
1687static PyObject *
1688instance_richcompare(PyObject *v, PyObject *w, int op)
1689{
1690 PyObject *res;
1691
1692 if (PyInstance_Check(v)) {
1693 res = half_richcompare(v, w, op);
1694 if (res != Py_NotImplemented)
1695 return res;
1696 Py_DECREF(res);
1697 }
1698
1699 if (PyInstance_Check(w)) {
1700 res = half_richcompare(w, v, swapped_op[op]);
1701 if (res != Py_NotImplemented)
1702 return res;
1703 Py_DECREF(res);
1704 }
1705
1706 Py_INCREF(Py_NotImplemented);
1707 return Py_NotImplemented;
1708}
1709
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001710
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001711static PyNumberMethods instance_as_number = {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001712 (binaryfunc)instance_add, /* nb_add */
1713 (binaryfunc)instance_sub, /* nb_subtract */
1714 (binaryfunc)instance_mul, /* nb_multiply */
1715 (binaryfunc)instance_div, /* nb_divide */
1716 (binaryfunc)instance_mod, /* nb_remainder */
1717 (binaryfunc)instance_divmod, /* nb_divmod */
1718 (ternaryfunc)instance_pow, /* nb_power */
1719 (unaryfunc)instance_neg, /* nb_negative */
1720 (unaryfunc)instance_pos, /* nb_positive */
1721 (unaryfunc)instance_abs, /* nb_absolute */
1722 (inquiry)instance_nonzero, /* nb_nonzero */
1723 (unaryfunc)instance_invert, /* nb_invert */
1724 (binaryfunc)instance_lshift, /* nb_lshift */
1725 (binaryfunc)instance_rshift, /* nb_rshift */
1726 (binaryfunc)instance_and, /* nb_and */
1727 (binaryfunc)instance_xor, /* nb_xor */
1728 (binaryfunc)instance_or, /* nb_or */
1729 (coercion)instance_coerce, /* nb_coerce */
1730 (unaryfunc)instance_int, /* nb_int */
1731 (unaryfunc)instance_long, /* nb_long */
1732 (unaryfunc)instance_float, /* nb_float */
1733 (unaryfunc)instance_oct, /* nb_oct */
1734 (unaryfunc)instance_hex, /* nb_hex */
1735 (binaryfunc)instance_iadd, /* nb_inplace_add */
1736 (binaryfunc)instance_isub, /* nb_inplace_subtract */
1737 (binaryfunc)instance_imul, /* nb_inplace_multiply */
1738 (binaryfunc)instance_idiv, /* nb_inplace_divide */
1739 (binaryfunc)instance_imod, /* nb_inplace_remainder */
1740 (ternaryfunc)instance_ipow, /* nb_inplace_power */
1741 (binaryfunc)instance_ilshift, /* nb_inplace_lshift */
1742 (binaryfunc)instance_irshift, /* nb_inplace_rshift */
1743 (binaryfunc)instance_iand, /* nb_inplace_and */
1744 (binaryfunc)instance_ixor, /* nb_inplace_xor */
1745 (binaryfunc)instance_ior, /* nb_inplace_or */
Guido van Rossum04691fc1992-08-12 15:35:34 +00001746};
1747
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001748PyTypeObject PyInstance_Type = {
1749 PyObject_HEAD_INIT(&PyType_Type)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001750 0,
Guido van Rossum21ed88c1991-04-04 10:42:10 +00001751 "instance",
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00001752 sizeof(PyInstanceObject) + PyGC_HEAD_SIZE,
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001753 0,
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001754 (destructor)instance_dealloc, /* tp_dealloc */
1755 0, /* tp_print */
1756 0, /* tp_getattr */
1757 0, /* tp_setattr */
1758 instance_compare, /* tp_compare */
1759 (reprfunc)instance_repr, /* tp_repr */
1760 &instance_as_number, /* tp_as_number */
1761 &instance_as_sequence, /* tp_as_sequence */
1762 &instance_as_mapping, /* tp_as_mapping */
1763 (hashfunc)instance_hash, /* tp_hash */
1764 0, /* tp_call */
1765 0, /* tp_str */
1766 (getattrofunc)instance_getattr, /* tp_getattro */
1767 (setattrofunc)instance_setattr, /* tp_setattro */
1768 0, /* tp_as_buffer */
1769 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_GC | Py_TPFLAGS_CHECKTYPES,/*tp_flags*/
1770 0, /* tp_doc */
Jeremy Hylton8caad492000-06-23 14:18:11 +00001771 (traverseproc)instance_traverse, /* tp_traverse */
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001772 0, /* tp_clear */
1773 instance_richcompare, /* tp_richcompare */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001774};
1775
1776
Guido van Rossum81daa321993-05-20 14:24:46 +00001777/* Instance method objects are used for two purposes:
1778 (a) as bound instance methods (returned by instancename.methodname)
1779 (b) as unbound methods (returned by ClassName.methodname)
1780 In case (b), im_self is NULL
1781*/
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001782
Guido van Rossuma0d349f1997-08-05 02:06:53 +00001783static PyMethodObject *free_list;
1784
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001785PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001786PyMethod_New(PyObject *func, PyObject *self, PyObject *class)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001787{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001788 register PyMethodObject *im;
Guido van Rossum7859f871998-07-08 14:58:16 +00001789 if (!PyCallable_Check(func)) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001790 PyErr_BadInternalCall();
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001791 return NULL;
1792 }
Guido van Rossuma0d349f1997-08-05 02:06:53 +00001793 im = free_list;
1794 if (im != NULL) {
1795 free_list = (PyMethodObject *)(im->im_self);
Guido van Rossumb18618d2000-05-03 23:44:39 +00001796 PyObject_INIT(im, &PyMethod_Type);
Guido van Rossuma0d349f1997-08-05 02:06:53 +00001797 }
1798 else {
1799 im = PyObject_NEW(PyMethodObject, &PyMethod_Type);
1800 if (im == NULL)
1801 return NULL;
1802 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001803 Py_INCREF(func);
Guido van Rossume8122f11991-05-05 20:03:07 +00001804 im->im_func = func;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001805 Py_XINCREF(self);
Guido van Rossume8122f11991-05-05 20:03:07 +00001806 im->im_self = self;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001807 Py_INCREF(class);
Guido van Rossum81daa321993-05-20 14:24:46 +00001808 im->im_class = class;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00001809 PyObject_GC_Init(im);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001810 return (PyObject *)im;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001811}
1812
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001813PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001814PyMethod_Function(register PyObject *im)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001815{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001816 if (!PyMethod_Check(im)) {
1817 PyErr_BadInternalCall();
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001818 return NULL;
1819 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001820 return ((PyMethodObject *)im)->im_func;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001821}
1822
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001823PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001824PyMethod_Self(register PyObject *im)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001825{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001826 if (!PyMethod_Check(im)) {
1827 PyErr_BadInternalCall();
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001828 return NULL;
1829 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001830 return ((PyMethodObject *)im)->im_self;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001831}
1832
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001833PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001834PyMethod_Class(register PyObject *im)
Guido van Rossum81daa321993-05-20 14:24:46 +00001835{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001836 if (!PyMethod_Check(im)) {
1837 PyErr_BadInternalCall();
Guido van Rossum81daa321993-05-20 14:24:46 +00001838 return NULL;
1839 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001840 return ((PyMethodObject *)im)->im_class;
Guido van Rossum81daa321993-05-20 14:24:46 +00001841}
1842
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001843/* Class method methods */
1844
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001845#define OFF(x) offsetof(PyMethodObject, x)
Guido van Rossum3f5da241990-12-20 15:06:42 +00001846
Guido van Rossume8122f11991-05-05 20:03:07 +00001847static struct memberlist instancemethod_memberlist[] = {
1848 {"im_func", T_OBJECT, OFF(im_func)},
1849 {"im_self", T_OBJECT, OFF(im_self)},
Guido van Rossum81daa321993-05-20 14:24:46 +00001850 {"im_class", T_OBJECT, OFF(im_class)},
Guido van Rossum6dabc981996-05-14 21:54:20 +00001851 /* Dummies that are not handled by getattr() except for __members__ */
1852 {"__doc__", T_INT, 0},
1853 {"__name__", T_INT, 0},
Barry Warsawd6a9e842001-01-15 20:40:19 +00001854 {"__dict__", T_OBJECT, 0},
Guido van Rossum3f5da241990-12-20 15:06:42 +00001855 {NULL} /* Sentinel */
1856};
1857
Barry Warsawd6a9e842001-01-15 20:40:19 +00001858static int
1859instancemethod_setattro(register PyMethodObject *im, PyObject *name,
1860 PyObject *v)
Guido van Rossum3f5da241990-12-20 15:06:42 +00001861{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001862 char *sname = PyString_AsString(name);
Barry Warsawd6a9e842001-01-15 20:40:19 +00001863
1864 if (PyEval_GetRestricted() ||
1865 strcmp(sname, "im_func") == 0 ||
1866 strcmp(sname, "im_self") == 0 ||
1867 strcmp(sname, "im_class") == 0)
1868 {
1869 PyErr_Format(PyExc_TypeError, "read-only attribute: %s",
1870 sname);
1871 return -1;
1872 }
1873 if (im->im_self != NULL) {
1874 PyErr_Format(PyExc_TypeError,
1875 "cannot set attributes through bound methods");
1876 return -1;
1877 }
1878 return PyObject_SetAttr(im->im_func, name, v);
1879}
1880
1881
1882static PyObject *
1883instancemethod_getattro(register PyMethodObject *im, PyObject *name)
1884{
1885 PyObject *rtn;
1886 char *sname = PyString_AsString(name);
Guido van Rossum2878a691996-08-09 20:53:24 +00001887 if (sname[0] == '_') {
Guido van Rossum7859f871998-07-08 14:58:16 +00001888 /* Inherit __name__ and __doc__ from the callable object
1889 implementing the method */
1890 if (strcmp(sname, "__name__") == 0 ||
1891 strcmp(sname, "__doc__") == 0)
1892 return PyObject_GetAttr(im->im_func, name);
Guido van Rossum6dabc981996-05-14 21:54:20 +00001893 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001894 if (PyEval_GetRestricted()) {
1895 PyErr_SetString(PyExc_RuntimeError,
1896 "instance-method attributes not accessible in restricted mode");
Guido van Rossum10393b11995-01-10 10:39:49 +00001897 return NULL;
1898 }
Barry Warsawd6a9e842001-01-15 20:40:19 +00001899 if (sname[0] == '_' && strcmp(sname, "__dict__") == 0)
1900 return PyObject_GetAttr(im->im_func, name);
1901
1902 rtn = PyMember_Get((char *)im, instancemethod_memberlist, sname);
1903 if (rtn == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
1904 PyErr_Clear();
1905 rtn = PyObject_GetAttr(im->im_func, name);
1906 }
1907 return rtn;
Guido van Rossum3f5da241990-12-20 15:06:42 +00001908}
1909
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001910static void
Fred Drake79912472000-07-09 04:06:11 +00001911instancemethod_dealloc(register PyMethodObject *im)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001912{
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00001913 PyObject_GC_Fini(im);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001914 Py_DECREF(im->im_func);
1915 Py_XDECREF(im->im_self);
1916 Py_DECREF(im->im_class);
Guido van Rossuma0d349f1997-08-05 02:06:53 +00001917 im->im_self = (PyObject *)free_list;
1918 free_list = im;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001919}
1920
Guido van Rossumebc8c511992-09-03 20:39:51 +00001921static int
Fred Drake79912472000-07-09 04:06:11 +00001922instancemethod_compare(PyMethodObject *a, PyMethodObject *b)
Guido van Rossumebc8c511992-09-03 20:39:51 +00001923{
Guido van Rossume9df7271995-04-06 14:46:51 +00001924 if (a->im_self != b->im_self)
1925 return (a->im_self < b->im_self) ? -1 : 1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001926 return PyObject_Compare(a->im_func, b->im_func);
Guido van Rossumebc8c511992-09-03 20:39:51 +00001927}
1928
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001929static PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001930instancemethod_repr(PyMethodObject *a)
Guido van Rossum25831651993-05-19 14:50:45 +00001931{
1932 char buf[240];
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001933 PyInstanceObject *self = (PyInstanceObject *)(a->im_self);
Guido van Rossum7859f871998-07-08 14:58:16 +00001934 PyObject *func = a->im_func;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001935 PyClassObject *class = (PyClassObject *)(a->im_class);
1936 PyObject *fclassname, *iclassname, *funcname;
Guido van Rossum81daa321993-05-20 14:24:46 +00001937 char *fcname, *icname, *fname;
1938 fclassname = class->cl_name;
Guido van Rossum7859f871998-07-08 14:58:16 +00001939 if (PyFunction_Check(func)) {
1940 funcname = ((PyFunctionObject *)func)->func_name;
1941 Py_INCREF(funcname);
1942 }
1943 else {
1944 funcname = PyObject_GetAttrString(func,"__name__");
1945 if (funcname == NULL)
1946 PyErr_Clear();
1947 }
1948 if (funcname != NULL && PyString_Check(funcname))
1949 fname = PyString_AS_STRING(funcname);
1950 else
1951 fname = "?";
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001952 if (fclassname != NULL && PyString_Check(fclassname))
1953 fcname = PyString_AsString(fclassname);
Guido van Rossum25831651993-05-19 14:50:45 +00001954 else
Guido van Rossum81daa321993-05-20 14:24:46 +00001955 fcname = "?";
Guido van Rossum81daa321993-05-20 14:24:46 +00001956 if (self == NULL)
1957 sprintf(buf, "<unbound method %.100s.%.100s>", fcname, fname);
1958 else {
1959 iclassname = self->in_class->cl_name;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001960 if (iclassname != NULL && PyString_Check(iclassname))
1961 icname = PyString_AsString(iclassname);
Guido van Rossum81daa321993-05-20 14:24:46 +00001962 else
1963 icname = "?";
Fred Drakea44d3532000-06-30 15:01:00 +00001964 sprintf(buf, "<method %.60s.%.60s of %.60s instance at %p>",
1965 fcname, fname, icname, self);
Guido van Rossum81daa321993-05-20 14:24:46 +00001966 }
Guido van Rossum42636dc1999-10-11 14:03:12 +00001967 Py_XDECREF(funcname);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001968 return PyString_FromString(buf);
Guido van Rossum25831651993-05-19 14:50:45 +00001969}
1970
Guido van Rossum9bfef441993-03-29 10:43:31 +00001971static long
Fred Drake79912472000-07-09 04:06:11 +00001972instancemethod_hash(PyMethodObject *a)
Guido van Rossum9bfef441993-03-29 10:43:31 +00001973{
1974 long x, y;
Guido van Rossum81daa321993-05-20 14:24:46 +00001975 if (a->im_self == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001976 x = PyObject_Hash(Py_None);
Guido van Rossum81daa321993-05-20 14:24:46 +00001977 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001978 x = PyObject_Hash(a->im_self);
Guido van Rossum9bfef441993-03-29 10:43:31 +00001979 if (x == -1)
1980 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001981 y = PyObject_Hash(a->im_func);
Guido van Rossum9bfef441993-03-29 10:43:31 +00001982 if (y == -1)
1983 return -1;
1984 return x ^ y;
1985}
1986
Jeremy Hylton8caad492000-06-23 14:18:11 +00001987static int
1988instancemethod_traverse(PyMethodObject *im, visitproc visit, void *arg)
1989{
1990 int err;
1991 if (im->im_func) {
1992 err = visit(im->im_func, arg);
1993 if (err)
1994 return err;
1995 }
1996 if (im->im_self) {
1997 err = visit(im->im_self, arg);
1998 if (err)
1999 return err;
2000 }
2001 if (im->im_class) {
2002 err = visit(im->im_class, arg);
2003 if (err)
2004 return err;
2005 }
Jeremy Hyltond22162b2000-06-23 17:14:56 +00002006 return 0;
Jeremy Hylton8caad492000-06-23 14:18:11 +00002007}
2008
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002009PyTypeObject PyMethod_Type = {
2010 PyObject_HEAD_INIT(&PyType_Type)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002011 0,
Guido van Rossum569fce71991-04-16 08:38:43 +00002012 "instance method",
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00002013 sizeof(PyMethodObject) + PyGC_HEAD_SIZE,
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002014 0,
Guido van Rossum8998b4f2001-01-17 15:28:20 +00002015 (destructor)instancemethod_dealloc, /* tp_dealloc */
2016 0, /* tp_print */
2017 0, /* tp_getattr */
2018 0, /* tp_setattr */
2019 (cmpfunc)instancemethod_compare, /* tp_compare */
2020 (reprfunc)instancemethod_repr, /* tp_repr */
2021 0, /* tp_as_number */
2022 0, /* tp_as_sequence */
2023 0, /* tp_as_mapping */
2024 (hashfunc)instancemethod_hash, /* tp_hash */
2025 0, /* tp_call */
2026 0, /* tp_str */
2027 (getattrofunc)instancemethod_getattro, /* tp_getattro */
2028 (setattrofunc)instancemethod_setattro, /* tp_setattro */
2029 0, /* tp_as_buffer */
2030 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_GC, /* tp_flags */
2031 0, /* tp_doc */
Jeremy Hylton8caad492000-06-23 14:18:11 +00002032 (traverseproc)instancemethod_traverse, /* tp_traverse */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002033};
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002034
2035/* Clear out the free list */
2036
2037void
Fred Drake79912472000-07-09 04:06:11 +00002038PyMethod_Fini(void)
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002039{
2040 while (free_list) {
Guido van Rossumb18618d2000-05-03 23:44:39 +00002041 PyMethodObject *im = free_list;
2042 free_list = (PyMethodObject *)(im->im_self);
Guido van Rossum4cc6ac72000-07-01 01:00:38 +00002043 im = (PyMethodObject *) PyObject_AS_GC(im);
Guido van Rossumb18618d2000-05-03 23:44:39 +00002044 PyObject_DEL(im);
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002045 }
2046}