1
2 #include "Python.h"
3 #include "structmember.h"
4
5 /* _functools module written and maintained
6 by Hye-Shik Chang <perky@FreeBSD.org>
7 with adaptations by Raymond Hettinger <python@rcn.com>
8 Copyright (c) 2004, 2005, 2006 Python Software Foundation.
9 All rights reserved.
10 */
11
12 /* reduce() *************************************************************/
13
14 static PyObject *
functools_reduce(PyObject * self,PyObject * args)15 functools_reduce(PyObject *self, PyObject *args)
16 {
17 PyObject *seq, *func, *result = NULL, *it;
18
19 if (!PyArg_UnpackTuple(args, "reduce", 2, 3, &func, &seq, &result))
20 return NULL;
21 if (result != NULL)
22 Py_INCREF(result);
23
24 it = PyObject_GetIter(seq);
25 if (it == NULL) {
26 PyErr_SetString(PyExc_TypeError,
27 "reduce() arg 2 must support iteration");
28 Py_XDECREF(result);
29 return NULL;
30 }
31
32 if ((args = PyTuple_New(2)) == NULL)
33 goto Fail;
34
35 for (;;) {
36 PyObject *op2;
37
38 if (args->ob_refcnt > 1) {
39 Py_DECREF(args);
40 if ((args = PyTuple_New(2)) == NULL)
41 goto Fail;
42 }
43
44 op2 = PyIter_Next(it);
45 if (op2 == NULL) {
46 if (PyErr_Occurred())
47 goto Fail;
48 break;
49 }
50
51 if (result == NULL)
52 result = op2;
53 else {
54 PyTuple_SetItem(args, 0, result);
55 PyTuple_SetItem(args, 1, op2);
56 if ((result = PyEval_CallObject(func, args)) == NULL)
57 goto Fail;
58 }
59 }
60
61 Py_DECREF(args);
62
63 if (result == NULL)
64 PyErr_SetString(PyExc_TypeError,
65 "reduce() of empty sequence with no initial value");
66
67 Py_DECREF(it);
68 return result;
69
70 Fail:
71 Py_XDECREF(args);
72 Py_XDECREF(result);
73 Py_DECREF(it);
74 return NULL;
75 }
76
77 PyDoc_STRVAR(reduce_doc,
78 "reduce(function, sequence[, initial]) -> value\n\
79 \n\
80 Apply a function of two arguments cumulatively to the items of a sequence,\n\
81 from left to right, so as to reduce the sequence to a single value.\n\
82 For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates\n\
83 ((((1+2)+3)+4)+5). If initial is present, it is placed before the items\n\
84 of the sequence in the calculation, and serves as a default when the\n\
85 sequence is empty.");
86
87
88
89
90 /* partial object **********************************************************/
91
92 typedef struct {
93 PyObject_HEAD
94 PyObject *fn;
95 PyObject *args;
96 PyObject *kw;
97 PyObject *dict;
98 PyObject *weakreflist; /* List of weak references */
99 } partialobject;
100
101 static PyTypeObject partial_type;
102
103 static PyObject *
partial_new(PyTypeObject * type,PyObject * args,PyObject * kw)104 partial_new(PyTypeObject *type, PyObject *args, PyObject *kw)
105 {
106 PyObject *func;
107 partialobject *pto;
108
109 if (PyTuple_GET_SIZE(args) < 1) {
110 PyErr_SetString(PyExc_TypeError,
111 "type 'partial' takes at least one argument");
112 return NULL;
113 }
114
115 func = PyTuple_GET_ITEM(args, 0);
116 if (!PyCallable_Check(func)) {
117 PyErr_SetString(PyExc_TypeError,
118 "the first argument must be callable");
119 return NULL;
120 }
121
122 /* create partialobject structure */
123 pto = (partialobject *)type->tp_alloc(type, 0);
124 if (pto == NULL)
125 return NULL;
126
127 pto->fn = func;
128 Py_INCREF(func);
129 pto->args = PyTuple_GetSlice(args, 1, PY_SSIZE_T_MAX);
130 if (pto->args == NULL) {
131 Py_DECREF(pto);
132 return NULL;
133 }
134 pto->kw = (kw != NULL) ? PyDict_Copy(kw) : PyDict_New();
135 if (pto->kw == NULL) {
136 Py_DECREF(pto);
137 return NULL;
138 }
139
140 return (PyObject *)pto;
141 }
142
143 static void
partial_dealloc(partialobject * pto)144 partial_dealloc(partialobject *pto)
145 {
146 /* bpo-31095: UnTrack is needed before calling any callbacks */
147 PyObject_GC_UnTrack(pto);
148 if (pto->weakreflist != NULL)
149 PyObject_ClearWeakRefs((PyObject *) pto);
150 Py_XDECREF(pto->fn);
151 Py_XDECREF(pto->args);
152 Py_XDECREF(pto->kw);
153 Py_XDECREF(pto->dict);
154 Py_TYPE(pto)->tp_free(pto);
155 }
156
157 static PyObject *
partial_call(partialobject * pto,PyObject * args,PyObject * kw)158 partial_call(partialobject *pto, PyObject *args, PyObject *kw)
159 {
160 PyObject *ret;
161 PyObject *argappl, *kwappl;
162
163 assert (PyCallable_Check(pto->fn));
164 assert (PyTuple_Check(pto->args));
165 assert (PyDict_Check(pto->kw));
166
167 if (PyTuple_GET_SIZE(pto->args) == 0) {
168 argappl = args;
169 Py_INCREF(args);
170 } else if (PyTuple_GET_SIZE(args) == 0) {
171 argappl = pto->args;
172 Py_INCREF(pto->args);
173 } else {
174 argappl = PySequence_Concat(pto->args, args);
175 if (argappl == NULL)
176 return NULL;
177 assert(PyTuple_Check(argappl));
178 }
179
180 if (PyDict_Size(pto->kw) == 0) {
181 kwappl = kw;
182 Py_XINCREF(kwappl);
183 } else {
184 kwappl = PyDict_Copy(pto->kw);
185 if (kwappl == NULL) {
186 Py_DECREF(argappl);
187 return NULL;
188 }
189 if (kw != NULL) {
190 if (PyDict_Merge(kwappl, kw, 1) != 0) {
191 Py_DECREF(argappl);
192 Py_DECREF(kwappl);
193 return NULL;
194 }
195 }
196 }
197
198 ret = PyObject_Call(pto->fn, argappl, kwappl);
199 Py_DECREF(argappl);
200 Py_XDECREF(kwappl);
201 return ret;
202 }
203
204 static int
partial_traverse(partialobject * pto,visitproc visit,void * arg)205 partial_traverse(partialobject *pto, visitproc visit, void *arg)
206 {
207 Py_VISIT(pto->fn);
208 Py_VISIT(pto->args);
209 Py_VISIT(pto->kw);
210 Py_VISIT(pto->dict);
211 return 0;
212 }
213
214 PyDoc_STRVAR(partial_doc,
215 "partial(func, *args, **keywords) - new function with partial application\n\
216 of the given arguments and keywords.\n");
217
218 #define OFF(x) offsetof(partialobject, x)
219 static PyMemberDef partial_memberlist[] = {
220 {"func", T_OBJECT, OFF(fn), READONLY,
221 "function object to use in future partial calls"},
222 {"args", T_OBJECT, OFF(args), READONLY,
223 "tuple of arguments to future partial calls"},
224 {"keywords", T_OBJECT, OFF(kw), READONLY,
225 "dictionary of keyword arguments to future partial calls"},
226 {NULL} /* Sentinel */
227 };
228
229 static PyObject *
partial_get_dict(partialobject * pto)230 partial_get_dict(partialobject *pto)
231 {
232 if (pto->dict == NULL) {
233 pto->dict = PyDict_New();
234 if (pto->dict == NULL)
235 return NULL;
236 }
237 Py_INCREF(pto->dict);
238 return pto->dict;
239 }
240
241 static int
partial_set_dict(partialobject * pto,PyObject * value)242 partial_set_dict(partialobject *pto, PyObject *value)
243 {
244 PyObject *tmp;
245
246 /* It is illegal to del p.__dict__ */
247 if (value == NULL) {
248 PyErr_SetString(PyExc_TypeError,
249 "a partial object's dictionary may not be deleted");
250 return -1;
251 }
252 /* Can only set __dict__ to a dictionary */
253 if (!PyDict_Check(value)) {
254 PyErr_SetString(PyExc_TypeError,
255 "setting partial object's dictionary to a non-dict");
256 return -1;
257 }
258 tmp = pto->dict;
259 Py_INCREF(value);
260 pto->dict = value;
261 Py_XDECREF(tmp);
262 return 0;
263 }
264
265 static PyGetSetDef partial_getsetlist[] = {
266 {"__dict__", (getter)partial_get_dict, (setter)partial_set_dict},
267 {NULL} /* Sentinel */
268 };
269
270 /* Pickle strategy:
271 __reduce__ by itself doesn't support getting kwargs in the unpickle
272 operation so we define a __setstate__ that replaces all the information
273 about the partial. If we only replaced part of it someone would use
274 it as a hook to do strange things.
275 */
276
277 PyObject *
partial_reduce(partialobject * pto,PyObject * unused)278 partial_reduce(partialobject *pto, PyObject *unused)
279 {
280 return Py_BuildValue("O(O)(OOOO)", Py_TYPE(pto), pto->fn, pto->fn,
281 pto->args, pto->kw,
282 pto->dict ? pto->dict : Py_None);
283 }
284
285 PyObject *
partial_setstate(partialobject * pto,PyObject * state)286 partial_setstate(partialobject *pto, PyObject *state)
287 {
288 PyObject *fn, *fnargs, *kw, *dict;
289
290 if (!PyTuple_Check(state) ||
291 !PyArg_ParseTuple(state, "OOOO", &fn, &fnargs, &kw, &dict) ||
292 !PyCallable_Check(fn) ||
293 !PyTuple_Check(fnargs) ||
294 (kw != Py_None && !PyDict_Check(kw)))
295 {
296 PyErr_SetString(PyExc_TypeError, "invalid partial state");
297 return NULL;
298 }
299
300 if(!PyTuple_CheckExact(fnargs))
301 fnargs = PySequence_Tuple(fnargs);
302 else
303 Py_INCREF(fnargs);
304 if (fnargs == NULL)
305 return NULL;
306
307 if (kw == Py_None)
308 kw = PyDict_New();
309 else if(!PyDict_CheckExact(kw))
310 kw = PyDict_Copy(kw);
311 else
312 Py_INCREF(kw);
313 if (kw == NULL) {
314 Py_DECREF(fnargs);
315 return NULL;
316 }
317
318 Py_INCREF(fn);
319 if (dict == Py_None)
320 dict = NULL;
321 else
322 Py_INCREF(dict);
323
324 Py_SETREF(pto->fn, fn);
325 Py_SETREF(pto->args, fnargs);
326 Py_SETREF(pto->kw, kw);
327 Py_XSETREF(pto->dict, dict);
328 Py_RETURN_NONE;
329 }
330
331 static PyMethodDef partial_methods[] = {
332 {"__reduce__", (PyCFunction)partial_reduce, METH_NOARGS},
333 {"__setstate__", (PyCFunction)partial_setstate, METH_O},
334 {NULL, NULL} /* sentinel */
335 };
336
337 static PyTypeObject partial_type = {
338 PyVarObject_HEAD_INIT(NULL, 0)
339 "functools.partial", /* tp_name */
340 sizeof(partialobject), /* tp_basicsize */
341 0, /* tp_itemsize */
342 /* methods */
343 (destructor)partial_dealloc, /* tp_dealloc */
344 0, /* tp_print */
345 0, /* tp_getattr */
346 0, /* tp_setattr */
347 0, /* tp_compare */
348 0, /* tp_repr */
349 0, /* tp_as_number */
350 0, /* tp_as_sequence */
351 0, /* tp_as_mapping */
352 0, /* tp_hash */
353 (ternaryfunc)partial_call, /* tp_call */
354 0, /* tp_str */
355 PyObject_GenericGetAttr, /* tp_getattro */
356 PyObject_GenericSetAttr, /* tp_setattro */
357 0, /* tp_as_buffer */
358 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
359 Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */
360 partial_doc, /* tp_doc */
361 (traverseproc)partial_traverse, /* tp_traverse */
362 0, /* tp_clear */
363 0, /* tp_richcompare */
364 offsetof(partialobject, weakreflist), /* tp_weaklistoffset */
365 0, /* tp_iter */
366 0, /* tp_iternext */
367 partial_methods, /* tp_methods */
368 partial_memberlist, /* tp_members */
369 partial_getsetlist, /* tp_getset */
370 0, /* tp_base */
371 0, /* tp_dict */
372 0, /* tp_descr_get */
373 0, /* tp_descr_set */
374 offsetof(partialobject, dict), /* tp_dictoffset */
375 0, /* tp_init */
376 0, /* tp_alloc */
377 partial_new, /* tp_new */
378 PyObject_GC_Del, /* tp_free */
379 };
380
381
382 /* module level code ********************************************************/
383
384 PyDoc_STRVAR(module_doc,
385 "Tools that operate on functions.");
386
387 static PyMethodDef module_methods[] = {
388 {"reduce", functools_reduce, METH_VARARGS, reduce_doc},
389 {NULL, NULL} /* sentinel */
390 };
391
392 PyMODINIT_FUNC
init_functools(void)393 init_functools(void)
394 {
395 int i;
396 PyObject *m;
397 char *name;
398 PyTypeObject *typelist[] = {
399 &partial_type,
400 NULL
401 };
402
403 m = Py_InitModule3("_functools", module_methods, module_doc);
404 if (m == NULL)
405 return;
406
407 for (i=0 ; typelist[i] != NULL ; i++) {
408 if (PyType_Ready(typelist[i]) < 0)
409 return;
410 name = strchr(typelist[i]->tp_name, '.');
411 assert (name != NULL);
412 Py_INCREF(typelist[i]);
413 PyModule_AddObject(m, name+1, (PyObject *)typelist[i]);
414 }
415 }
416