blob: 1033ab67f8945a6a3b88749229893bedc543266b [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
Guido van Rossum915f0eb2001-10-17 20:26:38 +00007#define TP_DESCR_GET(t) \
8 (PyType_HasFeature(t, Py_TPFLAGS_HAVE_CLASS) ? (t)->tp_descr_get : NULL)
9
Neil Schemenauer29bfc072001-01-04 01:43:46 +000010
Guido van Rossum52ca98a1994-09-05 07:32:29 +000011/* Forward */
Tim Petersdbd9ba62000-07-09 03:09:57 +000012static PyObject *class_lookup(PyClassObject *, PyObject *,
13 PyClassObject **);
14static PyObject *instance_getattr1(PyInstanceObject *, PyObject *);
15static PyObject *instance_getattr2(PyInstanceObject *, PyObject *);
Guido van Rossum52ca98a1994-09-05 07:32:29 +000016
Guido van Rossuma63eff61998-05-29 21:37:21 +000017static PyObject *getattrstr, *setattrstr, *delattrstr;
18
Fred Drake79912472000-07-09 04:06:11 +000019
Guido van Rossumc0b618a1997-05-02 03:12:38 +000020PyObject *
Fred Drake79912472000-07-09 04:06:11 +000021PyClass_New(PyObject *bases, PyObject *dict, PyObject *name)
22 /* bases is NULL or tuple of classobjects! */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000023{
Guido van Rossumc0b618a1997-05-02 03:12:38 +000024 PyClassObject *op, *dummy;
Guido van Rossum7cc56eb1997-09-12 20:04:46 +000025 static PyObject *docstr, *modstr, *namestr;
Guido van Rossum019f4241996-08-21 14:54:28 +000026 if (docstr == NULL) {
Guido van Rossuma412d241997-01-18 07:59:12 +000027 docstr= PyString_InternFromString("__doc__");
Guido van Rossum019f4241996-08-21 14:54:28 +000028 if (docstr == NULL)
29 return NULL;
30 }
Guido van Rossum7cc56eb1997-09-12 20:04:46 +000031 if (modstr == NULL) {
32 modstr= PyString_InternFromString("__module__");
33 if (modstr == NULL)
34 return NULL;
35 }
36 if (namestr == NULL) {
37 namestr= PyString_InternFromString("__name__");
38 if (namestr == NULL)
39 return NULL;
40 }
Guido van Rossum04d73c41997-10-07 14:54:11 +000041 if (name == NULL || !PyString_Check(name)) {
Tim Peters6d6c1a32001-08-02 04:15:00 +000042 PyErr_SetString(PyExc_TypeError,
Guido van Rossum04d73c41997-10-07 14:54:11 +000043 "PyClass_New: name must be a string");
44 return NULL;
45 }
46 if (dict == NULL || !PyDict_Check(dict)) {
Tim Peters6d6c1a32001-08-02 04:15:00 +000047 PyErr_SetString(PyExc_TypeError,
Guido van Rossum04d73c41997-10-07 14:54:11 +000048 "PyClass_New: dict must be a dictionary");
49 return NULL;
50 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +000051 if (PyDict_GetItem(dict, docstr) == NULL) {
52 if (PyDict_SetItem(dict, docstr, Py_None) < 0)
Guido van Rossume7d444f1995-01-07 12:35:18 +000053 return NULL;
54 }
Guido van Rossum7cc56eb1997-09-12 20:04:46 +000055 if (PyDict_GetItem(dict, modstr) == NULL) {
56 PyObject *globals = PyEval_GetGlobals();
57 if (globals != NULL) {
Guido van Rossum04d73c41997-10-07 14:54:11 +000058 PyObject *modname = PyDict_GetItem(globals, namestr);
59 if (modname != NULL) {
60 if (PyDict_SetItem(dict, modstr, modname) < 0)
Guido van Rossum7cc56eb1997-09-12 20:04:46 +000061 return NULL;
62 }
63 }
64 }
Guido van Rossume2966a61991-12-10 13:53:23 +000065 if (bases == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +000066 bases = PyTuple_New(0);
Guido van Rossume2966a61991-12-10 13:53:23 +000067 if (bases == NULL)
Guido van Rossume5372401993-03-16 12:15:04 +000068 return NULL;
Guido van Rossume2966a61991-12-10 13:53:23 +000069 }
Guido van Rossum04d73c41997-10-07 14:54:11 +000070 else {
Guido van Rossum28d80b12001-09-07 21:08:32 +000071 int i, n;
72 PyObject *base;
Guido van Rossum04d73c41997-10-07 14:54:11 +000073 if (!PyTuple_Check(bases)) {
Tim Peters6d6c1a32001-08-02 04:15:00 +000074 PyErr_SetString(PyExc_TypeError,
Guido van Rossum04d73c41997-10-07 14:54:11 +000075 "PyClass_New: bases must be a tuple");
76 return NULL;
77 }
Guido van Rossum28d80b12001-09-07 21:08:32 +000078 n = PyTuple_Size(bases);
79 for (i = 0; i < n; i++) {
80 base = PyTuple_GET_ITEM(bases, i);
81 if (!PyClass_Check(base)) {
82 if (PyCallable_Check(
83 (PyObject *) base->ob_type))
84 return PyObject_CallFunction(
85 (PyObject *) base->ob_type,
86 "OOO",
87 name,
88 bases,
89 dict);
Tim Peters6d6c1a32001-08-02 04:15:00 +000090 PyErr_SetString(PyExc_TypeError,
Guido van Rossum04d73c41997-10-07 14:54:11 +000091 "PyClass_New: base must be a class");
92 return NULL;
93 }
94 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +000095 Py_INCREF(bases);
Guido van Rossum04d73c41997-10-07 14:54:11 +000096 }
Neil Schemenauere83c00e2001-08-29 23:54:21 +000097 op = PyObject_GC_New(PyClassObject, &PyClass_Type);
Guido van Rossume2966a61991-12-10 13:53:23 +000098 if (op == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +000099 Py_DECREF(bases);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000100 return NULL;
Guido van Rossume2966a61991-12-10 13:53:23 +0000101 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000102 op->cl_bases = bases;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000103 Py_INCREF(dict);
Guido van Rossum81daa321993-05-20 14:24:46 +0000104 op->cl_dict = dict;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000105 Py_XINCREF(name);
Guido van Rossum94308391991-10-20 20:11:48 +0000106 op->cl_name = name;
Guido van Rossum2878a691996-08-09 20:53:24 +0000107 if (getattrstr == NULL) {
Guido van Rossuma412d241997-01-18 07:59:12 +0000108 getattrstr = PyString_InternFromString("__getattr__");
109 setattrstr = PyString_InternFromString("__setattr__");
110 delattrstr = PyString_InternFromString("__delattr__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000111 }
112 op->cl_getattr = class_lookup(op, getattrstr, &dummy);
113 op->cl_setattr = class_lookup(op, setattrstr, &dummy);
114 op->cl_delattr = class_lookup(op, delattrstr, &dummy);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000115 Py_XINCREF(op->cl_getattr);
116 Py_XINCREF(op->cl_setattr);
117 Py_XINCREF(op->cl_delattr);
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000118 _PyObject_GC_TRACK(op);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000119 return (PyObject *) op;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000120}
121
Guido van Rossumb479dc52001-09-05 22:52:50 +0000122PyObject *
123PyMethod_Function(PyObject *im)
124{
125 if (!PyMethod_Check(im)) {
126 PyErr_BadInternalCall();
127 return NULL;
128 }
129 return ((PyMethodObject *)im)->im_func;
130}
131
132PyObject *
133PyMethod_Self(PyObject *im)
134{
135 if (!PyMethod_Check(im)) {
136 PyErr_BadInternalCall();
137 return NULL;
138 }
139 return ((PyMethodObject *)im)->im_self;
140}
141
142PyObject *
143PyMethod_Class(PyObject *im)
144{
145 if (!PyMethod_Check(im)) {
146 PyErr_BadInternalCall();
147 return NULL;
148 }
149 return ((PyMethodObject *)im)->im_class;
150}
151
Tim Peters6d6c1a32001-08-02 04:15:00 +0000152static PyObject *
153class_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
154{
155 PyObject *name, *bases, *dict;
156 static char *kwlist[] = {"name", "bases", "dict", 0};
157
158 if (!PyArg_ParseTupleAndKeywords(args, kwds, "SOO", kwlist,
159 &name, &bases, &dict))
160 return NULL;
161 return PyClass_New(bases, dict, name);
162}
163
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000164/* Class methods */
165
166static void
Fred Drake79912472000-07-09 04:06:11 +0000167class_dealloc(PyClassObject *op)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000168{
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000169 _PyObject_GC_UNTRACK(op);
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000170 Py_DECREF(op->cl_bases);
171 Py_DECREF(op->cl_dict);
172 Py_XDECREF(op->cl_name);
Guido van Rossum152d8171998-08-04 14:59:16 +0000173 Py_XDECREF(op->cl_getattr);
174 Py_XDECREF(op->cl_setattr);
175 Py_XDECREF(op->cl_delattr);
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000176 PyObject_GC_Del(op);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000177}
178
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000179static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000180class_lookup(PyClassObject *cp, PyObject *name, PyClassObject **pclass)
Guido van Rossum81daa321993-05-20 14:24:46 +0000181{
182 int i, n;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000183 PyObject *value = PyDict_GetItem(cp->cl_dict, name);
Guido van Rossum81daa321993-05-20 14:24:46 +0000184 if (value != NULL) {
185 *pclass = cp;
186 return value;
187 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000188 n = PyTuple_Size(cp->cl_bases);
Guido van Rossum81daa321993-05-20 14:24:46 +0000189 for (i = 0; i < n; i++) {
Guido van Rossum7cc56eb1997-09-12 20:04:46 +0000190 /* XXX What if one of the bases is not a class? */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000191 PyObject *v = class_lookup(
192 (PyClassObject *)
193 PyTuple_GetItem(cp->cl_bases, i), name, pclass);
Guido van Rossum81daa321993-05-20 14:24:46 +0000194 if (v != NULL)
195 return v;
196 }
197 return NULL;
198}
199
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000200static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000201class_getattr(register PyClassObject *op, PyObject *name)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000202{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000203 register PyObject *v;
204 register char *sname = PyString_AsString(name);
205 PyClassObject *class;
Tim Peters6d6c1a32001-08-02 04:15:00 +0000206 descrgetfunc f;
207
Guido van Rossum2878a691996-08-09 20:53:24 +0000208 if (sname[0] == '_' && sname[1] == '_') {
209 if (strcmp(sname, "__dict__") == 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000210 if (PyEval_GetRestricted()) {
211 PyErr_SetString(PyExc_RuntimeError,
212 "class.__dict__ not accessible in restricted mode");
Guido van Rossum10393b11995-01-10 10:39:49 +0000213 return NULL;
214 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000215 Py_INCREF(op->cl_dict);
Guido van Rossum10393b11995-01-10 10:39:49 +0000216 return op->cl_dict;
217 }
Guido van Rossum2878a691996-08-09 20:53:24 +0000218 if (strcmp(sname, "__bases__") == 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000219 Py_INCREF(op->cl_bases);
Guido van Rossum10393b11995-01-10 10:39:49 +0000220 return op->cl_bases;
221 }
Guido van Rossum2878a691996-08-09 20:53:24 +0000222 if (strcmp(sname, "__name__") == 0) {
Guido van Rossum10393b11995-01-10 10:39:49 +0000223 if (op->cl_name == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000224 v = Py_None;
Guido van Rossum10393b11995-01-10 10:39:49 +0000225 else
226 v = op->cl_name;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000227 Py_INCREF(v);
Guido van Rossum10393b11995-01-10 10:39:49 +0000228 return v;
229 }
Guido van Rossum94308391991-10-20 20:11:48 +0000230 }
Guido van Rossum81daa321993-05-20 14:24:46 +0000231 v = class_lookup(op, name, &class);
Guido van Rossumb3f72581993-05-21 19:56:10 +0000232 if (v == NULL) {
Fred Drake661ea262000-10-24 19:57:45 +0000233 PyErr_Format(PyExc_AttributeError,
234 "class %.50s has no attribute '%.400s'",
235 PyString_AS_STRING(op->cl_name), sname);
Guido van Rossumb3f72581993-05-21 19:56:10 +0000236 return NULL;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000237 }
Guido van Rossum915f0eb2001-10-17 20:26:38 +0000238 f = TP_DESCR_GET(v->ob_type);
Tim Peters6d6c1a32001-08-02 04:15:00 +0000239 if (f == NULL)
240 Py_INCREF(v);
241 else
242 v = f(v, (PyObject *)NULL, (PyObject *)op);
Guido van Rossumb3f72581993-05-21 19:56:10 +0000243 return v;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000244}
245
Guido van Rossuma63eff61998-05-29 21:37:21 +0000246static void
Fred Drake79912472000-07-09 04:06:11 +0000247set_slot(PyObject **slot, PyObject *v)
Guido van Rossuma63eff61998-05-29 21:37:21 +0000248{
249 PyObject *temp = *slot;
250 Py_XINCREF(v);
251 *slot = v;
252 Py_XDECREF(temp);
253}
254
Guido van Rossum7ba30431998-07-08 13:34:48 +0000255static void
Fred Drake79912472000-07-09 04:06:11 +0000256set_attr_slots(PyClassObject *c)
Guido van Rossum7ba30431998-07-08 13:34:48 +0000257{
258 PyClassObject *dummy;
259
260 set_slot(&c->cl_getattr, class_lookup(c, getattrstr, &dummy));
261 set_slot(&c->cl_setattr, class_lookup(c, setattrstr, &dummy));
262 set_slot(&c->cl_delattr, class_lookup(c, delattrstr, &dummy));
263}
264
Guido van Rossuma63eff61998-05-29 21:37:21 +0000265static char *
Fred Drake79912472000-07-09 04:06:11 +0000266set_dict(PyClassObject *c, PyObject *v)
Guido van Rossuma63eff61998-05-29 21:37:21 +0000267{
Guido van Rossuma63eff61998-05-29 21:37:21 +0000268 if (v == NULL || !PyDict_Check(v))
269 return "__dict__ must be a dictionary object";
270 set_slot(&c->cl_dict, v);
Guido van Rossum7ba30431998-07-08 13:34:48 +0000271 set_attr_slots(c);
Guido van Rossuma63eff61998-05-29 21:37:21 +0000272 return "";
273}
274
275static char *
Fred Drake79912472000-07-09 04:06:11 +0000276set_bases(PyClassObject *c, PyObject *v)
Guido van Rossuma63eff61998-05-29 21:37:21 +0000277{
Guido van Rossuma63eff61998-05-29 21:37:21 +0000278 int i, n;
279
280 if (v == NULL || !PyTuple_Check(v))
281 return "__bases__ must be a tuple object";
282 n = PyTuple_Size(v);
283 for (i = 0; i < n; i++) {
284 PyObject *x = PyTuple_GET_ITEM(v, i);
285 if (!PyClass_Check(x))
286 return "__bases__ items must be classes";
287 if (PyClass_IsSubclass(x, (PyObject *)c))
288 return "a __bases__ item causes an inheritance cycle";
289 }
290 set_slot(&c->cl_bases, v);
Guido van Rossum7ba30431998-07-08 13:34:48 +0000291 set_attr_slots(c);
Guido van Rossuma63eff61998-05-29 21:37:21 +0000292 return "";
293}
294
295static char *
Fred Drake79912472000-07-09 04:06:11 +0000296set_name(PyClassObject *c, PyObject *v)
Guido van Rossuma63eff61998-05-29 21:37:21 +0000297{
Guido van Rossuma63eff61998-05-29 21:37:21 +0000298 if (v == NULL || !PyString_Check(v))
299 return "__name__ must be a string object";
Guido van Rossumad89bbc2000-06-28 21:57:18 +0000300 if (strlen(PyString_AS_STRING(v)) != (size_t)PyString_GET_SIZE(v))
Guido van Rossuma63eff61998-05-29 21:37:21 +0000301 return "__name__ must not contain null bytes";
302 set_slot(&c->cl_name, v);
303 return "";
304}
305
Guido van Rossum94308391991-10-20 20:11:48 +0000306static int
Fred Drake79912472000-07-09 04:06:11 +0000307class_setattr(PyClassObject *op, PyObject *name, PyObject *v)
Guido van Rossum94308391991-10-20 20:11:48 +0000308{
Guido van Rossumb2173c31997-08-25 21:23:56 +0000309 char *sname;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000310 if (PyEval_GetRestricted()) {
311 PyErr_SetString(PyExc_RuntimeError,
Guido van Rossumac21f6a1995-08-04 04:05:31 +0000312 "classes are read-only in restricted mode");
313 return -1;
314 }
Guido van Rossumb2173c31997-08-25 21:23:56 +0000315 sname = PyString_AsString(name);
316 if (sname[0] == '_' && sname[1] == '_') {
317 int n = PyString_Size(name);
318 if (sname[n-1] == '_' && sname[n-2] == '_') {
Guido van Rossuma63eff61998-05-29 21:37:21 +0000319 char *err = NULL;
320 if (strcmp(sname, "__dict__") == 0)
321 err = set_dict(op, v);
322 else if (strcmp(sname, "__bases__") == 0)
323 err = set_bases(op, v);
324 else if (strcmp(sname, "__name__") == 0)
325 err = set_name(op, v);
326 else if (strcmp(sname, "__getattr__") == 0)
327 set_slot(&op->cl_getattr, v);
328 else if (strcmp(sname, "__setattr__") == 0)
329 set_slot(&op->cl_setattr, v);
330 else if (strcmp(sname, "__delattr__") == 0)
331 set_slot(&op->cl_delattr, v);
332 /* For the last three, we fall through to update the
333 dictionary as well. */
334 if (err != NULL) {
335 if (*err == '\0')
336 return 0;
337 PyErr_SetString(PyExc_TypeError, err);
Guido van Rossumb2173c31997-08-25 21:23:56 +0000338 return -1;
339 }
340 }
341 }
Guido van Rossum94472a01992-09-04 09:45:18 +0000342 if (v == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000343 int rv = PyDict_DelItem(op->cl_dict, name);
Guido van Rossum94472a01992-09-04 09:45:18 +0000344 if (rv < 0)
Fred Drake661ea262000-10-24 19:57:45 +0000345 PyErr_Format(PyExc_AttributeError,
346 "class %.50s has no attribute '%.400s'",
347 PyString_AS_STRING(op->cl_name), sname);
Guido van Rossum94472a01992-09-04 09:45:18 +0000348 return rv;
349 }
Guido van Rossum94308391991-10-20 20:11:48 +0000350 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000351 return PyDict_SetItem(op->cl_dict, name, v);
Guido van Rossum94308391991-10-20 20:11:48 +0000352}
353
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000354static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000355class_repr(PyClassObject *op)
Guido van Rossum25831651993-05-19 14:50:45 +0000356{
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000357 PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
Guido van Rossum25831651993-05-19 14:50:45 +0000358 char *name;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000359 if (op->cl_name == NULL || !PyString_Check(op->cl_name))
Guido van Rossum25831651993-05-19 14:50:45 +0000360 name = "?";
361 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000362 name = PyString_AsString(op->cl_name);
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000363 if (mod == NULL || !PyString_Check(mod))
Martin v. Löwiscf95f9c2001-09-18 20:23:28 +0000364 return PyString_FromFormat("<class ?.%s at %p>", name, op);
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000365 else
Barry Warsaw7ce36942001-08-24 18:34:26 +0000366 return PyString_FromFormat("<class %s.%s at %p>",
367 PyString_AsString(mod),
368 name, op);
Guido van Rossum25831651993-05-19 14:50:45 +0000369}
370
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000371static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000372class_str(PyClassObject *op)
Guido van Rossum4a2a6211997-10-20 23:26:11 +0000373{
374 PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
375 PyObject *name = op->cl_name;
376 PyObject *res;
377 int m, n;
378
379 if (name == NULL || !PyString_Check(name))
380 return class_repr(op);
381 if (mod == NULL || !PyString_Check(mod)) {
382 Py_INCREF(name);
383 return name;
384 }
385 m = PyString_Size(mod);
386 n = PyString_Size(name);
387 res = PyString_FromStringAndSize((char *)NULL, m+1+n);
388 if (res != NULL) {
389 char *s = PyString_AsString(res);
390 memcpy(s, PyString_AsString(mod), m);
391 s += m;
392 *s++ = '.';
393 memcpy(s, PyString_AsString(name), n);
394 }
395 return res;
396}
397
Jeremy Hylton8caad492000-06-23 14:18:11 +0000398static int
399class_traverse(PyClassObject *o, visitproc visit, void *arg)
400{
401 int err;
402 if (o->cl_bases) {
403 err = visit(o->cl_bases, arg);
404 if (err)
405 return err;
406 }
407 if (o->cl_dict) {
408 err = visit(o->cl_dict, arg);
409 if (err)
410 return err;
411 }
412 if (o->cl_name) {
413 err = visit(o->cl_name, arg);
414 if (err)
415 return err;
416 }
417 if (o->cl_getattr) {
418 err = visit(o->cl_getattr, arg);
419 if (err)
420 return err;
421 }
422 if (o->cl_setattr) {
423 err = visit(o->cl_setattr, arg);
424 if (err)
425 return err;
426 }
427 if (o->cl_delattr) {
428 err = visit(o->cl_delattr, arg);
429 if (err)
430 return err;
431 }
432 return 0;
433}
434
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000435PyTypeObject PyClass_Type = {
436 PyObject_HEAD_INIT(&PyType_Type)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000437 0,
438 "class",
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000439 sizeof(PyClassObject),
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000440 0,
Guido van Rossum8998b4f2001-01-17 15:28:20 +0000441 (destructor)class_dealloc, /* tp_dealloc */
442 0, /* tp_print */
443 0, /* tp_getattr */
444 0, /* tp_setattr */
445 0, /* tp_compare */
446 (reprfunc)class_repr, /* tp_repr */
447 0, /* tp_as_number */
448 0, /* tp_as_sequence */
449 0, /* tp_as_mapping */
450 0, /* tp_hash */
Tim Peters6d6c1a32001-08-02 04:15:00 +0000451 PyInstance_New, /* tp_call */
Guido van Rossum8998b4f2001-01-17 15:28:20 +0000452 (reprfunc)class_str, /* tp_str */
453 (getattrofunc)class_getattr, /* tp_getattro */
454 (setattrofunc)class_setattr, /* tp_setattro */
455 0, /* tp_as_buffer */
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000456 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
Guido van Rossum8998b4f2001-01-17 15:28:20 +0000457 0, /* tp_doc */
458 (traverseproc)class_traverse, /* tp_traverse */
Tim Peters6d6c1a32001-08-02 04:15:00 +0000459 0, /* tp_clear */
460 0, /* tp_richcompare */
461 0, /* tp_weaklistoffset */
462 0, /* tp_iter */
463 0, /* tp_iternext */
464 0, /* tp_methods */
465 0, /* tp_members */
466 0, /* tp_getset */
467 0, /* tp_base */
468 0, /* tp_dict */
469 0, /* tp_descr_get */
470 0, /* tp_descr_set */
471 0, /* tp_dictoffset */
472 0, /* tp_init */
473 0, /* tp_alloc */
474 class_new, /* tp_new */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000475};
476
Guido van Rossum81daa321993-05-20 14:24:46 +0000477int
Fred Drake79912472000-07-09 04:06:11 +0000478PyClass_IsSubclass(PyObject *class, PyObject *base)
Guido van Rossum81daa321993-05-20 14:24:46 +0000479{
480 int i, n;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000481 PyClassObject *cp;
Guido van Rossum81daa321993-05-20 14:24:46 +0000482 if (class == base)
483 return 1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000484 if (class == NULL || !PyClass_Check(class))
Guido van Rossumeb6b33a1993-05-25 09:38:27 +0000485 return 0;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000486 cp = (PyClassObject *)class;
487 n = PyTuple_Size(cp->cl_bases);
Guido van Rossum81daa321993-05-20 14:24:46 +0000488 for (i = 0; i < n; i++) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000489 if (PyClass_IsSubclass(PyTuple_GetItem(cp->cl_bases, i), base))
Guido van Rossum81daa321993-05-20 14:24:46 +0000490 return 1;
491 }
492 return 0;
493}
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000494
Guido van Rossum81daa321993-05-20 14:24:46 +0000495
496/* Instance objects */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000497
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000498PyObject *
Fred Drake5cc2c8c2001-01-28 03:53:08 +0000499PyInstance_NewRaw(PyObject *klass, PyObject *dict)
500{
501 PyInstanceObject *inst;
502
503 if (!PyClass_Check(klass)) {
504 PyErr_BadInternalCall();
505 return NULL;
506 }
507 if (dict == NULL) {
508 dict = PyDict_New();
509 if (dict == NULL)
510 return NULL;
511 }
512 else {
513 if (!PyDict_Check(dict)) {
514 PyErr_BadInternalCall();
515 return NULL;
516 }
517 Py_INCREF(dict);
518 }
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000519 inst = PyObject_GC_New(PyInstanceObject, &PyInstance_Type);
Fred Drake5cc2c8c2001-01-28 03:53:08 +0000520 if (inst == NULL) {
521 Py_DECREF(dict);
522 return NULL;
523 }
Fred Drake4e262a92001-03-22 18:26:47 +0000524 inst->in_weakreflist = NULL;
Fred Drake5cc2c8c2001-01-28 03:53:08 +0000525 Py_INCREF(klass);
526 inst->in_class = (PyClassObject *)klass;
527 inst->in_dict = dict;
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000528 _PyObject_GC_TRACK(inst);
Fred Drake5cc2c8c2001-01-28 03:53:08 +0000529 return (PyObject *)inst;
530}
531
532PyObject *
533PyInstance_New(PyObject *klass, PyObject *arg, PyObject *kw)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000534{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000535 register PyInstanceObject *inst;
536 PyObject *init;
537 static PyObject *initstr;
Fred Drake5cc2c8c2001-01-28 03:53:08 +0000538
539 inst = (PyInstanceObject *) PyInstance_NewRaw(klass, NULL);
Guido van Rossume8122f11991-05-05 20:03:07 +0000540 if (inst == NULL)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000541 return NULL;
Guido van Rossum2878a691996-08-09 20:53:24 +0000542 if (initstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000543 initstr = PyString_InternFromString("__init__");
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000544 init = instance_getattr2(inst, initstr);
Guido van Rossum25831651993-05-19 14:50:45 +0000545 if (init == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000546 if ((arg != NULL && (!PyTuple_Check(arg) ||
547 PyTuple_Size(arg) != 0))
548 || (kw != NULL && (!PyDict_Check(kw) ||
549 PyDict_Size(kw) != 0))) {
550 PyErr_SetString(PyExc_TypeError,
Guido van Rossuma83f2701995-07-26 18:07:32 +0000551 "this constructor takes no arguments");
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000552 Py_DECREF(inst);
Guido van Rossum25831651993-05-19 14:50:45 +0000553 inst = NULL;
554 }
555 }
556 else {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000557 PyObject *res = PyEval_CallObjectWithKeywords(init, arg, kw);
558 Py_DECREF(init);
Guido van Rossum25831651993-05-19 14:50:45 +0000559 if (res == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000560 Py_DECREF(inst);
Guido van Rossum25831651993-05-19 14:50:45 +0000561 inst = NULL;
562 }
563 else {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000564 if (res != Py_None) {
565 PyErr_SetString(PyExc_TypeError,
Guido van Rossum25831651993-05-19 14:50:45 +0000566 "__init__() should return None");
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000567 Py_DECREF(inst);
Guido van Rossum25831651993-05-19 14:50:45 +0000568 inst = NULL;
569 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000570 Py_DECREF(res);
Guido van Rossum25831651993-05-19 14:50:45 +0000571 }
572 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000573 return (PyObject *)inst;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000574}
575
Guido van Rossum21ed88c1991-04-04 10:42:10 +0000576/* Instance methods */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000577
578static void
Fred Drake79912472000-07-09 04:06:11 +0000579instance_dealloc(register PyInstanceObject *inst)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000580{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000581 PyObject *error_type, *error_value, *error_traceback;
582 PyObject *del;
583 static PyObject *delstr;
Tim Peters6b184912000-09-17 14:40:17 +0000584#ifdef Py_REF_DEBUG
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000585 extern long _Py_RefTotal;
Skip Montanaro4ca150b2000-07-08 12:04:57 +0000586#endif
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000587 _PyObject_GC_UNTRACK(inst);
Fred Drakec916f5a2001-10-26 17:56:51 +0000588 if (inst->in_weakreflist != NULL)
589 PyObject_ClearWeakRefs((PyObject *) inst);
Fred Drake41deb1e2001-02-01 05:27:45 +0000590
Tim Peters6b184912000-09-17 14:40:17 +0000591 /* Temporarily resurrect the object. */
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000592#ifdef Py_TRACE_REFS
Tim Peters6b184912000-09-17 14:40:17 +0000593#ifndef Py_REF_DEBUG
594# error "Py_TRACE_REFS defined but Py_REF_DEBUG not."
595#endif
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000596 /* much too complicated if Py_TRACE_REFS defined */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000597 inst->ob_type = &PyInstance_Type;
Guido van Rossumbffd6832000-01-20 22:32:56 +0000598 _Py_NewReference((PyObject *)inst);
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000599#ifdef COUNT_ALLOCS
Tim Peters6b184912000-09-17 14:40:17 +0000600 /* compensate for boost in _Py_NewReference; note that
601 * _Py_RefTotal was also boosted; we'll knock that down later.
602 */
Tim Peters6d6c1a32001-08-02 04:15:00 +0000603 inst->ob_type->tp_allocs--;
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000604#endif
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000605#else /* !Py_TRACE_REFS */
Tim Peters6b184912000-09-17 14:40:17 +0000606 /* Py_INCREF boosts _Py_RefTotal if Py_REF_DEBUG is defined */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000607 Py_INCREF(inst);
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000608#endif /* !Py_TRACE_REFS */
Tim Peters6b184912000-09-17 14:40:17 +0000609
610 /* Save the current exception, if any. */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000611 PyErr_Fetch(&error_type, &error_value, &error_traceback);
Tim Peters6b184912000-09-17 14:40:17 +0000612 /* Execute __del__ method, if any. */
Guido van Rossum2878a691996-08-09 20:53:24 +0000613 if (delstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000614 delstr = PyString_InternFromString("__del__");
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000615 if ((del = instance_getattr2(inst, delstr)) != NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000616 PyObject *res = PyEval_CallObject(del, (PyObject *)NULL);
Tim Peters6b184912000-09-17 14:40:17 +0000617 if (res == NULL)
Jeremy Hyltonb709df32000-09-01 02:47:25 +0000618 PyErr_WriteUnraisable(del);
Guido van Rossum0dfcf751996-08-12 22:00:53 +0000619 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000620 Py_DECREF(res);
621 Py_DECREF(del);
Guido van Rossum25831651993-05-19 14:50:45 +0000622 }
Tim Peters6b184912000-09-17 14:40:17 +0000623 /* Restore the saved exception. */
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000624 PyErr_Restore(error_type, error_value, error_traceback);
Tim Peters6b184912000-09-17 14:40:17 +0000625 /* Undo the temporary resurrection; can't use DECREF here, it would
626 * cause a recursive call.
627 */
628#ifdef Py_REF_DEBUG
629 /* _Py_RefTotal was boosted either by _Py_NewReference or
630 * Py_INCREF above.
631 */
632 _Py_RefTotal--;
633#endif
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000634 if (--inst->ob_refcnt > 0) {
635#ifdef COUNT_ALLOCS
Tim Peters6d6c1a32001-08-02 04:15:00 +0000636 inst->ob_type->tp_frees--;
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000637#endif
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000638 _PyObject_GC_TRACK(inst);
Guido van Rossum25831651993-05-19 14:50:45 +0000639 return; /* __del__ added a reference; don't delete now */
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000640 }
Guido van Rossum441e4ab1996-05-23 22:46:51 +0000641#ifdef Py_TRACE_REFS
Guido van Rossumbffd6832000-01-20 22:32:56 +0000642 _Py_ForgetReference((PyObject *)inst);
Tim Peters6b184912000-09-17 14:40:17 +0000643#ifdef COUNT_ALLOCS
644 /* compensate for increment in _Py_ForgetReference */
Tim Peters6d6c1a32001-08-02 04:15:00 +0000645 inst->ob_type->tp_frees--;
Tim Peters6b184912000-09-17 14:40:17 +0000646#endif
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000647#ifndef WITH_CYCLE_GC
Sjoerd Mullender740f3571995-08-28 09:00:43 +0000648 inst->ob_type = NULL;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000649#endif
Tim Peters6b184912000-09-17 14:40:17 +0000650#endif
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000651 Py_DECREF(inst->in_class);
652 Py_XDECREF(inst->in_dict);
Neil Schemenauere83c00e2001-08-29 23:54:21 +0000653 PyObject_GC_Del(inst);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000654}
655
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000656static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000657instance_getattr1(register PyInstanceObject *inst, PyObject *name)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000658{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000659 register PyObject *v;
660 register char *sname = PyString_AsString(name);
Guido van Rossum2878a691996-08-09 20:53:24 +0000661 if (sname[0] == '_' && sname[1] == '_') {
662 if (strcmp(sname, "__dict__") == 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000663 if (PyEval_GetRestricted()) {
664 PyErr_SetString(PyExc_RuntimeError,
665 "instance.__dict__ not accessible in restricted mode");
Guido van Rossum10393b11995-01-10 10:39:49 +0000666 return NULL;
667 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000668 Py_INCREF(inst->in_dict);
Sjoerd Mullender3bb8a051993-10-22 12:04:32 +0000669 return inst->in_dict;
670 }
Guido van Rossum2878a691996-08-09 20:53:24 +0000671 if (strcmp(sname, "__class__") == 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000672 Py_INCREF(inst->in_class);
673 return (PyObject *)inst->in_class;
Sjoerd Mullender3bb8a051993-10-22 12:04:32 +0000674 }
Guido van Rossum94308391991-10-20 20:11:48 +0000675 }
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000676 v = instance_getattr2(inst, name);
677 if (v == NULL) {
Fred Drake661ea262000-10-24 19:57:45 +0000678 PyErr_Format(PyExc_AttributeError,
679 "%.50s instance has no attribute '%.400s'",
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000680 PyString_AS_STRING(inst->in_class->cl_name), sname);
681 }
682 return v;
683}
684
685static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000686instance_getattr2(register PyInstanceObject *inst, PyObject *name)
Jeremy Hylton9e392e22000-04-26 20:39:20 +0000687{
688 register PyObject *v;
689 PyClassObject *class;
Tim Peters6d6c1a32001-08-02 04:15:00 +0000690 descrgetfunc f;
691
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000692 v = PyDict_GetItem(inst->in_dict, name);
Guido van Rossumf23c41d2001-08-17 13:43:27 +0000693 if (v != NULL) {
694 Py_INCREF(v);
695 return v;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000696 }
Guido van Rossumf23c41d2001-08-17 13:43:27 +0000697 v = class_lookup(inst->in_class, name, &class);
698 if (v != NULL) {
699 Py_INCREF(v);
Guido van Rossum915f0eb2001-10-17 20:26:38 +0000700 f = TP_DESCR_GET(v->ob_type);
Tim Peters6d6c1a32001-08-02 04:15:00 +0000701 if (f != NULL) {
702 PyObject *w = f(v, (PyObject *)inst,
703 (PyObject *)(inst->in_class));
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000704 Py_DECREF(v);
Guido van Rossum21d335e1993-10-15 13:01:11 +0000705 v = w;
706 }
Guido van Rossumb3f72581993-05-21 19:56:10 +0000707 }
708 return v;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000709}
710
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000711static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000712instance_getattr(register PyInstanceObject *inst, PyObject *name)
Guido van Rossume7737541994-09-05 07:31:41 +0000713{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000714 register PyObject *func, *res;
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000715 res = instance_getattr1(inst, name);
716 if (res == NULL && (func = inst->in_class->cl_getattr) != NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000717 PyObject *args;
Guido van Rossume7b8ecf2002-06-13 21:42:04 +0000718 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
719 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000720 PyErr_Clear();
721 args = Py_BuildValue("(OO)", inst, name);
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000722 if (args == NULL)
Guido van Rossume7737541994-09-05 07:31:41 +0000723 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000724 res = PyEval_CallObject(func, args);
725 Py_DECREF(args);
Guido van Rossume7737541994-09-05 07:31:41 +0000726 }
727 return res;
728}
729
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000730static int
Fred Drake79912472000-07-09 04:06:11 +0000731instance_setattr1(PyInstanceObject *inst, PyObject *name, PyObject *v)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000732{
Guido van Rossum94472a01992-09-04 09:45:18 +0000733 if (v == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000734 int rv = PyDict_DelItem(inst->in_dict, name);
Guido van Rossum94472a01992-09-04 09:45:18 +0000735 if (rv < 0)
Fred Drake661ea262000-10-24 19:57:45 +0000736 PyErr_Format(PyExc_AttributeError,
737 "%.50s instance has no attribute '%.400s'",
738 PyString_AS_STRING(inst->in_class->cl_name),
739 PyString_AS_STRING(name));
Guido van Rossum94472a01992-09-04 09:45:18 +0000740 return rv;
741 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000742 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000743 return PyDict_SetItem(inst->in_dict, name, v);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000744}
745
Guido van Rossume7737541994-09-05 07:31:41 +0000746static int
Fred Drake79912472000-07-09 04:06:11 +0000747instance_setattr(PyInstanceObject *inst, PyObject *name, PyObject *v)
Guido van Rossume7737541994-09-05 07:31:41 +0000748{
Guido van Rossumb2173c31997-08-25 21:23:56 +0000749 PyObject *func, *args, *res, *tmp;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000750 char *sname = PyString_AsString(name);
Guido van Rossumb2173c31997-08-25 21:23:56 +0000751 if (sname[0] == '_' && sname[1] == '_') {
752 int n = PyString_Size(name);
Guido van Rossum2878a691996-08-09 20:53:24 +0000753 if (sname[n-1] == '_' && sname[n-2] == '_') {
Guido van Rossumb2173c31997-08-25 21:23:56 +0000754 if (strcmp(sname, "__dict__") == 0) {
755 if (PyEval_GetRestricted()) {
756 PyErr_SetString(PyExc_RuntimeError,
757 "__dict__ not accessible in restricted mode");
758 return -1;
759 }
760 if (v == NULL || !PyDict_Check(v)) {
761 PyErr_SetString(PyExc_TypeError,
762 "__dict__ must be set to a dictionary");
763 return -1;
764 }
765 tmp = inst->in_dict;
766 Py_INCREF(v);
767 inst->in_dict = v;
768 Py_DECREF(tmp);
769 return 0;
770 }
771 if (strcmp(sname, "__class__") == 0) {
772 if (PyEval_GetRestricted()) {
773 PyErr_SetString(PyExc_RuntimeError,
774 "__class__ not accessible in restricted mode");
775 return -1;
776 }
777 if (v == NULL || !PyClass_Check(v)) {
778 PyErr_SetString(PyExc_TypeError,
779 "__class__ must be set to a class");
780 return -1;
781 }
782 tmp = (PyObject *)(inst->in_class);
783 Py_INCREF(v);
784 inst->in_class = (PyClassObject *)v;
785 Py_DECREF(tmp);
786 return 0;
787 }
Guido van Rossume7737541994-09-05 07:31:41 +0000788 }
Guido van Rossume7737541994-09-05 07:31:41 +0000789 }
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000790 if (v == NULL)
791 func = inst->in_class->cl_delattr;
792 else
793 func = inst->in_class->cl_setattr;
794 if (func == NULL)
795 return instance_setattr1(inst, name, v);
796 if (v == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000797 args = Py_BuildValue("(OO)", inst, name);
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000798 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000799 args = Py_BuildValue("(OOO)", inst, name, v);
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000800 if (args == NULL)
801 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000802 res = PyEval_CallObject(func, args);
803 Py_DECREF(args);
Guido van Rossum52ca98a1994-09-05 07:32:29 +0000804 if (res == NULL)
805 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000806 Py_DECREF(res);
Guido van Rossume7737541994-09-05 07:31:41 +0000807 return 0;
808}
809
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000810static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000811instance_repr(PyInstanceObject *inst)
Guido van Rossum04691fc1992-08-12 15:35:34 +0000812{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000813 PyObject *func;
814 PyObject *res;
815 static PyObject *reprstr;
Guido van Rossum04691fc1992-08-12 15:35:34 +0000816
Guido van Rossum2878a691996-08-09 20:53:24 +0000817 if (reprstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000818 reprstr = PyString_InternFromString("__repr__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000819 func = instance_getattr(inst, reprstr);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000820 if (func == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +0000821 PyObject *classname, *mod;
Guido van Rossum25831651993-05-19 14:50:45 +0000822 char *cname;
Guido van Rossume7b8ecf2002-06-13 21:42:04 +0000823 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
824 return NULL;
825 PyErr_Clear();
826 classname = inst->in_class->cl_name;
827 mod = PyDict_GetItemString(inst->in_class->cl_dict,
828 "__module__");
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000829 if (classname != NULL && PyString_Check(classname))
830 cname = PyString_AsString(classname);
Guido van Rossum25831651993-05-19 14:50:45 +0000831 else
832 cname = "?";
Guido van Rossumb7f1afe1997-12-03 00:06:02 +0000833 if (mod == NULL || !PyString_Check(mod))
Barry Warsaw7ce36942001-08-24 18:34:26 +0000834 return PyString_FromFormat("<?.%s instance at %p>",
835 cname, inst);
Guido van Rossumb7f1afe1997-12-03 00:06:02 +0000836 else
Barry Warsaw7ce36942001-08-24 18:34:26 +0000837 return PyString_FromFormat("<%s.%s instance at %p>",
838 PyString_AsString(mod),
839 cname, inst);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000840 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000841 res = PyEval_CallObject(func, (PyObject *)NULL);
842 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000843 return res;
844}
845
Guido van Rossum82c690f2001-04-30 14:39:18 +0000846static PyObject *
847instance_str(PyInstanceObject *inst)
848{
849 PyObject *func;
850 PyObject *res;
851 static PyObject *strstr;
852
853 if (strstr == NULL)
854 strstr = PyString_InternFromString("__str__");
855 func = instance_getattr(inst, strstr);
856 if (func == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +0000857 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
858 return NULL;
Guido van Rossum82c690f2001-04-30 14:39:18 +0000859 PyErr_Clear();
860 return instance_repr(inst);
861 }
862 res = PyEval_CallObject(func, (PyObject *)NULL);
863 Py_DECREF(func);
864 return res;
865}
866
Guido van Rossum9bfef441993-03-29 10:43:31 +0000867static long
Fred Drake79912472000-07-09 04:06:11 +0000868instance_hash(PyInstanceObject *inst)
Guido van Rossum9bfef441993-03-29 10:43:31 +0000869{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000870 PyObject *func;
871 PyObject *res;
Guido van Rossum8a0c3451993-04-08 12:56:19 +0000872 long outcome;
Guido van Rossum65e8bd72001-01-18 23:46:31 +0000873 static PyObject *hashstr, *eqstr, *cmpstr;
Guido van Rossum9bfef441993-03-29 10:43:31 +0000874
Guido van Rossum2878a691996-08-09 20:53:24 +0000875 if (hashstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000876 hashstr = PyString_InternFromString("__hash__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000877 func = instance_getattr(inst, hashstr);
Guido van Rossum9bfef441993-03-29 10:43:31 +0000878 if (func == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +0000879 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
880 return -1;
881 PyErr_Clear();
Guido van Rossum65e8bd72001-01-18 23:46:31 +0000882 /* If there is no __eq__ and no __cmp__ method, we hash on the
883 address. If an __eq__ or __cmp__ method exists, there must
884 be a __hash__. */
Guido van Rossum65e8bd72001-01-18 23:46:31 +0000885 if (eqstr == NULL)
886 eqstr = PyString_InternFromString("__eq__");
887 func = instance_getattr(inst, eqstr);
Guido van Rossum8a0c3451993-04-08 12:56:19 +0000888 if (func == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +0000889 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
890 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000891 PyErr_Clear();
Guido van Rossum65e8bd72001-01-18 23:46:31 +0000892 if (cmpstr == NULL)
893 cmpstr = PyString_InternFromString("__cmp__");
894 func = instance_getattr(inst, cmpstr);
895 if (func == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +0000896 if (!PyErr_ExceptionMatches(
897 PyExc_AttributeError))
898 return -1;
Guido van Rossum65e8bd72001-01-18 23:46:31 +0000899 PyErr_Clear();
900 return _Py_HashPointer(inst);
901 }
Guido van Rossum8a0c3451993-04-08 12:56:19 +0000902 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000903 PyErr_SetString(PyExc_TypeError, "unhashable instance");
Guido van Rossum9bfef441993-03-29 10:43:31 +0000904 return -1;
905 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000906 res = PyEval_CallObject(func, (PyObject *)NULL);
907 Py_DECREF(func);
Guido van Rossum9bfef441993-03-29 10:43:31 +0000908 if (res == NULL)
909 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000910 if (PyInt_Check(res)) {
911 outcome = PyInt_AsLong(res);
Guido van Rossum9bfef441993-03-29 10:43:31 +0000912 if (outcome == -1)
913 outcome = -2;
914 }
915 else {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000916 PyErr_SetString(PyExc_TypeError,
917 "__hash__() should return an int");
Guido van Rossum9bfef441993-03-29 10:43:31 +0000918 outcome = -1;
919 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000920 Py_DECREF(res);
Guido van Rossum9bfef441993-03-29 10:43:31 +0000921 return outcome;
922}
923
Jeremy Hylton8caad492000-06-23 14:18:11 +0000924static int
925instance_traverse(PyInstanceObject *o, visitproc visit, void *arg)
926{
927 int err;
928 if (o->in_class) {
929 err = visit((PyObject *)(o->in_class), arg);
930 if (err)
931 return err;
932 }
933 if (o->in_dict) {
934 err = visit(o->in_dict, arg);
935 if (err)
936 return err;
937 }
Jeremy Hyltond22162b2000-06-23 17:14:56 +0000938 return 0;
Jeremy Hylton8caad492000-06-23 14:18:11 +0000939}
940
Guido van Rossum213c7a62001-04-23 14:08:49 +0000941static PyObject *getitemstr, *setitemstr, *delitemstr, *lenstr;
942static PyObject *iterstr, *nextstr;
Guido van Rossum2878a691996-08-09 20:53:24 +0000943
Guido van Rossum9bfef441993-03-29 10:43:31 +0000944static int
Fred Drake79912472000-07-09 04:06:11 +0000945instance_length(PyInstanceObject *inst)
Guido van Rossum04691fc1992-08-12 15:35:34 +0000946{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000947 PyObject *func;
948 PyObject *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +0000949 int outcome;
950
Guido van Rossum2878a691996-08-09 20:53:24 +0000951 if (lenstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000952 lenstr = PyString_InternFromString("__len__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000953 func = instance_getattr(inst, lenstr);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000954 if (func == NULL)
955 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000956 res = PyEval_CallObject(func, (PyObject *)NULL);
957 Py_DECREF(func);
Guido van Rossumd014ea61992-11-26 10:30:26 +0000958 if (res == NULL)
959 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000960 if (PyInt_Check(res)) {
961 outcome = PyInt_AsLong(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000962 if (outcome < 0)
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000963 PyErr_SetString(PyExc_ValueError,
964 "__len__() should return >= 0");
Guido van Rossum04691fc1992-08-12 15:35:34 +0000965 }
966 else {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000967 PyErr_SetString(PyExc_TypeError,
968 "__len__() should return an int");
Guido van Rossum04691fc1992-08-12 15:35:34 +0000969 outcome = -1;
970 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000971 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000972 return outcome;
973}
974
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000975static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000976instance_subscript(PyInstanceObject *inst, PyObject *key)
Guido van Rossum04691fc1992-08-12 15:35:34 +0000977{
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000978 PyObject *func;
979 PyObject *arg;
980 PyObject *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +0000981
Guido van Rossum2878a691996-08-09 20:53:24 +0000982 if (getitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +0000983 getitemstr = PyString_InternFromString("__getitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +0000984 func = instance_getattr(inst, getitemstr);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000985 if (func == NULL)
986 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000987 arg = Py_BuildValue("(O)", key);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000988 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000989 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000990 return NULL;
991 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000992 res = PyEval_CallObject(func, arg);
993 Py_DECREF(func);
994 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +0000995 return res;
996}
997
Guido van Rossum9bfef441993-03-29 10:43:31 +0000998static int
Fred Drake79912472000-07-09 04:06:11 +0000999instance_ass_subscript(PyInstanceObject *inst, PyObject *key, PyObject *value)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001000{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001001 PyObject *func;
1002 PyObject *arg;
1003 PyObject *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001004
Guido van Rossum2878a691996-08-09 20:53:24 +00001005 if (value == NULL) {
1006 if (delitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001007 delitemstr = PyString_InternFromString("__delitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001008 func = instance_getattr(inst, delitemstr);
1009 }
1010 else {
1011 if (setitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001012 setitemstr = PyString_InternFromString("__setitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001013 func = instance_getattr(inst, setitemstr);
1014 }
Guido van Rossum04691fc1992-08-12 15:35:34 +00001015 if (func == NULL)
1016 return -1;
1017 if (value == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001018 arg = Py_BuildValue("(O)", key);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001019 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001020 arg = Py_BuildValue("(OO)", key, value);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001021 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001022 Py_DECREF(func);
Guido van Rossum6d946f91992-08-14 13:49:30 +00001023 return -1;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001024 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001025 res = PyEval_CallObject(func, arg);
1026 Py_DECREF(func);
1027 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001028 if (res == NULL)
1029 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001030 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001031 return 0;
1032}
1033
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001034static PyMappingMethods instance_as_mapping = {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001035 (inquiry)instance_length, /* mp_length */
1036 (binaryfunc)instance_subscript, /* mp_subscript */
1037 (objobjargproc)instance_ass_subscript, /* mp_ass_subscript */
Guido van Rossum04691fc1992-08-12 15:35:34 +00001038};
1039
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001040static PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001041instance_item(PyInstanceObject *inst, int i)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001042{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001043 PyObject *func, *arg, *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001044
Guido van Rossum2878a691996-08-09 20:53:24 +00001045 if (getitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001046 getitemstr = PyString_InternFromString("__getitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001047 func = instance_getattr(inst, getitemstr);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001048 if (func == NULL)
1049 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001050 arg = Py_BuildValue("(i)", i);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001051 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001052 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001053 return NULL;
1054 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001055 res = PyEval_CallObject(func, arg);
1056 Py_DECREF(func);
1057 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001058 return res;
1059}
1060
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001061static PyObject *
Thomas Wouters1d75a792000-08-17 22:37:32 +00001062sliceobj_from_intint(int i, int j)
1063{
1064 PyObject *start, *end, *res;
1065
1066 start = PyInt_FromLong((long)i);
1067 if (!start)
1068 return NULL;
1069
1070 end = PyInt_FromLong((long)j);
1071 if (!end) {
1072 Py_DECREF(start);
1073 return NULL;
1074 }
1075 res = PySlice_New(start, end, NULL);
1076 Py_DECREF(start);
1077 Py_DECREF(end);
1078 return res;
1079}
1080
1081
1082static PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001083instance_slice(PyInstanceObject *inst, int i, int j)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001084{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001085 PyObject *func, *arg, *res;
1086 static PyObject *getslicestr;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001087
Guido van Rossum2878a691996-08-09 20:53:24 +00001088 if (getslicestr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001089 getslicestr = PyString_InternFromString("__getslice__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001090 func = instance_getattr(inst, getslicestr);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001091
1092 if (func == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00001093 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1094 return NULL;
Thomas Wouters1d75a792000-08-17 22:37:32 +00001095 PyErr_Clear();
1096
1097 if (getitemstr == NULL)
1098 getitemstr = PyString_InternFromString("__getitem__");
1099 func = instance_getattr(inst, getitemstr);
1100 if (func == NULL)
1101 return NULL;
1102 arg = Py_BuildValue("(N)", sliceobj_from_intint(i, j));
1103 } else
1104 arg = Py_BuildValue("(ii)", i, j);
1105
Guido van Rossum04691fc1992-08-12 15:35:34 +00001106 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001107 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001108 return NULL;
1109 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001110 res = PyEval_CallObject(func, arg);
1111 Py_DECREF(func);
1112 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001113 return res;
1114}
1115
1116static int
Fred Drake79912472000-07-09 04:06:11 +00001117instance_ass_item(PyInstanceObject *inst, int i, PyObject *item)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001118{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001119 PyObject *func, *arg, *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001120
Guido van Rossum2878a691996-08-09 20:53:24 +00001121 if (item == NULL) {
1122 if (delitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001123 delitemstr = PyString_InternFromString("__delitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001124 func = instance_getattr(inst, delitemstr);
1125 }
1126 else {
1127 if (setitemstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001128 setitemstr = PyString_InternFromString("__setitem__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001129 func = instance_getattr(inst, setitemstr);
1130 }
Guido van Rossum04691fc1992-08-12 15:35:34 +00001131 if (func == NULL)
Guido van Rossum6d946f91992-08-14 13:49:30 +00001132 return -1;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001133 if (item == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001134 arg = Py_BuildValue("i", i);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001135 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001136 arg = Py_BuildValue("(iO)", i, item);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001137 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001138 Py_DECREF(func);
Guido van Rossum6d946f91992-08-14 13:49:30 +00001139 return -1;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001140 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001141 res = PyEval_CallObject(func, arg);
1142 Py_DECREF(func);
1143 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001144 if (res == NULL)
1145 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001146 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001147 return 0;
1148}
1149
1150static int
Fred Drake79912472000-07-09 04:06:11 +00001151instance_ass_slice(PyInstanceObject *inst, int i, int j, PyObject *value)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001152{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001153 PyObject *func, *arg, *res;
1154 static PyObject *setslicestr, *delslicestr;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001155
Guido van Rossum2878a691996-08-09 20:53:24 +00001156 if (value == NULL) {
1157 if (delslicestr == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001158 delslicestr =
1159 PyString_InternFromString("__delslice__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001160 func = instance_getattr(inst, delslicestr);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001161 if (func == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00001162 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1163 return -1;
Thomas Wouters1d75a792000-08-17 22:37:32 +00001164 PyErr_Clear();
1165 if (delitemstr == NULL)
1166 delitemstr =
1167 PyString_InternFromString("__delitem__");
1168 func = instance_getattr(inst, delitemstr);
1169 if (func == NULL)
1170 return -1;
1171
1172 arg = Py_BuildValue("(N)",
1173 sliceobj_from_intint(i, j));
1174 } else
1175 arg = Py_BuildValue("(ii)", i, j);
Guido van Rossum2878a691996-08-09 20:53:24 +00001176 }
1177 else {
1178 if (setslicestr == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001179 setslicestr =
1180 PyString_InternFromString("__setslice__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001181 func = instance_getattr(inst, setslicestr);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001182 if (func == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00001183 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1184 return -1;
Thomas Wouters1d75a792000-08-17 22:37:32 +00001185 PyErr_Clear();
1186 if (setitemstr == NULL)
1187 setitemstr =
1188 PyString_InternFromString("__setitem__");
1189 func = instance_getattr(inst, setitemstr);
1190 if (func == NULL)
1191 return -1;
1192
1193 arg = Py_BuildValue("(NO)",
1194 sliceobj_from_intint(i, j), value);
1195 } else
1196 arg = Py_BuildValue("(iiO)", i, j, value);
Guido van Rossum2878a691996-08-09 20:53:24 +00001197 }
Guido van Rossum04691fc1992-08-12 15:35:34 +00001198 if (arg == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001199 Py_DECREF(func);
Guido van Rossum6d946f91992-08-14 13:49:30 +00001200 return -1;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001201 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001202 res = PyEval_CallObject(func, arg);
1203 Py_DECREF(func);
1204 Py_DECREF(arg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001205 if (res == NULL)
1206 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001207 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001208 return 0;
1209}
1210
Tim Peterscb8d3682001-05-05 21:05:01 +00001211static int
1212instance_contains(PyInstanceObject *inst, PyObject *member)
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001213{
1214 static PyObject *__contains__;
Tim Peterscb8d3682001-05-05 21:05:01 +00001215 PyObject *func;
1216
1217 /* Try __contains__ first.
1218 * If that can't be done, try iterator-based searching.
1219 */
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001220
1221 if(__contains__ == NULL) {
1222 __contains__ = PyString_InternFromString("__contains__");
1223 if(__contains__ == NULL)
1224 return -1;
1225 }
1226 func = instance_getattr(inst, __contains__);
Tim Peterscb8d3682001-05-05 21:05:01 +00001227 if (func) {
1228 PyObject *res;
1229 int ret;
1230 PyObject *arg = Py_BuildValue("(O)", member);
1231 if(arg == NULL) {
1232 Py_DECREF(func);
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001233 return -1;
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001234 }
Tim Peterscb8d3682001-05-05 21:05:01 +00001235 res = PyEval_CallObject(func, arg);
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001236 Py_DECREF(func);
Tim Peterscb8d3682001-05-05 21:05:01 +00001237 Py_DECREF(arg);
1238 if(res == NULL)
1239 return -1;
1240 ret = PyObject_IsTrue(res);
1241 Py_DECREF(res);
1242 return ret;
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001243 }
Tim Peterscb8d3682001-05-05 21:05:01 +00001244
1245 /* Couldn't find __contains__. */
1246 if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
1247 /* Assume the failure was simply due to that there is no
1248 * __contains__ attribute, and try iterating instead.
1249 */
1250 PyErr_Clear();
Tim Peters16a77ad2001-09-08 04:00:12 +00001251 return _PySequence_IterSearch((PyObject *)inst, member,
1252 PY_ITERSEARCH_CONTAINS);
Tim Peterscb8d3682001-05-05 21:05:01 +00001253 }
1254 else
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001255 return -1;
Guido van Rossumee28c3a2000-02-28 15:03:15 +00001256}
1257
Fred Drake79912472000-07-09 04:06:11 +00001258static PySequenceMethods
1259instance_as_sequence = {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001260 (inquiry)instance_length, /* sq_length */
1261 0, /* sq_concat */
1262 0, /* sq_repeat */
1263 (intargfunc)instance_item, /* sq_item */
1264 (intintargfunc)instance_slice, /* sq_slice */
1265 (intobjargproc)instance_ass_item, /* sq_ass_item */
1266 (intintobjargproc)instance_ass_slice, /* sq_ass_slice */
1267 (objobjproc)instance_contains, /* sq_contains */
Guido van Rossum04691fc1992-08-12 15:35:34 +00001268};
1269
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001270static PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001271generic_unary_op(PyInstanceObject *self, PyObject *methodname)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001272{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001273 PyObject *func, *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001274
1275 if ((func = instance_getattr(self, methodname)) == NULL)
1276 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001277 res = PyEval_CallObject(func, (PyObject *)NULL);
1278 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001279 return res;
1280}
1281
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001282static PyObject *
1283generic_binary_op(PyObject *v, PyObject *w, char *opname)
Guido van Rossum03093a21994-09-28 15:51:32 +00001284{
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001285 PyObject *result;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001286 PyObject *args;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001287 PyObject *func = PyObject_GetAttrString(v, opname);
Guido van Rossume7d444f1995-01-07 12:35:18 +00001288 if (func == NULL) {
Guido van Rossum617c1b01998-05-28 19:50:02 +00001289 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001290 return NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001291 PyErr_Clear();
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001292 Py_INCREF(Py_NotImplemented);
1293 return Py_NotImplemented;
Guido van Rossume7d444f1995-01-07 12:35:18 +00001294 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001295 args = Py_BuildValue("(O)", w);
Guido van Rossum03093a21994-09-28 15:51:32 +00001296 if (args == NULL) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001297 Py_DECREF(func);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001298 return NULL;
Guido van Rossum03093a21994-09-28 15:51:32 +00001299 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001300 result = PyEval_CallObject(func, args);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001301 Py_DECREF(args);
1302 Py_DECREF(func);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001303 return result;
1304}
1305
1306
1307static PyObject *coerce_obj;
1308
1309/* Try one half of a binary operator involving a class instance. */
1310static PyObject *
1311half_binop(PyObject *v, PyObject *w, char *opname, binaryfunc thisfunc,
1312 int swapped)
1313{
1314 PyObject *args;
1315 PyObject *coercefunc;
1316 PyObject *coerced = NULL;
1317 PyObject *v1;
1318 PyObject *result;
1319
1320 if (!PyInstance_Check(v)) {
1321 Py_INCREF(Py_NotImplemented);
1322 return Py_NotImplemented;
1323 }
1324
1325 if (coerce_obj == NULL) {
1326 coerce_obj = PyString_InternFromString("__coerce__");
1327 if (coerce_obj == NULL)
1328 return NULL;
1329 }
1330 coercefunc = PyObject_GetAttr(v, coerce_obj);
1331 if (coercefunc == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00001332 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1333 return NULL;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001334 PyErr_Clear();
1335 return generic_binary_op(v, w, opname);
1336 }
1337
1338 args = Py_BuildValue("(O)", w);
1339 if (args == NULL) {
1340 return NULL;
1341 }
1342 coerced = PyEval_CallObject(coercefunc, args);
1343 Py_DECREF(args);
1344 Py_DECREF(coercefunc);
1345 if (coerced == NULL) {
1346 return NULL;
1347 }
1348 if (coerced == Py_None || coerced == Py_NotImplemented) {
1349 Py_DECREF(coerced);
1350 return generic_binary_op(v, w, opname);
1351 }
1352 if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
1353 Py_DECREF(coerced);
1354 PyErr_SetString(PyExc_TypeError,
1355 "coercion should return None or 2-tuple");
1356 return NULL;
1357 }
1358 v1 = PyTuple_GetItem(coerced, 0);
1359 w = PyTuple_GetItem(coerced, 1);
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001360 if (v1->ob_type == v->ob_type && PyInstance_Check(v)) {
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001361 /* prevent recursion if __coerce__ returns self as the first
1362 * argument */
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001363 result = generic_binary_op(v1, w, opname);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001364 } else {
1365 if (swapped)
1366 result = (thisfunc)(w, v1);
1367 else
1368 result = (thisfunc)(v1, w);
1369 }
1370 Py_DECREF(coerced);
1371 return result;
1372}
1373
1374/* Implement a binary operator involving at least one class instance. */
1375static PyObject *
1376do_binop(PyObject *v, PyObject *w, char *opname, char *ropname,
1377 binaryfunc thisfunc)
1378{
1379 PyObject *result = half_binop(v, w, opname, thisfunc, 0);
1380 if (result == Py_NotImplemented) {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001381 Py_DECREF(result);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001382 result = half_binop(w, v, ropname, thisfunc, 1);
1383 }
1384 return result;
1385}
1386
1387static PyObject *
1388do_binop_inplace(PyObject *v, PyObject *w, char *iopname, char *opname,
1389 char *ropname, binaryfunc thisfunc)
1390{
1391 PyObject *result = half_binop(v, w, iopname, thisfunc, 0);
1392 if (result == Py_NotImplemented) {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001393 Py_DECREF(result);
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001394 result = do_binop(v, w, opname, ropname, thisfunc);
1395 }
1396 return result;
Guido van Rossum03093a21994-09-28 15:51:32 +00001397}
1398
Guido van Rossum879c5811995-01-10 15:24:06 +00001399static int
Fred Drake79912472000-07-09 04:06:11 +00001400instance_coerce(PyObject **pv, PyObject **pw)
Guido van Rossum879c5811995-01-10 15:24:06 +00001401{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001402 PyObject *v = *pv;
1403 PyObject *w = *pw;
Guido van Rossum3931df91997-11-18 19:23:07 +00001404 PyObject *coercefunc;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001405 PyObject *args;
1406 PyObject *coerced;
Guido van Rossum879c5811995-01-10 15:24:06 +00001407
Guido van Rossum2878a691996-08-09 20:53:24 +00001408 if (coerce_obj == NULL) {
Guido van Rossuma412d241997-01-18 07:59:12 +00001409 coerce_obj = PyString_InternFromString("__coerce__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001410 if (coerce_obj == NULL)
1411 return -1;
1412 }
Guido van Rossum3931df91997-11-18 19:23:07 +00001413 coercefunc = PyObject_GetAttr(v, coerce_obj);
1414 if (coercefunc == NULL) {
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001415 /* No __coerce__ method */
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00001416 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1417 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001418 PyErr_Clear();
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001419 return 1;
Guido van Rossum879c5811995-01-10 15:24:06 +00001420 }
1421 /* Has __coerce__ method: call it */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001422 args = Py_BuildValue("(O)", w);
Guido van Rossum879c5811995-01-10 15:24:06 +00001423 if (args == NULL) {
1424 return -1;
1425 }
Guido van Rossum3931df91997-11-18 19:23:07 +00001426 coerced = PyEval_CallObject(coercefunc, args);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001427 Py_DECREF(args);
Guido van Rossum3931df91997-11-18 19:23:07 +00001428 Py_DECREF(coercefunc);
Guido van Rossum879c5811995-01-10 15:24:06 +00001429 if (coerced == NULL) {
1430 /* __coerce__ call raised an exception */
1431 return -1;
1432 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001433 if (coerced == Py_None || coerced == Py_NotImplemented) {
Guido van Rossum879c5811995-01-10 15:24:06 +00001434 /* __coerce__ says "I can't do it" */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001435 Py_DECREF(coerced);
Guido van Rossum879c5811995-01-10 15:24:06 +00001436 return 1;
1437 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001438 if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
Guido van Rossum879c5811995-01-10 15:24:06 +00001439 /* __coerce__ return value is malformed */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001440 Py_DECREF(coerced);
1441 PyErr_SetString(PyExc_TypeError,
Guido van Rossum879c5811995-01-10 15:24:06 +00001442 "coercion should return None or 2-tuple");
1443 return -1;
1444 }
1445 /* __coerce__ returned two new values */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001446 *pv = PyTuple_GetItem(coerced, 0);
1447 *pw = PyTuple_GetItem(coerced, 1);
1448 Py_INCREF(*pv);
1449 Py_INCREF(*pw);
1450 Py_DECREF(coerced);
Guido van Rossum879c5811995-01-10 15:24:06 +00001451 return 0;
1452}
1453
Guido van Rossum04691fc1992-08-12 15:35:34 +00001454#define UNARY(funcname, methodname) \
Thomas Woutersc3073522000-07-23 22:09:59 +00001455static PyObject *funcname(PyInstanceObject *self) { \
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001456 static PyObject *o; \
Guido van Rossuma412d241997-01-18 07:59:12 +00001457 if (o == NULL) o = PyString_InternFromString(methodname); \
Guido van Rossum2878a691996-08-09 20:53:24 +00001458 return generic_unary_op(self, o); \
Guido van Rossum04691fc1992-08-12 15:35:34 +00001459}
1460
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001461#define BINARY(f, m, n) \
1462static PyObject *f(PyObject *v, PyObject *w) { \
1463 return do_binop(v, w, "__" m "__", "__r" m "__", n); \
1464}
1465
1466#define BINARY_INPLACE(f, m, n) \
1467static PyObject *f(PyObject *v, PyObject *w) { \
1468 return do_binop_inplace(v, w, "__i" m "__", "__" m "__", \
1469 "__r" m "__", n); \
1470}
1471
Guido van Rossum04691fc1992-08-12 15:35:34 +00001472UNARY(instance_neg, "__neg__")
1473UNARY(instance_pos, "__pos__")
1474UNARY(instance_abs, "__abs__")
1475
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001476BINARY(instance_or, "or", PyNumber_Or)
1477BINARY(instance_and, "and", PyNumber_And)
1478BINARY(instance_xor, "xor", PyNumber_Xor)
1479BINARY(instance_lshift, "lshift", PyNumber_Lshift)
1480BINARY(instance_rshift, "rshift", PyNumber_Rshift)
1481BINARY(instance_add, "add", PyNumber_Add)
1482BINARY(instance_sub, "sub", PyNumber_Subtract)
1483BINARY(instance_mul, "mul", PyNumber_Multiply)
1484BINARY(instance_div, "div", PyNumber_Divide)
1485BINARY(instance_mod, "mod", PyNumber_Remainder)
1486BINARY(instance_divmod, "divmod", PyNumber_Divmod)
Guido van Rossum4668b002001-08-08 05:00:18 +00001487BINARY(instance_floordiv, "floordiv", PyNumber_FloorDivide)
1488BINARY(instance_truediv, "truediv", PyNumber_TrueDivide)
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001489
1490BINARY_INPLACE(instance_ior, "or", PyNumber_InPlaceOr)
1491BINARY_INPLACE(instance_ixor, "xor", PyNumber_InPlaceXor)
1492BINARY_INPLACE(instance_iand, "and", PyNumber_InPlaceAnd)
1493BINARY_INPLACE(instance_ilshift, "lshift", PyNumber_InPlaceLshift)
1494BINARY_INPLACE(instance_irshift, "rshift", PyNumber_InPlaceRshift)
1495BINARY_INPLACE(instance_iadd, "add", PyNumber_InPlaceAdd)
1496BINARY_INPLACE(instance_isub, "sub", PyNumber_InPlaceSubtract)
1497BINARY_INPLACE(instance_imul, "mul", PyNumber_InPlaceMultiply)
1498BINARY_INPLACE(instance_idiv, "div", PyNumber_InPlaceDivide)
1499BINARY_INPLACE(instance_imod, "mod", PyNumber_InPlaceRemainder)
Guido van Rossum4668b002001-08-08 05:00:18 +00001500BINARY_INPLACE(instance_ifloordiv, "floordiv", PyNumber_InPlaceFloorDivide)
1501BINARY_INPLACE(instance_itruediv, "truediv", PyNumber_InPlaceTrueDivide)
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001502
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001503/* Try a 3-way comparison, returning an int; v is an instance. Return:
1504 -2 for an exception;
1505 -1 if v < w;
1506 0 if v == w;
1507 1 if v > w;
1508 2 if this particular 3-way comparison is not implemented or undefined.
1509*/
1510static int
1511half_cmp(PyObject *v, PyObject *w)
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001512{
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001513 static PyObject *cmp_obj;
1514 PyObject *args;
Guido van Rossum3202c6f2001-01-29 23:50:25 +00001515 PyObject *cmp_func;
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001516 PyObject *result;
1517 long l;
1518
1519 assert(PyInstance_Check(v));
1520
1521 if (cmp_obj == NULL) {
1522 cmp_obj = PyString_InternFromString("__cmp__");
1523 if (cmp_obj == NULL)
1524 return -2;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001525 }
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001526
Guido van Rossum3202c6f2001-01-29 23:50:25 +00001527 cmp_func = PyObject_GetAttr(v, cmp_obj);
1528 if (cmp_func == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00001529 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1530 return -2;
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001531 PyErr_Clear();
1532 return 2;
1533 }
1534
1535 args = Py_BuildValue("(O)", w);
1536 if (args == NULL)
1537 return -2;
1538
Guido van Rossum3202c6f2001-01-29 23:50:25 +00001539 result = PyEval_CallObject(cmp_func, args);
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001540 Py_DECREF(args);
Guido van Rossum3202c6f2001-01-29 23:50:25 +00001541 Py_DECREF(cmp_func);
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001542
1543 if (result == NULL)
1544 return -2;
1545
1546 if (result == Py_NotImplemented) {
1547 Py_DECREF(result);
1548 return 2;
1549 }
1550
1551 l = PyInt_AsLong(result);
1552 Py_DECREF(result);
1553 if (l == -1 && PyErr_Occurred()) {
1554 PyErr_SetString(PyExc_TypeError,
1555 "comparison did not return an int");
1556 return -2;
1557 }
1558
1559 return l < 0 ? -1 : l > 0 ? 1 : 0;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001560}
1561
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001562/* Try a 3-way comparison, returning an int; either v or w is an instance.
1563 We first try a coercion. Return:
1564 -2 for an exception;
1565 -1 if v < w;
1566 0 if v == w;
1567 1 if v > w;
1568 2 if this particular 3-way comparison is not implemented or undefined.
1569 THIS IS ONLY CALLED FROM object.c!
1570*/
1571static int
1572instance_compare(PyObject *v, PyObject *w)
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001573{
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001574 int c;
1575
1576 c = PyNumber_CoerceEx(&v, &w);
1577 if (c < 0)
1578 return -2;
1579 if (c == 0) {
1580 /* If neither is now an instance, use regular comparison */
1581 if (!PyInstance_Check(v) && !PyInstance_Check(w)) {
1582 c = PyObject_Compare(v, w);
1583 Py_DECREF(v);
1584 Py_DECREF(w);
1585 if (PyErr_Occurred())
1586 return -2;
1587 return c < 0 ? -1 : c > 0 ? 1 : 0;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001588 }
1589 }
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001590 else {
1591 /* The coercion didn't do anything.
1592 Treat this the same as returning v and w unchanged. */
1593 Py_INCREF(v);
1594 Py_INCREF(w);
1595 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001596
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001597 if (PyInstance_Check(v)) {
1598 c = half_cmp(v, w);
1599 if (c <= 1) {
1600 Py_DECREF(v);
1601 Py_DECREF(w);
1602 return c;
1603 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001604 }
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001605 if (PyInstance_Check(w)) {
1606 c = half_cmp(w, v);
1607 if (c <= 1) {
1608 Py_DECREF(v);
1609 Py_DECREF(w);
1610 if (c >= -1)
1611 c = -c;
1612 return c;
1613 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001614 }
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001615 Py_DECREF(v);
1616 Py_DECREF(w);
1617 return 2;
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001618}
1619
Guido van Rossum9bfef441993-03-29 10:43:31 +00001620static int
Fred Drake79912472000-07-09 04:06:11 +00001621instance_nonzero(PyInstanceObject *self)
Guido van Rossum04691fc1992-08-12 15:35:34 +00001622{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001623 PyObject *func, *res;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001624 long outcome;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001625 static PyObject *nonzerostr;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001626
Guido van Rossum2878a691996-08-09 20:53:24 +00001627 if (nonzerostr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001628 nonzerostr = PyString_InternFromString("__nonzero__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001629 if ((func = instance_getattr(self, nonzerostr)) == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00001630 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1631 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001632 PyErr_Clear();
Guido van Rossum2878a691996-08-09 20:53:24 +00001633 if (lenstr == NULL)
Guido van Rossuma412d241997-01-18 07:59:12 +00001634 lenstr = PyString_InternFromString("__len__");
Guido van Rossum2878a691996-08-09 20:53:24 +00001635 if ((func = instance_getattr(self, lenstr)) == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00001636 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1637 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001638 PyErr_Clear();
Guido van Rossum04691fc1992-08-12 15:35:34 +00001639 /* Fall back to the default behavior:
1640 all instances are nonzero */
1641 return 1;
1642 }
1643 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001644 res = PyEval_CallObject(func, (PyObject *)NULL);
1645 Py_DECREF(func);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001646 if (res == NULL)
1647 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001648 if (!PyInt_Check(res)) {
1649 Py_DECREF(res);
1650 PyErr_SetString(PyExc_TypeError,
1651 "__nonzero__ should return an int");
Guido van Rossum04691fc1992-08-12 15:35:34 +00001652 return -1;
1653 }
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001654 outcome = PyInt_AsLong(res);
1655 Py_DECREF(res);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001656 if (outcome < 0) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001657 PyErr_SetString(PyExc_ValueError,
1658 "__nonzero__ should return >= 0");
Guido van Rossum04691fc1992-08-12 15:35:34 +00001659 return -1;
1660 }
1661 return outcome > 0;
1662}
1663
1664UNARY(instance_invert, "__invert__")
Guido van Rossum1899c2e1992-09-12 11:09:23 +00001665UNARY(instance_int, "__int__")
1666UNARY(instance_long, "__long__")
1667UNARY(instance_float, "__float__")
1668UNARY(instance_oct, "__oct__")
1669UNARY(instance_hex, "__hex__")
1670
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001671static PyObject *
1672bin_power(PyObject *v, PyObject *w)
1673{
1674 return PyNumber_Power(v, w, Py_None);
1675}
1676
Guido van Rossum03093a21994-09-28 15:51:32 +00001677/* This version is for ternary calls only (z != None) */
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001678static PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001679instance_pow(PyObject *v, PyObject *w, PyObject *z)
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001680{
1681 if (z == Py_None) {
1682 return do_binop(v, w, "__pow__", "__rpow__", bin_power);
Guido van Rossum03093a21994-09-28 15:51:32 +00001683 }
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001684 else {
1685 PyObject *func;
1686 PyObject *args;
1687 PyObject *result;
1688
1689 /* XXX Doesn't do coercions... */
1690 func = PyObject_GetAttrString(v, "__pow__");
1691 if (func == NULL)
1692 return NULL;
1693 args = Py_BuildValue("(OO)", w, z);
1694 if (args == NULL) {
1695 Py_DECREF(func);
1696 return NULL;
1697 }
1698 result = PyEval_CallObject(func, args);
1699 Py_DECREF(func);
1700 Py_DECREF(args);
1701 return result;
1702 }
Guido van Rossum03093a21994-09-28 15:51:32 +00001703}
1704
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001705static PyObject *
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001706bin_inplace_power(PyObject *v, PyObject *w)
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001707{
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001708 return PyNumber_InPlacePower(v, w, Py_None);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001709}
1710
1711
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001712static PyObject *
1713instance_ipow(PyObject *v, PyObject *w, PyObject *z)
1714{
1715 if (z == Py_None) {
1716 return do_binop_inplace(v, w, "__ipow__", "__pow__",
1717 "__rpow__", bin_inplace_power);
1718 }
1719 else {
1720 /* XXX Doesn't do coercions... */
1721 PyObject *func;
1722 PyObject *args;
1723 PyObject *result;
1724
1725 func = PyObject_GetAttrString(v, "__ipow__");
1726 if (func == NULL) {
1727 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1728 return NULL;
1729 PyErr_Clear();
1730 return instance_pow(v, w, z);
1731 }
1732 args = Py_BuildValue("(OO)", w, z);
1733 if (args == NULL) {
1734 Py_DECREF(func);
1735 return NULL;
1736 }
1737 result = PyEval_CallObject(func, args);
1738 Py_DECREF(func);
1739 Py_DECREF(args);
1740 return result;
1741 }
1742}
1743
1744
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001745/* Map rich comparison operators to their __xx__ namesakes */
Jeremy Hylton1b0feb42001-05-11 14:48:41 +00001746#define NAME_OPS 6
1747static PyObject **name_op = NULL;
1748
1749static int
Guido van Rossum0ba9e3a2001-05-22 02:33:08 +00001750init_name_op(void)
Jeremy Hylton1b0feb42001-05-11 14:48:41 +00001751{
1752 int i;
1753 char *_name_op[] = {
1754 "__lt__",
1755 "__le__",
1756 "__eq__",
1757 "__ne__",
1758 "__gt__",
1759 "__ge__",
1760 };
1761
1762 name_op = (PyObject **)malloc(sizeof(PyObject *) * NAME_OPS);
1763 if (name_op == NULL)
1764 return -1;
1765 for (i = 0; i < NAME_OPS; ++i) {
1766 name_op[i] = PyString_InternFromString(_name_op[i]);
1767 if (name_op[i] == NULL)
1768 return -1;
1769 }
1770 return 0;
1771}
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001772
1773static PyObject *
1774half_richcompare(PyObject *v, PyObject *w, int op)
1775{
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001776 PyObject *method;
1777 PyObject *args;
1778 PyObject *res;
1779
1780 assert(PyInstance_Check(v));
1781
Jeremy Hylton1b0feb42001-05-11 14:48:41 +00001782 if (name_op == NULL) {
1783 if (init_name_op() < 0)
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001784 return NULL;
Jeremy Hylton1b0feb42001-05-11 14:48:41 +00001785 }
1786 /* If the instance doesn't define an __getattr__ method, use
1787 instance_getattr2 directly because it will not set an
1788 exception on failure. */
1789 if (((PyInstanceObject *)v)->in_class->cl_getattr == NULL) {
1790 method = instance_getattr2((PyInstanceObject *)v,
1791 name_op[op]);
1792 if (method == NULL) {
1793 assert(!PyErr_Occurred());
1794 res = Py_NotImplemented;
1795 Py_INCREF(res);
1796 return res;
1797 }
1798 } else {
1799 method = PyObject_GetAttr(v, name_op[op]);
1800 if (method == NULL) {
1801 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1802 return NULL;
1803 PyErr_Clear();
1804 res = Py_NotImplemented;
1805 Py_INCREF(res);
1806 return res;
1807 }
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001808 }
1809
1810 args = Py_BuildValue("(O)", w);
1811 if (args == NULL) {
1812 Py_DECREF(method);
1813 return NULL;
1814 }
1815
1816 res = PyEval_CallObject(method, args);
1817 Py_DECREF(args);
1818 Py_DECREF(method);
1819
1820 return res;
1821}
1822
1823/* Map rich comparison operators to their swapped version, e.g. LT --> GT */
1824static int swapped_op[] = {Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE};
1825
1826static PyObject *
1827instance_richcompare(PyObject *v, PyObject *w, int op)
1828{
1829 PyObject *res;
1830
1831 if (PyInstance_Check(v)) {
1832 res = half_richcompare(v, w, op);
1833 if (res != Py_NotImplemented)
1834 return res;
1835 Py_DECREF(res);
1836 }
1837
1838 if (PyInstance_Check(w)) {
1839 res = half_richcompare(w, v, swapped_op[op]);
1840 if (res != Py_NotImplemented)
1841 return res;
1842 Py_DECREF(res);
1843 }
1844
1845 Py_INCREF(Py_NotImplemented);
1846 return Py_NotImplemented;
1847}
1848
Neil Schemenauer29bfc072001-01-04 01:43:46 +00001849
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001850/* Get the iterator */
1851static PyObject *
1852instance_getiter(PyInstanceObject *self)
1853{
1854 PyObject *func;
1855
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00001856 if (iterstr == NULL) {
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001857 iterstr = PyString_InternFromString("__iter__");
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00001858 if (iterstr == NULL)
1859 return NULL;
1860 }
1861 if (getitemstr == NULL) {
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001862 getitemstr = PyString_InternFromString("__getitem__");
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00001863 if (getitemstr == NULL)
1864 return NULL;
1865 }
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001866
1867 if ((func = instance_getattr(self, iterstr)) != NULL) {
1868 PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
1869 Py_DECREF(func);
Guido van Rossum213c7a62001-04-23 14:08:49 +00001870 if (res != NULL && !PyIter_Check(res)) {
1871 PyErr_Format(PyExc_TypeError,
1872 "__iter__ returned non-iterator "
1873 "of type '%.100s'",
1874 res->ob_type->tp_name);
1875 Py_DECREF(res);
1876 res = NULL;
1877 }
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001878 return res;
1879 }
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00001880 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1881 return NULL;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001882 PyErr_Clear();
1883 if ((func = instance_getattr(self, getitemstr)) == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00001884 PyErr_SetString(PyExc_TypeError,
1885 "iteration over non-sequence");
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001886 return NULL;
1887 }
1888 Py_DECREF(func);
Guido van Rossum213c7a62001-04-23 14:08:49 +00001889 return PySeqIter_New((PyObject *)self);
1890}
1891
1892
1893/* Call the iterator's next */
1894static PyObject *
1895instance_iternext(PyInstanceObject *self)
1896{
1897 PyObject *func;
1898
1899 if (nextstr == NULL)
1900 nextstr = PyString_InternFromString("next");
1901
1902 if ((func = instance_getattr(self, nextstr)) != NULL) {
1903 PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
1904 Py_DECREF(func);
1905 if (res != NULL) {
1906 return res;
1907 }
1908 if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
1909 PyErr_Clear();
1910 return NULL;
1911 }
1912 return NULL;
1913 }
1914 PyErr_SetString(PyExc_TypeError, "instance has no next() method");
1915 return NULL;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001916}
1917
Tim Peters6d6c1a32001-08-02 04:15:00 +00001918static PyObject *
1919instance_call(PyObject *func, PyObject *arg, PyObject *kw)
1920{
Guido van Rossum16b93b32002-06-13 21:32:51 +00001921 PyThreadState *tstate = PyThreadState_GET();
Tim Peters6d6c1a32001-08-02 04:15:00 +00001922 PyObject *res, *call = PyObject_GetAttrString(func, "__call__");
1923 if (call == NULL) {
1924 PyInstanceObject *inst = (PyInstanceObject*) func;
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00001925 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
1926 return NULL;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001927 PyErr_Clear();
1928 PyErr_Format(PyExc_AttributeError,
1929 "%.200s instance has no __call__ method",
1930 PyString_AsString(inst->in_class->cl_name));
1931 return NULL;
1932 }
Guido van Rossum16b93b32002-06-13 21:32:51 +00001933 /* We must check and increment the recursion depth here. Scenario:
1934 class A:
1935 pass
1936 A.__call__ = A() # that's right
1937 a = A() # ok
1938 a() # infinite recursion
1939 This bounces between instance_call() and PyObject_Call() without
1940 ever hitting eval_frame() (which has the main recursion check). */
1941 if (tstate->recursion_depth++ > Py_GetRecursionLimit()) {
1942 PyErr_SetString(PyExc_RuntimeError,
1943 "maximum __call__ recursion depth exceeded");
1944 res = NULL;
1945 }
1946 else
1947 res = PyObject_Call(call, arg, kw);
1948 tstate->recursion_depth--;
Tim Peters6d6c1a32001-08-02 04:15:00 +00001949 Py_DECREF(call);
1950 return res;
1951}
1952
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00001953
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001954static PyNumberMethods instance_as_number = {
Guido van Rossum8998b4f2001-01-17 15:28:20 +00001955 (binaryfunc)instance_add, /* nb_add */
1956 (binaryfunc)instance_sub, /* nb_subtract */
1957 (binaryfunc)instance_mul, /* nb_multiply */
1958 (binaryfunc)instance_div, /* nb_divide */
1959 (binaryfunc)instance_mod, /* nb_remainder */
1960 (binaryfunc)instance_divmod, /* nb_divmod */
1961 (ternaryfunc)instance_pow, /* nb_power */
1962 (unaryfunc)instance_neg, /* nb_negative */
1963 (unaryfunc)instance_pos, /* nb_positive */
1964 (unaryfunc)instance_abs, /* nb_absolute */
1965 (inquiry)instance_nonzero, /* nb_nonzero */
1966 (unaryfunc)instance_invert, /* nb_invert */
1967 (binaryfunc)instance_lshift, /* nb_lshift */
1968 (binaryfunc)instance_rshift, /* nb_rshift */
1969 (binaryfunc)instance_and, /* nb_and */
1970 (binaryfunc)instance_xor, /* nb_xor */
1971 (binaryfunc)instance_or, /* nb_or */
1972 (coercion)instance_coerce, /* nb_coerce */
1973 (unaryfunc)instance_int, /* nb_int */
1974 (unaryfunc)instance_long, /* nb_long */
1975 (unaryfunc)instance_float, /* nb_float */
1976 (unaryfunc)instance_oct, /* nb_oct */
1977 (unaryfunc)instance_hex, /* nb_hex */
1978 (binaryfunc)instance_iadd, /* nb_inplace_add */
1979 (binaryfunc)instance_isub, /* nb_inplace_subtract */
1980 (binaryfunc)instance_imul, /* nb_inplace_multiply */
1981 (binaryfunc)instance_idiv, /* nb_inplace_divide */
1982 (binaryfunc)instance_imod, /* nb_inplace_remainder */
1983 (ternaryfunc)instance_ipow, /* nb_inplace_power */
1984 (binaryfunc)instance_ilshift, /* nb_inplace_lshift */
1985 (binaryfunc)instance_irshift, /* nb_inplace_rshift */
1986 (binaryfunc)instance_iand, /* nb_inplace_and */
1987 (binaryfunc)instance_ixor, /* nb_inplace_xor */
1988 (binaryfunc)instance_ior, /* nb_inplace_or */
Guido van Rossum4668b002001-08-08 05:00:18 +00001989 (binaryfunc)instance_floordiv, /* nb_floor_divide */
1990 (binaryfunc)instance_truediv, /* nb_true_divide */
1991 (binaryfunc)instance_ifloordiv, /* nb_inplace_floor_divide */
1992 (binaryfunc)instance_itruediv, /* nb_inplace_true_divide */
Guido van Rossum04691fc1992-08-12 15:35:34 +00001993};
1994
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001995PyTypeObject PyInstance_Type = {
1996 PyObject_HEAD_INIT(&PyType_Type)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00001997 0,
Guido van Rossum21ed88c1991-04-04 10:42:10 +00001998 "instance",
Neil Schemenauere83c00e2001-08-29 23:54:21 +00001999 sizeof(PyInstanceObject),
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002000 0,
Guido van Rossum8998b4f2001-01-17 15:28:20 +00002001 (destructor)instance_dealloc, /* tp_dealloc */
2002 0, /* tp_print */
2003 0, /* tp_getattr */
2004 0, /* tp_setattr */
2005 instance_compare, /* tp_compare */
2006 (reprfunc)instance_repr, /* tp_repr */
2007 &instance_as_number, /* tp_as_number */
2008 &instance_as_sequence, /* tp_as_sequence */
2009 &instance_as_mapping, /* tp_as_mapping */
2010 (hashfunc)instance_hash, /* tp_hash */
Tim Peters6d6c1a32001-08-02 04:15:00 +00002011 instance_call, /* tp_call */
Guido van Rossum82c690f2001-04-30 14:39:18 +00002012 (reprfunc)instance_str, /* tp_str */
Guido van Rossum8998b4f2001-01-17 15:28:20 +00002013 (getattrofunc)instance_getattr, /* tp_getattro */
2014 (setattrofunc)instance_setattr, /* tp_setattro */
2015 0, /* tp_as_buffer */
Neil Schemenauere83c00e2001-08-29 23:54:21 +00002016 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_CHECKTYPES,/*tp_flags*/
Guido van Rossum8998b4f2001-01-17 15:28:20 +00002017 0, /* tp_doc */
Jeremy Hylton8caad492000-06-23 14:18:11 +00002018 (traverseproc)instance_traverse, /* tp_traverse */
Guido van Rossum8998b4f2001-01-17 15:28:20 +00002019 0, /* tp_clear */
2020 instance_richcompare, /* tp_richcompare */
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002021 offsetof(PyInstanceObject, in_weakreflist), /* tp_weaklistoffset */
2022 (getiterfunc)instance_getiter, /* tp_iter */
Guido van Rossum213c7a62001-04-23 14:08:49 +00002023 (iternextfunc)instance_iternext, /* tp_iternext */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002024};
2025
2026
Guido van Rossum81daa321993-05-20 14:24:46 +00002027/* Instance method objects are used for two purposes:
2028 (a) as bound instance methods (returned by instancename.methodname)
2029 (b) as unbound methods (returned by ClassName.methodname)
2030 In case (b), im_self is NULL
2031*/
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002032
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002033static PyMethodObject *free_list;
2034
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002035PyObject *
Fred Drake79912472000-07-09 04:06:11 +00002036PyMethod_New(PyObject *func, PyObject *self, PyObject *class)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002037{
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002038 register PyMethodObject *im;
Guido van Rossum7859f871998-07-08 14:58:16 +00002039 if (!PyCallable_Check(func)) {
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002040 PyErr_BadInternalCall();
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002041 return NULL;
2042 }
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002043 im = free_list;
2044 if (im != NULL) {
2045 free_list = (PyMethodObject *)(im->im_self);
Guido van Rossumb18618d2000-05-03 23:44:39 +00002046 PyObject_INIT(im, &PyMethod_Type);
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002047 }
2048 else {
Neil Schemenauere83c00e2001-08-29 23:54:21 +00002049 im = PyObject_GC_New(PyMethodObject, &PyMethod_Type);
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002050 if (im == NULL)
2051 return NULL;
2052 }
Fred Drakedb81e8d2001-03-23 04:19:27 +00002053 im->im_weakreflist = NULL;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002054 Py_INCREF(func);
Guido van Rossume8122f11991-05-05 20:03:07 +00002055 im->im_func = func;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002056 Py_XINCREF(self);
Guido van Rossume8122f11991-05-05 20:03:07 +00002057 im->im_self = self;
Guido van Rossumcdf0d752001-08-17 12:07:34 +00002058 Py_XINCREF(class);
Guido van Rossum81daa321993-05-20 14:24:46 +00002059 im->im_class = class;
Neil Schemenauere83c00e2001-08-29 23:54:21 +00002060 _PyObject_GC_TRACK(im);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002061 return (PyObject *)im;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002062}
2063
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002064/* Descriptors for PyMethod attributes */
2065
2066/* im_class, im_func and im_self are stored in the PyMethod object */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002067
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002068#define OFF(x) offsetof(PyMethodObject, x)
Guido van Rossum3f5da241990-12-20 15:06:42 +00002069
Guido van Rossum6f799372001-09-20 20:46:19 +00002070static PyMemberDef instancemethod_memberlist[] = {
2071 {"im_class", T_OBJECT, OFF(im_class), READONLY|RESTRICTED,
2072 "the class associated with a method"},
2073 {"im_func", T_OBJECT, OFF(im_func), READONLY|RESTRICTED,
2074 "the function (or other callable) implementing a method"},
2075 {"im_self", T_OBJECT, OFF(im_self), READONLY|RESTRICTED,
2076 "the instance to which a method is bound; None for unbound methods"},
Guido van Rossum3f5da241990-12-20 15:06:42 +00002077 {NULL} /* Sentinel */
2078};
2079
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002080/* The getattr() implementation for PyMethod objects is similar to
2081 PyObject_GenericGetAttr(), but instead of looking in __dict__ it
2082 asks im_self for the attribute. Then the error handling is a bit
2083 different because we want to preserve the exception raised by the
2084 delegate, unless we have an alternative from our class. */
2085
2086static PyObject *
2087instancemethod_getattro(PyObject *obj, PyObject *name)
2088{
2089 PyMethodObject *im = (PyMethodObject *)obj;
2090 PyTypeObject *tp = obj->ob_type;
Guido van Rossum915f0eb2001-10-17 20:26:38 +00002091 PyObject *descr = NULL, *res;
2092 descrgetfunc f = NULL;
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002093
Guido van Rossum915f0eb2001-10-17 20:26:38 +00002094 if (PyType_HasFeature(tp, Py_TPFLAGS_HAVE_CLASS)) {
2095 if (tp->tp_dict == NULL) {
2096 if (PyType_Ready(tp) < 0)
2097 return NULL;
2098 }
2099 descr = _PyType_Lookup(tp, name);
Barry Warsawd6a9e842001-01-15 20:40:19 +00002100 }
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002101
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002102 f = NULL;
2103 if (descr != NULL) {
Guido van Rossum915f0eb2001-10-17 20:26:38 +00002104 f = TP_DESCR_GET(descr->ob_type);
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002105 if (f != NULL && PyDescr_IsData(descr))
2106 return f(descr, obj, (PyObject *)obj->ob_type);
2107 }
2108
2109 res = PyObject_GetAttr(im->im_func, name);
2110 if (res != NULL || !PyErr_ExceptionMatches(PyExc_AttributeError))
2111 return res;
2112
2113 if (f != NULL) {
2114 PyErr_Clear();
2115 return f(descr, obj, (PyObject *)obj->ob_type);
2116 }
2117
2118 if (descr != NULL) {
2119 PyErr_Clear();
2120 Py_INCREF(descr);
2121 return descr;
2122 }
2123
2124 assert(PyErr_Occurred());
2125 return NULL;
Guido van Rossum3f5da241990-12-20 15:06:42 +00002126}
2127
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002128static void
Fred Drake79912472000-07-09 04:06:11 +00002129instancemethod_dealloc(register PyMethodObject *im)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002130{
Neil Schemenauere83c00e2001-08-29 23:54:21 +00002131 _PyObject_GC_UNTRACK(im);
Fred Drakec916f5a2001-10-26 17:56:51 +00002132 if (im->im_weakreflist != NULL)
2133 PyObject_ClearWeakRefs((PyObject *)im);
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002134 Py_DECREF(im->im_func);
2135 Py_XDECREF(im->im_self);
Guido van Rossumcdf0d752001-08-17 12:07:34 +00002136 Py_XDECREF(im->im_class);
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002137 im->im_self = (PyObject *)free_list;
2138 free_list = im;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002139}
2140
Guido van Rossumebc8c511992-09-03 20:39:51 +00002141static int
Fred Drake79912472000-07-09 04:06:11 +00002142instancemethod_compare(PyMethodObject *a, PyMethodObject *b)
Guido van Rossumebc8c511992-09-03 20:39:51 +00002143{
Guido van Rossume9df7271995-04-06 14:46:51 +00002144 if (a->im_self != b->im_self)
2145 return (a->im_self < b->im_self) ? -1 : 1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002146 return PyObject_Compare(a->im_func, b->im_func);
Guido van Rossumebc8c511992-09-03 20:39:51 +00002147}
2148
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002149static PyObject *
Fred Drake79912472000-07-09 04:06:11 +00002150instancemethod_repr(PyMethodObject *a)
Guido van Rossum25831651993-05-19 14:50:45 +00002151{
Tim Peters6d6c1a32001-08-02 04:15:00 +00002152 PyObject *self = a->im_self;
Guido van Rossum7859f871998-07-08 14:58:16 +00002153 PyObject *func = a->im_func;
Tim Peters6d6c1a32001-08-02 04:15:00 +00002154 PyObject *klass = a->im_class;
2155 PyObject *funcname = NULL, *klassname = NULL, *result = NULL;
2156 char *sfuncname = "?", *sklassname = "?";
2157
2158 funcname = PyObject_GetAttrString(func, "__name__");
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00002159 if (funcname == NULL) {
2160 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
2161 return NULL;
Tim Peters6d6c1a32001-08-02 04:15:00 +00002162 PyErr_Clear();
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00002163 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00002164 else if (!PyString_Check(funcname)) {
2165 Py_DECREF(funcname);
2166 funcname = NULL;
Guido van Rossum7859f871998-07-08 14:58:16 +00002167 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00002168 else
2169 sfuncname = PyString_AS_STRING(funcname);
Guido van Rossum40667692001-08-17 13:59:27 +00002170 if (klass == NULL)
Tim Peters6d6c1a32001-08-02 04:15:00 +00002171 klassname = NULL;
Guido van Rossum40667692001-08-17 13:59:27 +00002172 else {
2173 klassname = PyObject_GetAttrString(klass, "__name__");
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00002174 if (klassname == NULL) {
2175 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
2176 return NULL;
Guido van Rossum40667692001-08-17 13:59:27 +00002177 PyErr_Clear();
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00002178 }
Guido van Rossum40667692001-08-17 13:59:27 +00002179 else if (!PyString_Check(klassname)) {
2180 Py_DECREF(klassname);
2181 klassname = NULL;
2182 }
2183 else
2184 sklassname = PyString_AS_STRING(klassname);
Guido van Rossum7859f871998-07-08 14:58:16 +00002185 }
Guido van Rossum81daa321993-05-20 14:24:46 +00002186 if (self == NULL)
Barry Warsaw7ce36942001-08-24 18:34:26 +00002187 result = PyString_FromFormat("<unbound method %s.%s>",
2188 sklassname, sfuncname);
Guido van Rossum81daa321993-05-20 14:24:46 +00002189 else {
Tim Peters6d6c1a32001-08-02 04:15:00 +00002190 /* XXX Shouldn't use repr() here! */
2191 PyObject *selfrepr = PyObject_Repr(self);
2192 if (selfrepr == NULL)
2193 goto fail;
2194 if (!PyString_Check(selfrepr)) {
2195 Py_DECREF(selfrepr);
2196 goto fail;
2197 }
Barry Warsaw7ce36942001-08-24 18:34:26 +00002198 result = PyString_FromFormat("<bound method %s.%s of %s>",
2199 sklassname, sfuncname,
2200 PyString_AS_STRING(selfrepr));
Tim Peters6d6c1a32001-08-02 04:15:00 +00002201 Py_DECREF(selfrepr);
Guido van Rossum81daa321993-05-20 14:24:46 +00002202 }
Tim Peters6d6c1a32001-08-02 04:15:00 +00002203 fail:
Guido van Rossum42636dc1999-10-11 14:03:12 +00002204 Py_XDECREF(funcname);
Tim Peters6d6c1a32001-08-02 04:15:00 +00002205 Py_XDECREF(klassname);
2206 return result;
Guido van Rossum25831651993-05-19 14:50:45 +00002207}
2208
Guido van Rossum9bfef441993-03-29 10:43:31 +00002209static long
Fred Drake79912472000-07-09 04:06:11 +00002210instancemethod_hash(PyMethodObject *a)
Guido van Rossum9bfef441993-03-29 10:43:31 +00002211{
2212 long x, y;
Guido van Rossum81daa321993-05-20 14:24:46 +00002213 if (a->im_self == NULL)
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002214 x = PyObject_Hash(Py_None);
Guido van Rossum81daa321993-05-20 14:24:46 +00002215 else
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002216 x = PyObject_Hash(a->im_self);
Guido van Rossum9bfef441993-03-29 10:43:31 +00002217 if (x == -1)
2218 return -1;
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002219 y = PyObject_Hash(a->im_func);
Guido van Rossum9bfef441993-03-29 10:43:31 +00002220 if (y == -1)
2221 return -1;
2222 return x ^ y;
2223}
2224
Jeremy Hylton8caad492000-06-23 14:18:11 +00002225static int
2226instancemethod_traverse(PyMethodObject *im, visitproc visit, void *arg)
2227{
2228 int err;
2229 if (im->im_func) {
2230 err = visit(im->im_func, arg);
2231 if (err)
2232 return err;
2233 }
2234 if (im->im_self) {
2235 err = visit(im->im_self, arg);
2236 if (err)
2237 return err;
2238 }
2239 if (im->im_class) {
2240 err = visit(im->im_class, arg);
2241 if (err)
2242 return err;
2243 }
Jeremy Hyltond22162b2000-06-23 17:14:56 +00002244 return 0;
Jeremy Hylton8caad492000-06-23 14:18:11 +00002245}
2246
Guido van Rossuma15dece2001-08-24 18:48:27 +00002247static char *
2248getclassname(PyObject *class)
2249{
2250 PyObject *name;
2251
2252 if (class == NULL)
2253 name = NULL;
2254 else
2255 name = PyObject_GetAttrString(class, "__name__");
2256 if (name == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00002257 /* This function cannot return an exception */
Guido van Rossuma15dece2001-08-24 18:48:27 +00002258 PyErr_Clear();
2259 return "?";
2260 }
2261 if (!PyString_Check(name)) {
2262 Py_DECREF(name);
2263 return "?";
2264 }
2265 PyString_InternInPlace(&name);
2266 Py_DECREF(name);
2267 return PyString_AS_STRING(name);
2268}
2269
2270static char *
2271getinstclassname(PyObject *inst)
2272{
2273 PyObject *class;
2274 char *name;
2275
2276 if (inst == NULL)
2277 return "nothing";
2278
2279 class = PyObject_GetAttrString(inst, "__class__");
2280 if (class == NULL) {
Guido van Rossume7b8ecf2002-06-13 21:42:04 +00002281 /* This function cannot return an exception */
Guido van Rossuma15dece2001-08-24 18:48:27 +00002282 PyErr_Clear();
2283 class = (PyObject *)(inst->ob_type);
2284 Py_INCREF(class);
2285 }
2286 name = getclassname(class);
2287 Py_XDECREF(class);
2288 return name;
2289}
2290
Tim Peters6d6c1a32001-08-02 04:15:00 +00002291static PyObject *
2292instancemethod_call(PyObject *func, PyObject *arg, PyObject *kw)
2293{
2294 PyObject *self = PyMethod_GET_SELF(func);
2295 PyObject *class = PyMethod_GET_CLASS(func);
2296 PyObject *result;
2297
2298 func = PyMethod_GET_FUNCTION(func);
2299 if (self == NULL) {
2300 /* Unbound methods must be called with an instance of
2301 the class (or a derived class) as first argument */
2302 int ok;
2303 if (PyTuple_Size(arg) >= 1)
2304 self = PyTuple_GET_ITEM(arg, 0);
2305 if (self == NULL)
2306 ok = 0;
2307 else {
2308 ok = PyObject_IsInstance(self, class);
2309 if (ok < 0)
2310 return NULL;
2311 }
2312 if (!ok) {
2313 PyErr_Format(PyExc_TypeError,
Guido van Rossuma15dece2001-08-24 18:48:27 +00002314 "unbound method %s%s must be called with "
2315 "%s instance as first argument "
2316 "(got %s%s instead)",
Tim Peters6d6c1a32001-08-02 04:15:00 +00002317 PyEval_GetFuncName(func),
Guido van Rossuma15dece2001-08-24 18:48:27 +00002318 PyEval_GetFuncDesc(func),
2319 getclassname(class),
2320 getinstclassname(self),
2321 self == NULL ? "" : " instance");
Tim Peters6d6c1a32001-08-02 04:15:00 +00002322 return NULL;
2323 }
2324 Py_INCREF(arg);
2325 }
2326 else {
2327 int argcount = PyTuple_Size(arg);
2328 PyObject *newarg = PyTuple_New(argcount + 1);
2329 int i;
2330 if (newarg == NULL)
2331 return NULL;
2332 Py_INCREF(self);
2333 PyTuple_SET_ITEM(newarg, 0, self);
2334 for (i = 0; i < argcount; i++) {
2335 PyObject *v = PyTuple_GET_ITEM(arg, i);
2336 Py_XINCREF(v);
2337 PyTuple_SET_ITEM(newarg, i+1, v);
2338 }
2339 arg = newarg;
2340 }
2341 result = PyObject_Call((PyObject *)func, arg, kw);
2342 Py_DECREF(arg);
2343 return result;
2344}
2345
Guido van Rossum23cc2b42001-08-15 17:52:31 +00002346static PyObject *
Guido van Rossumf23c41d2001-08-17 13:43:27 +00002347instancemethod_descr_get(PyObject *meth, PyObject *obj, PyObject *class)
Guido van Rossum23cc2b42001-08-15 17:52:31 +00002348{
Guido van Rossumf23c41d2001-08-17 13:43:27 +00002349 /* Don't rebind an already bound method, or an unbound method
2350 of a class that's not a base class of class */
2351 if (PyMethod_GET_SELF(meth) != NULL ||
2352 (PyMethod_GET_CLASS(meth) != NULL &&
2353 !PyObject_IsSubclass(class, PyMethod_GET_CLASS(meth)))) {
Guido van Rossum501c7c72001-08-16 20:41:56 +00002354 Py_INCREF(meth);
2355 return meth;
2356 }
Guido van Rossum23cc2b42001-08-15 17:52:31 +00002357 if (obj == Py_None)
2358 obj = NULL;
Guido van Rossumf23c41d2001-08-17 13:43:27 +00002359 return PyMethod_New(PyMethod_GET_FUNCTION(meth), obj, class);
Guido van Rossum23cc2b42001-08-15 17:52:31 +00002360}
2361
Guido van Rossumc0b618a1997-05-02 03:12:38 +00002362PyTypeObject PyMethod_Type = {
2363 PyObject_HEAD_INIT(&PyType_Type)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002364 0,
Guido van Rossum569fce71991-04-16 08:38:43 +00002365 "instance method",
Neil Schemenauere83c00e2001-08-29 23:54:21 +00002366 sizeof(PyMethodObject),
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002367 0,
Guido van Rossum8998b4f2001-01-17 15:28:20 +00002368 (destructor)instancemethod_dealloc, /* tp_dealloc */
2369 0, /* tp_print */
2370 0, /* tp_getattr */
2371 0, /* tp_setattr */
2372 (cmpfunc)instancemethod_compare, /* tp_compare */
2373 (reprfunc)instancemethod_repr, /* tp_repr */
2374 0, /* tp_as_number */
2375 0, /* tp_as_sequence */
2376 0, /* tp_as_mapping */
2377 (hashfunc)instancemethod_hash, /* tp_hash */
Tim Peters6d6c1a32001-08-02 04:15:00 +00002378 instancemethod_call, /* tp_call */
Guido van Rossum8998b4f2001-01-17 15:28:20 +00002379 0, /* tp_str */
2380 (getattrofunc)instancemethod_getattro, /* tp_getattro */
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002381 PyObject_GenericSetAttr, /* tp_setattro */
Guido van Rossum8998b4f2001-01-17 15:28:20 +00002382 0, /* tp_as_buffer */
Neil Schemenauere83c00e2001-08-29 23:54:21 +00002383 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
Guido van Rossum8998b4f2001-01-17 15:28:20 +00002384 0, /* tp_doc */
Jeremy Hylton8caad492000-06-23 14:18:11 +00002385 (traverseproc)instancemethod_traverse, /* tp_traverse */
Fred Drakedb81e8d2001-03-23 04:19:27 +00002386 0, /* tp_clear */
2387 0, /* tp_richcompare */
Guido van Rossum23cc2b42001-08-15 17:52:31 +00002388 offsetof(PyMethodObject, im_weakreflist), /* tp_weaklistoffset */
2389 0, /* tp_iter */
2390 0, /* tp_iternext */
2391 0, /* tp_methods */
Guido van Rossumf0b35e12001-09-18 03:53:24 +00002392 instancemethod_memberlist, /* tp_members */
Guido van Rossum56ff3872001-10-22 02:00:09 +00002393 0, /* tp_getset */
Guido van Rossum23cc2b42001-08-15 17:52:31 +00002394 0, /* tp_base */
2395 0, /* tp_dict */
2396 instancemethod_descr_get, /* tp_descr_get */
2397 0, /* tp_descr_set */
2398 0, /* tp_dictoffset */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002399};
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002400
2401/* Clear out the free list */
2402
2403void
Fred Drake79912472000-07-09 04:06:11 +00002404PyMethod_Fini(void)
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002405{
2406 while (free_list) {
Guido van Rossumb18618d2000-05-03 23:44:39 +00002407 PyMethodObject *im = free_list;
2408 free_list = (PyMethodObject *)(im->im_self);
Neil Schemenauere83c00e2001-08-29 23:54:21 +00002409 PyObject_GC_Del(im);
Guido van Rossuma0d349f1997-08-05 02:06:53 +00002410 }
2411}