blob: 25a0743a3cf73fc17f6bc5fb5101068160484f55 [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)) {
Tim Peters6d6c1a32001-08-02 04:15:00 +000039 PyErr_SetString(PyExc_TypeError,
Guido van Rossum04d73c41997-10-07 14:54:11 +000040 "PyClass_New: name must be a string");
41 return NULL;
42 }
43 if (dict == NULL || !PyDict_Check(dict)) {
Tim Peters6d6c1a32001-08-02 04:15:00 +000044 PyErr_SetString(PyExc_TypeError,
Guido van Rossum04d73c41997-10-07 14:54:11 +000045 "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 {
Guido van Rossum28d80b12001-09-07 21:08:32 +000068 int i, n;
69 PyObject *base;
Guido van Rossum04d73c41997-10-07 14:54:11 +000070 if (!PyTuple_Check(bases)) {
Tim Peters6d6c1a32001-08-02 04:15:00 +000071 PyErr_SetString(PyExc_TypeError,
Guido van Rossum04d73c41997-10-07 14:54:11 +000072 "PyClass_New: bases must be a tuple");
73 return NULL;
74 }
Guido van Rossum28d80b12001-09-07 21:08:32 +000075 n = PyTuple_Size(bases);
76 for (i = 0; i < n; i++) {
77 base = PyTuple_GET_ITEM(bases, i);
78 if (!PyClass_Check(base)) {
79 if (PyCallable_Check(
80 (PyObject *) base->ob_type))
81 return PyObject_CallFunction(
82 (PyObject *) base->ob_type,
83 "OOO",
84 name,
85 bases,
86 dict);
Tim Peters6d6c1a32001-08-02 04:15:00 +000087 PyErr_SetString(PyExc_TypeError,
Guido van Rossum04d73c41997-10-07 14:54:11 +000088 "PyClass_New: base must be a class");
89 return NULL;
90 }
91 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +000092 Py_INCREF(bases);
Guido van Rossum04d73c41997-10-07 14:54:11 +000093 }
Neil Schemenauere83c00e2001-08-29 23:54:21 +000094 op = PyObject_GC_New(PyClassObject, &PyClass_Type);
Guido van Rossume2966a61991-12-10 13:53:23 +000095 if (op == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +000096 Py_DECREF(bases);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000097 return NULL;
Guido van Rossume2966a61991-12-10 13:53:23 +000098 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000099 op->cl_bases = bases;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000100 Py_INCREF(dict);
Guido van Rossum81daa321993-05-20 14:24:46 +0000101 op->cl_dict = dict;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000102 Py_XINCREF(name);
Guido van Rossum94308391991-10-20 20:11:48 +0000103 op->cl_name = name;
Guido van Rossum2878a691996-08-09 20:53:24 +0000104 if (getattrstr == NULL) {
Guido van Rossuma412d241997-01-18 07:59:12 +0000105 getattrstr = PyString_InternFromString("__getattr__");
106 setattrstr = PyString_InternFromString("__setattr__");
107 delattrstr = PyString_InternFromString("__delattr__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000108 }
109 op->cl_getattr = class_lookup(op, getattrstr, &dummy);
110 op->cl_setattr = class_lookup(op, setattrstr, &dummy);
111 op->cl_delattr = class_lookup(op, delattrstr, &dummy);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000112 Py_XINCREF(op->cl_getattr);
113 Py_XINCREF(op->cl_setattr);
114 Py_XINCREF(op->cl_delattr);
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000115 _PyObject_GC_TRACK(op);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000116 return (PyObject *) op;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000117}
118
Guido van Rossumb479dc52001-09-05 22:52:50 +0000119PyObject *
120PyMethod_Function(PyObject *im)
121{
122 if (!PyMethod_Check(im)) {
123 PyErr_BadInternalCall();
124 return NULL;
125 }
126 return ((PyMethodObject *)im)->im_func;
127}
128
129PyObject *
130PyMethod_Self(PyObject *im)
131{
132 if (!PyMethod_Check(im)) {
133 PyErr_BadInternalCall();
134 return NULL;
135 }
136 return ((PyMethodObject *)im)->im_self;
137}
138
139PyObject *
140PyMethod_Class(PyObject *im)
141{
142 if (!PyMethod_Check(im)) {
143 PyErr_BadInternalCall();
144 return NULL;
145 }
146 return ((PyMethodObject *)im)->im_class;
147}
148
Tim Peters6d6c1a32001-08-02 04:15:00 +0000149static PyObject *
150class_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
151{
152 PyObject *name, *bases, *dict;
153 static char *kwlist[] = {"name", "bases", "dict", 0};
154
155 if (!PyArg_ParseTupleAndKeywords(args, kwds, "SOO", kwlist,
156 &name, &bases, &dict))
157 return NULL;
158 return PyClass_New(bases, dict, name);
159}
160
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000161/* Class methods */
162
163static void
Fred Drake79912472000-07-09 04:06:11 +0000164class_dealloc(PyClassObject *op)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000165{
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000166 _PyObject_GC_UNTRACK(op);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000167 Py_DECREF(op->cl_bases);
168 Py_DECREF(op->cl_dict);
169 Py_XDECREF(op->cl_name);
Guido van Rossum152d8171998-08-04 14:59:16 +0000170 Py_XDECREF(op->cl_getattr);
171 Py_XDECREF(op->cl_setattr);
172 Py_XDECREF(op->cl_delattr);
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000173 PyObject_GC_Del(op);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000174}
175
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000176static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000177class_lookup(PyClassObject *cp, PyObject *name, PyClassObject **pclass)
Guido van Rossum81daa321993-05-20 14:24:46 +0000178{
179 int i, n;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000180 PyObject *value = PyDict_GetItem(cp->cl_dict, name);
Guido van Rossum81daa321993-05-20 14:24:46 +0000181 if (value != NULL) {
182 *pclass = cp;
183 return value;
184 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000185 n = PyTuple_Size(cp->cl_bases);
Guido van Rossum81daa321993-05-20 14:24:46 +0000186 for (i = 0; i < n; i++) {
Guido van Rossum7cc56eb1997-09-12 20:04:46 +0000187 /* XXX What if one of the bases is not a class? */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000188 PyObject *v = class_lookup(
189 (PyClassObject *)
190 PyTuple_GetItem(cp->cl_bases, i), name, pclass);
Guido van Rossum81daa321993-05-20 14:24:46 +0000191 if (v != NULL)
192 return v;
193 }
194 return NULL;
195}
196
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000197static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000198class_getattr(register PyClassObject *op, PyObject *name)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000199{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000200 register PyObject *v;
201 register char *sname = PyString_AsString(name);
202 PyClassObject *class;
Tim Peters6d6c1a32001-08-02 04:15:00 +0000203 descrgetfunc f;
204
Guido van Rossum2878a691996-08-09 20:53:24 +0000205 if (sname[0] == '_' && sname[1] == '_') {
206 if (strcmp(sname, "__dict__") == 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000207 if (PyEval_GetRestricted()) {
208 PyErr_SetString(PyExc_RuntimeError,
209 "class.__dict__ not accessible in restricted mode");
Guido van Rossum10393b11995-01-10 10:39:49 +0000210 return NULL;
211 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000212 Py_INCREF(op->cl_dict);
Guido van Rossum10393b11995-01-10 10:39:49 +0000213 return op->cl_dict;
214 }
Guido van Rossum2878a691996-08-09 20:53:24 +0000215 if (strcmp(sname, "__bases__") == 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000216 Py_INCREF(op->cl_bases);
Guido van Rossum10393b11995-01-10 10:39:49 +0000217 return op->cl_bases;
218 }
Guido van Rossum2878a691996-08-09 20:53:24 +0000219 if (strcmp(sname, "__name__") == 0) {
Guido van Rossum10393b11995-01-10 10:39:49 +0000220 if (op->cl_name == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000221 v = Py_None;
Guido van Rossum10393b11995-01-10 10:39:49 +0000222 else
223 v = op->cl_name;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000224 Py_INCREF(v);
Guido van Rossum10393b11995-01-10 10:39:49 +0000225 return v;
226 }
Guido van Rossum94308391991-10-20 20:11:48 +0000227 }
Guido van Rossum81daa321993-05-20 14:24:46 +0000228 v = class_lookup(op, name, &class);
Guido van Rossumb3f72581993-05-21 19:56:10 +0000229 if (v == NULL) {
Fred Drake661ea262000-10-24 19:57:45 +0000230 PyErr_Format(PyExc_AttributeError,
231 "class %.50s has no attribute '%.400s'",
232 PyString_AS_STRING(op->cl_name), sname);
Guido van Rossumb3f72581993-05-21 19:56:10 +0000233 return NULL;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000234 }
Tim Peters6d6c1a32001-08-02 04:15:00 +0000235 f = v->ob_type->tp_descr_get;
236 if (f == NULL)
237 Py_INCREF(v);
238 else
239 v = f(v, (PyObject *)NULL, (PyObject *)op);
Guido van Rossumb3f72581993-05-21 19:56:10 +0000240 return v;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000241}
242
Guido van Rossuma63eff61998-05-29 21:37:21 +0000243static void
Fred Drake79912472000-07-09 04:06:11 +0000244set_slot(PyObject **slot, PyObject *v)
Guido van Rossuma63eff61998-05-29 21:37:21 +0000245{
246 PyObject *temp = *slot;
247 Py_XINCREF(v);
248 *slot = v;
249 Py_XDECREF(temp);
250}
251
Guido van Rossum7ba30431998-07-08 13:34:48 +0000252static void
Fred Drake79912472000-07-09 04:06:11 +0000253set_attr_slots(PyClassObject *c)
Guido van Rossum7ba30431998-07-08 13:34:48 +0000254{
255 PyClassObject *dummy;
256
257 set_slot(&c->cl_getattr, class_lookup(c, getattrstr, &dummy));
258 set_slot(&c->cl_setattr, class_lookup(c, setattrstr, &dummy));
259 set_slot(&c->cl_delattr, class_lookup(c, delattrstr, &dummy));
260}
261
Guido van Rossuma63eff61998-05-29 21:37:21 +0000262static char *
Fred Drake79912472000-07-09 04:06:11 +0000263set_dict(PyClassObject *c, PyObject *v)
Guido van Rossuma63eff61998-05-29 21:37:21 +0000264{
Guido van Rossuma63eff61998-05-29 21:37:21 +0000265 if (v == NULL || !PyDict_Check(v))
266 return "__dict__ must be a dictionary object";
267 set_slot(&c->cl_dict, v);
Guido van Rossum7ba30431998-07-08 13:34:48 +0000268 set_attr_slots(c);
Guido van Rossuma63eff61998-05-29 21:37:21 +0000269 return "";
270}
271
272static char *
Fred Drake79912472000-07-09 04:06:11 +0000273set_bases(PyClassObject *c, PyObject *v)
Guido van Rossuma63eff61998-05-29 21:37:21 +0000274{
Guido van Rossuma63eff61998-05-29 21:37:21 +0000275 int i, n;
276
277 if (v == NULL || !PyTuple_Check(v))
278 return "__bases__ must be a tuple object";
279 n = PyTuple_Size(v);
280 for (i = 0; i < n; i++) {
281 PyObject *x = PyTuple_GET_ITEM(v, i);
282 if (!PyClass_Check(x))
283 return "__bases__ items must be classes";
284 if (PyClass_IsSubclass(x, (PyObject *)c))
285 return "a __bases__ item causes an inheritance cycle";
286 }
287 set_slot(&c->cl_bases, v);
Guido van Rossum7ba30431998-07-08 13:34:48 +0000288 set_attr_slots(c);
Guido van Rossuma63eff61998-05-29 21:37:21 +0000289 return "";
290}
291
292static char *
Fred Drake79912472000-07-09 04:06:11 +0000293set_name(PyClassObject *c, PyObject *v)
Guido van Rossuma63eff61998-05-29 21:37:21 +0000294{
Guido van Rossuma63eff61998-05-29 21:37:21 +0000295 if (v == NULL || !PyString_Check(v))
296 return "__name__ must be a string object";
Guido van Rossumad89bbc2000-06-28 21:57:18 +0000297 if (strlen(PyString_AS_STRING(v)) != (size_t)PyString_GET_SIZE(v))
Guido van Rossuma63eff61998-05-29 21:37:21 +0000298 return "__name__ must not contain null bytes";
299 set_slot(&c->cl_name, v);
300 return "";
301}
302
Guido van Rossum94308391991-10-20 20:11:48 +0000303static int
Fred Drake79912472000-07-09 04:06:11 +0000304class_setattr(PyClassObject *op, PyObject *name, PyObject *v)
Guido van Rossum94308391991-10-20 20:11:48 +0000305{
Guido van Rossumb2173c31997-08-25 21:23:56 +0000306 char *sname;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000307 if (PyEval_GetRestricted()) {
308 PyErr_SetString(PyExc_RuntimeError,
Guido van Rossumac21f6a1995-08-04 04:05:31 +0000309 "classes are read-only in restricted mode");
310 return -1;
311 }
Guido van Rossumb2173c31997-08-25 21:23:56 +0000312 sname = PyString_AsString(name);
313 if (sname[0] == '_' && sname[1] == '_') {
314 int n = PyString_Size(name);
315 if (sname[n-1] == '_' && sname[n-2] == '_') {
Guido van Rossuma63eff61998-05-29 21:37:21 +0000316 char *err = NULL;
317 if (strcmp(sname, "__dict__") == 0)
318 err = set_dict(op, v);
319 else if (strcmp(sname, "__bases__") == 0)
320 err = set_bases(op, v);
321 else if (strcmp(sname, "__name__") == 0)
322 err = set_name(op, v);
323 else if (strcmp(sname, "__getattr__") == 0)
324 set_slot(&op->cl_getattr, v);
325 else if (strcmp(sname, "__setattr__") == 0)
326 set_slot(&op->cl_setattr, v);
327 else if (strcmp(sname, "__delattr__") == 0)
328 set_slot(&op->cl_delattr, v);
329 /* For the last three, we fall through to update the
330 dictionary as well. */
331 if (err != NULL) {
332 if (*err == '\0')
333 return 0;
334 PyErr_SetString(PyExc_TypeError, err);
Guido van Rossumb2173c31997-08-25 21:23:56 +0000335 return -1;
336 }
337 }
338 }
Guido van Rossum94472a01992-09-04 09:45:18 +0000339 if (v == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000340 int rv = PyDict_DelItem(op->cl_dict, name);
Guido van Rossum94472a01992-09-04 09:45:18 +0000341 if (rv < 0)
Fred Drake661ea262000-10-24 19:57:45 +0000342 PyErr_Format(PyExc_AttributeError,
343 "class %.50s has no attribute '%.400s'",
344 PyString_AS_STRING(op->cl_name), sname);
Guido van Rossum94472a01992-09-04 09:45:18 +0000345 return rv;
346 }
Guido van Rossum94308391991-10-20 20:11:48 +0000347 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000348 return PyDict_SetItem(op->cl_dict, name, v);
Guido van Rossum94308391991-10-20 20:11:48 +0000349}
350
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000351static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000352class_repr(PyClassObject *op)
Guido van Rossum25831651993-05-19 14:50:45 +0000353{
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000354 PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
Guido van Rossum25831651993-05-19 14:50:45 +0000355 char *name;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000356 if (op->cl_name == NULL || !PyString_Check(op->cl_name))
Guido van Rossum25831651993-05-19 14:50:45 +0000357 name = "?";
358 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000359 name = PyString_AsString(op->cl_name);
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000360 if (mod == NULL || !PyString_Check(mod))
Barry Warsaw7ce36942001-08-24 18:34:26 +0000361 return PyString_FromFormat("<class ?.s at %p>", name, op);
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000362 else
Barry Warsaw7ce36942001-08-24 18:34:26 +0000363 return PyString_FromFormat("<class %s.%s at %p>",
364 PyString_AsString(mod),
365 name, op);
Guido van Rossum25831651993-05-19 14:50:45 +0000366}
367
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000368static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000369class_str(PyClassObject *op)
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000370{
371 PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
372 PyObject *name = op->cl_name;
373 PyObject *res;
374 int m, n;
375
376 if (name == NULL || !PyString_Check(name))
377 return class_repr(op);
378 if (mod == NULL || !PyString_Check(mod)) {
379 Py_INCREF(name);
380 return name;
381 }
382 m = PyString_Size(mod);
383 n = PyString_Size(name);
384 res = PyString_FromStringAndSize((char *)NULL, m+1+n);
385 if (res != NULL) {
386 char *s = PyString_AsString(res);
387 memcpy(s, PyString_AsString(mod), m);
388 s += m;
389 *s++ = '.';
390 memcpy(s, PyString_AsString(name), n);
391 }
392 return res;
393}
394
Jeremy Hylton8caad492000-06-23 14:18:11 +0000395static int
396class_traverse(PyClassObject *o, visitproc visit, void *arg)
397{
398 int err;
399 if (o->cl_bases) {
400 err = visit(o->cl_bases, arg);
401 if (err)
402 return err;
403 }
404 if (o->cl_dict) {
405 err = visit(o->cl_dict, arg);
406 if (err)
407 return err;
408 }
409 if (o->cl_name) {
410 err = visit(o->cl_name, arg);
411 if (err)
412 return err;
413 }
414 if (o->cl_getattr) {
415 err = visit(o->cl_getattr, arg);
416 if (err)
417 return err;
418 }
419 if (o->cl_setattr) {
420 err = visit(o->cl_setattr, arg);
421 if (err)
422 return err;
423 }
424 if (o->cl_delattr) {
425 err = visit(o->cl_delattr, arg);
426 if (err)
427 return err;
428 }
429 return 0;
430}
431
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000432PyTypeObject PyClass_Type = {
433 PyObject_HEAD_INIT(&PyType_Type)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000434 0,
435 "class",
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000436 sizeof(PyClassObject),
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000437 0,
Guido van Rossum8998b4f2001-01-17 15:28:20 +0000438 (destructor)class_dealloc, /* tp_dealloc */
439 0, /* tp_print */
440 0, /* tp_getattr */
441 0, /* tp_setattr */
442 0, /* tp_compare */
443 (reprfunc)class_repr, /* tp_repr */
444 0, /* tp_as_number */
445 0, /* tp_as_sequence */
446 0, /* tp_as_mapping */
447 0, /* tp_hash */
Tim Peters6d6c1a32001-08-02 04:15:00 +0000448 PyInstance_New, /* tp_call */
Guido van Rossum8998b4f2001-01-17 15:28:20 +0000449 (reprfunc)class_str, /* tp_str */
450 (getattrofunc)class_getattr, /* tp_getattro */
451 (setattrofunc)class_setattr, /* tp_setattro */
452 0, /* tp_as_buffer */
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000453 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
Guido van Rossum8998b4f2001-01-17 15:28:20 +0000454 0, /* tp_doc */
455 (traverseproc)class_traverse, /* tp_traverse */
Tim Peters6d6c1a32001-08-02 04:15:00 +0000456 0, /* tp_clear */
457 0, /* tp_richcompare */
458 0, /* tp_weaklistoffset */
459 0, /* tp_iter */
460 0, /* tp_iternext */
461 0, /* tp_methods */
462 0, /* tp_members */
463 0, /* tp_getset */
464 0, /* tp_base */
465 0, /* tp_dict */
466 0, /* tp_descr_get */
467 0, /* tp_descr_set */
468 0, /* tp_dictoffset */
469 0, /* tp_init */
470 0, /* tp_alloc */
471 class_new, /* tp_new */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000472};
473
Guido van Rossum81daa321993-05-20 14:24:46 +0000474int
Fred Drake79912472000-07-09 04:06:11 +0000475PyClass_IsSubclass(PyObject *class, PyObject *base)
Guido van Rossum81daa321993-05-20 14:24:46 +0000476{
477 int i, n;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000478 PyClassObject *cp;
Guido van Rossum81daa321993-05-20 14:24:46 +0000479 if (class == base)
480 return 1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000481 if (class == NULL || !PyClass_Check(class))
Guido van Rossumeb6b33a1993-05-25 09:38:27 +0000482 return 0;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000483 cp = (PyClassObject *)class;
484 n = PyTuple_Size(cp->cl_bases);
Guido van Rossum81daa321993-05-20 14:24:46 +0000485 for (i = 0; i < n; i++) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000486 if (PyClass_IsSubclass(PyTuple_GetItem(cp->cl_bases, i), base))
Guido van Rossum81daa321993-05-20 14:24:46 +0000487 return 1;
488 }
489 return 0;
490}
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000491
Guido van Rossum81daa321993-05-20 14:24:46 +0000492
493/* Instance objects */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000494
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000495PyObject *
Fred Drake5cc2c8c2001-01-28 03:53:08 +0000496PyInstance_NewRaw(PyObject *klass, PyObject *dict)
497{
498 PyInstanceObject *inst;
499
500 if (!PyClass_Check(klass)) {
501 PyErr_BadInternalCall();
502 return NULL;
503 }
504 if (dict == NULL) {
505 dict = PyDict_New();
506 if (dict == NULL)
507 return NULL;
508 }
509 else {
510 if (!PyDict_Check(dict)) {
511 PyErr_BadInternalCall();
512 return NULL;
513 }
514 Py_INCREF(dict);
515 }
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000516 inst = PyObject_GC_New(PyInstanceObject, &PyInstance_Type);
Fred Drake5cc2c8c2001-01-28 03:53:08 +0000517 if (inst == NULL) {
518 Py_DECREF(dict);
519 return NULL;
520 }
Fred Drake4e262a92001-03-22 18:26:47 +0000521 inst->in_weakreflist = NULL;
Fred Drake5cc2c8c2001-01-28 03:53:08 +0000522 Py_INCREF(klass);
523 inst->in_class = (PyClassObject *)klass;
524 inst->in_dict = dict;
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000525 _PyObject_GC_TRACK(inst);
Fred Drake5cc2c8c2001-01-28 03:53:08 +0000526 return (PyObject *)inst;
527}
528
529PyObject *
530PyInstance_New(PyObject *klass, PyObject *arg, PyObject *kw)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000531{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000532 register PyInstanceObject *inst;
533 PyObject *init;
534 static PyObject *initstr;
Fred Drake5cc2c8c2001-01-28 03:53:08 +0000535
536 inst = (PyInstanceObject *) PyInstance_NewRaw(klass, NULL);
Guido van Rossume8122f11991-05-05 20:03:07 +0000537 if (inst == NULL)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000538 return NULL;
Guido van Rossum2878a691996-08-09 20:53:24 +0000539 if (initstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000540 initstr = PyString_InternFromString("__init__");
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000541 init = instance_getattr2(inst, initstr);
Guido van Rossum25831651993-05-19 14:50:45 +0000542 if (init == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000543 if ((arg != NULL && (!PyTuple_Check(arg) ||
544 PyTuple_Size(arg) != 0))
545 || (kw != NULL && (!PyDict_Check(kw) ||
546 PyDict_Size(kw) != 0))) {
547 PyErr_SetString(PyExc_TypeError,
Guido van Rossuma83f2701995-07-26 18:07:32 +0000548 "this constructor takes no arguments");
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000549 Py_DECREF(inst);
Guido van Rossum25831651993-05-19 14:50:45 +0000550 inst = NULL;
551 }
552 }
553 else {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000554 PyObject *res = PyEval_CallObjectWithKeywords(init, arg, kw);
555 Py_DECREF(init);
Guido van Rossum25831651993-05-19 14:50:45 +0000556 if (res == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000557 Py_DECREF(inst);
Guido van Rossum25831651993-05-19 14:50:45 +0000558 inst = NULL;
559 }
560 else {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000561 if (res != Py_None) {
562 PyErr_SetString(PyExc_TypeError,
Guido van Rossum25831651993-05-19 14:50:45 +0000563 "__init__() should return None");
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000564 Py_DECREF(inst);
Guido van Rossum25831651993-05-19 14:50:45 +0000565 inst = NULL;
566 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000567 Py_DECREF(res);
Guido van Rossum25831651993-05-19 14:50:45 +0000568 }
569 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000570 return (PyObject *)inst;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000571}
572
Guido van Rossum21ed88c1991-04-04 10:42:10 +0000573/* Instance methods */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000574
575static void
Fred Drake79912472000-07-09 04:06:11 +0000576instance_dealloc(register PyInstanceObject *inst)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000577{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000578 PyObject *error_type, *error_value, *error_traceback;
579 PyObject *del;
580 static PyObject *delstr;
Tim Peters6b184912000-09-17 14:40:17 +0000581#ifdef Py_REF_DEBUG
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000582 extern long _Py_RefTotal;
Skip Montanaro4ca150b2000-07-08 12:04:57 +0000583#endif
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000584 _PyObject_GC_UNTRACK(inst);
Fred Drakeb60654b2001-02-26 18:56:37 +0000585 PyObject_ClearWeakRefs((PyObject *) inst);
Fred Drake41deb1e2001-02-01 05:27:45 +0000586
Tim Peters6b184912000-09-17 14:40:17 +0000587 /* Temporarily resurrect the object. */
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000588#ifdef Py_TRACE_REFS
Tim Peters6b184912000-09-17 14:40:17 +0000589#ifndef Py_REF_DEBUG
590# error "Py_TRACE_REFS defined but Py_REF_DEBUG not."
591#endif
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000592 /* much too complicated if Py_TRACE_REFS defined */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000593 inst->ob_type = &PyInstance_Type;
Guido van Rossumbffd6832000-01-20 22:32:56 +0000594 _Py_NewReference((PyObject *)inst);
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000595#ifdef COUNT_ALLOCS
Tim Peters6b184912000-09-17 14:40:17 +0000596 /* compensate for boost in _Py_NewReference; note that
597 * _Py_RefTotal was also boosted; we'll knock that down later.
598 */
Tim Peters6d6c1a32001-08-02 04:15:00 +0000599 inst->ob_type->tp_allocs--;
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000600#endif
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000601#else /* !Py_TRACE_REFS */
Tim Peters6b184912000-09-17 14:40:17 +0000602 /* Py_INCREF boosts _Py_RefTotal if Py_REF_DEBUG is defined */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000603 Py_INCREF(inst);
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000604#endif /* !Py_TRACE_REFS */
Tim Peters6b184912000-09-17 14:40:17 +0000605
606 /* Save the current exception, if any. */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000607 PyErr_Fetch(&error_type, &error_value, &error_traceback);
Tim Peters6b184912000-09-17 14:40:17 +0000608 /* Execute __del__ method, if any. */
Guido van Rossum2878a691996-08-09 20:53:24 +0000609 if (delstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000610 delstr = PyString_InternFromString("__del__");
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000611 if ((del = instance_getattr2(inst, delstr)) != NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000612 PyObject *res = PyEval_CallObject(del, (PyObject *)NULL);
Tim Peters6b184912000-09-17 14:40:17 +0000613 if (res == NULL)
Jeremy Hyltonb709df32000-09-01 02:47:25 +0000614 PyErr_WriteUnraisable(del);
Guido van Rossum0dfcf751996-08-12 22:00:53 +0000615 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000616 Py_DECREF(res);
617 Py_DECREF(del);
Guido van Rossum25831651993-05-19 14:50:45 +0000618 }
Tim Peters6b184912000-09-17 14:40:17 +0000619 /* Restore the saved exception. */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000620 PyErr_Restore(error_type, error_value, error_traceback);
Tim Peters6b184912000-09-17 14:40:17 +0000621 /* Undo the temporary resurrection; can't use DECREF here, it would
622 * cause a recursive call.
623 */
624#ifdef Py_REF_DEBUG
625 /* _Py_RefTotal was boosted either by _Py_NewReference or
626 * Py_INCREF above.
627 */
628 _Py_RefTotal--;
629#endif
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000630 if (--inst->ob_refcnt > 0) {
631#ifdef COUNT_ALLOCS
Tim Peters6d6c1a32001-08-02 04:15:00 +0000632 inst->ob_type->tp_frees--;
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000633#endif
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000634 _PyObject_GC_TRACK(inst);
Guido van Rossum25831651993-05-19 14:50:45 +0000635 return; /* __del__ added a reference; don't delete now */
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000636 }
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000637#ifdef Py_TRACE_REFS
Guido van Rossumbffd6832000-01-20 22:32:56 +0000638 _Py_ForgetReference((PyObject *)inst);
Tim Peters6b184912000-09-17 14:40:17 +0000639#ifdef COUNT_ALLOCS
640 /* compensate for increment in _Py_ForgetReference */
Tim Peters6d6c1a32001-08-02 04:15:00 +0000641 inst->ob_type->tp_frees--;
Tim Peters6b184912000-09-17 14:40:17 +0000642#endif
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000643#ifndef WITH_CYCLE_GC
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000644 inst->ob_type = NULL;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000645#endif
Tim Peters6b184912000-09-17 14:40:17 +0000646#endif
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000647 Py_DECREF(inst->in_class);
648 Py_XDECREF(inst->in_dict);
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000649 PyObject_GC_Del(inst);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000650}
651
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000652static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000653instance_getattr1(register PyInstanceObject *inst, PyObject *name)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000654{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000655 register PyObject *v;
656 register char *sname = PyString_AsString(name);
Guido van Rossum2878a691996-08-09 20:53:24 +0000657 if (sname[0] == '_' && sname[1] == '_') {
658 if (strcmp(sname, "__dict__") == 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000659 if (PyEval_GetRestricted()) {
660 PyErr_SetString(PyExc_RuntimeError,
661 "instance.__dict__ not accessible in restricted mode");
Guido van Rossum10393b11995-01-10 10:39:49 +0000662 return NULL;
663 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000664 Py_INCREF(inst->in_dict);
Sjoerd Mullender3bb8a051993-10-22 12:04:32 +0000665 return inst->in_dict;
666 }
Guido van Rossum2878a691996-08-09 20:53:24 +0000667 if (strcmp(sname, "__class__") == 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000668 Py_INCREF(inst->in_class);
669 return (PyObject *)inst->in_class;
Sjoerd Mullender3bb8a051993-10-22 12:04:32 +0000670 }
Guido van Rossum94308391991-10-20 20:11:48 +0000671 }
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000672 v = instance_getattr2(inst, name);
673 if (v == NULL) {
Fred Drake661ea262000-10-24 19:57:45 +0000674 PyErr_Format(PyExc_AttributeError,
675 "%.50s instance has no attribute '%.400s'",
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000676 PyString_AS_STRING(inst->in_class->cl_name), sname);
677 }
678 return v;
679}
680
681static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000682instance_getattr2(register PyInstanceObject *inst, PyObject *name)
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000683{
684 register PyObject *v;
685 PyClassObject *class;
Tim Peters6d6c1a32001-08-02 04:15:00 +0000686 descrgetfunc f;
687
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000688 v = PyDict_GetItem(inst->in_dict, name);
Guido van Rossumf23c41d2001-08-17 13:43:27 +0000689 if (v != NULL) {
690 Py_INCREF(v);
691 return v;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000692 }
Guido van Rossumf23c41d2001-08-17 13:43:27 +0000693 v = class_lookup(inst->in_class, name, &class);
694 if (v != NULL) {
695 Py_INCREF(v);
Tim Peters6d6c1a32001-08-02 04:15:00 +0000696 f = v->ob_type->tp_descr_get;
697 if (f != NULL) {
698 PyObject *w = f(v, (PyObject *)inst,
699 (PyObject *)(inst->in_class));
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000700 Py_DECREF(v);
Guido van Rossum21d335e1993-10-15 13:01:11 +0000701 v = w;
702 }
Guido van Rossumb3f72581993-05-21 19:56:10 +0000703 }
704 return v;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000705}
706
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000707static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000708instance_getattr(register PyInstanceObject *inst, PyObject *name)
Guido van Rossume7737541994-09-05 07:31:41 +0000709{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000710 register PyObject *func, *res;
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000711 res = instance_getattr1(inst, name);
712 if (res == NULL && (func = inst->in_class->cl_getattr) != NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000713 PyObject *args;
714 PyErr_Clear();
715 args = Py_BuildValue("(OO)", inst, name);
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000716 if (args == NULL)
Guido van Rossume7737541994-09-05 07:31:41 +0000717 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000718 res = PyEval_CallObject(func, args);
719 Py_DECREF(args);
Guido van Rossume7737541994-09-05 07:31:41 +0000720 }
721 return res;
722}
723
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000724static int
Fred Drake79912472000-07-09 04:06:11 +0000725instance_setattr1(PyInstanceObject *inst, PyObject *name, PyObject *v)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000726{
Guido van Rossum94472a01992-09-04 09:45:18 +0000727 if (v == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000728 int rv = PyDict_DelItem(inst->in_dict, name);
Guido van Rossum94472a01992-09-04 09:45:18 +0000729 if (rv < 0)
Fred Drake661ea262000-10-24 19:57:45 +0000730 PyErr_Format(PyExc_AttributeError,
731 "%.50s instance has no attribute '%.400s'",
732 PyString_AS_STRING(inst->in_class->cl_name),
733 PyString_AS_STRING(name));
Guido van Rossum94472a01992-09-04 09:45:18 +0000734 return rv;
735 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000736 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000737 return PyDict_SetItem(inst->in_dict, name, v);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000738}
739
Guido van Rossume7737541994-09-05 07:31:41 +0000740static int
Fred Drake79912472000-07-09 04:06:11 +0000741instance_setattr(PyInstanceObject *inst, PyObject *name, PyObject *v)
Guido van Rossume7737541994-09-05 07:31:41 +0000742{
Guido van Rossumb2173c31997-08-25 21:23:56 +0000743 PyObject *func, *args, *res, *tmp;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000744 char *sname = PyString_AsString(name);
Guido van Rossumb2173c31997-08-25 21:23:56 +0000745 if (sname[0] == '_' && sname[1] == '_') {
746 int n = PyString_Size(name);
Guido van Rossum2878a691996-08-09 20:53:24 +0000747 if (sname[n-1] == '_' && sname[n-2] == '_') {
Guido van Rossumb2173c31997-08-25 21:23:56 +0000748 if (strcmp(sname, "__dict__") == 0) {
749 if (PyEval_GetRestricted()) {
750 PyErr_SetString(PyExc_RuntimeError,
751 "__dict__ not accessible in restricted mode");
752 return -1;
753 }
754 if (v == NULL || !PyDict_Check(v)) {
755 PyErr_SetString(PyExc_TypeError,
756 "__dict__ must be set to a dictionary");
757 return -1;
758 }
759 tmp = inst->in_dict;
760 Py_INCREF(v);
761 inst->in_dict = v;
762 Py_DECREF(tmp);
763 return 0;
764 }
765 if (strcmp(sname, "__class__") == 0) {
766 if (PyEval_GetRestricted()) {
767 PyErr_SetString(PyExc_RuntimeError,
768 "__class__ not accessible in restricted mode");
769 return -1;
770 }
771 if (v == NULL || !PyClass_Check(v)) {
772 PyErr_SetString(PyExc_TypeError,
773 "__class__ must be set to a class");
774 return -1;
775 }
776 tmp = (PyObject *)(inst->in_class);
777 Py_INCREF(v);
778 inst->in_class = (PyClassObject *)v;
779 Py_DECREF(tmp);
780 return 0;
781 }
Guido van Rossume7737541994-09-05 07:31:41 +0000782 }
Guido van Rossume7737541994-09-05 07:31:41 +0000783 }
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000784 if (v == NULL)
785 func = inst->in_class->cl_delattr;
786 else
787 func = inst->in_class->cl_setattr;
788 if (func == NULL)
789 return instance_setattr1(inst, name, v);
790 if (v == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000791 args = Py_BuildValue("(OO)", inst, name);
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000792 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000793 args = Py_BuildValue("(OOO)", inst, name, v);
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000794 if (args == NULL)
795 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000796 res = PyEval_CallObject(func, args);
797 Py_DECREF(args);
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000798 if (res == NULL)
799 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000800 Py_DECREF(res);
Guido van Rossume7737541994-09-05 07:31:41 +0000801 return 0;
802}
803
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000804static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000805instance_repr(PyInstanceObject *inst)
Guido van Rossum04691fc1992-08-12 15:35:34 +0000806{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000807 PyObject *func;
808 PyObject *res;
809 static PyObject *reprstr;
Guido van Rossum04691fc1992-08-12 15:35:34 +0000810
Guido van Rossum2878a691996-08-09 20:53:24 +0000811 if (reprstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000812 reprstr = PyString_InternFromString("__repr__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000813 func = instance_getattr(inst, reprstr);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000814 if (func == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000815 PyObject *classname = inst->in_class->cl_name;
Guido van Rossumb7f1afe1997-12-03 00:06:02 +0000816 PyObject *mod = PyDict_GetItemString(
817 inst->in_class->cl_dict, "__module__");
Guido van Rossum25831651993-05-19 14:50:45 +0000818 char *cname;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000819 if (classname != NULL && PyString_Check(classname))
820 cname = PyString_AsString(classname);
Guido van Rossum25831651993-05-19 14:50:45 +0000821 else
822 cname = "?";
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000823 PyErr_Clear();
Guido van Rossumb7f1afe1997-12-03 00:06:02 +0000824 if (mod == NULL || !PyString_Check(mod))
Barry Warsaw7ce36942001-08-24 18:34:26 +0000825 return PyString_FromFormat("<?.%s instance at %p>",
826 cname, inst);
Guido van Rossumb7f1afe1997-12-03 00:06:02 +0000827 else
Barry Warsaw7ce36942001-08-24 18:34:26 +0000828 return PyString_FromFormat("<%s.%s instance at %p>",
829 PyString_AsString(mod),
830 cname, inst);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000831 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000832 res = PyEval_CallObject(func, (PyObject *)NULL);
833 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000834 return res;
835}
836
Guido van Rossum82c690f2001-04-30 14:39:18 +0000837static PyObject *
838instance_str(PyInstanceObject *inst)
839{
840 PyObject *func;
841 PyObject *res;
842 static PyObject *strstr;
843
844 if (strstr == NULL)
845 strstr = PyString_InternFromString("__str__");
846 func = instance_getattr(inst, strstr);
847 if (func == NULL) {
848 PyErr_Clear();
849 return instance_repr(inst);
850 }
851 res = PyEval_CallObject(func, (PyObject *)NULL);
852 Py_DECREF(func);
853 return res;
854}
855
Guido van Rossum9bfef441993-03-29 10:43:31 +0000856static long
Fred Drake79912472000-07-09 04:06:11 +0000857instance_hash(PyInstanceObject *inst)
Guido van Rossum9bfef441993-03-29 10:43:31 +0000858{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000859 PyObject *func;
860 PyObject *res;
Guido van Rossum8a0c3451993-04-08 12:56:19 +0000861 long outcome;
Guido van Rossum65e8bd72001-01-18 23:46:31 +0000862 static PyObject *hashstr, *eqstr, *cmpstr;
Guido van Rossum9bfef441993-03-29 10:43:31 +0000863
Guido van Rossum2878a691996-08-09 20:53:24 +0000864 if (hashstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000865 hashstr = PyString_InternFromString("__hash__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000866 func = instance_getattr(inst, hashstr);
Guido van Rossum9bfef441993-03-29 10:43:31 +0000867 if (func == NULL) {
Guido van Rossum65e8bd72001-01-18 23:46:31 +0000868 /* If there is no __eq__ and no __cmp__ method, we hash on the
869 address. If an __eq__ or __cmp__ method exists, there must
870 be a __hash__. */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000871 PyErr_Clear();
Guido van Rossum65e8bd72001-01-18 23:46:31 +0000872 if (eqstr == NULL)
873 eqstr = PyString_InternFromString("__eq__");
874 func = instance_getattr(inst, eqstr);
Guido van Rossum8a0c3451993-04-08 12:56:19 +0000875 if (func == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000876 PyErr_Clear();
Guido van Rossum65e8bd72001-01-18 23:46:31 +0000877 if (cmpstr == NULL)
878 cmpstr = PyString_InternFromString("__cmp__");
879 func = instance_getattr(inst, cmpstr);
880 if (func == NULL) {
881 PyErr_Clear();
882 return _Py_HashPointer(inst);
883 }
Guido van Rossum8a0c3451993-04-08 12:56:19 +0000884 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000885 PyErr_SetString(PyExc_TypeError, "unhashable instance");
Guido van Rossum9bfef441993-03-29 10:43:31 +0000886 return -1;
887 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000888 res = PyEval_CallObject(func, (PyObject *)NULL);
889 Py_DECREF(func);
Guido van Rossum9bfef441993-03-29 10:43:31 +0000890 if (res == NULL)
891 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000892 if (PyInt_Check(res)) {
893 outcome = PyInt_AsLong(res);
Guido van Rossum9bfef441993-03-29 10:43:31 +0000894 if (outcome == -1)
895 outcome = -2;
896 }
897 else {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000898 PyErr_SetString(PyExc_TypeError,
899 "__hash__() should return an int");
Guido van Rossum9bfef441993-03-29 10:43:31 +0000900 outcome = -1;
901 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000902 Py_DECREF(res);
Guido van Rossum9bfef441993-03-29 10:43:31 +0000903 return outcome;
904}
905
Jeremy Hylton8caad492000-06-23 14:18:11 +0000906static int
907instance_traverse(PyInstanceObject *o, visitproc visit, void *arg)
908{
909 int err;
910 if (o->in_class) {
911 err = visit((PyObject *)(o->in_class), arg);
912 if (err)
913 return err;
914 }
915 if (o->in_dict) {
916 err = visit(o->in_dict, arg);
917 if (err)
918 return err;
919 }
Jeremy Hyltond22162b2000-06-23 17:14:56 +0000920 return 0;
Jeremy Hylton8caad492000-06-23 14:18:11 +0000921}
922
Guido van Rossum213c7a62001-04-23 14:08:49 +0000923static PyObject *getitemstr, *setitemstr, *delitemstr, *lenstr;
924static PyObject *iterstr, *nextstr;
Guido van Rossum2878a691996-08-09 20:53:24 +0000925
Guido van Rossum9bfef441993-03-29 10:43:31 +0000926static int
Fred Drake79912472000-07-09 04:06:11 +0000927instance_length(PyInstanceObject *inst)
Guido van Rossum04691fc1992-08-12 15:35:34 +0000928{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000929 PyObject *func;
930 PyObject *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +0000931 int outcome;
932
Guido van Rossum2878a691996-08-09 20:53:24 +0000933 if (lenstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000934 lenstr = PyString_InternFromString("__len__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000935 func = instance_getattr(inst, lenstr);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000936 if (func == NULL)
937 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000938 res = PyEval_CallObject(func, (PyObject *)NULL);
939 Py_DECREF(func);
Guido van Rossumd014ea61992-11-26 10:30:26 +0000940 if (res == NULL)
941 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000942 if (PyInt_Check(res)) {
943 outcome = PyInt_AsLong(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000944 if (outcome < 0)
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000945 PyErr_SetString(PyExc_ValueError,
946 "__len__() should return >= 0");
Guido van Rossum04691fc1992-08-12 15:35:34 +0000947 }
948 else {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000949 PyErr_SetString(PyExc_TypeError,
950 "__len__() should return an int");
Guido van Rossum04691fc1992-08-12 15:35:34 +0000951 outcome = -1;
952 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000953 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000954 return outcome;
955}
956
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000957static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000958instance_subscript(PyInstanceObject *inst, PyObject *key)
Guido van Rossum04691fc1992-08-12 15:35:34 +0000959{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000960 PyObject *func;
961 PyObject *arg;
962 PyObject *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +0000963
Guido van Rossum2878a691996-08-09 20:53:24 +0000964 if (getitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000965 getitemstr = PyString_InternFromString("__getitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000966 func = instance_getattr(inst, getitemstr);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000967 if (func == NULL)
968 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000969 arg = Py_BuildValue("(O)", key);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000970 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000971 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000972 return NULL;
973 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000974 res = PyEval_CallObject(func, arg);
975 Py_DECREF(func);
976 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000977 return res;
978}
979
Guido van Rossum9bfef441993-03-29 10:43:31 +0000980static int
Fred Drake79912472000-07-09 04:06:11 +0000981instance_ass_subscript(PyInstanceObject *inst, PyObject *key, PyObject *value)
Guido van Rossum04691fc1992-08-12 15:35:34 +0000982{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000983 PyObject *func;
984 PyObject *arg;
985 PyObject *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +0000986
Guido van Rossum2878a691996-08-09 20:53:24 +0000987 if (value == NULL) {
988 if (delitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000989 delitemstr = PyString_InternFromString("__delitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000990 func = instance_getattr(inst, delitemstr);
991 }
992 else {
993 if (setitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000994 setitemstr = PyString_InternFromString("__setitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000995 func = instance_getattr(inst, setitemstr);
996 }
Guido van Rossum04691fc1992-08-12 15:35:34 +0000997 if (func == NULL)
998 return -1;
999 if (value == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001000 arg = Py_BuildValue("(O)", key);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001001 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001002 arg = Py_BuildValue("(OO)", key, value);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001003 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001004 Py_DECREF(func);
Guido van Rossum6d946f91992-08-14 13:49:30 +00001005 return -1;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001006 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001007 res = PyEval_CallObject(func, arg);
1008 Py_DECREF(func);
1009 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001010 if (res == NULL)
1011 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001012 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001013 return 0;
1014}
1015
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001016static PyMappingMethods instance_as_mapping = {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001017 (inquiry)instance_length, /* mp_length */
1018 (binaryfunc)instance_subscript, /* mp_subscript */
1019 (objobjargproc)instance_ass_subscript, /* mp_ass_subscript */
Guido van Rossum04691fc1992-08-12 15:35:34 +00001020};
1021
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001022static PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001023instance_item(PyInstanceObject *inst, int i)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001024{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001025 PyObject *func, *arg, *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001026
Guido van Rossum2878a691996-08-09 20:53:24 +00001027 if (getitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001028 getitemstr = PyString_InternFromString("__getitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001029 func = instance_getattr(inst, getitemstr);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001030 if (func == NULL)
1031 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001032 arg = Py_BuildValue("(i)", i);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001033 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001034 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001035 return NULL;
1036 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001037 res = PyEval_CallObject(func, arg);
1038 Py_DECREF(func);
1039 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001040 return res;
1041}
1042
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001043static PyObject *
Thomas Wouters1d75a792000-08-17 22:37:32 +00001044sliceobj_from_intint(int i, int j)
1045{
1046 PyObject *start, *end, *res;
1047
1048 start = PyInt_FromLong((long)i);
1049 if (!start)
1050 return NULL;
1051
1052 end = PyInt_FromLong((long)j);
1053 if (!end) {
1054 Py_DECREF(start);
1055 return NULL;
1056 }
1057 res = PySlice_New(start, end, NULL);
1058 Py_DECREF(start);
1059 Py_DECREF(end);
1060 return res;
1061}
1062
1063
1064static PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001065instance_slice(PyInstanceObject *inst, int i, int j)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001066{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001067 PyObject *func, *arg, *res;
1068 static PyObject *getslicestr;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001069
Guido van Rossum2878a691996-08-09 20:53:24 +00001070 if (getslicestr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001071 getslicestr = PyString_InternFromString("__getslice__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001072 func = instance_getattr(inst, getslicestr);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001073
1074 if (func == NULL) {
1075 PyErr_Clear();
1076
1077 if (getitemstr == NULL)
1078 getitemstr = PyString_InternFromString("__getitem__");
1079 func = instance_getattr(inst, getitemstr);
1080 if (func == NULL)
1081 return NULL;
1082 arg = Py_BuildValue("(N)", sliceobj_from_intint(i, j));
1083 } else
1084 arg = Py_BuildValue("(ii)", i, j);
1085
Guido van Rossum04691fc1992-08-12 15:35:34 +00001086 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001087 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001088 return NULL;
1089 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001090 res = PyEval_CallObject(func, arg);
1091 Py_DECREF(func);
1092 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001093 return res;
1094}
1095
1096static int
Fred Drake79912472000-07-09 04:06:11 +00001097instance_ass_item(PyInstanceObject *inst, int i, PyObject *item)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001098{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001099 PyObject *func, *arg, *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001100
Guido van Rossum2878a691996-08-09 20:53:24 +00001101 if (item == NULL) {
1102 if (delitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001103 delitemstr = PyString_InternFromString("__delitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001104 func = instance_getattr(inst, delitemstr);
1105 }
1106 else {
1107 if (setitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001108 setitemstr = PyString_InternFromString("__setitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001109 func = instance_getattr(inst, setitemstr);
1110 }
Guido van Rossum04691fc1992-08-12 15:35:34 +00001111 if (func == NULL)
Guido van Rossum6d946f91992-08-14 13:49:30 +00001112 return -1;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001113 if (item == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001114 arg = Py_BuildValue("i", i);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001115 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001116 arg = Py_BuildValue("(iO)", i, item);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001117 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001118 Py_DECREF(func);
Guido van Rossum6d946f91992-08-14 13:49:30 +00001119 return -1;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001120 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001121 res = PyEval_CallObject(func, arg);
1122 Py_DECREF(func);
1123 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001124 if (res == NULL)
1125 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001126 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001127 return 0;
1128}
1129
1130static int
Fred Drake79912472000-07-09 04:06:11 +00001131instance_ass_slice(PyInstanceObject *inst, int i, int j, PyObject *value)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001132{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001133 PyObject *func, *arg, *res;
1134 static PyObject *setslicestr, *delslicestr;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001135
Guido van Rossum2878a691996-08-09 20:53:24 +00001136 if (value == NULL) {
1137 if (delslicestr == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001138 delslicestr =
1139 PyString_InternFromString("__delslice__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001140 func = instance_getattr(inst, delslicestr);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001141 if (func == NULL) {
1142 PyErr_Clear();
1143 if (delitemstr == NULL)
1144 delitemstr =
1145 PyString_InternFromString("__delitem__");
1146 func = instance_getattr(inst, delitemstr);
1147 if (func == NULL)
1148 return -1;
1149
1150 arg = Py_BuildValue("(N)",
1151 sliceobj_from_intint(i, j));
1152 } else
1153 arg = Py_BuildValue("(ii)", i, j);
Guido van Rossum2878a691996-08-09 20:53:24 +00001154 }
1155 else {
1156 if (setslicestr == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001157 setslicestr =
1158 PyString_InternFromString("__setslice__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001159 func = instance_getattr(inst, setslicestr);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001160 if (func == NULL) {
1161 PyErr_Clear();
1162 if (setitemstr == NULL)
1163 setitemstr =
1164 PyString_InternFromString("__setitem__");
1165 func = instance_getattr(inst, setitemstr);
1166 if (func == NULL)
1167 return -1;
1168
1169 arg = Py_BuildValue("(NO)",
1170 sliceobj_from_intint(i, j), value);
1171 } else
1172 arg = Py_BuildValue("(iiO)", i, j, value);
Guido van Rossum2878a691996-08-09 20:53:24 +00001173 }
Guido van Rossum04691fc1992-08-12 15:35:34 +00001174 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001175 Py_DECREF(func);
Guido van Rossum6d946f91992-08-14 13:49:30 +00001176 return -1;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001177 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001178 res = PyEval_CallObject(func, arg);
1179 Py_DECREF(func);
1180 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001181 if (res == NULL)
1182 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001183 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001184 return 0;
1185}
1186
Tim Peterscb8d3682001-05-05 21:05:01 +00001187static int
1188instance_contains(PyInstanceObject *inst, PyObject *member)
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001189{
1190 static PyObject *__contains__;
Tim Peterscb8d3682001-05-05 21:05:01 +00001191 PyObject *func;
1192
1193 /* Try __contains__ first.
1194 * If that can't be done, try iterator-based searching.
1195 */
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001196
1197 if(__contains__ == NULL) {
1198 __contains__ = PyString_InternFromString("__contains__");
1199 if(__contains__ == NULL)
1200 return -1;
1201 }
1202 func = instance_getattr(inst, __contains__);
Tim Peterscb8d3682001-05-05 21:05:01 +00001203 if (func) {
1204 PyObject *res;
1205 int ret;
1206 PyObject *arg = Py_BuildValue("(O)", member);
1207 if(arg == NULL) {
1208 Py_DECREF(func);
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001209 return -1;
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001210 }
Tim Peterscb8d3682001-05-05 21:05:01 +00001211 res = PyEval_CallObject(func, arg);
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001212 Py_DECREF(func);
Tim Peterscb8d3682001-05-05 21:05:01 +00001213 Py_DECREF(arg);
1214 if(res == NULL)
1215 return -1;
1216 ret = PyObject_IsTrue(res);
1217 Py_DECREF(res);
1218 return ret;
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001219 }
Tim Peterscb8d3682001-05-05 21:05:01 +00001220
1221 /* Couldn't find __contains__. */
1222 if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
1223 /* Assume the failure was simply due to that there is no
1224 * __contains__ attribute, and try iterating instead.
1225 */
1226 PyErr_Clear();
Tim Peters16a77ad2001-09-08 04:00:12 +00001227 return _PySequence_IterSearch((PyObject *)inst, member,
1228 PY_ITERSEARCH_CONTAINS);
Tim Peterscb8d3682001-05-05 21:05:01 +00001229 }
1230 else
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001231 return -1;
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001232}
1233
Fred Drake79912472000-07-09 04:06:11 +00001234static PySequenceMethods
1235instance_as_sequence = {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001236 (inquiry)instance_length, /* sq_length */
1237 0, /* sq_concat */
1238 0, /* sq_repeat */
1239 (intargfunc)instance_item, /* sq_item */
1240 (intintargfunc)instance_slice, /* sq_slice */
1241 (intobjargproc)instance_ass_item, /* sq_ass_item */
1242 (intintobjargproc)instance_ass_slice, /* sq_ass_slice */
1243 (objobjproc)instance_contains, /* sq_contains */
Guido van Rossum04691fc1992-08-12 15:35:34 +00001244};
1245
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001246static PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001247generic_unary_op(PyInstanceObject *self, PyObject *methodname)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001248{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001249 PyObject *func, *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001250
1251 if ((func = instance_getattr(self, methodname)) == NULL)
1252 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001253 res = PyEval_CallObject(func, (PyObject *)NULL);
1254 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001255 return res;
1256}
1257
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001258static PyObject *
1259generic_binary_op(PyObject *v, PyObject *w, char *opname)
Guido van Rossum03093a21994-09-28 15:51:32 +00001260{
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001261 PyObject *result;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001262 PyObject *args;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001263 PyObject *func = PyObject_GetAttrString(v, opname);
Guido van Rossume7d444f1995-01-07 12:35:18 +00001264 if (func == NULL) {
Guido van Rossum617c1b01998-05-28 19:50:02 +00001265 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001266 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001267 PyErr_Clear();
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001268 Py_INCREF(Py_NotImplemented);
1269 return Py_NotImplemented;
Guido van Rossume7d444f1995-01-07 12:35:18 +00001270 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001271 args = Py_BuildValue("(O)", w);
Guido van Rossum03093a21994-09-28 15:51:32 +00001272 if (args == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001273 Py_DECREF(func);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001274 return NULL;
Guido van Rossum03093a21994-09-28 15:51:32 +00001275 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001276 result = PyEval_CallObject(func, args);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001277 Py_DECREF(args);
1278 Py_DECREF(func);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001279 return result;
1280}
1281
1282
1283static PyObject *coerce_obj;
1284
1285/* Try one half of a binary operator involving a class instance. */
1286static PyObject *
1287half_binop(PyObject *v, PyObject *w, char *opname, binaryfunc thisfunc,
1288 int swapped)
1289{
1290 PyObject *args;
1291 PyObject *coercefunc;
1292 PyObject *coerced = NULL;
1293 PyObject *v1;
1294 PyObject *result;
1295
1296 if (!PyInstance_Check(v)) {
1297 Py_INCREF(Py_NotImplemented);
1298 return Py_NotImplemented;
1299 }
1300
1301 if (coerce_obj == NULL) {
1302 coerce_obj = PyString_InternFromString("__coerce__");
1303 if (coerce_obj == NULL)
1304 return NULL;
1305 }
1306 coercefunc = PyObject_GetAttr(v, coerce_obj);
1307 if (coercefunc == NULL) {
1308 PyErr_Clear();
1309 return generic_binary_op(v, w, opname);
1310 }
1311
1312 args = Py_BuildValue("(O)", w);
1313 if (args == NULL) {
1314 return NULL;
1315 }
1316 coerced = PyEval_CallObject(coercefunc, args);
1317 Py_DECREF(args);
1318 Py_DECREF(coercefunc);
1319 if (coerced == NULL) {
1320 return NULL;
1321 }
1322 if (coerced == Py_None || coerced == Py_NotImplemented) {
1323 Py_DECREF(coerced);
1324 return generic_binary_op(v, w, opname);
1325 }
1326 if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
1327 Py_DECREF(coerced);
1328 PyErr_SetString(PyExc_TypeError,
1329 "coercion should return None or 2-tuple");
1330 return NULL;
1331 }
1332 v1 = PyTuple_GetItem(coerced, 0);
1333 w = PyTuple_GetItem(coerced, 1);
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001334 if (v1->ob_type == v->ob_type && PyInstance_Check(v)) {
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001335 /* prevent recursion if __coerce__ returns self as the first
1336 * argument */
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001337 result = generic_binary_op(v1, w, opname);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001338 } else {
1339 if (swapped)
1340 result = (thisfunc)(w, v1);
1341 else
1342 result = (thisfunc)(v1, w);
1343 }
1344 Py_DECREF(coerced);
1345 return result;
1346}
1347
1348/* Implement a binary operator involving at least one class instance. */
1349static PyObject *
1350do_binop(PyObject *v, PyObject *w, char *opname, char *ropname,
1351 binaryfunc thisfunc)
1352{
1353 PyObject *result = half_binop(v, w, opname, thisfunc, 0);
1354 if (result == Py_NotImplemented) {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001355 Py_DECREF(result);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001356 result = half_binop(w, v, ropname, thisfunc, 1);
1357 }
1358 return result;
1359}
1360
1361static PyObject *
1362do_binop_inplace(PyObject *v, PyObject *w, char *iopname, char *opname,
1363 char *ropname, binaryfunc thisfunc)
1364{
1365 PyObject *result = half_binop(v, w, iopname, thisfunc, 0);
1366 if (result == Py_NotImplemented) {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001367 Py_DECREF(result);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001368 result = do_binop(v, w, opname, ropname, thisfunc);
1369 }
1370 return result;
Guido van Rossum03093a21994-09-28 15:51:32 +00001371}
1372
Guido van Rossum879c5811995-01-10 15:24:06 +00001373static int
Fred Drake79912472000-07-09 04:06:11 +00001374instance_coerce(PyObject **pv, PyObject **pw)
Guido van Rossum879c5811995-01-10 15:24:06 +00001375{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001376 PyObject *v = *pv;
1377 PyObject *w = *pw;
Guido van Rossum3931df91997-11-18 19:23:07 +00001378 PyObject *coercefunc;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001379 PyObject *args;
1380 PyObject *coerced;
Guido van Rossum879c5811995-01-10 15:24:06 +00001381
Guido van Rossum2878a691996-08-09 20:53:24 +00001382 if (coerce_obj == NULL) {
Guido van Rossuma412d241997-01-18 07:59:12 +00001383 coerce_obj = PyString_InternFromString("__coerce__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001384 if (coerce_obj == NULL)
1385 return -1;
1386 }
Guido van Rossum3931df91997-11-18 19:23:07 +00001387 coercefunc = PyObject_GetAttr(v, coerce_obj);
1388 if (coercefunc == NULL) {
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001389 /* No __coerce__ method */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001390 PyErr_Clear();
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001391 return 1;
Guido van Rossum879c5811995-01-10 15:24:06 +00001392 }
1393 /* Has __coerce__ method: call it */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001394 args = Py_BuildValue("(O)", w);
Guido van Rossum879c5811995-01-10 15:24:06 +00001395 if (args == NULL) {
1396 return -1;
1397 }
Guido van Rossum3931df91997-11-18 19:23:07 +00001398 coerced = PyEval_CallObject(coercefunc, args);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001399 Py_DECREF(args);
Guido van Rossum3931df91997-11-18 19:23:07 +00001400 Py_DECREF(coercefunc);
Guido van Rossum879c5811995-01-10 15:24:06 +00001401 if (coerced == NULL) {
1402 /* __coerce__ call raised an exception */
1403 return -1;
1404 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001405 if (coerced == Py_None || coerced == Py_NotImplemented) {
Guido van Rossum879c5811995-01-10 15:24:06 +00001406 /* __coerce__ says "I can't do it" */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001407 Py_DECREF(coerced);
Guido van Rossum879c5811995-01-10 15:24:06 +00001408 return 1;
1409 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001410 if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
Guido van Rossum879c5811995-01-10 15:24:06 +00001411 /* __coerce__ return value is malformed */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001412 Py_DECREF(coerced);
1413 PyErr_SetString(PyExc_TypeError,
Guido van Rossum879c5811995-01-10 15:24:06 +00001414 "coercion should return None or 2-tuple");
1415 return -1;
1416 }
1417 /* __coerce__ returned two new values */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001418 *pv = PyTuple_GetItem(coerced, 0);
1419 *pw = PyTuple_GetItem(coerced, 1);
1420 Py_INCREF(*pv);
1421 Py_INCREF(*pw);
1422 Py_DECREF(coerced);
Guido van Rossum879c5811995-01-10 15:24:06 +00001423 return 0;
1424}
1425
Guido van Rossum04691fc1992-08-12 15:35:34 +00001426#define UNARY(funcname, methodname) \
Thomas Woutersc3073522000-07-23 22:09:59 +00001427static PyObject *funcname(PyInstanceObject *self) { \
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001428 static PyObject *o; \
Guido van Rossuma412d241997-01-18 07:59:12 +00001429 if (o == NULL) o = PyString_InternFromString(methodname); \
Guido van Rossum2878a691996-08-09 20:53:24 +00001430 return generic_unary_op(self, o); \
Guido van Rossum04691fc1992-08-12 15:35:34 +00001431}
1432
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001433#define BINARY(f, m, n) \
1434static PyObject *f(PyObject *v, PyObject *w) { \
1435 return do_binop(v, w, "__" m "__", "__r" m "__", n); \
1436}
1437
1438#define BINARY_INPLACE(f, m, n) \
1439static PyObject *f(PyObject *v, PyObject *w) { \
1440 return do_binop_inplace(v, w, "__i" m "__", "__" m "__", \
1441 "__r" m "__", n); \
1442}
1443
Guido van Rossum04691fc1992-08-12 15:35:34 +00001444UNARY(instance_neg, "__neg__")
1445UNARY(instance_pos, "__pos__")
1446UNARY(instance_abs, "__abs__")
1447
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001448BINARY(instance_or, "or", PyNumber_Or)
1449BINARY(instance_and, "and", PyNumber_And)
1450BINARY(instance_xor, "xor", PyNumber_Xor)
1451BINARY(instance_lshift, "lshift", PyNumber_Lshift)
1452BINARY(instance_rshift, "rshift", PyNumber_Rshift)
1453BINARY(instance_add, "add", PyNumber_Add)
1454BINARY(instance_sub, "sub", PyNumber_Subtract)
1455BINARY(instance_mul, "mul", PyNumber_Multiply)
1456BINARY(instance_div, "div", PyNumber_Divide)
1457BINARY(instance_mod, "mod", PyNumber_Remainder)
1458BINARY(instance_divmod, "divmod", PyNumber_Divmod)
Guido van Rossum4668b002001-08-08 05:00:18 +00001459BINARY(instance_floordiv, "floordiv", PyNumber_FloorDivide)
1460BINARY(instance_truediv, "truediv", PyNumber_TrueDivide)
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001461
1462BINARY_INPLACE(instance_ior, "or", PyNumber_InPlaceOr)
1463BINARY_INPLACE(instance_ixor, "xor", PyNumber_InPlaceXor)
1464BINARY_INPLACE(instance_iand, "and", PyNumber_InPlaceAnd)
1465BINARY_INPLACE(instance_ilshift, "lshift", PyNumber_InPlaceLshift)
1466BINARY_INPLACE(instance_irshift, "rshift", PyNumber_InPlaceRshift)
1467BINARY_INPLACE(instance_iadd, "add", PyNumber_InPlaceAdd)
1468BINARY_INPLACE(instance_isub, "sub", PyNumber_InPlaceSubtract)
1469BINARY_INPLACE(instance_imul, "mul", PyNumber_InPlaceMultiply)
1470BINARY_INPLACE(instance_idiv, "div", PyNumber_InPlaceDivide)
1471BINARY_INPLACE(instance_imod, "mod", PyNumber_InPlaceRemainder)
Guido van Rossum4668b002001-08-08 05:00:18 +00001472BINARY_INPLACE(instance_ifloordiv, "floordiv", PyNumber_InPlaceFloorDivide)
1473BINARY_INPLACE(instance_itruediv, "truediv", PyNumber_InPlaceTrueDivide)
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001474
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001475/* Try a 3-way comparison, returning an int; v is an instance. Return:
1476 -2 for an exception;
1477 -1 if v < w;
1478 0 if v == w;
1479 1 if v > w;
1480 2 if this particular 3-way comparison is not implemented or undefined.
1481*/
1482static int
1483half_cmp(PyObject *v, PyObject *w)
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001484{
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001485 static PyObject *cmp_obj;
1486 PyObject *args;
Guido van Rossum3202c6f2001-01-29 23:50:25 +00001487 PyObject *cmp_func;
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001488 PyObject *result;
1489 long l;
1490
1491 assert(PyInstance_Check(v));
1492
1493 if (cmp_obj == NULL) {
1494 cmp_obj = PyString_InternFromString("__cmp__");
1495 if (cmp_obj == NULL)
1496 return -2;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001497 }
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001498
Guido van Rossum3202c6f2001-01-29 23:50:25 +00001499 cmp_func = PyObject_GetAttr(v, cmp_obj);
1500 if (cmp_func == NULL) {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001501 PyErr_Clear();
1502 return 2;
1503 }
1504
1505 args = Py_BuildValue("(O)", w);
1506 if (args == NULL)
1507 return -2;
1508
Guido van Rossum3202c6f2001-01-29 23:50:25 +00001509 result = PyEval_CallObject(cmp_func, args);
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001510 Py_DECREF(args);
Guido van Rossum3202c6f2001-01-29 23:50:25 +00001511 Py_DECREF(cmp_func);
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001512
1513 if (result == NULL)
1514 return -2;
1515
1516 if (result == Py_NotImplemented) {
1517 Py_DECREF(result);
1518 return 2;
1519 }
1520
1521 l = PyInt_AsLong(result);
1522 Py_DECREF(result);
1523 if (l == -1 && PyErr_Occurred()) {
1524 PyErr_SetString(PyExc_TypeError,
1525 "comparison did not return an int");
1526 return -2;
1527 }
1528
1529 return l < 0 ? -1 : l > 0 ? 1 : 0;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001530}
1531
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001532/* Try a 3-way comparison, returning an int; either v or w is an instance.
1533 We first try a coercion. Return:
1534 -2 for an exception;
1535 -1 if v < w;
1536 0 if v == w;
1537 1 if v > w;
1538 2 if this particular 3-way comparison is not implemented or undefined.
1539 THIS IS ONLY CALLED FROM object.c!
1540*/
1541static int
1542instance_compare(PyObject *v, PyObject *w)
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001543{
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001544 int c;
1545
1546 c = PyNumber_CoerceEx(&v, &w);
1547 if (c < 0)
1548 return -2;
1549 if (c == 0) {
1550 /* If neither is now an instance, use regular comparison */
1551 if (!PyInstance_Check(v) && !PyInstance_Check(w)) {
1552 c = PyObject_Compare(v, w);
1553 Py_DECREF(v);
1554 Py_DECREF(w);
1555 if (PyErr_Occurred())
1556 return -2;
1557 return c < 0 ? -1 : c > 0 ? 1 : 0;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001558 }
1559 }
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001560 else {
1561 /* The coercion didn't do anything.
1562 Treat this the same as returning v and w unchanged. */
1563 Py_INCREF(v);
1564 Py_INCREF(w);
1565 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001566
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001567 if (PyInstance_Check(v)) {
1568 c = half_cmp(v, w);
1569 if (c <= 1) {
1570 Py_DECREF(v);
1571 Py_DECREF(w);
1572 return c;
1573 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001574 }
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001575 if (PyInstance_Check(w)) {
1576 c = half_cmp(w, v);
1577 if (c <= 1) {
1578 Py_DECREF(v);
1579 Py_DECREF(w);
1580 if (c >= -1)
1581 c = -c;
1582 return c;
1583 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001584 }
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001585 Py_DECREF(v);
1586 Py_DECREF(w);
1587 return 2;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001588}
1589
Guido van Rossum9bfef441993-03-29 10:43:31 +00001590static int
Fred Drake79912472000-07-09 04:06:11 +00001591instance_nonzero(PyInstanceObject *self)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001592{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001593 PyObject *func, *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001594 long outcome;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001595 static PyObject *nonzerostr;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001596
Guido van Rossum2878a691996-08-09 20:53:24 +00001597 if (nonzerostr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001598 nonzerostr = PyString_InternFromString("__nonzero__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001599 if ((func = instance_getattr(self, nonzerostr)) == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001600 PyErr_Clear();
Guido van Rossum2878a691996-08-09 20:53:24 +00001601 if (lenstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001602 lenstr = PyString_InternFromString("__len__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001603 if ((func = instance_getattr(self, lenstr)) == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001604 PyErr_Clear();
Guido van Rossum04691fc1992-08-12 15:35:34 +00001605 /* Fall back to the default behavior:
1606 all instances are nonzero */
1607 return 1;
1608 }
1609 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001610 res = PyEval_CallObject(func, (PyObject *)NULL);
1611 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001612 if (res == NULL)
1613 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001614 if (!PyInt_Check(res)) {
1615 Py_DECREF(res);
1616 PyErr_SetString(PyExc_TypeError,
1617 "__nonzero__ should return an int");
Guido van Rossum04691fc1992-08-12 15:35:34 +00001618 return -1;
1619 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001620 outcome = PyInt_AsLong(res);
1621 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001622 if (outcome < 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001623 PyErr_SetString(PyExc_ValueError,
1624 "__nonzero__ should return >= 0");
Guido van Rossum04691fc1992-08-12 15:35:34 +00001625 return -1;
1626 }
1627 return outcome > 0;
1628}
1629
1630UNARY(instance_invert, "__invert__")
Guido van Rossum1899c2e1992-09-12 11:09:23 +00001631UNARY(instance_int, "__int__")
1632UNARY(instance_long, "__long__")
1633UNARY(instance_float, "__float__")
1634UNARY(instance_oct, "__oct__")
1635UNARY(instance_hex, "__hex__")
1636
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001637static PyObject *
1638bin_power(PyObject *v, PyObject *w)
1639{
1640 return PyNumber_Power(v, w, Py_None);
1641}
1642
Guido van Rossum03093a21994-09-28 15:51:32 +00001643/* This version is for ternary calls only (z != None) */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001644static PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001645instance_pow(PyObject *v, PyObject *w, PyObject *z)
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001646{
1647 if (z == Py_None) {
1648 return do_binop(v, w, "__pow__", "__rpow__", bin_power);
Guido van Rossum03093a21994-09-28 15:51:32 +00001649 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001650 else {
1651 PyObject *func;
1652 PyObject *args;
1653 PyObject *result;
1654
1655 /* XXX Doesn't do coercions... */
1656 func = PyObject_GetAttrString(v, "__pow__");
1657 if (func == NULL)
1658 return NULL;
1659 args = Py_BuildValue("(OO)", w, z);
1660 if (args == NULL) {
1661 Py_DECREF(func);
1662 return NULL;
1663 }
1664 result = PyEval_CallObject(func, args);
1665 Py_DECREF(func);
1666 Py_DECREF(args);
1667 return result;
1668 }
Guido van Rossum03093a21994-09-28 15:51:32 +00001669}
1670
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001671static PyObject *
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001672bin_inplace_power(PyObject *v, PyObject *w)
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001673{
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001674 return PyNumber_InPlacePower(v, w, Py_None);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001675}
1676
1677
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001678static PyObject *
1679instance_ipow(PyObject *v, PyObject *w, PyObject *z)
1680{
1681 if (z == Py_None) {
1682 return do_binop_inplace(v, w, "__ipow__", "__pow__",
1683 "__rpow__", bin_inplace_power);
1684 }
1685 else {
1686 /* XXX Doesn't do coercions... */
1687 PyObject *func;
1688 PyObject *args;
1689 PyObject *result;
1690
1691 func = PyObject_GetAttrString(v, "__ipow__");
1692 if (func == NULL) {
1693 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1694 return NULL;
1695 PyErr_Clear();
1696 return instance_pow(v, w, z);
1697 }
1698 args = Py_BuildValue("(OO)", w, z);
1699 if (args == NULL) {
1700 Py_DECREF(func);
1701 return NULL;
1702 }
1703 result = PyEval_CallObject(func, args);
1704 Py_DECREF(func);
1705 Py_DECREF(args);
1706 return result;
1707 }
1708}
1709
1710
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001711/* Map rich comparison operators to their __xx__ namesakes */
Jeremy Hylton1b0feb42001-05-11 14:48:41 +00001712#define NAME_OPS 6
1713static PyObject **name_op = NULL;
1714
1715static int
Guido van Rossum0ba9e3a2001-05-22 02:33:08 +00001716init_name_op(void)
Jeremy Hylton1b0feb42001-05-11 14:48:41 +00001717{
1718 int i;
1719 char *_name_op[] = {
1720 "__lt__",
1721 "__le__",
1722 "__eq__",
1723 "__ne__",
1724 "__gt__",
1725 "__ge__",
1726 };
1727
1728 name_op = (PyObject **)malloc(sizeof(PyObject *) * NAME_OPS);
1729 if (name_op == NULL)
1730 return -1;
1731 for (i = 0; i < NAME_OPS; ++i) {
1732 name_op[i] = PyString_InternFromString(_name_op[i]);
1733 if (name_op[i] == NULL)
1734 return -1;
1735 }
1736 return 0;
1737}
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001738
1739static PyObject *
1740half_richcompare(PyObject *v, PyObject *w, int op)
1741{
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001742 PyObject *method;
1743 PyObject *args;
1744 PyObject *res;
1745
1746 assert(PyInstance_Check(v));
1747
Jeremy Hylton1b0feb42001-05-11 14:48:41 +00001748 if (name_op == NULL) {
1749 if (init_name_op() < 0)
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001750 return NULL;
Jeremy Hylton1b0feb42001-05-11 14:48:41 +00001751 }
1752 /* If the instance doesn't define an __getattr__ method, use
1753 instance_getattr2 directly because it will not set an
1754 exception on failure. */
1755 if (((PyInstanceObject *)v)->in_class->cl_getattr == NULL) {
1756 method = instance_getattr2((PyInstanceObject *)v,
1757 name_op[op]);
1758 if (method == NULL) {
1759 assert(!PyErr_Occurred());
1760 res = Py_NotImplemented;
1761 Py_INCREF(res);
1762 return res;
1763 }
1764 } else {
1765 method = PyObject_GetAttr(v, name_op[op]);
1766 if (method == NULL) {
1767 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1768 return NULL;
1769 PyErr_Clear();
1770 res = Py_NotImplemented;
1771 Py_INCREF(res);
1772 return res;
1773 }
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001774 }
1775
1776 args = Py_BuildValue("(O)", w);
1777 if (args == NULL) {
1778 Py_DECREF(method);
1779 return NULL;
1780 }
1781
1782 res = PyEval_CallObject(method, args);
1783 Py_DECREF(args);
1784 Py_DECREF(method);
1785
1786 return res;
1787}
1788
1789/* Map rich comparison operators to their swapped version, e.g. LT --> GT */
1790static int swapped_op[] = {Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE};
1791
1792static PyObject *
1793instance_richcompare(PyObject *v, PyObject *w, int op)
1794{
1795 PyObject *res;
1796
1797 if (PyInstance_Check(v)) {
1798 res = half_richcompare(v, w, op);
1799 if (res != Py_NotImplemented)
1800 return res;
1801 Py_DECREF(res);
1802 }
1803
1804 if (PyInstance_Check(w)) {
1805 res = half_richcompare(w, v, swapped_op[op]);
1806 if (res != Py_NotImplemented)
1807 return res;
1808 Py_DECREF(res);
1809 }
1810
1811 Py_INCREF(Py_NotImplemented);
1812 return Py_NotImplemented;
1813}
1814
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001815
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001816/* Get the iterator */
1817static PyObject *
1818instance_getiter(PyInstanceObject *self)
1819{
1820 PyObject *func;
1821
1822 if (iterstr == NULL)
1823 iterstr = PyString_InternFromString("__iter__");
1824 if (getitemstr == NULL)
1825 getitemstr = PyString_InternFromString("__getitem__");
1826
1827 if ((func = instance_getattr(self, iterstr)) != NULL) {
1828 PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
1829 Py_DECREF(func);
Guido van Rossum213c7a62001-04-23 14:08:49 +00001830 if (res != NULL && !PyIter_Check(res)) {
1831 PyErr_Format(PyExc_TypeError,
1832 "__iter__ returned non-iterator "
1833 "of type '%.100s'",
1834 res->ob_type->tp_name);
1835 Py_DECREF(res);
1836 res = NULL;
1837 }
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001838 return res;
1839 }
1840 PyErr_Clear();
1841 if ((func = instance_getattr(self, getitemstr)) == NULL) {
1842 PyErr_SetString(PyExc_TypeError, "iter() of non-sequence");
1843 return NULL;
1844 }
1845 Py_DECREF(func);
Guido van Rossum213c7a62001-04-23 14:08:49 +00001846 return PySeqIter_New((PyObject *)self);
1847}
1848
1849
1850/* Call the iterator's next */
1851static PyObject *
1852instance_iternext(PyInstanceObject *self)
1853{
1854 PyObject *func;
1855
1856 if (nextstr == NULL)
1857 nextstr = PyString_InternFromString("next");
1858
1859 if ((func = instance_getattr(self, nextstr)) != NULL) {
1860 PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
1861 Py_DECREF(func);
1862 if (res != NULL) {
1863 return res;
1864 }
1865 if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
1866 PyErr_Clear();
1867 return NULL;
1868 }
1869 return NULL;
1870 }
1871 PyErr_SetString(PyExc_TypeError, "instance has no next() method");
1872 return NULL;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001873}
1874
Tim Peters6d6c1a32001-08-02 04:15:00 +00001875static PyObject *
1876instance_call(PyObject *func, PyObject *arg, PyObject *kw)
1877{
1878 PyObject *res, *call = PyObject_GetAttrString(func, "__call__");
1879 if (call == NULL) {
1880 PyInstanceObject *inst = (PyInstanceObject*) func;
1881 PyErr_Clear();
1882 PyErr_Format(PyExc_AttributeError,
1883 "%.200s instance has no __call__ method",
1884 PyString_AsString(inst->in_class->cl_name));
1885 return NULL;
1886 }
1887 res = PyObject_Call(call, arg, kw);
1888 Py_DECREF(call);
1889 return res;
1890}
1891
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001892
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001893static PyNumberMethods instance_as_number = {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001894 (binaryfunc)instance_add, /* nb_add */
1895 (binaryfunc)instance_sub, /* nb_subtract */
1896 (binaryfunc)instance_mul, /* nb_multiply */
1897 (binaryfunc)instance_div, /* nb_divide */
1898 (binaryfunc)instance_mod, /* nb_remainder */
1899 (binaryfunc)instance_divmod, /* nb_divmod */
1900 (ternaryfunc)instance_pow, /* nb_power */
1901 (unaryfunc)instance_neg, /* nb_negative */
1902 (unaryfunc)instance_pos, /* nb_positive */
1903 (unaryfunc)instance_abs, /* nb_absolute */
1904 (inquiry)instance_nonzero, /* nb_nonzero */
1905 (unaryfunc)instance_invert, /* nb_invert */
1906 (binaryfunc)instance_lshift, /* nb_lshift */
1907 (binaryfunc)instance_rshift, /* nb_rshift */
1908 (binaryfunc)instance_and, /* nb_and */
1909 (binaryfunc)instance_xor, /* nb_xor */
1910 (binaryfunc)instance_or, /* nb_or */
1911 (coercion)instance_coerce, /* nb_coerce */
1912 (unaryfunc)instance_int, /* nb_int */
1913 (unaryfunc)instance_long, /* nb_long */
1914 (unaryfunc)instance_float, /* nb_float */
1915 (unaryfunc)instance_oct, /* nb_oct */
1916 (unaryfunc)instance_hex, /* nb_hex */
1917 (binaryfunc)instance_iadd, /* nb_inplace_add */
1918 (binaryfunc)instance_isub, /* nb_inplace_subtract */
1919 (binaryfunc)instance_imul, /* nb_inplace_multiply */
1920 (binaryfunc)instance_idiv, /* nb_inplace_divide */
1921 (binaryfunc)instance_imod, /* nb_inplace_remainder */
1922 (ternaryfunc)instance_ipow, /* nb_inplace_power */
1923 (binaryfunc)instance_ilshift, /* nb_inplace_lshift */
1924 (binaryfunc)instance_irshift, /* nb_inplace_rshift */
1925 (binaryfunc)instance_iand, /* nb_inplace_and */
1926 (binaryfunc)instance_ixor, /* nb_inplace_xor */
1927 (binaryfunc)instance_ior, /* nb_inplace_or */
Guido van Rossum4668b002001-08-08 05:00:18 +00001928 (binaryfunc)instance_floordiv, /* nb_floor_divide */
1929 (binaryfunc)instance_truediv, /* nb_true_divide */
1930 (binaryfunc)instance_ifloordiv, /* nb_inplace_floor_divide */
1931 (binaryfunc)instance_itruediv, /* nb_inplace_true_divide */
Guido van Rossum04691fc1992-08-12 15:35:34 +00001932};
1933
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001934PyTypeObject PyInstance_Type = {
1935 PyObject_HEAD_INIT(&PyType_Type)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001936 0,
Guido van Rossum21ed88c1991-04-04 10:42:10 +00001937 "instance",
Neil Schemenauere83c00e2001-08-29 23:54:21 +00001938 sizeof(PyInstanceObject),
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001939 0,
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001940 (destructor)instance_dealloc, /* tp_dealloc */
1941 0, /* tp_print */
1942 0, /* tp_getattr */
1943 0, /* tp_setattr */
1944 instance_compare, /* tp_compare */
1945 (reprfunc)instance_repr, /* tp_repr */
1946 &instance_as_number, /* tp_as_number */
1947 &instance_as_sequence, /* tp_as_sequence */
1948 &instance_as_mapping, /* tp_as_mapping */
1949 (hashfunc)instance_hash, /* tp_hash */
Tim Peters6d6c1a32001-08-02 04:15:00 +00001950 instance_call, /* tp_call */
Guido van Rossum82c690f2001-04-30 14:39:18 +00001951 (reprfunc)instance_str, /* tp_str */
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001952 (getattrofunc)instance_getattr, /* tp_getattro */
1953 (setattrofunc)instance_setattr, /* tp_setattro */
1954 0, /* tp_as_buffer */
Neil Schemenauere83c00e2001-08-29 23:54:21 +00001955 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_CHECKTYPES,/*tp_flags*/
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001956 0, /* tp_doc */
Jeremy Hylton8caad492000-06-23 14:18:11 +00001957 (traverseproc)instance_traverse, /* tp_traverse */
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001958 0, /* tp_clear */
1959 instance_richcompare, /* tp_richcompare */
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001960 offsetof(PyInstanceObject, in_weakreflist), /* tp_weaklistoffset */
1961 (getiterfunc)instance_getiter, /* tp_iter */
Guido van Rossum213c7a62001-04-23 14:08:49 +00001962 (iternextfunc)instance_iternext, /* tp_iternext */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001963};
1964
1965
Guido van Rossum81daa321993-05-20 14:24:46 +00001966/* Instance method objects are used for two purposes:
1967 (a) as bound instance methods (returned by instancename.methodname)
1968 (b) as unbound methods (returned by ClassName.methodname)
1969 In case (b), im_self is NULL
1970*/
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001971
Guido van Rossuma0d349f1997-08-05 02:06:53 +00001972static PyMethodObject *free_list;
1973
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001974PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001975PyMethod_New(PyObject *func, PyObject *self, PyObject *class)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001976{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001977 register PyMethodObject *im;
Guido van Rossum7859f871998-07-08 14:58:16 +00001978 if (!PyCallable_Check(func)) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001979 PyErr_BadInternalCall();
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001980 return NULL;
1981 }
Guido van Rossuma0d349f1997-08-05 02:06:53 +00001982 im = free_list;
1983 if (im != NULL) {
1984 free_list = (PyMethodObject *)(im->im_self);
Guido van Rossumb18618d2000-05-03 23:44:39 +00001985 PyObject_INIT(im, &PyMethod_Type);
Guido van Rossuma0d349f1997-08-05 02:06:53 +00001986 }
1987 else {
Neil Schemenauere83c00e2001-08-29 23:54:21 +00001988 im = PyObject_GC_New(PyMethodObject, &PyMethod_Type);
Guido van Rossuma0d349f1997-08-05 02:06:53 +00001989 if (im == NULL)
1990 return NULL;
1991 }
Fred Drakedb81e8d2001-03-23 04:19:27 +00001992 im->im_weakreflist = NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001993 Py_INCREF(func);
Guido van Rossume8122f11991-05-05 20:03:07 +00001994 im->im_func = func;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001995 Py_XINCREF(self);
Guido van Rossume8122f11991-05-05 20:03:07 +00001996 im->im_self = self;
Guido van Rossumcdf0d752001-08-17 12:07:34 +00001997 Py_XINCREF(class);
Guido van Rossum81daa321993-05-20 14:24:46 +00001998 im->im_class = class;
Neil Schemenauere83c00e2001-08-29 23:54:21 +00001999 _PyObject_GC_TRACK(im);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002000 return (PyObject *)im;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002001}
2002
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002003/* Descriptors for PyMethod attributes */
2004
2005/* im_class, im_func and im_self are stored in the PyMethod object */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002006
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002007#define OFF(x) offsetof(PyMethodObject, x)
Guido van Rossum3f5da241990-12-20 15:06:42 +00002008
Guido van Rossume8122f11991-05-05 20:03:07 +00002009static struct memberlist instancemethod_memberlist[] = {
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002010 {"im_class", T_OBJECT, OFF(im_class), READONLY|RESTRICTED},
2011 {"im_func", T_OBJECT, OFF(im_func), READONLY|RESTRICTED},
2012 {"im_self", T_OBJECT, OFF(im_self), READONLY|RESTRICTED},
Guido van Rossum3f5da241990-12-20 15:06:42 +00002013 {NULL} /* Sentinel */
2014};
2015
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002016/* __dict__, __doc__ and __name__ are retrieved from im_func */
Barry Warsawd6a9e842001-01-15 20:40:19 +00002017
2018static PyObject *
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002019im_get_dict(PyMethodObject *im)
Barry Warsawd6a9e842001-01-15 20:40:19 +00002020{
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002021 return PyObject_GetAttrString(im->im_func, "__dict__");
2022}
Barry Warsawd6a9e842001-01-15 20:40:19 +00002023
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002024static PyObject *
2025im_get_doc(PyMethodObject *im)
2026{
2027 return PyObject_GetAttrString(im->im_func, "__doc__");
2028}
2029
2030static PyObject *
2031im_get_name(PyMethodObject *im)
2032{
2033 return PyObject_GetAttrString(im->im_func, "__name__");
2034}
2035
2036static struct getsetlist instancemethod_getsetlist[] = {
2037 {"__dict__", (getter)im_get_dict},
2038 {"__doc__", (getter)im_get_doc},
2039 {"__name__", (getter)im_get_name},
2040 {NULL} /* Sentinel */
2041};
2042
2043/* The getattr() implementation for PyMethod objects is similar to
2044 PyObject_GenericGetAttr(), but instead of looking in __dict__ it
2045 asks im_self for the attribute. Then the error handling is a bit
2046 different because we want to preserve the exception raised by the
2047 delegate, unless we have an alternative from our class. */
2048
2049static PyObject *
2050instancemethod_getattro(PyObject *obj, PyObject *name)
2051{
2052 PyMethodObject *im = (PyMethodObject *)obj;
2053 PyTypeObject *tp = obj->ob_type;
2054 PyObject *descr, *res;
2055 descrgetfunc f;
2056
2057 if (tp->tp_dict == NULL) {
2058 if (PyType_Ready(tp) < 0)
2059 return NULL;
Barry Warsawd6a9e842001-01-15 20:40:19 +00002060 }
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002061
2062 descr = _PyType_Lookup(tp, name);
2063 f = NULL;
2064 if (descr != NULL) {
2065 f = descr->ob_type->tp_descr_get;
2066 if (f != NULL && PyDescr_IsData(descr))
2067 return f(descr, obj, (PyObject *)obj->ob_type);
2068 }
2069
2070 res = PyObject_GetAttr(im->im_func, name);
2071 if (res != NULL || !PyErr_ExceptionMatches(PyExc_AttributeError))
2072 return res;
2073
2074 if (f != NULL) {
2075 PyErr_Clear();
2076 return f(descr, obj, (PyObject *)obj->ob_type);
2077 }
2078
2079 if (descr != NULL) {
2080 PyErr_Clear();
2081 Py_INCREF(descr);
2082 return descr;
2083 }
2084
2085 assert(PyErr_Occurred());
2086 return NULL;
Guido van Rossum3f5da241990-12-20 15:06:42 +00002087}
2088
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002089static void
Fred Drake79912472000-07-09 04:06:11 +00002090instancemethod_dealloc(register PyMethodObject *im)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002091{
Neil Schemenauere83c00e2001-08-29 23:54:21 +00002092 _PyObject_GC_UNTRACK(im);
Fred Drakedb81e8d2001-03-23 04:19:27 +00002093 PyObject_ClearWeakRefs((PyObject *)im);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002094 Py_DECREF(im->im_func);
2095 Py_XDECREF(im->im_self);
Guido van Rossumcdf0d752001-08-17 12:07:34 +00002096 Py_XDECREF(im->im_class);
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002097 im->im_self = (PyObject *)free_list;
2098 free_list = im;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002099}
2100
Guido van Rossumebc8c511992-09-03 20:39:51 +00002101static int
Fred Drake79912472000-07-09 04:06:11 +00002102instancemethod_compare(PyMethodObject *a, PyMethodObject *b)
Guido van Rossumebc8c511992-09-03 20:39:51 +00002103{
Guido van Rossume9df7271995-04-06 14:46:51 +00002104 if (a->im_self != b->im_self)
2105 return (a->im_self < b->im_self) ? -1 : 1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002106 return PyObject_Compare(a->im_func, b->im_func);
Guido van Rossumebc8c511992-09-03 20:39:51 +00002107}
2108
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002109static PyObject *
Fred Drake79912472000-07-09 04:06:11 +00002110instancemethod_repr(PyMethodObject *a)
Guido van Rossum25831651993-05-19 14:50:45 +00002111{
Tim Peters6d6c1a32001-08-02 04:15:00 +00002112 PyObject *self = a->im_self;
Guido van Rossum7859f871998-07-08 14:58:16 +00002113 PyObject *func = a->im_func;
Tim Peters6d6c1a32001-08-02 04:15:00 +00002114 PyObject *klass = a->im_class;
2115 PyObject *funcname = NULL, *klassname = NULL, *result = NULL;
2116 char *sfuncname = "?", *sklassname = "?";
2117
2118 funcname = PyObject_GetAttrString(func, "__name__");
2119 if (funcname == NULL)
2120 PyErr_Clear();
2121 else if (!PyString_Check(funcname)) {
2122 Py_DECREF(funcname);
2123 funcname = NULL;
Guido van Rossum7859f871998-07-08 14:58:16 +00002124 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00002125 else
2126 sfuncname = PyString_AS_STRING(funcname);
Guido van Rossum40667692001-08-17 13:59:27 +00002127 if (klass == NULL)
Tim Peters6d6c1a32001-08-02 04:15:00 +00002128 klassname = NULL;
Guido van Rossum40667692001-08-17 13:59:27 +00002129 else {
2130 klassname = PyObject_GetAttrString(klass, "__name__");
2131 if (klassname == NULL)
2132 PyErr_Clear();
2133 else if (!PyString_Check(klassname)) {
2134 Py_DECREF(klassname);
2135 klassname = NULL;
2136 }
2137 else
2138 sklassname = PyString_AS_STRING(klassname);
Guido van Rossum7859f871998-07-08 14:58:16 +00002139 }
Guido van Rossum81daa321993-05-20 14:24:46 +00002140 if (self == NULL)
Barry Warsaw7ce36942001-08-24 18:34:26 +00002141 result = PyString_FromFormat("<unbound method %s.%s>",
2142 sklassname, sfuncname);
Guido van Rossum81daa321993-05-20 14:24:46 +00002143 else {
Tim Peters6d6c1a32001-08-02 04:15:00 +00002144 /* XXX Shouldn't use repr() here! */
2145 PyObject *selfrepr = PyObject_Repr(self);
2146 if (selfrepr == NULL)
2147 goto fail;
2148 if (!PyString_Check(selfrepr)) {
2149 Py_DECREF(selfrepr);
2150 goto fail;
2151 }
Barry Warsaw7ce36942001-08-24 18:34:26 +00002152 result = PyString_FromFormat("<bound method %s.%s of %s>",
2153 sklassname, sfuncname,
2154 PyString_AS_STRING(selfrepr));
Tim Peters6d6c1a32001-08-02 04:15:00 +00002155 Py_DECREF(selfrepr);
Guido van Rossum81daa321993-05-20 14:24:46 +00002156 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00002157 fail:
Guido van Rossum42636dc1999-10-11 14:03:12 +00002158 Py_XDECREF(funcname);
Tim Peters6d6c1a32001-08-02 04:15:00 +00002159 Py_XDECREF(klassname);
2160 return result;
Guido van Rossum25831651993-05-19 14:50:45 +00002161}
2162
Guido van Rossum9bfef441993-03-29 10:43:31 +00002163static long
Fred Drake79912472000-07-09 04:06:11 +00002164instancemethod_hash(PyMethodObject *a)
Guido van Rossum9bfef441993-03-29 10:43:31 +00002165{
2166 long x, y;
Guido van Rossum81daa321993-05-20 14:24:46 +00002167 if (a->im_self == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002168 x = PyObject_Hash(Py_None);
Guido van Rossum81daa321993-05-20 14:24:46 +00002169 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002170 x = PyObject_Hash(a->im_self);
Guido van Rossum9bfef441993-03-29 10:43:31 +00002171 if (x == -1)
2172 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002173 y = PyObject_Hash(a->im_func);
Guido van Rossum9bfef441993-03-29 10:43:31 +00002174 if (y == -1)
2175 return -1;
2176 return x ^ y;
2177}
2178
Jeremy Hylton8caad492000-06-23 14:18:11 +00002179static int
2180instancemethod_traverse(PyMethodObject *im, visitproc visit, void *arg)
2181{
2182 int err;
2183 if (im->im_func) {
2184 err = visit(im->im_func, arg);
2185 if (err)
2186 return err;
2187 }
2188 if (im->im_self) {
2189 err = visit(im->im_self, arg);
2190 if (err)
2191 return err;
2192 }
2193 if (im->im_class) {
2194 err = visit(im->im_class, arg);
2195 if (err)
2196 return err;
2197 }
Jeremy Hyltond22162b2000-06-23 17:14:56 +00002198 return 0;
Jeremy Hylton8caad492000-06-23 14:18:11 +00002199}
2200
Guido van Rossuma15dece2001-08-24 18:48:27 +00002201static char *
2202getclassname(PyObject *class)
2203{
2204 PyObject *name;
2205
2206 if (class == NULL)
2207 name = NULL;
2208 else
2209 name = PyObject_GetAttrString(class, "__name__");
2210 if (name == NULL) {
2211 PyErr_Clear();
2212 return "?";
2213 }
2214 if (!PyString_Check(name)) {
2215 Py_DECREF(name);
2216 return "?";
2217 }
2218 PyString_InternInPlace(&name);
2219 Py_DECREF(name);
2220 return PyString_AS_STRING(name);
2221}
2222
2223static char *
2224getinstclassname(PyObject *inst)
2225{
2226 PyObject *class;
2227 char *name;
2228
2229 if (inst == NULL)
2230 return "nothing";
2231
2232 class = PyObject_GetAttrString(inst, "__class__");
2233 if (class == NULL) {
2234 PyErr_Clear();
2235 class = (PyObject *)(inst->ob_type);
2236 Py_INCREF(class);
2237 }
2238 name = getclassname(class);
2239 Py_XDECREF(class);
2240 return name;
2241}
2242
Tim Peters6d6c1a32001-08-02 04:15:00 +00002243static PyObject *
2244instancemethod_call(PyObject *func, PyObject *arg, PyObject *kw)
2245{
2246 PyObject *self = PyMethod_GET_SELF(func);
2247 PyObject *class = PyMethod_GET_CLASS(func);
2248 PyObject *result;
2249
2250 func = PyMethod_GET_FUNCTION(func);
2251 if (self == NULL) {
2252 /* Unbound methods must be called with an instance of
2253 the class (or a derived class) as first argument */
2254 int ok;
2255 if (PyTuple_Size(arg) >= 1)
2256 self = PyTuple_GET_ITEM(arg, 0);
2257 if (self == NULL)
2258 ok = 0;
2259 else {
2260 ok = PyObject_IsInstance(self, class);
2261 if (ok < 0)
2262 return NULL;
2263 }
2264 if (!ok) {
2265 PyErr_Format(PyExc_TypeError,
Guido van Rossuma15dece2001-08-24 18:48:27 +00002266 "unbound method %s%s must be called with "
2267 "%s instance as first argument "
2268 "(got %s%s instead)",
Tim Peters6d6c1a32001-08-02 04:15:00 +00002269 PyEval_GetFuncName(func),
Guido van Rossuma15dece2001-08-24 18:48:27 +00002270 PyEval_GetFuncDesc(func),
2271 getclassname(class),
2272 getinstclassname(self),
2273 self == NULL ? "" : " instance");
Tim Peters6d6c1a32001-08-02 04:15:00 +00002274 return NULL;
2275 }
2276 Py_INCREF(arg);
2277 }
2278 else {
2279 int argcount = PyTuple_Size(arg);
2280 PyObject *newarg = PyTuple_New(argcount + 1);
2281 int i;
2282 if (newarg == NULL)
2283 return NULL;
2284 Py_INCREF(self);
2285 PyTuple_SET_ITEM(newarg, 0, self);
2286 for (i = 0; i < argcount; i++) {
2287 PyObject *v = PyTuple_GET_ITEM(arg, i);
2288 Py_XINCREF(v);
2289 PyTuple_SET_ITEM(newarg, i+1, v);
2290 }
2291 arg = newarg;
2292 }
2293 result = PyObject_Call((PyObject *)func, arg, kw);
2294 Py_DECREF(arg);
2295 return result;
2296}
2297
Guido van Rossum23cc2b42001-08-15 17:52:31 +00002298static PyObject *
Guido van Rossumf23c41d2001-08-17 13:43:27 +00002299instancemethod_descr_get(PyObject *meth, PyObject *obj, PyObject *class)
Guido van Rossum23cc2b42001-08-15 17:52:31 +00002300{
Guido van Rossumf23c41d2001-08-17 13:43:27 +00002301 /* Don't rebind an already bound method, or an unbound method
2302 of a class that's not a base class of class */
2303 if (PyMethod_GET_SELF(meth) != NULL ||
2304 (PyMethod_GET_CLASS(meth) != NULL &&
2305 !PyObject_IsSubclass(class, PyMethod_GET_CLASS(meth)))) {
Guido van Rossum501c7c72001-08-16 20:41:56 +00002306 Py_INCREF(meth);
2307 return meth;
2308 }
Guido van Rossum23cc2b42001-08-15 17:52:31 +00002309 if (obj == Py_None)
2310 obj = NULL;
Guido van Rossumf23c41d2001-08-17 13:43:27 +00002311 return PyMethod_New(PyMethod_GET_FUNCTION(meth), obj, class);
Guido van Rossum23cc2b42001-08-15 17:52:31 +00002312}
2313
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002314PyTypeObject PyMethod_Type = {
2315 PyObject_HEAD_INIT(&PyType_Type)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002316 0,
Guido van Rossum569fce71991-04-16 08:38:43 +00002317 "instance method",
Neil Schemenauere83c00e2001-08-29 23:54:21 +00002318 sizeof(PyMethodObject),
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002319 0,
Guido van Rossum8998b4f2001-01-17 15:28:20 +00002320 (destructor)instancemethod_dealloc, /* tp_dealloc */
2321 0, /* tp_print */
2322 0, /* tp_getattr */
2323 0, /* tp_setattr */
2324 (cmpfunc)instancemethod_compare, /* tp_compare */
2325 (reprfunc)instancemethod_repr, /* tp_repr */
2326 0, /* tp_as_number */
2327 0, /* tp_as_sequence */
2328 0, /* tp_as_mapping */
2329 (hashfunc)instancemethod_hash, /* tp_hash */
Tim Peters6d6c1a32001-08-02 04:15:00 +00002330 instancemethod_call, /* tp_call */
Guido van Rossum8998b4f2001-01-17 15:28:20 +00002331 0, /* tp_str */
2332 (getattrofunc)instancemethod_getattro, /* tp_getattro */
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002333 PyObject_GenericSetAttr, /* tp_setattro */
Guido van Rossum8998b4f2001-01-17 15:28:20 +00002334 0, /* tp_as_buffer */
Neil Schemenauere83c00e2001-08-29 23:54:21 +00002335 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
Guido van Rossum8998b4f2001-01-17 15:28:20 +00002336 0, /* tp_doc */
Jeremy Hylton8caad492000-06-23 14:18:11 +00002337 (traverseproc)instancemethod_traverse, /* tp_traverse */
Fred Drakedb81e8d2001-03-23 04:19:27 +00002338 0, /* tp_clear */
2339 0, /* tp_richcompare */
Guido van Rossum23cc2b42001-08-15 17:52:31 +00002340 offsetof(PyMethodObject, im_weakreflist), /* tp_weaklistoffset */
2341 0, /* tp_iter */
2342 0, /* tp_iternext */
2343 0, /* tp_methods */
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002344 instancemethod_memberlist, /* tp_members */
2345 instancemethod_getsetlist, /* tp_getset */
Guido van Rossum23cc2b42001-08-15 17:52:31 +00002346 0, /* tp_base */
2347 0, /* tp_dict */
2348 instancemethod_descr_get, /* tp_descr_get */
2349 0, /* tp_descr_set */
2350 0, /* tp_dictoffset */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002351};
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002352
2353/* Clear out the free list */
2354
2355void
Fred Drake79912472000-07-09 04:06:11 +00002356PyMethod_Fini(void)
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002357{
2358 while (free_list) {
Guido van Rossumb18618d2000-05-03 23:44:39 +00002359 PyMethodObject *im = free_list;
2360 free_list = (PyMethodObject *)(im->im_self);
Neil Schemenauere83c00e2001-08-29 23:54:21 +00002361 PyObject_GC_Del(im);
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002362 }
2363}