]>
Commit | Line | Data |
---|---|---|
53b2ba57 DM |
1 | \r |
2 | /* Class object implementation */\r | |
3 | \r | |
4 | #include "Python.h"\r | |
5 | #include "structmember.h"\r | |
6 | \r | |
7 | /* Free list for method objects to save malloc/free overhead\r | |
8 | * The im_self element is used to chain the elements.\r | |
9 | */\r | |
10 | static PyMethodObject *free_list;\r | |
11 | static int numfree = 0;\r | |
12 | #ifndef PyMethod_MAXFREELIST\r | |
13 | #define PyMethod_MAXFREELIST 256\r | |
14 | #endif\r | |
15 | \r | |
16 | #define TP_DESCR_GET(t) \\r | |
17 | (PyType_HasFeature(t, Py_TPFLAGS_HAVE_CLASS) ? (t)->tp_descr_get : NULL)\r | |
18 | \r | |
19 | /* Forward */\r | |
20 | static PyObject *class_lookup(PyClassObject *, PyObject *,\r | |
21 | PyClassObject **);\r | |
22 | static PyObject *instance_getattr1(PyInstanceObject *, PyObject *);\r | |
23 | static PyObject *instance_getattr2(PyInstanceObject *, PyObject *);\r | |
24 | \r | |
25 | static PyObject *getattrstr, *setattrstr, *delattrstr;\r | |
26 | \r | |
27 | \r | |
28 | PyObject *\r | |
29 | PyClass_New(PyObject *bases, PyObject *dict, PyObject *name)\r | |
30 | /* bases is NULL or tuple of classobjects! */\r | |
31 | {\r | |
32 | PyClassObject *op, *dummy;\r | |
33 | static PyObject *docstr, *modstr, *namestr;\r | |
34 | if (docstr == NULL) {\r | |
35 | docstr= PyString_InternFromString("__doc__");\r | |
36 | if (docstr == NULL)\r | |
37 | return NULL;\r | |
38 | }\r | |
39 | if (modstr == NULL) {\r | |
40 | modstr= PyString_InternFromString("__module__");\r | |
41 | if (modstr == NULL)\r | |
42 | return NULL;\r | |
43 | }\r | |
44 | if (namestr == NULL) {\r | |
45 | namestr= PyString_InternFromString("__name__");\r | |
46 | if (namestr == NULL)\r | |
47 | return NULL;\r | |
48 | }\r | |
49 | if (name == NULL || !PyString_Check(name)) {\r | |
50 | PyErr_SetString(PyExc_TypeError,\r | |
51 | "PyClass_New: name must be a string");\r | |
52 | return NULL;\r | |
53 | }\r | |
54 | if (dict == NULL || !PyDict_Check(dict)) {\r | |
55 | PyErr_SetString(PyExc_TypeError,\r | |
56 | "PyClass_New: dict must be a dictionary");\r | |
57 | return NULL;\r | |
58 | }\r | |
59 | if (PyDict_GetItem(dict, docstr) == NULL) {\r | |
60 | if (PyDict_SetItem(dict, docstr, Py_None) < 0)\r | |
61 | return NULL;\r | |
62 | }\r | |
63 | if (PyDict_GetItem(dict, modstr) == NULL) {\r | |
64 | PyObject *globals = PyEval_GetGlobals();\r | |
65 | if (globals != NULL) {\r | |
66 | PyObject *modname = PyDict_GetItem(globals, namestr);\r | |
67 | if (modname != NULL) {\r | |
68 | if (PyDict_SetItem(dict, modstr, modname) < 0)\r | |
69 | return NULL;\r | |
70 | }\r | |
71 | }\r | |
72 | }\r | |
73 | if (bases == NULL) {\r | |
74 | bases = PyTuple_New(0);\r | |
75 | if (bases == NULL)\r | |
76 | return NULL;\r | |
77 | }\r | |
78 | else {\r | |
79 | Py_ssize_t i, n;\r | |
80 | PyObject *base;\r | |
81 | if (!PyTuple_Check(bases)) {\r | |
82 | PyErr_SetString(PyExc_TypeError,\r | |
83 | "PyClass_New: bases must be a tuple");\r | |
84 | return NULL;\r | |
85 | }\r | |
86 | n = PyTuple_Size(bases);\r | |
87 | for (i = 0; i < n; i++) {\r | |
88 | base = PyTuple_GET_ITEM(bases, i);\r | |
89 | if (!PyClass_Check(base)) {\r | |
90 | if (PyCallable_Check(\r | |
91 | (PyObject *) base->ob_type))\r | |
92 | return PyObject_CallFunctionObjArgs(\r | |
93 | (PyObject *) base->ob_type,\r | |
94 | name, bases, dict, NULL);\r | |
95 | PyErr_SetString(PyExc_TypeError,\r | |
96 | "PyClass_New: base must be a class");\r | |
97 | return NULL;\r | |
98 | }\r | |
99 | }\r | |
100 | Py_INCREF(bases);\r | |
101 | }\r | |
102 | \r | |
103 | if (getattrstr == NULL) {\r | |
104 | getattrstr = PyString_InternFromString("__getattr__");\r | |
105 | if (getattrstr == NULL)\r | |
106 | goto alloc_error;\r | |
107 | setattrstr = PyString_InternFromString("__setattr__");\r | |
108 | if (setattrstr == NULL)\r | |
109 | goto alloc_error;\r | |
110 | delattrstr = PyString_InternFromString("__delattr__");\r | |
111 | if (delattrstr == NULL)\r | |
112 | goto alloc_error;\r | |
113 | }\r | |
114 | \r | |
115 | op = PyObject_GC_New(PyClassObject, &PyClass_Type);\r | |
116 | if (op == NULL) {\r | |
117 | alloc_error:\r | |
118 | Py_DECREF(bases);\r | |
119 | return NULL;\r | |
120 | }\r | |
121 | op->cl_bases = bases;\r | |
122 | Py_INCREF(dict);\r | |
123 | op->cl_dict = dict;\r | |
124 | Py_XINCREF(name);\r | |
125 | op->cl_name = name;\r | |
126 | op->cl_weakreflist = NULL;\r | |
127 | \r | |
128 | op->cl_getattr = class_lookup(op, getattrstr, &dummy);\r | |
129 | op->cl_setattr = class_lookup(op, setattrstr, &dummy);\r | |
130 | op->cl_delattr = class_lookup(op, delattrstr, &dummy);\r | |
131 | Py_XINCREF(op->cl_getattr);\r | |
132 | Py_XINCREF(op->cl_setattr);\r | |
133 | Py_XINCREF(op->cl_delattr);\r | |
134 | _PyObject_GC_TRACK(op);\r | |
135 | return (PyObject *) op;\r | |
136 | }\r | |
137 | \r | |
138 | PyObject *\r | |
139 | PyMethod_Function(PyObject *im)\r | |
140 | {\r | |
141 | if (!PyMethod_Check(im)) {\r | |
142 | PyErr_BadInternalCall();\r | |
143 | return NULL;\r | |
144 | }\r | |
145 | return ((PyMethodObject *)im)->im_func;\r | |
146 | }\r | |
147 | \r | |
148 | PyObject *\r | |
149 | PyMethod_Self(PyObject *im)\r | |
150 | {\r | |
151 | if (!PyMethod_Check(im)) {\r | |
152 | PyErr_BadInternalCall();\r | |
153 | return NULL;\r | |
154 | }\r | |
155 | return ((PyMethodObject *)im)->im_self;\r | |
156 | }\r | |
157 | \r | |
158 | PyObject *\r | |
159 | PyMethod_Class(PyObject *im)\r | |
160 | {\r | |
161 | if (!PyMethod_Check(im)) {\r | |
162 | PyErr_BadInternalCall();\r | |
163 | return NULL;\r | |
164 | }\r | |
165 | return ((PyMethodObject *)im)->im_class;\r | |
166 | }\r | |
167 | \r | |
168 | PyDoc_STRVAR(class_doc,\r | |
169 | "classobj(name, bases, dict)\n\\r | |
170 | \n\\r | |
171 | Create a class object. The name must be a string; the second argument\n\\r | |
172 | a tuple of classes, and the third a dictionary.");\r | |
173 | \r | |
174 | static PyObject *\r | |
175 | class_new(PyTypeObject *type, PyObject *args, PyObject *kwds)\r | |
176 | {\r | |
177 | PyObject *name, *bases, *dict;\r | |
178 | static char *kwlist[] = {"name", "bases", "dict", 0};\r | |
179 | \r | |
180 | if (!PyArg_ParseTupleAndKeywords(args, kwds, "SOO", kwlist,\r | |
181 | &name, &bases, &dict))\r | |
182 | return NULL;\r | |
183 | return PyClass_New(bases, dict, name);\r | |
184 | }\r | |
185 | \r | |
186 | /* Class methods */\r | |
187 | \r | |
188 | static void\r | |
189 | class_dealloc(PyClassObject *op)\r | |
190 | {\r | |
191 | _PyObject_GC_UNTRACK(op);\r | |
192 | if (op->cl_weakreflist != NULL)\r | |
193 | PyObject_ClearWeakRefs((PyObject *) op);\r | |
194 | Py_DECREF(op->cl_bases);\r | |
195 | Py_DECREF(op->cl_dict);\r | |
196 | Py_XDECREF(op->cl_name);\r | |
197 | Py_XDECREF(op->cl_getattr);\r | |
198 | Py_XDECREF(op->cl_setattr);\r | |
199 | Py_XDECREF(op->cl_delattr);\r | |
200 | PyObject_GC_Del(op);\r | |
201 | }\r | |
202 | \r | |
203 | static PyObject *\r | |
204 | class_lookup(PyClassObject *cp, PyObject *name, PyClassObject **pclass)\r | |
205 | {\r | |
206 | Py_ssize_t i, n;\r | |
207 | PyObject *value = PyDict_GetItem(cp->cl_dict, name);\r | |
208 | if (value != NULL) {\r | |
209 | *pclass = cp;\r | |
210 | return value;\r | |
211 | }\r | |
212 | n = PyTuple_Size(cp->cl_bases);\r | |
213 | for (i = 0; i < n; i++) {\r | |
214 | /* XXX What if one of the bases is not a class? */\r | |
215 | PyObject *v = class_lookup(\r | |
216 | (PyClassObject *)\r | |
217 | PyTuple_GetItem(cp->cl_bases, i), name, pclass);\r | |
218 | if (v != NULL)\r | |
219 | return v;\r | |
220 | }\r | |
221 | return NULL;\r | |
222 | }\r | |
223 | \r | |
224 | static PyObject *\r | |
225 | class_getattr(register PyClassObject *op, PyObject *name)\r | |
226 | {\r | |
227 | register PyObject *v;\r | |
228 | register char *sname;\r | |
229 | PyClassObject *klass;\r | |
230 | descrgetfunc f;\r | |
231 | \r | |
232 | if (!PyString_Check(name)) {\r | |
233 | PyErr_SetString(PyExc_TypeError, "attribute name must be a string");\r | |
234 | return NULL;\r | |
235 | }\r | |
236 | \r | |
237 | sname = PyString_AsString(name);\r | |
238 | if (sname[0] == '_' && sname[1] == '_') {\r | |
239 | if (strcmp(sname, "__dict__") == 0) {\r | |
240 | if (PyEval_GetRestricted()) {\r | |
241 | PyErr_SetString(PyExc_RuntimeError,\r | |
242 | "class.__dict__ not accessible in restricted mode");\r | |
243 | return NULL;\r | |
244 | }\r | |
245 | Py_INCREF(op->cl_dict);\r | |
246 | return op->cl_dict;\r | |
247 | }\r | |
248 | if (strcmp(sname, "__bases__") == 0) {\r | |
249 | Py_INCREF(op->cl_bases);\r | |
250 | return op->cl_bases;\r | |
251 | }\r | |
252 | if (strcmp(sname, "__name__") == 0) {\r | |
253 | if (op->cl_name == NULL)\r | |
254 | v = Py_None;\r | |
255 | else\r | |
256 | v = op->cl_name;\r | |
257 | Py_INCREF(v);\r | |
258 | return v;\r | |
259 | }\r | |
260 | }\r | |
261 | v = class_lookup(op, name, &klass);\r | |
262 | if (v == NULL) {\r | |
263 | PyErr_Format(PyExc_AttributeError,\r | |
264 | "class %.50s has no attribute '%.400s'",\r | |
265 | PyString_AS_STRING(op->cl_name), sname);\r | |
266 | return NULL;\r | |
267 | }\r | |
268 | f = TP_DESCR_GET(v->ob_type);\r | |
269 | if (f == NULL)\r | |
270 | Py_INCREF(v);\r | |
271 | else\r | |
272 | v = f(v, (PyObject *)NULL, (PyObject *)op);\r | |
273 | return v;\r | |
274 | }\r | |
275 | \r | |
276 | static void\r | |
277 | set_slot(PyObject **slot, PyObject *v)\r | |
278 | {\r | |
279 | PyObject *temp = *slot;\r | |
280 | Py_XINCREF(v);\r | |
281 | *slot = v;\r | |
282 | Py_XDECREF(temp);\r | |
283 | }\r | |
284 | \r | |
285 | static void\r | |
286 | set_attr_slots(PyClassObject *c)\r | |
287 | {\r | |
288 | PyClassObject *dummy;\r | |
289 | \r | |
290 | set_slot(&c->cl_getattr, class_lookup(c, getattrstr, &dummy));\r | |
291 | set_slot(&c->cl_setattr, class_lookup(c, setattrstr, &dummy));\r | |
292 | set_slot(&c->cl_delattr, class_lookup(c, delattrstr, &dummy));\r | |
293 | }\r | |
294 | \r | |
295 | static char *\r | |
296 | set_dict(PyClassObject *c, PyObject *v)\r | |
297 | {\r | |
298 | if (v == NULL || !PyDict_Check(v))\r | |
299 | return "__dict__ must be a dictionary object";\r | |
300 | set_slot(&c->cl_dict, v);\r | |
301 | set_attr_slots(c);\r | |
302 | return "";\r | |
303 | }\r | |
304 | \r | |
305 | static char *\r | |
306 | set_bases(PyClassObject *c, PyObject *v)\r | |
307 | {\r | |
308 | Py_ssize_t i, n;\r | |
309 | \r | |
310 | if (v == NULL || !PyTuple_Check(v))\r | |
311 | return "__bases__ must be a tuple object";\r | |
312 | n = PyTuple_Size(v);\r | |
313 | for (i = 0; i < n; i++) {\r | |
314 | PyObject *x = PyTuple_GET_ITEM(v, i);\r | |
315 | if (!PyClass_Check(x))\r | |
316 | return "__bases__ items must be classes";\r | |
317 | if (PyClass_IsSubclass(x, (PyObject *)c))\r | |
318 | return "a __bases__ item causes an inheritance cycle";\r | |
319 | }\r | |
320 | set_slot(&c->cl_bases, v);\r | |
321 | set_attr_slots(c);\r | |
322 | return "";\r | |
323 | }\r | |
324 | \r | |
325 | static char *\r | |
326 | set_name(PyClassObject *c, PyObject *v)\r | |
327 | {\r | |
328 | if (v == NULL || !PyString_Check(v))\r | |
329 | return "__name__ must be a string object";\r | |
330 | if (strlen(PyString_AS_STRING(v)) != (size_t)PyString_GET_SIZE(v))\r | |
331 | return "__name__ must not contain null bytes";\r | |
332 | set_slot(&c->cl_name, v);\r | |
333 | return "";\r | |
334 | }\r | |
335 | \r | |
336 | static int\r | |
337 | class_setattr(PyClassObject *op, PyObject *name, PyObject *v)\r | |
338 | {\r | |
339 | char *sname;\r | |
340 | if (PyEval_GetRestricted()) {\r | |
341 | PyErr_SetString(PyExc_RuntimeError,\r | |
342 | "classes are read-only in restricted mode");\r | |
343 | return -1;\r | |
344 | }\r | |
345 | if (!PyString_Check(name)) {\r | |
346 | PyErr_SetString(PyExc_TypeError, "attribute name must be a string");\r | |
347 | return -1;\r | |
348 | }\r | |
349 | sname = PyString_AsString(name);\r | |
350 | if (sname[0] == '_' && sname[1] == '_') {\r | |
351 | Py_ssize_t n = PyString_Size(name);\r | |
352 | if (sname[n-1] == '_' && sname[n-2] == '_') {\r | |
353 | char *err = NULL;\r | |
354 | if (strcmp(sname, "__dict__") == 0)\r | |
355 | err = set_dict(op, v);\r | |
356 | else if (strcmp(sname, "__bases__") == 0)\r | |
357 | err = set_bases(op, v);\r | |
358 | else if (strcmp(sname, "__name__") == 0)\r | |
359 | err = set_name(op, v);\r | |
360 | else if (strcmp(sname, "__getattr__") == 0)\r | |
361 | set_slot(&op->cl_getattr, v);\r | |
362 | else if (strcmp(sname, "__setattr__") == 0)\r | |
363 | set_slot(&op->cl_setattr, v);\r | |
364 | else if (strcmp(sname, "__delattr__") == 0)\r | |
365 | set_slot(&op->cl_delattr, v);\r | |
366 | /* For the last three, we fall through to update the\r | |
367 | dictionary as well. */\r | |
368 | if (err != NULL) {\r | |
369 | if (*err == '\0')\r | |
370 | return 0;\r | |
371 | PyErr_SetString(PyExc_TypeError, err);\r | |
372 | return -1;\r | |
373 | }\r | |
374 | }\r | |
375 | }\r | |
376 | if (v == NULL) {\r | |
377 | int rv = PyDict_DelItem(op->cl_dict, name);\r | |
378 | if (rv < 0)\r | |
379 | PyErr_Format(PyExc_AttributeError,\r | |
380 | "class %.50s has no attribute '%.400s'",\r | |
381 | PyString_AS_STRING(op->cl_name), sname);\r | |
382 | return rv;\r | |
383 | }\r | |
384 | else\r | |
385 | return PyDict_SetItem(op->cl_dict, name, v);\r | |
386 | }\r | |
387 | \r | |
388 | static PyObject *\r | |
389 | class_repr(PyClassObject *op)\r | |
390 | {\r | |
391 | PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");\r | |
392 | char *name;\r | |
393 | if (op->cl_name == NULL || !PyString_Check(op->cl_name))\r | |
394 | name = "?";\r | |
395 | else\r | |
396 | name = PyString_AsString(op->cl_name);\r | |
397 | if (mod == NULL || !PyString_Check(mod))\r | |
398 | return PyString_FromFormat("<class ?.%s at %p>", name, op);\r | |
399 | else\r | |
400 | return PyString_FromFormat("<class %s.%s at %p>",\r | |
401 | PyString_AsString(mod),\r | |
402 | name, op);\r | |
403 | }\r | |
404 | \r | |
405 | static PyObject *\r | |
406 | class_str(PyClassObject *op)\r | |
407 | {\r | |
408 | PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");\r | |
409 | PyObject *name = op->cl_name;\r | |
410 | PyObject *res;\r | |
411 | Py_ssize_t m, n;\r | |
412 | \r | |
413 | if (name == NULL || !PyString_Check(name))\r | |
414 | return class_repr(op);\r | |
415 | if (mod == NULL || !PyString_Check(mod)) {\r | |
416 | Py_INCREF(name);\r | |
417 | return name;\r | |
418 | }\r | |
419 | m = PyString_GET_SIZE(mod);\r | |
420 | n = PyString_GET_SIZE(name);\r | |
421 | res = PyString_FromStringAndSize((char *)NULL, m+1+n);\r | |
422 | if (res != NULL) {\r | |
423 | char *s = PyString_AS_STRING(res);\r | |
424 | memcpy(s, PyString_AS_STRING(mod), m);\r | |
425 | s += m;\r | |
426 | *s++ = '.';\r | |
427 | memcpy(s, PyString_AS_STRING(name), n);\r | |
428 | }\r | |
429 | return res;\r | |
430 | }\r | |
431 | \r | |
432 | static int\r | |
433 | class_traverse(PyClassObject *o, visitproc visit, void *arg)\r | |
434 | {\r | |
435 | Py_VISIT(o->cl_bases);\r | |
436 | Py_VISIT(o->cl_dict);\r | |
437 | Py_VISIT(o->cl_name);\r | |
438 | Py_VISIT(o->cl_getattr);\r | |
439 | Py_VISIT(o->cl_setattr);\r | |
440 | Py_VISIT(o->cl_delattr);\r | |
441 | return 0;\r | |
442 | }\r | |
443 | \r | |
444 | PyTypeObject PyClass_Type = {\r | |
445 | PyObject_HEAD_INIT(&PyType_Type)\r | |
446 | 0,\r | |
447 | "classobj",\r | |
448 | sizeof(PyClassObject),\r | |
449 | 0,\r | |
450 | (destructor)class_dealloc, /* tp_dealloc */\r | |
451 | 0, /* tp_print */\r | |
452 | 0, /* tp_getattr */\r | |
453 | 0, /* tp_setattr */\r | |
454 | 0, /* tp_compare */\r | |
455 | (reprfunc)class_repr, /* tp_repr */\r | |
456 | 0, /* tp_as_number */\r | |
457 | 0, /* tp_as_sequence */\r | |
458 | 0, /* tp_as_mapping */\r | |
459 | 0, /* tp_hash */\r | |
460 | PyInstance_New, /* tp_call */\r | |
461 | (reprfunc)class_str, /* tp_str */\r | |
462 | (getattrofunc)class_getattr, /* tp_getattro */\r | |
463 | (setattrofunc)class_setattr, /* tp_setattro */\r | |
464 | 0, /* tp_as_buffer */\r | |
465 | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */\r | |
466 | class_doc, /* tp_doc */\r | |
467 | (traverseproc)class_traverse, /* tp_traverse */\r | |
468 | 0, /* tp_clear */\r | |
469 | 0, /* tp_richcompare */\r | |
470 | offsetof(PyClassObject, cl_weakreflist), /* tp_weaklistoffset */\r | |
471 | 0, /* tp_iter */\r | |
472 | 0, /* tp_iternext */\r | |
473 | 0, /* tp_methods */\r | |
474 | 0, /* tp_members */\r | |
475 | 0, /* tp_getset */\r | |
476 | 0, /* tp_base */\r | |
477 | 0, /* tp_dict */\r | |
478 | 0, /* tp_descr_get */\r | |
479 | 0, /* tp_descr_set */\r | |
480 | 0, /* tp_dictoffset */\r | |
481 | 0, /* tp_init */\r | |
482 | 0, /* tp_alloc */\r | |
483 | class_new, /* tp_new */\r | |
484 | };\r | |
485 | \r | |
486 | int\r | |
487 | PyClass_IsSubclass(PyObject *klass, PyObject *base)\r | |
488 | {\r | |
489 | Py_ssize_t i, n;\r | |
490 | PyClassObject *cp;\r | |
491 | if (klass == base)\r | |
492 | return 1;\r | |
493 | if (PyTuple_Check(base)) {\r | |
494 | n = PyTuple_GET_SIZE(base);\r | |
495 | for (i = 0; i < n; i++) {\r | |
496 | if (PyClass_IsSubclass(klass, PyTuple_GET_ITEM(base, i)))\r | |
497 | return 1;\r | |
498 | }\r | |
499 | return 0;\r | |
500 | }\r | |
501 | if (klass == NULL || !PyClass_Check(klass))\r | |
502 | return 0;\r | |
503 | cp = (PyClassObject *)klass;\r | |
504 | n = PyTuple_Size(cp->cl_bases);\r | |
505 | for (i = 0; i < n; i++) {\r | |
506 | if (PyClass_IsSubclass(PyTuple_GetItem(cp->cl_bases, i), base))\r | |
507 | return 1;\r | |
508 | }\r | |
509 | return 0;\r | |
510 | }\r | |
511 | \r | |
512 | \r | |
513 | /* Instance objects */\r | |
514 | \r | |
515 | PyObject *\r | |
516 | PyInstance_NewRaw(PyObject *klass, PyObject *dict)\r | |
517 | {\r | |
518 | PyInstanceObject *inst;\r | |
519 | \r | |
520 | if (!PyClass_Check(klass)) {\r | |
521 | PyErr_BadInternalCall();\r | |
522 | return NULL;\r | |
523 | }\r | |
524 | if (dict == NULL) {\r | |
525 | dict = PyDict_New();\r | |
526 | if (dict == NULL)\r | |
527 | return NULL;\r | |
528 | }\r | |
529 | else {\r | |
530 | if (!PyDict_Check(dict)) {\r | |
531 | PyErr_BadInternalCall();\r | |
532 | return NULL;\r | |
533 | }\r | |
534 | Py_INCREF(dict);\r | |
535 | }\r | |
536 | inst = PyObject_GC_New(PyInstanceObject, &PyInstance_Type);\r | |
537 | if (inst == NULL) {\r | |
538 | Py_DECREF(dict);\r | |
539 | return NULL;\r | |
540 | }\r | |
541 | inst->in_weakreflist = NULL;\r | |
542 | Py_INCREF(klass);\r | |
543 | inst->in_class = (PyClassObject *)klass;\r | |
544 | inst->in_dict = dict;\r | |
545 | _PyObject_GC_TRACK(inst);\r | |
546 | return (PyObject *)inst;\r | |
547 | }\r | |
548 | \r | |
549 | PyObject *\r | |
550 | PyInstance_New(PyObject *klass, PyObject *arg, PyObject *kw)\r | |
551 | {\r | |
552 | register PyInstanceObject *inst;\r | |
553 | PyObject *init;\r | |
554 | static PyObject *initstr;\r | |
555 | \r | |
556 | if (initstr == NULL) {\r | |
557 | initstr = PyString_InternFromString("__init__");\r | |
558 | if (initstr == NULL)\r | |
559 | return NULL;\r | |
560 | }\r | |
561 | inst = (PyInstanceObject *) PyInstance_NewRaw(klass, NULL);\r | |
562 | if (inst == NULL)\r | |
563 | return NULL;\r | |
564 | init = instance_getattr2(inst, initstr);\r | |
565 | if (init == NULL) {\r | |
566 | if (PyErr_Occurred()) {\r | |
567 | Py_DECREF(inst);\r | |
568 | return NULL;\r | |
569 | }\r | |
570 | if ((arg != NULL && (!PyTuple_Check(arg) ||\r | |
571 | PyTuple_Size(arg) != 0))\r | |
572 | || (kw != NULL && (!PyDict_Check(kw) ||\r | |
573 | PyDict_Size(kw) != 0))) {\r | |
574 | PyErr_SetString(PyExc_TypeError,\r | |
575 | "this constructor takes no arguments");\r | |
576 | Py_DECREF(inst);\r | |
577 | inst = NULL;\r | |
578 | }\r | |
579 | }\r | |
580 | else {\r | |
581 | PyObject *res = PyEval_CallObjectWithKeywords(init, arg, kw);\r | |
582 | Py_DECREF(init);\r | |
583 | if (res == NULL) {\r | |
584 | Py_DECREF(inst);\r | |
585 | inst = NULL;\r | |
586 | }\r | |
587 | else {\r | |
588 | if (res != Py_None) {\r | |
589 | PyErr_SetString(PyExc_TypeError,\r | |
590 | "__init__() should return None");\r | |
591 | Py_DECREF(inst);\r | |
592 | inst = NULL;\r | |
593 | }\r | |
594 | Py_DECREF(res);\r | |
595 | }\r | |
596 | }\r | |
597 | return (PyObject *)inst;\r | |
598 | }\r | |
599 | \r | |
600 | /* Instance methods */\r | |
601 | \r | |
602 | PyDoc_STRVAR(instance_doc,\r | |
603 | "instance(class[, dict])\n\\r | |
604 | \n\\r | |
605 | Create an instance without calling its __init__() method.\n\\r | |
606 | The class must be a classic class.\n\\r | |
607 | If present, dict must be a dictionary or None.");\r | |
608 | \r | |
609 | static PyObject *\r | |
610 | instance_new(PyTypeObject* type, PyObject* args, PyObject *kw)\r | |
611 | {\r | |
612 | PyObject *klass;\r | |
613 | PyObject *dict = Py_None;\r | |
614 | \r | |
615 | if (!PyArg_ParseTuple(args, "O!|O:instance",\r | |
616 | &PyClass_Type, &klass, &dict))\r | |
617 | return NULL;\r | |
618 | \r | |
619 | if (dict == Py_None)\r | |
620 | dict = NULL;\r | |
621 | else if (!PyDict_Check(dict)) {\r | |
622 | PyErr_SetString(PyExc_TypeError,\r | |
623 | "instance() second arg must be dictionary or None");\r | |
624 | return NULL;\r | |
625 | }\r | |
626 | return PyInstance_NewRaw(klass, dict);\r | |
627 | }\r | |
628 | \r | |
629 | \r | |
630 | static void\r | |
631 | instance_dealloc(register PyInstanceObject *inst)\r | |
632 | {\r | |
633 | PyObject *error_type, *error_value, *error_traceback;\r | |
634 | PyObject *del;\r | |
635 | static PyObject *delstr;\r | |
636 | \r | |
637 | _PyObject_GC_UNTRACK(inst);\r | |
638 | if (inst->in_weakreflist != NULL)\r | |
639 | PyObject_ClearWeakRefs((PyObject *) inst);\r | |
640 | \r | |
641 | /* Temporarily resurrect the object. */\r | |
642 | assert(inst->ob_type == &PyInstance_Type);\r | |
643 | assert(inst->ob_refcnt == 0);\r | |
644 | inst->ob_refcnt = 1;\r | |
645 | \r | |
646 | /* Save the current exception, if any. */\r | |
647 | PyErr_Fetch(&error_type, &error_value, &error_traceback);\r | |
648 | /* Execute __del__ method, if any. */\r | |
649 | if (delstr == NULL) {\r | |
650 | delstr = PyString_InternFromString("__del__");\r | |
651 | if (delstr == NULL)\r | |
652 | PyErr_WriteUnraisable((PyObject*)inst);\r | |
653 | }\r | |
654 | if (delstr && (del = instance_getattr2(inst, delstr)) != NULL) {\r | |
655 | PyObject *res = PyEval_CallObject(del, (PyObject *)NULL);\r | |
656 | if (res == NULL)\r | |
657 | PyErr_WriteUnraisable(del);\r | |
658 | else\r | |
659 | Py_DECREF(res);\r | |
660 | Py_DECREF(del);\r | |
661 | }\r | |
662 | /* Restore the saved exception. */\r | |
663 | PyErr_Restore(error_type, error_value, error_traceback);\r | |
664 | \r | |
665 | /* Undo the temporary resurrection; can't use DECREF here, it would\r | |
666 | * cause a recursive call.\r | |
667 | */\r | |
668 | assert(inst->ob_refcnt > 0);\r | |
669 | if (--inst->ob_refcnt == 0) {\r | |
670 | \r | |
671 | /* New weakrefs could be created during the finalizer call.\r | |
672 | If this occurs, clear them out without calling their\r | |
673 | finalizers since they might rely on part of the object\r | |
674 | being finalized that has already been destroyed. */\r | |
675 | while (inst->in_weakreflist != NULL) {\r | |
676 | _PyWeakref_ClearRef((PyWeakReference *)\r | |
677 | (inst->in_weakreflist));\r | |
678 | }\r | |
679 | \r | |
680 | Py_DECREF(inst->in_class);\r | |
681 | Py_XDECREF(inst->in_dict);\r | |
682 | PyObject_GC_Del(inst);\r | |
683 | }\r | |
684 | else {\r | |
685 | Py_ssize_t refcnt = inst->ob_refcnt;\r | |
686 | /* __del__ resurrected it! Make it look like the original\r | |
687 | * Py_DECREF never happened.\r | |
688 | */\r | |
689 | _Py_NewReference((PyObject *)inst);\r | |
690 | inst->ob_refcnt = refcnt;\r | |
691 | _PyObject_GC_TRACK(inst);\r | |
692 | /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so\r | |
693 | * we need to undo that. */\r | |
694 | _Py_DEC_REFTOTAL;\r | |
695 | /* If Py_TRACE_REFS, _Py_NewReference re-added self to the\r | |
696 | * object chain, so no more to do there.\r | |
697 | * If COUNT_ALLOCS, the original decref bumped tp_frees, and\r | |
698 | * _Py_NewReference bumped tp_allocs: both of those need to be\r | |
699 | * undone.\r | |
700 | */\r | |
701 | #ifdef COUNT_ALLOCS\r | |
702 | --inst->ob_type->tp_frees;\r | |
703 | --inst->ob_type->tp_allocs;\r | |
704 | #endif\r | |
705 | }\r | |
706 | }\r | |
707 | \r | |
708 | static PyObject *\r | |
709 | instance_getattr1(register PyInstanceObject *inst, PyObject *name)\r | |
710 | {\r | |
711 | register PyObject *v;\r | |
712 | register char *sname;\r | |
713 | \r | |
714 | if (!PyString_Check(name)) {\r | |
715 | PyErr_SetString(PyExc_TypeError, "attribute name must be a string");\r | |
716 | return NULL;\r | |
717 | }\r | |
718 | \r | |
719 | sname = PyString_AsString(name);\r | |
720 | if (sname[0] == '_' && sname[1] == '_') {\r | |
721 | if (strcmp(sname, "__dict__") == 0) {\r | |
722 | if (PyEval_GetRestricted()) {\r | |
723 | PyErr_SetString(PyExc_RuntimeError,\r | |
724 | "instance.__dict__ not accessible in restricted mode");\r | |
725 | return NULL;\r | |
726 | }\r | |
727 | Py_INCREF(inst->in_dict);\r | |
728 | return inst->in_dict;\r | |
729 | }\r | |
730 | if (strcmp(sname, "__class__") == 0) {\r | |
731 | Py_INCREF(inst->in_class);\r | |
732 | return (PyObject *)inst->in_class;\r | |
733 | }\r | |
734 | }\r | |
735 | v = instance_getattr2(inst, name);\r | |
736 | if (v == NULL && !PyErr_Occurred()) {\r | |
737 | PyErr_Format(PyExc_AttributeError,\r | |
738 | "%.50s instance has no attribute '%.400s'",\r | |
739 | PyString_AS_STRING(inst->in_class->cl_name), sname);\r | |
740 | }\r | |
741 | return v;\r | |
742 | }\r | |
743 | \r | |
744 | static PyObject *\r | |
745 | instance_getattr2(register PyInstanceObject *inst, PyObject *name)\r | |
746 | {\r | |
747 | register PyObject *v;\r | |
748 | PyClassObject *klass;\r | |
749 | descrgetfunc f;\r | |
750 | \r | |
751 | v = PyDict_GetItem(inst->in_dict, name);\r | |
752 | if (v != NULL) {\r | |
753 | Py_INCREF(v);\r | |
754 | return v;\r | |
755 | }\r | |
756 | v = class_lookup(inst->in_class, name, &klass);\r | |
757 | if (v != NULL) {\r | |
758 | Py_INCREF(v);\r | |
759 | f = TP_DESCR_GET(v->ob_type);\r | |
760 | if (f != NULL) {\r | |
761 | PyObject *w = f(v, (PyObject *)inst,\r | |
762 | (PyObject *)(inst->in_class));\r | |
763 | Py_DECREF(v);\r | |
764 | v = w;\r | |
765 | }\r | |
766 | }\r | |
767 | return v;\r | |
768 | }\r | |
769 | \r | |
770 | static PyObject *\r | |
771 | instance_getattr(register PyInstanceObject *inst, PyObject *name)\r | |
772 | {\r | |
773 | register PyObject *func, *res;\r | |
774 | res = instance_getattr1(inst, name);\r | |
775 | if (res == NULL && (func = inst->in_class->cl_getattr) != NULL) {\r | |
776 | PyObject *args;\r | |
777 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
778 | return NULL;\r | |
779 | PyErr_Clear();\r | |
780 | args = PyTuple_Pack(2, inst, name);\r | |
781 | if (args == NULL)\r | |
782 | return NULL;\r | |
783 | res = PyEval_CallObject(func, args);\r | |
784 | Py_DECREF(args);\r | |
785 | }\r | |
786 | return res;\r | |
787 | }\r | |
788 | \r | |
789 | /* See classobject.h comments: this only does dict lookups, and is always\r | |
790 | * safe to call.\r | |
791 | */\r | |
792 | PyObject *\r | |
793 | _PyInstance_Lookup(PyObject *pinst, PyObject *name)\r | |
794 | {\r | |
795 | PyObject *v;\r | |
796 | PyClassObject *klass;\r | |
797 | PyInstanceObject *inst; /* pinst cast to the right type */\r | |
798 | \r | |
799 | assert(PyInstance_Check(pinst));\r | |
800 | inst = (PyInstanceObject *)pinst;\r | |
801 | \r | |
802 | assert(PyString_Check(name));\r | |
803 | \r | |
804 | v = PyDict_GetItem(inst->in_dict, name);\r | |
805 | if (v == NULL)\r | |
806 | v = class_lookup(inst->in_class, name, &klass);\r | |
807 | return v;\r | |
808 | }\r | |
809 | \r | |
810 | static int\r | |
811 | instance_setattr1(PyInstanceObject *inst, PyObject *name, PyObject *v)\r | |
812 | {\r | |
813 | if (v == NULL) {\r | |
814 | int rv = PyDict_DelItem(inst->in_dict, name);\r | |
815 | if (rv < 0)\r | |
816 | PyErr_Format(PyExc_AttributeError,\r | |
817 | "%.50s instance has no attribute '%.400s'",\r | |
818 | PyString_AS_STRING(inst->in_class->cl_name),\r | |
819 | PyString_AS_STRING(name));\r | |
820 | return rv;\r | |
821 | }\r | |
822 | else\r | |
823 | return PyDict_SetItem(inst->in_dict, name, v);\r | |
824 | }\r | |
825 | \r | |
826 | static int\r | |
827 | instance_setattr(PyInstanceObject *inst, PyObject *name, PyObject *v)\r | |
828 | {\r | |
829 | PyObject *func, *args, *res, *tmp;\r | |
830 | char *sname;\r | |
831 | \r | |
832 | if (!PyString_Check(name)) {\r | |
833 | PyErr_SetString(PyExc_TypeError, "attribute name must be a string");\r | |
834 | return -1;\r | |
835 | }\r | |
836 | \r | |
837 | sname = PyString_AsString(name);\r | |
838 | if (sname[0] == '_' && sname[1] == '_') {\r | |
839 | Py_ssize_t n = PyString_Size(name);\r | |
840 | if (sname[n-1] == '_' && sname[n-2] == '_') {\r | |
841 | if (strcmp(sname, "__dict__") == 0) {\r | |
842 | if (PyEval_GetRestricted()) {\r | |
843 | PyErr_SetString(PyExc_RuntimeError,\r | |
844 | "__dict__ not accessible in restricted mode");\r | |
845 | return -1;\r | |
846 | }\r | |
847 | if (v == NULL || !PyDict_Check(v)) {\r | |
848 | PyErr_SetString(PyExc_TypeError,\r | |
849 | "__dict__ must be set to a dictionary");\r | |
850 | return -1;\r | |
851 | }\r | |
852 | tmp = inst->in_dict;\r | |
853 | Py_INCREF(v);\r | |
854 | inst->in_dict = v;\r | |
855 | Py_DECREF(tmp);\r | |
856 | return 0;\r | |
857 | }\r | |
858 | if (strcmp(sname, "__class__") == 0) {\r | |
859 | if (PyEval_GetRestricted()) {\r | |
860 | PyErr_SetString(PyExc_RuntimeError,\r | |
861 | "__class__ not accessible in restricted mode");\r | |
862 | return -1;\r | |
863 | }\r | |
864 | if (v == NULL || !PyClass_Check(v)) {\r | |
865 | PyErr_SetString(PyExc_TypeError,\r | |
866 | "__class__ must be set to a class");\r | |
867 | return -1;\r | |
868 | }\r | |
869 | tmp = (PyObject *)(inst->in_class);\r | |
870 | Py_INCREF(v);\r | |
871 | inst->in_class = (PyClassObject *)v;\r | |
872 | Py_DECREF(tmp);\r | |
873 | return 0;\r | |
874 | }\r | |
875 | }\r | |
876 | }\r | |
877 | if (v == NULL)\r | |
878 | func = inst->in_class->cl_delattr;\r | |
879 | else\r | |
880 | func = inst->in_class->cl_setattr;\r | |
881 | if (func == NULL)\r | |
882 | return instance_setattr1(inst, name, v);\r | |
883 | if (v == NULL)\r | |
884 | args = PyTuple_Pack(2, inst, name);\r | |
885 | else\r | |
886 | args = PyTuple_Pack(3, inst, name, v);\r | |
887 | if (args == NULL)\r | |
888 | return -1;\r | |
889 | res = PyEval_CallObject(func, args);\r | |
890 | Py_DECREF(args);\r | |
891 | if (res == NULL)\r | |
892 | return -1;\r | |
893 | Py_DECREF(res);\r | |
894 | return 0;\r | |
895 | }\r | |
896 | \r | |
897 | static PyObject *\r | |
898 | instance_repr(PyInstanceObject *inst)\r | |
899 | {\r | |
900 | PyObject *func;\r | |
901 | PyObject *res;\r | |
902 | static PyObject *reprstr;\r | |
903 | \r | |
904 | if (reprstr == NULL) {\r | |
905 | reprstr = PyString_InternFromString("__repr__");\r | |
906 | if (reprstr == NULL)\r | |
907 | return NULL;\r | |
908 | }\r | |
909 | func = instance_getattr(inst, reprstr);\r | |
910 | if (func == NULL) {\r | |
911 | PyObject *classname, *mod;\r | |
912 | char *cname;\r | |
913 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
914 | return NULL;\r | |
915 | PyErr_Clear();\r | |
916 | classname = inst->in_class->cl_name;\r | |
917 | mod = PyDict_GetItemString(inst->in_class->cl_dict,\r | |
918 | "__module__");\r | |
919 | if (classname != NULL && PyString_Check(classname))\r | |
920 | cname = PyString_AsString(classname);\r | |
921 | else\r | |
922 | cname = "?";\r | |
923 | if (mod == NULL || !PyString_Check(mod))\r | |
924 | return PyString_FromFormat("<?.%s instance at %p>",\r | |
925 | cname, inst);\r | |
926 | else\r | |
927 | return PyString_FromFormat("<%s.%s instance at %p>",\r | |
928 | PyString_AsString(mod),\r | |
929 | cname, inst);\r | |
930 | }\r | |
931 | res = PyEval_CallObject(func, (PyObject *)NULL);\r | |
932 | Py_DECREF(func);\r | |
933 | return res;\r | |
934 | }\r | |
935 | \r | |
936 | static PyObject *\r | |
937 | instance_str(PyInstanceObject *inst)\r | |
938 | {\r | |
939 | PyObject *func;\r | |
940 | PyObject *res;\r | |
941 | static PyObject *strstr;\r | |
942 | \r | |
943 | if (strstr == NULL) {\r | |
944 | strstr = PyString_InternFromString("__str__");\r | |
945 | if (strstr == NULL)\r | |
946 | return NULL;\r | |
947 | }\r | |
948 | func = instance_getattr(inst, strstr);\r | |
949 | if (func == NULL) {\r | |
950 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
951 | return NULL;\r | |
952 | PyErr_Clear();\r | |
953 | return instance_repr(inst);\r | |
954 | }\r | |
955 | res = PyEval_CallObject(func, (PyObject *)NULL);\r | |
956 | Py_DECREF(func);\r | |
957 | return res;\r | |
958 | }\r | |
959 | \r | |
960 | static long\r | |
961 | instance_hash(PyInstanceObject *inst)\r | |
962 | {\r | |
963 | PyObject *func;\r | |
964 | PyObject *res;\r | |
965 | long outcome;\r | |
966 | static PyObject *hashstr, *eqstr, *cmpstr;\r | |
967 | \r | |
968 | if (hashstr == NULL) {\r | |
969 | hashstr = PyString_InternFromString("__hash__");\r | |
970 | if (hashstr == NULL)\r | |
971 | return -1;\r | |
972 | }\r | |
973 | func = instance_getattr(inst, hashstr);\r | |
974 | if (func == NULL) {\r | |
975 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
976 | return -1;\r | |
977 | PyErr_Clear();\r | |
978 | /* If there is no __eq__ and no __cmp__ method, we hash on the\r | |
979 | address. If an __eq__ or __cmp__ method exists, there must\r | |
980 | be a __hash__. */\r | |
981 | if (eqstr == NULL) {\r | |
982 | eqstr = PyString_InternFromString("__eq__");\r | |
983 | if (eqstr == NULL)\r | |
984 | return -1;\r | |
985 | }\r | |
986 | func = instance_getattr(inst, eqstr);\r | |
987 | if (func == NULL) {\r | |
988 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
989 | return -1;\r | |
990 | PyErr_Clear();\r | |
991 | if (cmpstr == NULL) {\r | |
992 | cmpstr = PyString_InternFromString("__cmp__");\r | |
993 | if (cmpstr == NULL)\r | |
994 | return -1;\r | |
995 | }\r | |
996 | func = instance_getattr(inst, cmpstr);\r | |
997 | if (func == NULL) {\r | |
998 | if (!PyErr_ExceptionMatches(\r | |
999 | PyExc_AttributeError))\r | |
1000 | return -1;\r | |
1001 | PyErr_Clear();\r | |
1002 | return _Py_HashPointer(inst);\r | |
1003 | }\r | |
1004 | }\r | |
1005 | Py_XDECREF(func);\r | |
1006 | PyErr_SetString(PyExc_TypeError, "unhashable instance");\r | |
1007 | return -1;\r | |
1008 | }\r | |
1009 | res = PyEval_CallObject(func, (PyObject *)NULL);\r | |
1010 | Py_DECREF(func);\r | |
1011 | if (res == NULL)\r | |
1012 | return -1;\r | |
1013 | if (PyInt_Check(res) || PyLong_Check(res))\r | |
1014 | /* This already converts a -1 result to -2. */\r | |
1015 | outcome = res->ob_type->tp_hash(res);\r | |
1016 | else {\r | |
1017 | PyErr_SetString(PyExc_TypeError,\r | |
1018 | "__hash__() should return an int");\r | |
1019 | outcome = -1;\r | |
1020 | }\r | |
1021 | Py_DECREF(res);\r | |
1022 | return outcome;\r | |
1023 | }\r | |
1024 | \r | |
1025 | static int\r | |
1026 | instance_traverse(PyInstanceObject *o, visitproc visit, void *arg)\r | |
1027 | {\r | |
1028 | Py_VISIT(o->in_class);\r | |
1029 | Py_VISIT(o->in_dict);\r | |
1030 | return 0;\r | |
1031 | }\r | |
1032 | \r | |
1033 | static PyObject *getitemstr, *setitemstr, *delitemstr, *lenstr;\r | |
1034 | static PyObject *iterstr, *nextstr;\r | |
1035 | \r | |
1036 | static Py_ssize_t\r | |
1037 | instance_length(PyInstanceObject *inst)\r | |
1038 | {\r | |
1039 | PyObject *func;\r | |
1040 | PyObject *res;\r | |
1041 | Py_ssize_t outcome;\r | |
1042 | \r | |
1043 | if (lenstr == NULL) {\r | |
1044 | lenstr = PyString_InternFromString("__len__");\r | |
1045 | if (lenstr == NULL)\r | |
1046 | return -1;\r | |
1047 | }\r | |
1048 | func = instance_getattr(inst, lenstr);\r | |
1049 | if (func == NULL)\r | |
1050 | return -1;\r | |
1051 | res = PyEval_CallObject(func, (PyObject *)NULL);\r | |
1052 | Py_DECREF(func);\r | |
1053 | if (res == NULL)\r | |
1054 | return -1;\r | |
1055 | if (PyInt_Check(res)) {\r | |
1056 | outcome = PyInt_AsSsize_t(res);\r | |
1057 | if (outcome == -1 && PyErr_Occurred()) {\r | |
1058 | Py_DECREF(res);\r | |
1059 | return -1;\r | |
1060 | }\r | |
1061 | #if SIZEOF_SIZE_T < SIZEOF_INT\r | |
1062 | /* Overflow check -- range of PyInt is more than C int */\r | |
1063 | if (outcome != (int)outcome) {\r | |
1064 | PyErr_SetString(PyExc_OverflowError,\r | |
1065 | "__len__() should return 0 <= outcome < 2**31");\r | |
1066 | outcome = -1;\r | |
1067 | }\r | |
1068 | else\r | |
1069 | #endif\r | |
1070 | if (outcome < 0) {\r | |
1071 | PyErr_SetString(PyExc_ValueError,\r | |
1072 | "__len__() should return >= 0");\r | |
1073 | outcome = -1;\r | |
1074 | }\r | |
1075 | }\r | |
1076 | else {\r | |
1077 | PyErr_SetString(PyExc_TypeError,\r | |
1078 | "__len__() should return an int");\r | |
1079 | outcome = -1;\r | |
1080 | }\r | |
1081 | Py_DECREF(res);\r | |
1082 | return outcome;\r | |
1083 | }\r | |
1084 | \r | |
1085 | static PyObject *\r | |
1086 | instance_subscript(PyInstanceObject *inst, PyObject *key)\r | |
1087 | {\r | |
1088 | PyObject *func;\r | |
1089 | PyObject *arg;\r | |
1090 | PyObject *res;\r | |
1091 | \r | |
1092 | if (getitemstr == NULL) {\r | |
1093 | getitemstr = PyString_InternFromString("__getitem__");\r | |
1094 | if (getitemstr == NULL)\r | |
1095 | return NULL;\r | |
1096 | }\r | |
1097 | func = instance_getattr(inst, getitemstr);\r | |
1098 | if (func == NULL)\r | |
1099 | return NULL;\r | |
1100 | arg = PyTuple_Pack(1, key);\r | |
1101 | if (arg == NULL) {\r | |
1102 | Py_DECREF(func);\r | |
1103 | return NULL;\r | |
1104 | }\r | |
1105 | res = PyEval_CallObject(func, arg);\r | |
1106 | Py_DECREF(func);\r | |
1107 | Py_DECREF(arg);\r | |
1108 | return res;\r | |
1109 | }\r | |
1110 | \r | |
1111 | static int\r | |
1112 | instance_ass_subscript(PyInstanceObject *inst, PyObject *key, PyObject *value)\r | |
1113 | {\r | |
1114 | PyObject *func;\r | |
1115 | PyObject *arg;\r | |
1116 | PyObject *res;\r | |
1117 | \r | |
1118 | if (value == NULL) {\r | |
1119 | if (delitemstr == NULL) {\r | |
1120 | delitemstr = PyString_InternFromString("__delitem__");\r | |
1121 | if (delitemstr == NULL)\r | |
1122 | return -1;\r | |
1123 | }\r | |
1124 | func = instance_getattr(inst, delitemstr);\r | |
1125 | }\r | |
1126 | else {\r | |
1127 | if (setitemstr == NULL) {\r | |
1128 | setitemstr = PyString_InternFromString("__setitem__");\r | |
1129 | if (setitemstr == NULL)\r | |
1130 | return -1;\r | |
1131 | }\r | |
1132 | func = instance_getattr(inst, setitemstr);\r | |
1133 | }\r | |
1134 | if (func == NULL)\r | |
1135 | return -1;\r | |
1136 | if (value == NULL)\r | |
1137 | arg = PyTuple_Pack(1, key);\r | |
1138 | else\r | |
1139 | arg = PyTuple_Pack(2, key, value);\r | |
1140 | if (arg == NULL) {\r | |
1141 | Py_DECREF(func);\r | |
1142 | return -1;\r | |
1143 | }\r | |
1144 | res = PyEval_CallObject(func, arg);\r | |
1145 | Py_DECREF(func);\r | |
1146 | Py_DECREF(arg);\r | |
1147 | if (res == NULL)\r | |
1148 | return -1;\r | |
1149 | Py_DECREF(res);\r | |
1150 | return 0;\r | |
1151 | }\r | |
1152 | \r | |
1153 | static PyMappingMethods instance_as_mapping = {\r | |
1154 | (lenfunc)instance_length, /* mp_length */\r | |
1155 | (binaryfunc)instance_subscript, /* mp_subscript */\r | |
1156 | (objobjargproc)instance_ass_subscript, /* mp_ass_subscript */\r | |
1157 | };\r | |
1158 | \r | |
1159 | static PyObject *\r | |
1160 | instance_item(PyInstanceObject *inst, Py_ssize_t i)\r | |
1161 | {\r | |
1162 | PyObject *func, *res;\r | |
1163 | \r | |
1164 | if (getitemstr == NULL) {\r | |
1165 | getitemstr = PyString_InternFromString("__getitem__");\r | |
1166 | if (getitemstr == NULL)\r | |
1167 | return NULL;\r | |
1168 | }\r | |
1169 | func = instance_getattr(inst, getitemstr);\r | |
1170 | if (func == NULL)\r | |
1171 | return NULL;\r | |
1172 | res = PyObject_CallFunction(func, "n", i);\r | |
1173 | Py_DECREF(func);\r | |
1174 | return res;\r | |
1175 | }\r | |
1176 | \r | |
1177 | static PyObject *\r | |
1178 | instance_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j)\r | |
1179 | {\r | |
1180 | PyObject *func, *arg, *res;\r | |
1181 | static PyObject *getslicestr;\r | |
1182 | \r | |
1183 | if (getslicestr == NULL) {\r | |
1184 | getslicestr = PyString_InternFromString("__getslice__");\r | |
1185 | if (getslicestr == NULL)\r | |
1186 | return NULL;\r | |
1187 | }\r | |
1188 | func = instance_getattr(inst, getslicestr);\r | |
1189 | \r | |
1190 | if (func == NULL) {\r | |
1191 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
1192 | return NULL;\r | |
1193 | PyErr_Clear();\r | |
1194 | \r | |
1195 | if (getitemstr == NULL) {\r | |
1196 | getitemstr = PyString_InternFromString("__getitem__");\r | |
1197 | if (getitemstr == NULL)\r | |
1198 | return NULL;\r | |
1199 | }\r | |
1200 | func = instance_getattr(inst, getitemstr);\r | |
1201 | if (func == NULL)\r | |
1202 | return NULL;\r | |
1203 | arg = Py_BuildValue("(N)", _PySlice_FromIndices(i, j));\r | |
1204 | }\r | |
1205 | else {\r | |
1206 | if (PyErr_WarnPy3k("in 3.x, __getslice__ has been removed; "\r | |
1207 | "use __getitem__", 1) < 0) {\r | |
1208 | Py_DECREF(func);\r | |
1209 | return NULL;\r | |
1210 | }\r | |
1211 | arg = Py_BuildValue("(nn)", i, j);\r | |
1212 | }\r | |
1213 | \r | |
1214 | if (arg == NULL) {\r | |
1215 | Py_DECREF(func);\r | |
1216 | return NULL;\r | |
1217 | }\r | |
1218 | res = PyEval_CallObject(func, arg);\r | |
1219 | Py_DECREF(func);\r | |
1220 | Py_DECREF(arg);\r | |
1221 | return res;\r | |
1222 | }\r | |
1223 | \r | |
1224 | static int\r | |
1225 | instance_ass_item(PyInstanceObject *inst, Py_ssize_t i, PyObject *item)\r | |
1226 | {\r | |
1227 | PyObject *func, *arg, *res;\r | |
1228 | \r | |
1229 | if (item == NULL) {\r | |
1230 | if (delitemstr == NULL) {\r | |
1231 | delitemstr = PyString_InternFromString("__delitem__");\r | |
1232 | if (delitemstr == NULL)\r | |
1233 | return -1;\r | |
1234 | }\r | |
1235 | func = instance_getattr(inst, delitemstr);\r | |
1236 | }\r | |
1237 | else {\r | |
1238 | if (setitemstr == NULL) {\r | |
1239 | setitemstr = PyString_InternFromString("__setitem__");\r | |
1240 | if (setitemstr == NULL)\r | |
1241 | return -1;\r | |
1242 | }\r | |
1243 | func = instance_getattr(inst, setitemstr);\r | |
1244 | }\r | |
1245 | if (func == NULL)\r | |
1246 | return -1;\r | |
1247 | if (item == NULL)\r | |
1248 | arg = Py_BuildValue("(n)", i);\r | |
1249 | else\r | |
1250 | arg = Py_BuildValue("(nO)", i, item);\r | |
1251 | if (arg == NULL) {\r | |
1252 | Py_DECREF(func);\r | |
1253 | return -1;\r | |
1254 | }\r | |
1255 | res = PyEval_CallObject(func, arg);\r | |
1256 | Py_DECREF(func);\r | |
1257 | Py_DECREF(arg);\r | |
1258 | if (res == NULL)\r | |
1259 | return -1;\r | |
1260 | Py_DECREF(res);\r | |
1261 | return 0;\r | |
1262 | }\r | |
1263 | \r | |
1264 | static int\r | |
1265 | instance_ass_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j, PyObject *value)\r | |
1266 | {\r | |
1267 | PyObject *func, *arg, *res;\r | |
1268 | static PyObject *setslicestr, *delslicestr;\r | |
1269 | \r | |
1270 | if (value == NULL) {\r | |
1271 | if (delslicestr == NULL) {\r | |
1272 | delslicestr =\r | |
1273 | PyString_InternFromString("__delslice__");\r | |
1274 | if (delslicestr == NULL)\r | |
1275 | return -1;\r | |
1276 | }\r | |
1277 | func = instance_getattr(inst, delslicestr);\r | |
1278 | if (func == NULL) {\r | |
1279 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
1280 | return -1;\r | |
1281 | PyErr_Clear();\r | |
1282 | if (delitemstr == NULL) {\r | |
1283 | delitemstr =\r | |
1284 | PyString_InternFromString("__delitem__");\r | |
1285 | if (delitemstr == NULL)\r | |
1286 | return -1;\r | |
1287 | }\r | |
1288 | func = instance_getattr(inst, delitemstr);\r | |
1289 | if (func == NULL)\r | |
1290 | return -1;\r | |
1291 | \r | |
1292 | arg = Py_BuildValue("(N)",\r | |
1293 | _PySlice_FromIndices(i, j));\r | |
1294 | }\r | |
1295 | else {\r | |
1296 | if (PyErr_WarnPy3k("in 3.x, __delslice__ has been "\r | |
1297 | "removed; use __delitem__", 1) < 0) {\r | |
1298 | Py_DECREF(func);\r | |
1299 | return -1;\r | |
1300 | }\r | |
1301 | arg = Py_BuildValue("(nn)", i, j);\r | |
1302 | }\r | |
1303 | }\r | |
1304 | else {\r | |
1305 | if (setslicestr == NULL) {\r | |
1306 | setslicestr =\r | |
1307 | PyString_InternFromString("__setslice__");\r | |
1308 | if (setslicestr == NULL)\r | |
1309 | return -1;\r | |
1310 | }\r | |
1311 | func = instance_getattr(inst, setslicestr);\r | |
1312 | if (func == NULL) {\r | |
1313 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
1314 | return -1;\r | |
1315 | PyErr_Clear();\r | |
1316 | if (setitemstr == NULL) {\r | |
1317 | setitemstr =\r | |
1318 | PyString_InternFromString("__setitem__");\r | |
1319 | if (setitemstr == NULL)\r | |
1320 | return -1;\r | |
1321 | }\r | |
1322 | func = instance_getattr(inst, setitemstr);\r | |
1323 | if (func == NULL)\r | |
1324 | return -1;\r | |
1325 | \r | |
1326 | arg = Py_BuildValue("(NO)",\r | |
1327 | _PySlice_FromIndices(i, j), value);\r | |
1328 | }\r | |
1329 | else {\r | |
1330 | if (PyErr_WarnPy3k("in 3.x, __setslice__ has been "\r | |
1331 | "removed; use __setitem__", 1) < 0) {\r | |
1332 | Py_DECREF(func);\r | |
1333 | return -1;\r | |
1334 | }\r | |
1335 | arg = Py_BuildValue("(nnO)", i, j, value);\r | |
1336 | }\r | |
1337 | }\r | |
1338 | if (arg == NULL) {\r | |
1339 | Py_DECREF(func);\r | |
1340 | return -1;\r | |
1341 | }\r | |
1342 | res = PyEval_CallObject(func, arg);\r | |
1343 | Py_DECREF(func);\r | |
1344 | Py_DECREF(arg);\r | |
1345 | if (res == NULL)\r | |
1346 | return -1;\r | |
1347 | Py_DECREF(res);\r | |
1348 | return 0;\r | |
1349 | }\r | |
1350 | \r | |
1351 | static int\r | |
1352 | instance_contains(PyInstanceObject *inst, PyObject *member)\r | |
1353 | {\r | |
1354 | static PyObject *__contains__;\r | |
1355 | PyObject *func;\r | |
1356 | \r | |
1357 | /* Try __contains__ first.\r | |
1358 | * If that can't be done, try iterator-based searching.\r | |
1359 | */\r | |
1360 | \r | |
1361 | if(__contains__ == NULL) {\r | |
1362 | __contains__ = PyString_InternFromString("__contains__");\r | |
1363 | if(__contains__ == NULL)\r | |
1364 | return -1;\r | |
1365 | }\r | |
1366 | func = instance_getattr(inst, __contains__);\r | |
1367 | if (func) {\r | |
1368 | PyObject *res;\r | |
1369 | int ret;\r | |
1370 | PyObject *arg = PyTuple_Pack(1, member);\r | |
1371 | if(arg == NULL) {\r | |
1372 | Py_DECREF(func);\r | |
1373 | return -1;\r | |
1374 | }\r | |
1375 | res = PyEval_CallObject(func, arg);\r | |
1376 | Py_DECREF(func);\r | |
1377 | Py_DECREF(arg);\r | |
1378 | if(res == NULL)\r | |
1379 | return -1;\r | |
1380 | ret = PyObject_IsTrue(res);\r | |
1381 | Py_DECREF(res);\r | |
1382 | return ret;\r | |
1383 | }\r | |
1384 | \r | |
1385 | /* Couldn't find __contains__. */\r | |
1386 | if (PyErr_ExceptionMatches(PyExc_AttributeError)) {\r | |
1387 | Py_ssize_t rc;\r | |
1388 | /* Assume the failure was simply due to that there is no\r | |
1389 | * __contains__ attribute, and try iterating instead.\r | |
1390 | */\r | |
1391 | PyErr_Clear();\r | |
1392 | rc = _PySequence_IterSearch((PyObject *)inst, member,\r | |
1393 | PY_ITERSEARCH_CONTAINS);\r | |
1394 | if (rc >= 0)\r | |
1395 | return rc > 0;\r | |
1396 | }\r | |
1397 | return -1;\r | |
1398 | }\r | |
1399 | \r | |
1400 | static PySequenceMethods\r | |
1401 | instance_as_sequence = {\r | |
1402 | (lenfunc)instance_length, /* sq_length */\r | |
1403 | 0, /* sq_concat */\r | |
1404 | 0, /* sq_repeat */\r | |
1405 | (ssizeargfunc)instance_item, /* sq_item */\r | |
1406 | (ssizessizeargfunc)instance_slice, /* sq_slice */\r | |
1407 | (ssizeobjargproc)instance_ass_item, /* sq_ass_item */\r | |
1408 | (ssizessizeobjargproc)instance_ass_slice,/* sq_ass_slice */\r | |
1409 | (objobjproc)instance_contains, /* sq_contains */\r | |
1410 | };\r | |
1411 | \r | |
1412 | static PyObject *\r | |
1413 | generic_unary_op(PyInstanceObject *self, PyObject *methodname)\r | |
1414 | {\r | |
1415 | PyObject *func, *res;\r | |
1416 | \r | |
1417 | if ((func = instance_getattr(self, methodname)) == NULL)\r | |
1418 | return NULL;\r | |
1419 | res = PyEval_CallObject(func, (PyObject *)NULL);\r | |
1420 | Py_DECREF(func);\r | |
1421 | return res;\r | |
1422 | }\r | |
1423 | \r | |
1424 | static PyObject *\r | |
1425 | generic_binary_op(PyObject *v, PyObject *w, char *opname)\r | |
1426 | {\r | |
1427 | PyObject *result;\r | |
1428 | PyObject *args;\r | |
1429 | PyObject *func = PyObject_GetAttrString(v, opname);\r | |
1430 | if (func == NULL) {\r | |
1431 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
1432 | return NULL;\r | |
1433 | PyErr_Clear();\r | |
1434 | Py_INCREF(Py_NotImplemented);\r | |
1435 | return Py_NotImplemented;\r | |
1436 | }\r | |
1437 | args = PyTuple_Pack(1, w);\r | |
1438 | if (args == NULL) {\r | |
1439 | Py_DECREF(func);\r | |
1440 | return NULL;\r | |
1441 | }\r | |
1442 | result = PyEval_CallObject(func, args);\r | |
1443 | Py_DECREF(args);\r | |
1444 | Py_DECREF(func);\r | |
1445 | return result;\r | |
1446 | }\r | |
1447 | \r | |
1448 | \r | |
1449 | static PyObject *coerce_obj;\r | |
1450 | \r | |
1451 | /* Try one half of a binary operator involving a class instance. */\r | |
1452 | static PyObject *\r | |
1453 | half_binop(PyObject *v, PyObject *w, char *opname, binaryfunc thisfunc,\r | |
1454 | int swapped)\r | |
1455 | {\r | |
1456 | PyObject *args;\r | |
1457 | PyObject *coercefunc;\r | |
1458 | PyObject *coerced = NULL;\r | |
1459 | PyObject *v1;\r | |
1460 | PyObject *result;\r | |
1461 | \r | |
1462 | if (!PyInstance_Check(v)) {\r | |
1463 | Py_INCREF(Py_NotImplemented);\r | |
1464 | return Py_NotImplemented;\r | |
1465 | }\r | |
1466 | \r | |
1467 | if (coerce_obj == NULL) {\r | |
1468 | coerce_obj = PyString_InternFromString("__coerce__");\r | |
1469 | if (coerce_obj == NULL)\r | |
1470 | return NULL;\r | |
1471 | }\r | |
1472 | coercefunc = PyObject_GetAttr(v, coerce_obj);\r | |
1473 | if (coercefunc == NULL) {\r | |
1474 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
1475 | return NULL;\r | |
1476 | PyErr_Clear();\r | |
1477 | return generic_binary_op(v, w, opname);\r | |
1478 | }\r | |
1479 | \r | |
1480 | args = PyTuple_Pack(1, w);\r | |
1481 | if (args == NULL) {\r | |
1482 | Py_DECREF(coercefunc);\r | |
1483 | return NULL;\r | |
1484 | }\r | |
1485 | coerced = PyEval_CallObject(coercefunc, args);\r | |
1486 | Py_DECREF(args);\r | |
1487 | Py_DECREF(coercefunc);\r | |
1488 | if (coerced == NULL) {\r | |
1489 | return NULL;\r | |
1490 | }\r | |
1491 | if (coerced == Py_None || coerced == Py_NotImplemented) {\r | |
1492 | Py_DECREF(coerced);\r | |
1493 | return generic_binary_op(v, w, opname);\r | |
1494 | }\r | |
1495 | if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {\r | |
1496 | Py_DECREF(coerced);\r | |
1497 | PyErr_SetString(PyExc_TypeError,\r | |
1498 | "coercion should return None or 2-tuple");\r | |
1499 | return NULL;\r | |
1500 | }\r | |
1501 | v1 = PyTuple_GetItem(coerced, 0);\r | |
1502 | w = PyTuple_GetItem(coerced, 1);\r | |
1503 | if (v1->ob_type == v->ob_type && PyInstance_Check(v)) {\r | |
1504 | /* prevent recursion if __coerce__ returns self as the first\r | |
1505 | * argument */\r | |
1506 | result = generic_binary_op(v1, w, opname);\r | |
1507 | } else {\r | |
1508 | if (Py_EnterRecursiveCall(" after coercion"))\r | |
1509 | return NULL;\r | |
1510 | if (swapped)\r | |
1511 | result = (thisfunc)(w, v1);\r | |
1512 | else\r | |
1513 | result = (thisfunc)(v1, w);\r | |
1514 | Py_LeaveRecursiveCall();\r | |
1515 | }\r | |
1516 | Py_DECREF(coerced);\r | |
1517 | return result;\r | |
1518 | }\r | |
1519 | \r | |
1520 | /* Implement a binary operator involving at least one class instance. */\r | |
1521 | static PyObject *\r | |
1522 | do_binop(PyObject *v, PyObject *w, char *opname, char *ropname,\r | |
1523 | binaryfunc thisfunc)\r | |
1524 | {\r | |
1525 | PyObject *result = half_binop(v, w, opname, thisfunc, 0);\r | |
1526 | if (result == Py_NotImplemented) {\r | |
1527 | Py_DECREF(result);\r | |
1528 | result = half_binop(w, v, ropname, thisfunc, 1);\r | |
1529 | }\r | |
1530 | return result;\r | |
1531 | }\r | |
1532 | \r | |
1533 | static PyObject *\r | |
1534 | do_binop_inplace(PyObject *v, PyObject *w, char *iopname, char *opname,\r | |
1535 | char *ropname, binaryfunc thisfunc)\r | |
1536 | {\r | |
1537 | PyObject *result = half_binop(v, w, iopname, thisfunc, 0);\r | |
1538 | if (result == Py_NotImplemented) {\r | |
1539 | Py_DECREF(result);\r | |
1540 | result = do_binop(v, w, opname, ropname, thisfunc);\r | |
1541 | }\r | |
1542 | return result;\r | |
1543 | }\r | |
1544 | \r | |
1545 | static int\r | |
1546 | instance_coerce(PyObject **pv, PyObject **pw)\r | |
1547 | {\r | |
1548 | PyObject *v = *pv;\r | |
1549 | PyObject *w = *pw;\r | |
1550 | PyObject *coercefunc;\r | |
1551 | PyObject *args;\r | |
1552 | PyObject *coerced;\r | |
1553 | \r | |
1554 | if (coerce_obj == NULL) {\r | |
1555 | coerce_obj = PyString_InternFromString("__coerce__");\r | |
1556 | if (coerce_obj == NULL)\r | |
1557 | return -1;\r | |
1558 | }\r | |
1559 | coercefunc = PyObject_GetAttr(v, coerce_obj);\r | |
1560 | if (coercefunc == NULL) {\r | |
1561 | /* No __coerce__ method */\r | |
1562 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
1563 | return -1;\r | |
1564 | PyErr_Clear();\r | |
1565 | return 1;\r | |
1566 | }\r | |
1567 | /* Has __coerce__ method: call it */\r | |
1568 | args = PyTuple_Pack(1, w);\r | |
1569 | if (args == NULL) {\r | |
1570 | return -1;\r | |
1571 | }\r | |
1572 | coerced = PyEval_CallObject(coercefunc, args);\r | |
1573 | Py_DECREF(args);\r | |
1574 | Py_DECREF(coercefunc);\r | |
1575 | if (coerced == NULL) {\r | |
1576 | /* __coerce__ call raised an exception */\r | |
1577 | return -1;\r | |
1578 | }\r | |
1579 | if (coerced == Py_None || coerced == Py_NotImplemented) {\r | |
1580 | /* __coerce__ says "I can't do it" */\r | |
1581 | Py_DECREF(coerced);\r | |
1582 | return 1;\r | |
1583 | }\r | |
1584 | if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {\r | |
1585 | /* __coerce__ return value is malformed */\r | |
1586 | Py_DECREF(coerced);\r | |
1587 | PyErr_SetString(PyExc_TypeError,\r | |
1588 | "coercion should return None or 2-tuple");\r | |
1589 | return -1;\r | |
1590 | }\r | |
1591 | /* __coerce__ returned two new values */\r | |
1592 | *pv = PyTuple_GetItem(coerced, 0);\r | |
1593 | *pw = PyTuple_GetItem(coerced, 1);\r | |
1594 | Py_INCREF(*pv);\r | |
1595 | Py_INCREF(*pw);\r | |
1596 | Py_DECREF(coerced);\r | |
1597 | return 0;\r | |
1598 | }\r | |
1599 | \r | |
1600 | #define UNARY(funcname, methodname) \\r | |
1601 | static PyObject *funcname(PyInstanceObject *self) { \\r | |
1602 | static PyObject *o; \\r | |
1603 | if (o == NULL) { o = PyString_InternFromString(methodname); \\r | |
1604 | if (o == NULL) return NULL; } \\r | |
1605 | return generic_unary_op(self, o); \\r | |
1606 | }\r | |
1607 | \r | |
1608 | /* unary function with a fallback */\r | |
1609 | #define UNARY_FB(funcname, methodname, funcname_fb) \\r | |
1610 | static PyObject *funcname(PyInstanceObject *self) { \\r | |
1611 | static PyObject *o; \\r | |
1612 | if (o == NULL) { o = PyString_InternFromString(methodname); \\r | |
1613 | if (o == NULL) return NULL; } \\r | |
1614 | if (PyObject_HasAttr((PyObject*)self, o)) \\r | |
1615 | return generic_unary_op(self, o); \\r | |
1616 | else \\r | |
1617 | return funcname_fb(self); \\r | |
1618 | }\r | |
1619 | \r | |
1620 | #define BINARY(f, m, n) \\r | |
1621 | static PyObject *f(PyObject *v, PyObject *w) { \\r | |
1622 | return do_binop(v, w, "__" m "__", "__r" m "__", n); \\r | |
1623 | }\r | |
1624 | \r | |
1625 | #define BINARY_INPLACE(f, m, n) \\r | |
1626 | static PyObject *f(PyObject *v, PyObject *w) { \\r | |
1627 | return do_binop_inplace(v, w, "__i" m "__", "__" m "__", \\r | |
1628 | "__r" m "__", n); \\r | |
1629 | }\r | |
1630 | \r | |
1631 | UNARY(instance_neg, "__neg__")\r | |
1632 | UNARY(instance_pos, "__pos__")\r | |
1633 | UNARY(instance_abs, "__abs__")\r | |
1634 | \r | |
1635 | BINARY(instance_or, "or", PyNumber_Or)\r | |
1636 | BINARY(instance_and, "and", PyNumber_And)\r | |
1637 | BINARY(instance_xor, "xor", PyNumber_Xor)\r | |
1638 | BINARY(instance_lshift, "lshift", PyNumber_Lshift)\r | |
1639 | BINARY(instance_rshift, "rshift", PyNumber_Rshift)\r | |
1640 | BINARY(instance_add, "add", PyNumber_Add)\r | |
1641 | BINARY(instance_sub, "sub", PyNumber_Subtract)\r | |
1642 | BINARY(instance_mul, "mul", PyNumber_Multiply)\r | |
1643 | BINARY(instance_div, "div", PyNumber_Divide)\r | |
1644 | BINARY(instance_mod, "mod", PyNumber_Remainder)\r | |
1645 | BINARY(instance_divmod, "divmod", PyNumber_Divmod)\r | |
1646 | BINARY(instance_floordiv, "floordiv", PyNumber_FloorDivide)\r | |
1647 | BINARY(instance_truediv, "truediv", PyNumber_TrueDivide)\r | |
1648 | \r | |
1649 | BINARY_INPLACE(instance_ior, "or", PyNumber_InPlaceOr)\r | |
1650 | BINARY_INPLACE(instance_ixor, "xor", PyNumber_InPlaceXor)\r | |
1651 | BINARY_INPLACE(instance_iand, "and", PyNumber_InPlaceAnd)\r | |
1652 | BINARY_INPLACE(instance_ilshift, "lshift", PyNumber_InPlaceLshift)\r | |
1653 | BINARY_INPLACE(instance_irshift, "rshift", PyNumber_InPlaceRshift)\r | |
1654 | BINARY_INPLACE(instance_iadd, "add", PyNumber_InPlaceAdd)\r | |
1655 | BINARY_INPLACE(instance_isub, "sub", PyNumber_InPlaceSubtract)\r | |
1656 | BINARY_INPLACE(instance_imul, "mul", PyNumber_InPlaceMultiply)\r | |
1657 | BINARY_INPLACE(instance_idiv, "div", PyNumber_InPlaceDivide)\r | |
1658 | BINARY_INPLACE(instance_imod, "mod", PyNumber_InPlaceRemainder)\r | |
1659 | BINARY_INPLACE(instance_ifloordiv, "floordiv", PyNumber_InPlaceFloorDivide)\r | |
1660 | BINARY_INPLACE(instance_itruediv, "truediv", PyNumber_InPlaceTrueDivide)\r | |
1661 | \r | |
1662 | /* Try a 3-way comparison, returning an int; v is an instance. Return:\r | |
1663 | -2 for an exception;\r | |
1664 | -1 if v < w;\r | |
1665 | 0 if v == w;\r | |
1666 | 1 if v > w;\r | |
1667 | 2 if this particular 3-way comparison is not implemented or undefined.\r | |
1668 | */\r | |
1669 | static int\r | |
1670 | half_cmp(PyObject *v, PyObject *w)\r | |
1671 | {\r | |
1672 | static PyObject *cmp_obj;\r | |
1673 | PyObject *args;\r | |
1674 | PyObject *cmp_func;\r | |
1675 | PyObject *result;\r | |
1676 | long l;\r | |
1677 | \r | |
1678 | assert(PyInstance_Check(v));\r | |
1679 | \r | |
1680 | if (cmp_obj == NULL) {\r | |
1681 | cmp_obj = PyString_InternFromString("__cmp__");\r | |
1682 | if (cmp_obj == NULL)\r | |
1683 | return -2;\r | |
1684 | }\r | |
1685 | \r | |
1686 | cmp_func = PyObject_GetAttr(v, cmp_obj);\r | |
1687 | if (cmp_func == NULL) {\r | |
1688 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
1689 | return -2;\r | |
1690 | PyErr_Clear();\r | |
1691 | return 2;\r | |
1692 | }\r | |
1693 | \r | |
1694 | args = PyTuple_Pack(1, w);\r | |
1695 | if (args == NULL) {\r | |
1696 | Py_DECREF(cmp_func);\r | |
1697 | return -2;\r | |
1698 | }\r | |
1699 | \r | |
1700 | result = PyEval_CallObject(cmp_func, args);\r | |
1701 | Py_DECREF(args);\r | |
1702 | Py_DECREF(cmp_func);\r | |
1703 | \r | |
1704 | if (result == NULL)\r | |
1705 | return -2;\r | |
1706 | \r | |
1707 | if (result == Py_NotImplemented) {\r | |
1708 | Py_DECREF(result);\r | |
1709 | return 2;\r | |
1710 | }\r | |
1711 | \r | |
1712 | l = PyInt_AsLong(result);\r | |
1713 | Py_DECREF(result);\r | |
1714 | if (l == -1 && PyErr_Occurred()) {\r | |
1715 | PyErr_SetString(PyExc_TypeError,\r | |
1716 | "comparison did not return an int");\r | |
1717 | return -2;\r | |
1718 | }\r | |
1719 | \r | |
1720 | return l < 0 ? -1 : l > 0 ? 1 : 0;\r | |
1721 | }\r | |
1722 | \r | |
1723 | /* Try a 3-way comparison, returning an int; either v or w is an instance.\r | |
1724 | We first try a coercion. Return:\r | |
1725 | -2 for an exception;\r | |
1726 | -1 if v < w;\r | |
1727 | 0 if v == w;\r | |
1728 | 1 if v > w;\r | |
1729 | 2 if this particular 3-way comparison is not implemented or undefined.\r | |
1730 | THIS IS ONLY CALLED FROM object.c!\r | |
1731 | */\r | |
1732 | static int\r | |
1733 | instance_compare(PyObject *v, PyObject *w)\r | |
1734 | {\r | |
1735 | int c;\r | |
1736 | \r | |
1737 | c = PyNumber_CoerceEx(&v, &w);\r | |
1738 | if (c < 0)\r | |
1739 | return -2;\r | |
1740 | if (c == 0) {\r | |
1741 | /* If neither is now an instance, use regular comparison */\r | |
1742 | if (!PyInstance_Check(v) && !PyInstance_Check(w)) {\r | |
1743 | c = PyObject_Compare(v, w);\r | |
1744 | Py_DECREF(v);\r | |
1745 | Py_DECREF(w);\r | |
1746 | if (PyErr_Occurred())\r | |
1747 | return -2;\r | |
1748 | return c < 0 ? -1 : c > 0 ? 1 : 0;\r | |
1749 | }\r | |
1750 | }\r | |
1751 | else {\r | |
1752 | /* The coercion didn't do anything.\r | |
1753 | Treat this the same as returning v and w unchanged. */\r | |
1754 | Py_INCREF(v);\r | |
1755 | Py_INCREF(w);\r | |
1756 | }\r | |
1757 | \r | |
1758 | if (PyInstance_Check(v)) {\r | |
1759 | c = half_cmp(v, w);\r | |
1760 | if (c <= 1) {\r | |
1761 | Py_DECREF(v);\r | |
1762 | Py_DECREF(w);\r | |
1763 | return c;\r | |
1764 | }\r | |
1765 | }\r | |
1766 | if (PyInstance_Check(w)) {\r | |
1767 | c = half_cmp(w, v);\r | |
1768 | if (c <= 1) {\r | |
1769 | Py_DECREF(v);\r | |
1770 | Py_DECREF(w);\r | |
1771 | if (c >= -1)\r | |
1772 | c = -c;\r | |
1773 | return c;\r | |
1774 | }\r | |
1775 | }\r | |
1776 | Py_DECREF(v);\r | |
1777 | Py_DECREF(w);\r | |
1778 | return 2;\r | |
1779 | }\r | |
1780 | \r | |
1781 | static int\r | |
1782 | instance_nonzero(PyInstanceObject *self)\r | |
1783 | {\r | |
1784 | PyObject *func, *res;\r | |
1785 | long outcome;\r | |
1786 | static PyObject *nonzerostr;\r | |
1787 | \r | |
1788 | if (nonzerostr == NULL) {\r | |
1789 | nonzerostr = PyString_InternFromString("__nonzero__");\r | |
1790 | if (nonzerostr == NULL)\r | |
1791 | return -1;\r | |
1792 | }\r | |
1793 | if ((func = instance_getattr(self, nonzerostr)) == NULL) {\r | |
1794 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
1795 | return -1;\r | |
1796 | PyErr_Clear();\r | |
1797 | if (lenstr == NULL) {\r | |
1798 | lenstr = PyString_InternFromString("__len__");\r | |
1799 | if (lenstr == NULL)\r | |
1800 | return -1;\r | |
1801 | }\r | |
1802 | if ((func = instance_getattr(self, lenstr)) == NULL) {\r | |
1803 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
1804 | return -1;\r | |
1805 | PyErr_Clear();\r | |
1806 | /* Fall back to the default behavior:\r | |
1807 | all instances are nonzero */\r | |
1808 | return 1;\r | |
1809 | }\r | |
1810 | }\r | |
1811 | res = PyEval_CallObject(func, (PyObject *)NULL);\r | |
1812 | Py_DECREF(func);\r | |
1813 | if (res == NULL)\r | |
1814 | return -1;\r | |
1815 | if (!PyInt_Check(res)) {\r | |
1816 | Py_DECREF(res);\r | |
1817 | PyErr_SetString(PyExc_TypeError,\r | |
1818 | "__nonzero__ should return an int");\r | |
1819 | return -1;\r | |
1820 | }\r | |
1821 | outcome = PyInt_AsLong(res);\r | |
1822 | Py_DECREF(res);\r | |
1823 | if (outcome < 0) {\r | |
1824 | PyErr_SetString(PyExc_ValueError,\r | |
1825 | "__nonzero__ should return >= 0");\r | |
1826 | return -1;\r | |
1827 | }\r | |
1828 | return outcome > 0;\r | |
1829 | }\r | |
1830 | \r | |
1831 | static PyObject *\r | |
1832 | instance_index(PyInstanceObject *self)\r | |
1833 | {\r | |
1834 | PyObject *func, *res;\r | |
1835 | static PyObject *indexstr = NULL;\r | |
1836 | \r | |
1837 | if (indexstr == NULL) {\r | |
1838 | indexstr = PyString_InternFromString("__index__");\r | |
1839 | if (indexstr == NULL)\r | |
1840 | return NULL;\r | |
1841 | }\r | |
1842 | if ((func = instance_getattr(self, indexstr)) == NULL) {\r | |
1843 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
1844 | return NULL;\r | |
1845 | PyErr_Clear();\r | |
1846 | PyErr_SetString(PyExc_TypeError,\r | |
1847 | "object cannot be interpreted as an index");\r | |
1848 | return NULL;\r | |
1849 | }\r | |
1850 | res = PyEval_CallObject(func, (PyObject *)NULL);\r | |
1851 | Py_DECREF(func);\r | |
1852 | return res;\r | |
1853 | }\r | |
1854 | \r | |
1855 | \r | |
1856 | UNARY(instance_invert, "__invert__")\r | |
1857 | UNARY(_instance_trunc, "__trunc__")\r | |
1858 | \r | |
1859 | static PyObject *\r | |
1860 | instance_int(PyInstanceObject *self)\r | |
1861 | {\r | |
1862 | PyObject *truncated;\r | |
1863 | static PyObject *int_name;\r | |
1864 | if (int_name == NULL) {\r | |
1865 | int_name = PyString_InternFromString("__int__");\r | |
1866 | if (int_name == NULL)\r | |
1867 | return NULL;\r | |
1868 | }\r | |
1869 | if (PyObject_HasAttr((PyObject*)self, int_name))\r | |
1870 | return generic_unary_op(self, int_name);\r | |
1871 | \r | |
1872 | truncated = _instance_trunc(self);\r | |
1873 | /* __trunc__ is specified to return an Integral type, but\r | |
1874 | int() needs to return an int. */\r | |
1875 | return _PyNumber_ConvertIntegralToInt(\r | |
1876 | truncated,\r | |
1877 | "__trunc__ returned non-Integral (type %.200s)");\r | |
1878 | }\r | |
1879 | \r | |
1880 | UNARY_FB(instance_long, "__long__", instance_int)\r | |
1881 | UNARY(instance_float, "__float__")\r | |
1882 | UNARY(instance_oct, "__oct__")\r | |
1883 | UNARY(instance_hex, "__hex__")\r | |
1884 | \r | |
1885 | static PyObject *\r | |
1886 | bin_power(PyObject *v, PyObject *w)\r | |
1887 | {\r | |
1888 | return PyNumber_Power(v, w, Py_None);\r | |
1889 | }\r | |
1890 | \r | |
1891 | /* This version is for ternary calls only (z != None) */\r | |
1892 | static PyObject *\r | |
1893 | instance_pow(PyObject *v, PyObject *w, PyObject *z)\r | |
1894 | {\r | |
1895 | if (z == Py_None) {\r | |
1896 | return do_binop(v, w, "__pow__", "__rpow__", bin_power);\r | |
1897 | }\r | |
1898 | else {\r | |
1899 | PyObject *func;\r | |
1900 | PyObject *args;\r | |
1901 | PyObject *result;\r | |
1902 | \r | |
1903 | /* XXX Doesn't do coercions... */\r | |
1904 | func = PyObject_GetAttrString(v, "__pow__");\r | |
1905 | if (func == NULL)\r | |
1906 | return NULL;\r | |
1907 | args = PyTuple_Pack(2, w, z);\r | |
1908 | if (args == NULL) {\r | |
1909 | Py_DECREF(func);\r | |
1910 | return NULL;\r | |
1911 | }\r | |
1912 | result = PyEval_CallObject(func, args);\r | |
1913 | Py_DECREF(func);\r | |
1914 | Py_DECREF(args);\r | |
1915 | return result;\r | |
1916 | }\r | |
1917 | }\r | |
1918 | \r | |
1919 | static PyObject *\r | |
1920 | bin_inplace_power(PyObject *v, PyObject *w)\r | |
1921 | {\r | |
1922 | return PyNumber_InPlacePower(v, w, Py_None);\r | |
1923 | }\r | |
1924 | \r | |
1925 | \r | |
1926 | static PyObject *\r | |
1927 | instance_ipow(PyObject *v, PyObject *w, PyObject *z)\r | |
1928 | {\r | |
1929 | if (z == Py_None) {\r | |
1930 | return do_binop_inplace(v, w, "__ipow__", "__pow__",\r | |
1931 | "__rpow__", bin_inplace_power);\r | |
1932 | }\r | |
1933 | else {\r | |
1934 | /* XXX Doesn't do coercions... */\r | |
1935 | PyObject *func;\r | |
1936 | PyObject *args;\r | |
1937 | PyObject *result;\r | |
1938 | \r | |
1939 | func = PyObject_GetAttrString(v, "__ipow__");\r | |
1940 | if (func == NULL) {\r | |
1941 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
1942 | return NULL;\r | |
1943 | PyErr_Clear();\r | |
1944 | return instance_pow(v, w, z);\r | |
1945 | }\r | |
1946 | args = PyTuple_Pack(2, w, z);\r | |
1947 | if (args == NULL) {\r | |
1948 | Py_DECREF(func);\r | |
1949 | return NULL;\r | |
1950 | }\r | |
1951 | result = PyEval_CallObject(func, args);\r | |
1952 | Py_DECREF(func);\r | |
1953 | Py_DECREF(args);\r | |
1954 | return result;\r | |
1955 | }\r | |
1956 | }\r | |
1957 | \r | |
1958 | \r | |
1959 | /* Map rich comparison operators to their __xx__ namesakes */\r | |
1960 | #define NAME_OPS 6\r | |
1961 | static PyObject **name_op = NULL;\r | |
1962 | \r | |
1963 | static int\r | |
1964 | init_name_op(void)\r | |
1965 | {\r | |
1966 | int i;\r | |
1967 | char *_name_op[] = {\r | |
1968 | "__lt__",\r | |
1969 | "__le__",\r | |
1970 | "__eq__",\r | |
1971 | "__ne__",\r | |
1972 | "__gt__",\r | |
1973 | "__ge__",\r | |
1974 | };\r | |
1975 | \r | |
1976 | name_op = (PyObject **)malloc(sizeof(PyObject *) * NAME_OPS);\r | |
1977 | if (name_op == NULL)\r | |
1978 | return -1;\r | |
1979 | for (i = 0; i < NAME_OPS; ++i) {\r | |
1980 | name_op[i] = PyString_InternFromString(_name_op[i]);\r | |
1981 | if (name_op[i] == NULL)\r | |
1982 | return -1;\r | |
1983 | }\r | |
1984 | return 0;\r | |
1985 | }\r | |
1986 | \r | |
1987 | static PyObject *\r | |
1988 | half_richcompare(PyObject *v, PyObject *w, int op)\r | |
1989 | {\r | |
1990 | PyObject *method;\r | |
1991 | PyObject *args;\r | |
1992 | PyObject *res;\r | |
1993 | \r | |
1994 | assert(PyInstance_Check(v));\r | |
1995 | \r | |
1996 | if (name_op == NULL) {\r | |
1997 | if (init_name_op() < 0)\r | |
1998 | return NULL;\r | |
1999 | }\r | |
2000 | /* If the instance doesn't define an __getattr__ method, use\r | |
2001 | instance_getattr2 directly because it will not set an\r | |
2002 | exception on failure. */\r | |
2003 | if (((PyInstanceObject *)v)->in_class->cl_getattr == NULL)\r | |
2004 | method = instance_getattr2((PyInstanceObject *)v,\r | |
2005 | name_op[op]);\r | |
2006 | else\r | |
2007 | method = PyObject_GetAttr(v, name_op[op]);\r | |
2008 | if (method == NULL) {\r | |
2009 | if (PyErr_Occurred()) {\r | |
2010 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
2011 | return NULL;\r | |
2012 | PyErr_Clear();\r | |
2013 | }\r | |
2014 | res = Py_NotImplemented;\r | |
2015 | Py_INCREF(res);\r | |
2016 | return res;\r | |
2017 | }\r | |
2018 | \r | |
2019 | args = PyTuple_Pack(1, w);\r | |
2020 | if (args == NULL) {\r | |
2021 | Py_DECREF(method);\r | |
2022 | return NULL;\r | |
2023 | }\r | |
2024 | \r | |
2025 | res = PyEval_CallObject(method, args);\r | |
2026 | Py_DECREF(args);\r | |
2027 | Py_DECREF(method);\r | |
2028 | \r | |
2029 | return res;\r | |
2030 | }\r | |
2031 | \r | |
2032 | static PyObject *\r | |
2033 | instance_richcompare(PyObject *v, PyObject *w, int op)\r | |
2034 | {\r | |
2035 | PyObject *res;\r | |
2036 | \r | |
2037 | if (PyInstance_Check(v)) {\r | |
2038 | res = half_richcompare(v, w, op);\r | |
2039 | if (res != Py_NotImplemented)\r | |
2040 | return res;\r | |
2041 | Py_DECREF(res);\r | |
2042 | }\r | |
2043 | \r | |
2044 | if (PyInstance_Check(w)) {\r | |
2045 | res = half_richcompare(w, v, _Py_SwappedOp[op]);\r | |
2046 | if (res != Py_NotImplemented)\r | |
2047 | return res;\r | |
2048 | Py_DECREF(res);\r | |
2049 | }\r | |
2050 | \r | |
2051 | Py_INCREF(Py_NotImplemented);\r | |
2052 | return Py_NotImplemented;\r | |
2053 | }\r | |
2054 | \r | |
2055 | \r | |
2056 | /* Get the iterator */\r | |
2057 | static PyObject *\r | |
2058 | instance_getiter(PyInstanceObject *self)\r | |
2059 | {\r | |
2060 | PyObject *func;\r | |
2061 | \r | |
2062 | if (iterstr == NULL) {\r | |
2063 | iterstr = PyString_InternFromString("__iter__");\r | |
2064 | if (iterstr == NULL)\r | |
2065 | return NULL;\r | |
2066 | }\r | |
2067 | if (getitemstr == NULL) {\r | |
2068 | getitemstr = PyString_InternFromString("__getitem__");\r | |
2069 | if (getitemstr == NULL)\r | |
2070 | return NULL;\r | |
2071 | }\r | |
2072 | \r | |
2073 | if ((func = instance_getattr(self, iterstr)) != NULL) {\r | |
2074 | PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);\r | |
2075 | Py_DECREF(func);\r | |
2076 | if (res != NULL && !PyIter_Check(res)) {\r | |
2077 | PyErr_Format(PyExc_TypeError,\r | |
2078 | "__iter__ returned non-iterator "\r | |
2079 | "of type '%.100s'",\r | |
2080 | res->ob_type->tp_name);\r | |
2081 | Py_DECREF(res);\r | |
2082 | res = NULL;\r | |
2083 | }\r | |
2084 | return res;\r | |
2085 | }\r | |
2086 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
2087 | return NULL;\r | |
2088 | PyErr_Clear();\r | |
2089 | if ((func = instance_getattr(self, getitemstr)) == NULL) {\r | |
2090 | PyErr_SetString(PyExc_TypeError,\r | |
2091 | "iteration over non-sequence");\r | |
2092 | return NULL;\r | |
2093 | }\r | |
2094 | Py_DECREF(func);\r | |
2095 | return PySeqIter_New((PyObject *)self);\r | |
2096 | }\r | |
2097 | \r | |
2098 | \r | |
2099 | /* Call the iterator's next */\r | |
2100 | static PyObject *\r | |
2101 | instance_iternext(PyInstanceObject *self)\r | |
2102 | {\r | |
2103 | PyObject *func;\r | |
2104 | \r | |
2105 | if (nextstr == NULL) {\r | |
2106 | nextstr = PyString_InternFromString("next");\r | |
2107 | if (nextstr == NULL)\r | |
2108 | return NULL;\r | |
2109 | }\r | |
2110 | \r | |
2111 | if ((func = instance_getattr(self, nextstr)) != NULL) {\r | |
2112 | PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);\r | |
2113 | Py_DECREF(func);\r | |
2114 | if (res != NULL) {\r | |
2115 | return res;\r | |
2116 | }\r | |
2117 | if (PyErr_ExceptionMatches(PyExc_StopIteration)) {\r | |
2118 | PyErr_Clear();\r | |
2119 | return NULL;\r | |
2120 | }\r | |
2121 | return NULL;\r | |
2122 | }\r | |
2123 | PyErr_SetString(PyExc_TypeError, "instance has no next() method");\r | |
2124 | return NULL;\r | |
2125 | }\r | |
2126 | \r | |
2127 | static PyObject *\r | |
2128 | instance_call(PyObject *func, PyObject *arg, PyObject *kw)\r | |
2129 | {\r | |
2130 | PyObject *res, *call = PyObject_GetAttrString(func, "__call__");\r | |
2131 | if (call == NULL) {\r | |
2132 | PyInstanceObject *inst = (PyInstanceObject*) func;\r | |
2133 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
2134 | return NULL;\r | |
2135 | PyErr_Clear();\r | |
2136 | PyErr_Format(PyExc_AttributeError,\r | |
2137 | "%.200s instance has no __call__ method",\r | |
2138 | PyString_AsString(inst->in_class->cl_name));\r | |
2139 | return NULL;\r | |
2140 | }\r | |
2141 | /* We must check and increment the recursion depth here. Scenario:\r | |
2142 | class A:\r | |
2143 | pass\r | |
2144 | A.__call__ = A() # that's right\r | |
2145 | a = A() # ok\r | |
2146 | a() # infinite recursion\r | |
2147 | This bounces between instance_call() and PyObject_Call() without\r | |
2148 | ever hitting eval_frame() (which has the main recursion check). */\r | |
2149 | if (Py_EnterRecursiveCall(" in __call__")) {\r | |
2150 | res = NULL;\r | |
2151 | }\r | |
2152 | else {\r | |
2153 | res = PyObject_Call(call, arg, kw);\r | |
2154 | Py_LeaveRecursiveCall();\r | |
2155 | }\r | |
2156 | Py_DECREF(call);\r | |
2157 | return res;\r | |
2158 | }\r | |
2159 | \r | |
2160 | \r | |
2161 | static PyNumberMethods instance_as_number = {\r | |
2162 | instance_add, /* nb_add */\r | |
2163 | instance_sub, /* nb_subtract */\r | |
2164 | instance_mul, /* nb_multiply */\r | |
2165 | instance_div, /* nb_divide */\r | |
2166 | instance_mod, /* nb_remainder */\r | |
2167 | instance_divmod, /* nb_divmod */\r | |
2168 | instance_pow, /* nb_power */\r | |
2169 | (unaryfunc)instance_neg, /* nb_negative */\r | |
2170 | (unaryfunc)instance_pos, /* nb_positive */\r | |
2171 | (unaryfunc)instance_abs, /* nb_absolute */\r | |
2172 | (inquiry)instance_nonzero, /* nb_nonzero */\r | |
2173 | (unaryfunc)instance_invert, /* nb_invert */\r | |
2174 | instance_lshift, /* nb_lshift */\r | |
2175 | instance_rshift, /* nb_rshift */\r | |
2176 | instance_and, /* nb_and */\r | |
2177 | instance_xor, /* nb_xor */\r | |
2178 | instance_or, /* nb_or */\r | |
2179 | instance_coerce, /* nb_coerce */\r | |
2180 | (unaryfunc)instance_int, /* nb_int */\r | |
2181 | (unaryfunc)instance_long, /* nb_long */\r | |
2182 | (unaryfunc)instance_float, /* nb_float */\r | |
2183 | (unaryfunc)instance_oct, /* nb_oct */\r | |
2184 | (unaryfunc)instance_hex, /* nb_hex */\r | |
2185 | instance_iadd, /* nb_inplace_add */\r | |
2186 | instance_isub, /* nb_inplace_subtract */\r | |
2187 | instance_imul, /* nb_inplace_multiply */\r | |
2188 | instance_idiv, /* nb_inplace_divide */\r | |
2189 | instance_imod, /* nb_inplace_remainder */\r | |
2190 | instance_ipow, /* nb_inplace_power */\r | |
2191 | instance_ilshift, /* nb_inplace_lshift */\r | |
2192 | instance_irshift, /* nb_inplace_rshift */\r | |
2193 | instance_iand, /* nb_inplace_and */\r | |
2194 | instance_ixor, /* nb_inplace_xor */\r | |
2195 | instance_ior, /* nb_inplace_or */\r | |
2196 | instance_floordiv, /* nb_floor_divide */\r | |
2197 | instance_truediv, /* nb_true_divide */\r | |
2198 | instance_ifloordiv, /* nb_inplace_floor_divide */\r | |
2199 | instance_itruediv, /* nb_inplace_true_divide */\r | |
2200 | (unaryfunc)instance_index, /* nb_index */\r | |
2201 | };\r | |
2202 | \r | |
2203 | PyTypeObject PyInstance_Type = {\r | |
2204 | PyObject_HEAD_INIT(&PyType_Type)\r | |
2205 | 0,\r | |
2206 | "instance",\r | |
2207 | sizeof(PyInstanceObject),\r | |
2208 | 0,\r | |
2209 | (destructor)instance_dealloc, /* tp_dealloc */\r | |
2210 | 0, /* tp_print */\r | |
2211 | 0, /* tp_getattr */\r | |
2212 | 0, /* tp_setattr */\r | |
2213 | instance_compare, /* tp_compare */\r | |
2214 | (reprfunc)instance_repr, /* tp_repr */\r | |
2215 | &instance_as_number, /* tp_as_number */\r | |
2216 | &instance_as_sequence, /* tp_as_sequence */\r | |
2217 | &instance_as_mapping, /* tp_as_mapping */\r | |
2218 | (hashfunc)instance_hash, /* tp_hash */\r | |
2219 | instance_call, /* tp_call */\r | |
2220 | (reprfunc)instance_str, /* tp_str */\r | |
2221 | (getattrofunc)instance_getattr, /* tp_getattro */\r | |
2222 | (setattrofunc)instance_setattr, /* tp_setattro */\r | |
2223 | 0, /* tp_as_buffer */\r | |
2224 | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_CHECKTYPES,/*tp_flags*/\r | |
2225 | instance_doc, /* tp_doc */\r | |
2226 | (traverseproc)instance_traverse, /* tp_traverse */\r | |
2227 | 0, /* tp_clear */\r | |
2228 | instance_richcompare, /* tp_richcompare */\r | |
2229 | offsetof(PyInstanceObject, in_weakreflist), /* tp_weaklistoffset */\r | |
2230 | (getiterfunc)instance_getiter, /* tp_iter */\r | |
2231 | (iternextfunc)instance_iternext, /* tp_iternext */\r | |
2232 | 0, /* tp_methods */\r | |
2233 | 0, /* tp_members */\r | |
2234 | 0, /* tp_getset */\r | |
2235 | 0, /* tp_base */\r | |
2236 | 0, /* tp_dict */\r | |
2237 | 0, /* tp_descr_get */\r | |
2238 | 0, /* tp_descr_set */\r | |
2239 | 0, /* tp_dictoffset */\r | |
2240 | 0, /* tp_init */\r | |
2241 | 0, /* tp_alloc */\r | |
2242 | instance_new, /* tp_new */\r | |
2243 | };\r | |
2244 | \r | |
2245 | \r | |
2246 | /* Instance method objects are used for two purposes:\r | |
2247 | (a) as bound instance methods (returned by instancename.methodname)\r | |
2248 | (b) as unbound methods (returned by ClassName.methodname)\r | |
2249 | In case (b), im_self is NULL\r | |
2250 | */\r | |
2251 | \r | |
2252 | PyObject *\r | |
2253 | PyMethod_New(PyObject *func, PyObject *self, PyObject *klass)\r | |
2254 | {\r | |
2255 | register PyMethodObject *im;\r | |
2256 | im = free_list;\r | |
2257 | if (im != NULL) {\r | |
2258 | free_list = (PyMethodObject *)(im->im_self);\r | |
2259 | PyObject_INIT(im, &PyMethod_Type);\r | |
2260 | numfree--;\r | |
2261 | }\r | |
2262 | else {\r | |
2263 | im = PyObject_GC_New(PyMethodObject, &PyMethod_Type);\r | |
2264 | if (im == NULL)\r | |
2265 | return NULL;\r | |
2266 | }\r | |
2267 | im->im_weakreflist = NULL;\r | |
2268 | Py_INCREF(func);\r | |
2269 | im->im_func = func;\r | |
2270 | Py_XINCREF(self);\r | |
2271 | im->im_self = self;\r | |
2272 | Py_XINCREF(klass);\r | |
2273 | im->im_class = klass;\r | |
2274 | _PyObject_GC_TRACK(im);\r | |
2275 | return (PyObject *)im;\r | |
2276 | }\r | |
2277 | \r | |
2278 | /* Descriptors for PyMethod attributes */\r | |
2279 | \r | |
2280 | /* im_class, im_func and im_self are stored in the PyMethod object */\r | |
2281 | \r | |
2282 | #define OFF(x) offsetof(PyMethodObject, x)\r | |
2283 | \r | |
2284 | static PyMemberDef instancemethod_memberlist[] = {\r | |
2285 | {"im_class", T_OBJECT, OFF(im_class), READONLY|RESTRICTED,\r | |
2286 | "the class associated with a method"},\r | |
2287 | {"im_func", T_OBJECT, OFF(im_func), READONLY|RESTRICTED,\r | |
2288 | "the function (or other callable) implementing a method"},\r | |
2289 | {"__func__", T_OBJECT, OFF(im_func), READONLY|RESTRICTED,\r | |
2290 | "the function (or other callable) implementing a method"},\r | |
2291 | {"im_self", T_OBJECT, OFF(im_self), READONLY|RESTRICTED,\r | |
2292 | "the instance to which a method is bound; None for unbound methods"},\r | |
2293 | {"__self__", T_OBJECT, OFF(im_self), READONLY|RESTRICTED,\r | |
2294 | "the instance to which a method is bound; None for unbound methods"},\r | |
2295 | {NULL} /* Sentinel */\r | |
2296 | };\r | |
2297 | \r | |
2298 | /* Christian Tismer argued convincingly that method attributes should\r | |
2299 | (nearly) always override function attributes.\r | |
2300 | The one exception is __doc__; there's a default __doc__ which\r | |
2301 | should only be used for the class, not for instances */\r | |
2302 | \r | |
2303 | static PyObject *\r | |
2304 | instancemethod_get_doc(PyMethodObject *im, void *context)\r | |
2305 | {\r | |
2306 | static PyObject *docstr;\r | |
2307 | if (docstr == NULL) {\r | |
2308 | docstr= PyString_InternFromString("__doc__");\r | |
2309 | if (docstr == NULL)\r | |
2310 | return NULL;\r | |
2311 | }\r | |
2312 | return PyObject_GetAttr(im->im_func, docstr);\r | |
2313 | }\r | |
2314 | \r | |
2315 | static PyGetSetDef instancemethod_getset[] = {\r | |
2316 | {"__doc__", (getter)instancemethod_get_doc, NULL, NULL},\r | |
2317 | {0}\r | |
2318 | };\r | |
2319 | \r | |
2320 | static PyObject *\r | |
2321 | instancemethod_getattro(PyObject *obj, PyObject *name)\r | |
2322 | {\r | |
2323 | PyMethodObject *im = (PyMethodObject *)obj;\r | |
2324 | PyTypeObject *tp = obj->ob_type;\r | |
2325 | PyObject *descr = NULL;\r | |
2326 | \r | |
2327 | if (PyType_HasFeature(tp, Py_TPFLAGS_HAVE_CLASS)) {\r | |
2328 | if (tp->tp_dict == NULL) {\r | |
2329 | if (PyType_Ready(tp) < 0)\r | |
2330 | return NULL;\r | |
2331 | }\r | |
2332 | descr = _PyType_Lookup(tp, name);\r | |
2333 | }\r | |
2334 | \r | |
2335 | if (descr != NULL) {\r | |
2336 | descrgetfunc f = TP_DESCR_GET(descr->ob_type);\r | |
2337 | if (f != NULL)\r | |
2338 | return f(descr, obj, (PyObject *)obj->ob_type);\r | |
2339 | else {\r | |
2340 | Py_INCREF(descr);\r | |
2341 | return descr;\r | |
2342 | }\r | |
2343 | }\r | |
2344 | \r | |
2345 | return PyObject_GetAttr(im->im_func, name);\r | |
2346 | }\r | |
2347 | \r | |
2348 | PyDoc_STRVAR(instancemethod_doc,\r | |
2349 | "instancemethod(function, instance, class)\n\\r | |
2350 | \n\\r | |
2351 | Create an instance method object.");\r | |
2352 | \r | |
2353 | static PyObject *\r | |
2354 | instancemethod_new(PyTypeObject* type, PyObject* args, PyObject *kw)\r | |
2355 | {\r | |
2356 | PyObject *func;\r | |
2357 | PyObject *self;\r | |
2358 | PyObject *classObj = NULL;\r | |
2359 | \r | |
2360 | if (!_PyArg_NoKeywords("instancemethod", kw))\r | |
2361 | return NULL;\r | |
2362 | if (!PyArg_UnpackTuple(args, "instancemethod", 2, 3,\r | |
2363 | &func, &self, &classObj))\r | |
2364 | return NULL;\r | |
2365 | if (!PyCallable_Check(func)) {\r | |
2366 | PyErr_SetString(PyExc_TypeError,\r | |
2367 | "first argument must be callable");\r | |
2368 | return NULL;\r | |
2369 | }\r | |
2370 | if (self == Py_None)\r | |
2371 | self = NULL;\r | |
2372 | if (self == NULL && classObj == NULL) {\r | |
2373 | PyErr_SetString(PyExc_TypeError,\r | |
2374 | "unbound methods must have non-NULL im_class");\r | |
2375 | return NULL;\r | |
2376 | }\r | |
2377 | \r | |
2378 | return PyMethod_New(func, self, classObj);\r | |
2379 | }\r | |
2380 | \r | |
2381 | static void\r | |
2382 | instancemethod_dealloc(register PyMethodObject *im)\r | |
2383 | {\r | |
2384 | _PyObject_GC_UNTRACK(im);\r | |
2385 | if (im->im_weakreflist != NULL)\r | |
2386 | PyObject_ClearWeakRefs((PyObject *)im);\r | |
2387 | Py_DECREF(im->im_func);\r | |
2388 | Py_XDECREF(im->im_self);\r | |
2389 | Py_XDECREF(im->im_class);\r | |
2390 | if (numfree < PyMethod_MAXFREELIST) {\r | |
2391 | im->im_self = (PyObject *)free_list;\r | |
2392 | free_list = im;\r | |
2393 | numfree++;\r | |
2394 | }\r | |
2395 | else {\r | |
2396 | PyObject_GC_Del(im);\r | |
2397 | }\r | |
2398 | }\r | |
2399 | \r | |
2400 | static int\r | |
2401 | instancemethod_compare(PyMethodObject *a, PyMethodObject *b)\r | |
2402 | {\r | |
2403 | int cmp;\r | |
2404 | cmp = PyObject_Compare(a->im_func, b->im_func);\r | |
2405 | if (cmp)\r | |
2406 | return cmp;\r | |
2407 | \r | |
2408 | if (a->im_self == b->im_self)\r | |
2409 | return 0;\r | |
2410 | if (a->im_self == NULL || b->im_self == NULL)\r | |
2411 | return (a->im_self < b->im_self) ? -1 : 1;\r | |
2412 | else\r | |
2413 | return PyObject_Compare(a->im_self, b->im_self);\r | |
2414 | }\r | |
2415 | \r | |
2416 | static PyObject *\r | |
2417 | instancemethod_repr(PyMethodObject *a)\r | |
2418 | {\r | |
2419 | PyObject *self = a->im_self;\r | |
2420 | PyObject *func = a->im_func;\r | |
2421 | PyObject *klass = a->im_class;\r | |
2422 | PyObject *funcname = NULL, *klassname = NULL, *result = NULL;\r | |
2423 | char *sfuncname = "?", *sklassname = "?";\r | |
2424 | \r | |
2425 | funcname = PyObject_GetAttrString(func, "__name__");\r | |
2426 | if (funcname == NULL) {\r | |
2427 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
2428 | return NULL;\r | |
2429 | PyErr_Clear();\r | |
2430 | }\r | |
2431 | else if (!PyString_Check(funcname)) {\r | |
2432 | Py_DECREF(funcname);\r | |
2433 | funcname = NULL;\r | |
2434 | }\r | |
2435 | else\r | |
2436 | sfuncname = PyString_AS_STRING(funcname);\r | |
2437 | if (klass == NULL)\r | |
2438 | klassname = NULL;\r | |
2439 | else {\r | |
2440 | klassname = PyObject_GetAttrString(klass, "__name__");\r | |
2441 | if (klassname == NULL) {\r | |
2442 | if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r | |
2443 | return NULL;\r | |
2444 | PyErr_Clear();\r | |
2445 | }\r | |
2446 | else if (!PyString_Check(klassname)) {\r | |
2447 | Py_DECREF(klassname);\r | |
2448 | klassname = NULL;\r | |
2449 | }\r | |
2450 | else\r | |
2451 | sklassname = PyString_AS_STRING(klassname);\r | |
2452 | }\r | |
2453 | if (self == NULL)\r | |
2454 | result = PyString_FromFormat("<unbound method %s.%s>",\r | |
2455 | sklassname, sfuncname);\r | |
2456 | else {\r | |
2457 | /* XXX Shouldn't use repr() here! */\r | |
2458 | PyObject *selfrepr = PyObject_Repr(self);\r | |
2459 | if (selfrepr == NULL)\r | |
2460 | goto fail;\r | |
2461 | if (!PyString_Check(selfrepr)) {\r | |
2462 | Py_DECREF(selfrepr);\r | |
2463 | goto fail;\r | |
2464 | }\r | |
2465 | result = PyString_FromFormat("<bound method %s.%s of %s>",\r | |
2466 | sklassname, sfuncname,\r | |
2467 | PyString_AS_STRING(selfrepr));\r | |
2468 | Py_DECREF(selfrepr);\r | |
2469 | }\r | |
2470 | fail:\r | |
2471 | Py_XDECREF(funcname);\r | |
2472 | Py_XDECREF(klassname);\r | |
2473 | return result;\r | |
2474 | }\r | |
2475 | \r | |
2476 | static long\r | |
2477 | instancemethod_hash(PyMethodObject *a)\r | |
2478 | {\r | |
2479 | long x, y;\r | |
2480 | if (a->im_self == NULL)\r | |
2481 | x = PyObject_Hash(Py_None);\r | |
2482 | else\r | |
2483 | x = PyObject_Hash(a->im_self);\r | |
2484 | if (x == -1)\r | |
2485 | return -1;\r | |
2486 | y = PyObject_Hash(a->im_func);\r | |
2487 | if (y == -1)\r | |
2488 | return -1;\r | |
2489 | x = x ^ y;\r | |
2490 | if (x == -1)\r | |
2491 | x = -2;\r | |
2492 | return x;\r | |
2493 | }\r | |
2494 | \r | |
2495 | static int\r | |
2496 | instancemethod_traverse(PyMethodObject *im, visitproc visit, void *arg)\r | |
2497 | {\r | |
2498 | Py_VISIT(im->im_func);\r | |
2499 | Py_VISIT(im->im_self);\r | |
2500 | Py_VISIT(im->im_class);\r | |
2501 | return 0;\r | |
2502 | }\r | |
2503 | \r | |
2504 | static void\r | |
2505 | getclassname(PyObject *klass, char *buf, int bufsize)\r | |
2506 | {\r | |
2507 | PyObject *name;\r | |
2508 | \r | |
2509 | assert(bufsize > 1);\r | |
2510 | strcpy(buf, "?"); /* Default outcome */\r | |
2511 | if (klass == NULL)\r | |
2512 | return;\r | |
2513 | name = PyObject_GetAttrString(klass, "__name__");\r | |
2514 | if (name == NULL) {\r | |
2515 | /* This function cannot return an exception */\r | |
2516 | PyErr_Clear();\r | |
2517 | return;\r | |
2518 | }\r | |
2519 | if (PyString_Check(name)) {\r | |
2520 | strncpy(buf, PyString_AS_STRING(name), bufsize);\r | |
2521 | buf[bufsize-1] = '\0';\r | |
2522 | }\r | |
2523 | Py_DECREF(name);\r | |
2524 | }\r | |
2525 | \r | |
2526 | static void\r | |
2527 | getinstclassname(PyObject *inst, char *buf, int bufsize)\r | |
2528 | {\r | |
2529 | PyObject *klass;\r | |
2530 | \r | |
2531 | if (inst == NULL) {\r | |
2532 | assert(bufsize > 0 && (size_t)bufsize > strlen("nothing"));\r | |
2533 | strcpy(buf, "nothing");\r | |
2534 | return;\r | |
2535 | }\r | |
2536 | \r | |
2537 | klass = PyObject_GetAttrString(inst, "__class__");\r | |
2538 | if (klass == NULL) {\r | |
2539 | /* This function cannot return an exception */\r | |
2540 | PyErr_Clear();\r | |
2541 | klass = (PyObject *)(inst->ob_type);\r | |
2542 | Py_INCREF(klass);\r | |
2543 | }\r | |
2544 | getclassname(klass, buf, bufsize);\r | |
2545 | Py_XDECREF(klass);\r | |
2546 | }\r | |
2547 | \r | |
2548 | static PyObject *\r | |
2549 | instancemethod_call(PyObject *func, PyObject *arg, PyObject *kw)\r | |
2550 | {\r | |
2551 | PyObject *self = PyMethod_GET_SELF(func);\r | |
2552 | PyObject *klass = PyMethod_GET_CLASS(func);\r | |
2553 | PyObject *result;\r | |
2554 | \r | |
2555 | func = PyMethod_GET_FUNCTION(func);\r | |
2556 | if (self == NULL) {\r | |
2557 | /* Unbound methods must be called with an instance of\r | |
2558 | the class (or a derived class) as first argument */\r | |
2559 | int ok;\r | |
2560 | if (PyTuple_Size(arg) >= 1)\r | |
2561 | self = PyTuple_GET_ITEM(arg, 0);\r | |
2562 | if (self == NULL)\r | |
2563 | ok = 0;\r | |
2564 | else {\r | |
2565 | ok = PyObject_IsInstance(self, klass);\r | |
2566 | if (ok < 0)\r | |
2567 | return NULL;\r | |
2568 | }\r | |
2569 | if (!ok) {\r | |
2570 | char clsbuf[256];\r | |
2571 | char instbuf[256];\r | |
2572 | getclassname(klass, clsbuf, sizeof(clsbuf));\r | |
2573 | getinstclassname(self, instbuf, sizeof(instbuf));\r | |
2574 | PyErr_Format(PyExc_TypeError,\r | |
2575 | "unbound method %s%s must be called with "\r | |
2576 | "%s instance as first argument "\r | |
2577 | "(got %s%s instead)",\r | |
2578 | PyEval_GetFuncName(func),\r | |
2579 | PyEval_GetFuncDesc(func),\r | |
2580 | clsbuf,\r | |
2581 | instbuf,\r | |
2582 | self == NULL ? "" : " instance");\r | |
2583 | return NULL;\r | |
2584 | }\r | |
2585 | Py_INCREF(arg);\r | |
2586 | }\r | |
2587 | else {\r | |
2588 | Py_ssize_t argcount = PyTuple_Size(arg);\r | |
2589 | PyObject *newarg = PyTuple_New(argcount + 1);\r | |
2590 | int i;\r | |
2591 | if (newarg == NULL)\r | |
2592 | return NULL;\r | |
2593 | Py_INCREF(self);\r | |
2594 | PyTuple_SET_ITEM(newarg, 0, self);\r | |
2595 | for (i = 0; i < argcount; i++) {\r | |
2596 | PyObject *v = PyTuple_GET_ITEM(arg, i);\r | |
2597 | Py_XINCREF(v);\r | |
2598 | PyTuple_SET_ITEM(newarg, i+1, v);\r | |
2599 | }\r | |
2600 | arg = newarg;\r | |
2601 | }\r | |
2602 | result = PyObject_Call((PyObject *)func, arg, kw);\r | |
2603 | Py_DECREF(arg);\r | |
2604 | return result;\r | |
2605 | }\r | |
2606 | \r | |
2607 | static PyObject *\r | |
2608 | instancemethod_descr_get(PyObject *meth, PyObject *obj, PyObject *cls)\r | |
2609 | {\r | |
2610 | /* Don't rebind an already bound method, or an unbound method\r | |
2611 | of a class that's not a base class of cls. */\r | |
2612 | \r | |
2613 | if (PyMethod_GET_SELF(meth) != NULL) {\r | |
2614 | /* Already bound */\r | |
2615 | Py_INCREF(meth);\r | |
2616 | return meth;\r | |
2617 | }\r | |
2618 | /* No, it is an unbound method */\r | |
2619 | if (PyMethod_GET_CLASS(meth) != NULL && cls != NULL) {\r | |
2620 | /* Do subclass test. If it fails, return meth unchanged. */\r | |
2621 | int ok = PyObject_IsSubclass(cls, PyMethod_GET_CLASS(meth));\r | |
2622 | if (ok < 0)\r | |
2623 | return NULL;\r | |
2624 | if (!ok) {\r | |
2625 | Py_INCREF(meth);\r | |
2626 | return meth;\r | |
2627 | }\r | |
2628 | }\r | |
2629 | /* Bind it to obj */\r | |
2630 | return PyMethod_New(PyMethod_GET_FUNCTION(meth), obj, cls);\r | |
2631 | }\r | |
2632 | \r | |
2633 | PyTypeObject PyMethod_Type = {\r | |
2634 | PyObject_HEAD_INIT(&PyType_Type)\r | |
2635 | 0,\r | |
2636 | "instancemethod",\r | |
2637 | sizeof(PyMethodObject),\r | |
2638 | 0,\r | |
2639 | (destructor)instancemethod_dealloc, /* tp_dealloc */\r | |
2640 | 0, /* tp_print */\r | |
2641 | 0, /* tp_getattr */\r | |
2642 | 0, /* tp_setattr */\r | |
2643 | (cmpfunc)instancemethod_compare, /* tp_compare */\r | |
2644 | (reprfunc)instancemethod_repr, /* tp_repr */\r | |
2645 | 0, /* tp_as_number */\r | |
2646 | 0, /* tp_as_sequence */\r | |
2647 | 0, /* tp_as_mapping */\r | |
2648 | (hashfunc)instancemethod_hash, /* tp_hash */\r | |
2649 | instancemethod_call, /* tp_call */\r | |
2650 | 0, /* tp_str */\r | |
2651 | instancemethod_getattro, /* tp_getattro */\r | |
2652 | PyObject_GenericSetAttr, /* tp_setattro */\r | |
2653 | 0, /* tp_as_buffer */\r | |
2654 | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */\r | |
2655 | instancemethod_doc, /* tp_doc */\r | |
2656 | (traverseproc)instancemethod_traverse, /* tp_traverse */\r | |
2657 | 0, /* tp_clear */\r | |
2658 | 0, /* tp_richcompare */\r | |
2659 | offsetof(PyMethodObject, im_weakreflist), /* tp_weaklistoffset */\r | |
2660 | 0, /* tp_iter */\r | |
2661 | 0, /* tp_iternext */\r | |
2662 | 0, /* tp_methods */\r | |
2663 | instancemethod_memberlist, /* tp_members */\r | |
2664 | instancemethod_getset, /* tp_getset */\r | |
2665 | 0, /* tp_base */\r | |
2666 | 0, /* tp_dict */\r | |
2667 | instancemethod_descr_get, /* tp_descr_get */\r | |
2668 | 0, /* tp_descr_set */\r | |
2669 | 0, /* tp_dictoffset */\r | |
2670 | 0, /* tp_init */\r | |
2671 | 0, /* tp_alloc */\r | |
2672 | instancemethod_new, /* tp_new */\r | |
2673 | };\r | |
2674 | \r | |
2675 | /* Clear out the free list */\r | |
2676 | \r | |
2677 | int\r | |
2678 | PyMethod_ClearFreeList(void)\r | |
2679 | {\r | |
2680 | int freelist_size = numfree;\r | |
2681 | \r | |
2682 | while (free_list) {\r | |
2683 | PyMethodObject *im = free_list;\r | |
2684 | free_list = (PyMethodObject *)(im->im_self);\r | |
2685 | PyObject_GC_Del(im);\r | |
2686 | numfree--;\r | |
2687 | }\r | |
2688 | assert(numfree == 0);\r | |
2689 | return freelist_size;\r | |
2690 | }\r | |
2691 | \r | |
2692 | void\r | |
2693 | PyMethod_Fini(void)\r | |
2694 | {\r | |
2695 | (void)PyMethod_ClearFreeList();\r | |
2696 | }\r |