source: python/trunk/Objects/methodobject.c@ 1538

Last change on this file since 1538 was 391, checked in by dmik, 12 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 11.6 KB
Line 
1
2/* Method object implementation */
3
4#include "Python.h"
5#include "structmember.h"
6
7/* Free list for method objects to safe malloc/free overhead
8 * The m_self element is used to chain the objects.
9 */
10static PyCFunctionObject *free_list = NULL;
11static int numfree = 0;
12#ifndef PyCFunction_MAXFREELIST
13#define PyCFunction_MAXFREELIST 256
14#endif
15
16PyObject *
17PyCFunction_NewEx(PyMethodDef *ml, PyObject *self, PyObject *module)
18{
19 PyCFunctionObject *op;
20 op = free_list;
21 if (op != NULL) {
22 free_list = (PyCFunctionObject *)(op->m_self);
23 PyObject_INIT(op, &PyCFunction_Type);
24 numfree--;
25 }
26 else {
27 op = PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type);
28 if (op == NULL)
29 return NULL;
30 }
31 op->m_ml = ml;
32 Py_XINCREF(self);
33 op->m_self = self;
34 Py_XINCREF(module);
35 op->m_module = module;
36 _PyObject_GC_TRACK(op);
37 return (PyObject *)op;
38}
39
40PyCFunction
41PyCFunction_GetFunction(PyObject *op)
42{
43 if (!PyCFunction_Check(op)) {
44 PyErr_BadInternalCall();
45 return NULL;
46 }
47 return ((PyCFunctionObject *)op) -> m_ml -> ml_meth;
48}
49
50PyObject *
51PyCFunction_GetSelf(PyObject *op)
52{
53 if (!PyCFunction_Check(op)) {
54 PyErr_BadInternalCall();
55 return NULL;
56 }
57 return ((PyCFunctionObject *)op) -> m_self;
58}
59
60int
61PyCFunction_GetFlags(PyObject *op)
62{
63 if (!PyCFunction_Check(op)) {
64 PyErr_BadInternalCall();
65 return -1;
66 }
67 return ((PyCFunctionObject *)op) -> m_ml -> ml_flags;
68}
69
70PyObject *
71PyCFunction_Call(PyObject *func, PyObject *arg, PyObject *kw)
72{
73 PyCFunctionObject* f = (PyCFunctionObject*)func;
74 PyCFunction meth = PyCFunction_GET_FUNCTION(func);
75 PyObject *self = PyCFunction_GET_SELF(func);
76 Py_ssize_t size;
77
78 switch (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)) {
79 case METH_VARARGS:
80 if (kw == NULL || PyDict_Size(kw) == 0)
81 return (*meth)(self, arg);
82 break;
83 case METH_VARARGS | METH_KEYWORDS:
84 case METH_OLDARGS | METH_KEYWORDS:
85 return (*(PyCFunctionWithKeywords)meth)(self, arg, kw);
86 case METH_NOARGS:
87 if (kw == NULL || PyDict_Size(kw) == 0) {
88 size = PyTuple_GET_SIZE(arg);
89 if (size == 0)
90 return (*meth)(self, NULL);
91 PyErr_Format(PyExc_TypeError,
92 "%.200s() takes no arguments (%zd given)",
93 f->m_ml->ml_name, size);
94 return NULL;
95 }
96 break;
97 case METH_O:
98 if (kw == NULL || PyDict_Size(kw) == 0) {
99 size = PyTuple_GET_SIZE(arg);
100 if (size == 1)
101 return (*meth)(self, PyTuple_GET_ITEM(arg, 0));
102 PyErr_Format(PyExc_TypeError,
103 "%.200s() takes exactly one argument (%zd given)",
104 f->m_ml->ml_name, size);
105 return NULL;
106 }
107 break;
108 case METH_OLDARGS:
109 /* the really old style */
110 if (kw == NULL || PyDict_Size(kw) == 0) {
111 size = PyTuple_GET_SIZE(arg);
112 if (size == 1)
113 arg = PyTuple_GET_ITEM(arg, 0);
114 else if (size == 0)
115 arg = NULL;
116 return (*meth)(self, arg);
117 }
118 break;
119 default:
120 PyErr_BadInternalCall();
121 return NULL;
122 }
123 PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
124 f->m_ml->ml_name);
125 return NULL;
126}
127
128/* Methods (the standard built-in methods, that is) */
129
130static void
131meth_dealloc(PyCFunctionObject *m)
132{
133 _PyObject_GC_UNTRACK(m);
134 Py_XDECREF(m->m_self);
135 Py_XDECREF(m->m_module);
136 if (numfree < PyCFunction_MAXFREELIST) {
137 m->m_self = (PyObject *)free_list;
138 free_list = m;
139 numfree++;
140 }
141 else {
142 PyObject_GC_Del(m);
143 }
144}
145
146static PyObject *
147meth_get__doc__(PyCFunctionObject *m, void *closure)
148{
149 const char *doc = m->m_ml->ml_doc;
150
151 if (doc != NULL)
152 return PyString_FromString(doc);
153 Py_INCREF(Py_None);
154 return Py_None;
155}
156
157static PyObject *
158meth_get__name__(PyCFunctionObject *m, void *closure)
159{
160 return PyString_FromString(m->m_ml->ml_name);
161}
162
163static int
164meth_traverse(PyCFunctionObject *m, visitproc visit, void *arg)
165{
166 Py_VISIT(m->m_self);
167 Py_VISIT(m->m_module);
168 return 0;
169}
170
171static PyObject *
172meth_get__self__(PyCFunctionObject *m, void *closure)
173{
174 PyObject *self;
175 if (PyEval_GetRestricted()) {
176 PyErr_SetString(PyExc_RuntimeError,
177 "method.__self__ not accessible in restricted mode");
178 return NULL;
179 }
180 self = m->m_self;
181 if (self == NULL)
182 self = Py_None;
183 Py_INCREF(self);
184 return self;
185}
186
187static PyGetSetDef meth_getsets [] = {
188 {"__doc__", (getter)meth_get__doc__, NULL, NULL},
189 {"__name__", (getter)meth_get__name__, NULL, NULL},
190 {"__self__", (getter)meth_get__self__, NULL, NULL},
191 {0}
192};
193
194#define OFF(x) offsetof(PyCFunctionObject, x)
195
196static PyMemberDef meth_members[] = {
197 {"__module__", T_OBJECT, OFF(m_module), PY_WRITE_RESTRICTED},
198 {NULL}
199};
200
201static PyObject *
202meth_repr(PyCFunctionObject *m)
203{
204 if (m->m_self == NULL)
205 return PyString_FromFormat("<built-in function %s>",
206 m->m_ml->ml_name);
207 return PyString_FromFormat("<built-in method %s of %s object at %p>",
208 m->m_ml->ml_name,
209 m->m_self->ob_type->tp_name,
210 m->m_self);
211}
212
213static int
214meth_compare(PyCFunctionObject *a, PyCFunctionObject *b)
215{
216 if (a->m_self != b->m_self)
217 return (a->m_self < b->m_self) ? -1 : 1;
218 if (a->m_ml->ml_meth == b->m_ml->ml_meth)
219 return 0;
220 if (strcmp(a->m_ml->ml_name, b->m_ml->ml_name) < 0)
221 return -1;
222 else
223 return 1;
224}
225
226static PyObject *
227meth_richcompare(PyObject *self, PyObject *other, int op)
228{
229 PyCFunctionObject *a, *b;
230 PyObject *res;
231 int eq;
232
233 if (op != Py_EQ && op != Py_NE) {
234 /* Py3K warning if comparison isn't == or !=. */
235 if (PyErr_WarnPy3k("builtin_function_or_method order "
236 "comparisons not supported in 3.x", 1) < 0) {
237 return NULL;
238 }
239
240 Py_INCREF(Py_NotImplemented);
241 return Py_NotImplemented;
242 }
243 else if (!PyCFunction_Check(self) || !PyCFunction_Check(other)) {
244 Py_INCREF(Py_NotImplemented);
245 return Py_NotImplemented;
246 }
247 a = (PyCFunctionObject *)self;
248 b = (PyCFunctionObject *)other;
249 eq = a->m_self == b->m_self;
250 if (eq)
251 eq = a->m_ml->ml_meth == b->m_ml->ml_meth;
252 if (op == Py_EQ)
253 res = eq ? Py_True : Py_False;
254 else
255 res = eq ? Py_False : Py_True;
256 Py_INCREF(res);
257 return res;
258}
259
260static long
261meth_hash(PyCFunctionObject *a)
262{
263 long x,y;
264 if (a->m_self == NULL)
265 x = 0;
266 else {
267 x = PyObject_Hash(a->m_self);
268 if (x == -1)
269 return -1;
270 }
271 y = _Py_HashPointer((void*)(a->m_ml->ml_meth));
272 if (y == -1)
273 return -1;
274 x ^= y;
275 if (x == -1)
276 x = -2;
277 return x;
278}
279
280
281PyTypeObject PyCFunction_Type = {
282 PyVarObject_HEAD_INIT(&PyType_Type, 0)
283 "builtin_function_or_method",
284 sizeof(PyCFunctionObject),
285 0,
286 (destructor)meth_dealloc, /* tp_dealloc */
287 0, /* tp_print */
288 0, /* tp_getattr */
289 0, /* tp_setattr */
290 (cmpfunc)meth_compare, /* tp_compare */
291 (reprfunc)meth_repr, /* tp_repr */
292 0, /* tp_as_number */
293 0, /* tp_as_sequence */
294 0, /* tp_as_mapping */
295 (hashfunc)meth_hash, /* tp_hash */
296 PyCFunction_Call, /* tp_call */
297 0, /* tp_str */
298 PyObject_GenericGetAttr, /* tp_getattro */
299 0, /* tp_setattro */
300 0, /* tp_as_buffer */
301 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
302 0, /* tp_doc */
303 (traverseproc)meth_traverse, /* tp_traverse */
304 0, /* tp_clear */
305 meth_richcompare, /* tp_richcompare */
306 0, /* tp_weaklistoffset */
307 0, /* tp_iter */
308 0, /* tp_iternext */
309 0, /* tp_methods */
310 meth_members, /* tp_members */
311 meth_getsets, /* tp_getset */
312 0, /* tp_base */
313 0, /* tp_dict */
314};
315
316/* List all methods in a chain -- helper for findmethodinchain */
317
318static PyObject *
319listmethodchain(PyMethodChain *chain)
320{
321 PyMethodChain *c;
322 PyMethodDef *ml;
323 int i, n;
324 PyObject *v;
325
326 n = 0;
327 for (c = chain; c != NULL; c = c->link) {
328 for (ml = c->methods; ml->ml_name != NULL; ml++)
329 n++;
330 }
331 v = PyList_New(n);
332 if (v == NULL)
333 return NULL;
334 i = 0;
335 for (c = chain; c != NULL; c = c->link) {
336 for (ml = c->methods; ml->ml_name != NULL; ml++) {
337 PyList_SetItem(v, i, PyString_FromString(ml->ml_name));
338 i++;
339 }
340 }
341 if (PyErr_Occurred()) {
342 Py_DECREF(v);
343 return NULL;
344 }
345 PyList_Sort(v);
346 return v;
347}
348
349/* Find a method in a method chain */
350
351PyObject *
352Py_FindMethodInChain(PyMethodChain *chain, PyObject *self, const char *name)
353{
354 if (name[0] == '_' && name[1] == '_') {
355 if (strcmp(name, "__methods__") == 0) {
356 if (PyErr_WarnPy3k("__methods__ not supported in 3.x",
357 1) < 0)
358 return NULL;
359 return listmethodchain(chain);
360 }
361 if (strcmp(name, "__doc__") == 0) {
362 const char *doc = self->ob_type->tp_doc;
363 if (doc != NULL)
364 return PyString_FromString(doc);
365 }
366 }
367 while (chain != NULL) {
368 PyMethodDef *ml = chain->methods;
369 for (; ml->ml_name != NULL; ml++) {
370 if (name[0] == ml->ml_name[0] &&
371 strcmp(name+1, ml->ml_name+1) == 0)
372 /* XXX */
373 return PyCFunction_New(ml, self);
374 }
375 chain = chain->link;
376 }
377 PyErr_SetString(PyExc_AttributeError, name);
378 return NULL;
379}
380
381/* Find a method in a single method list */
382
383PyObject *
384Py_FindMethod(PyMethodDef *methods, PyObject *self, const char *name)
385{
386 PyMethodChain chain;
387 chain.methods = methods;
388 chain.link = NULL;
389 return Py_FindMethodInChain(&chain, self, name);
390}
391
392/* Clear out the free list */
393
394int
395PyCFunction_ClearFreeList(void)
396{
397 int freelist_size = numfree;
398
399 while (free_list) {
400 PyCFunctionObject *v = free_list;
401 free_list = (PyCFunctionObject *)(v->m_self);
402 PyObject_GC_Del(v);
403 numfree--;
404 }
405 assert(numfree == 0);
406 return freelist_size;
407}
408
409void
410PyCFunction_Fini(void)
411{
412 (void)PyCFunction_ClearFreeList();
413}
414
415/* PyCFunction_New() is now just a macro that calls PyCFunction_NewEx(),
416 but it's part of the API so we need to keep a function around that
417 existing C extensions can call.
418*/
419
420#undef PyCFunction_New
421PyAPI_FUNC(PyObject *) PyCFunction_New(PyMethodDef *, PyObject *);
422
423PyObject *
424PyCFunction_New(PyMethodDef *ml, PyObject *self)
425{
426 return PyCFunction_NewEx(ml, self, NULL);
427}
Note: See TracBrowser for help on using the repository browser.