|
27
|
1 /* Built-in functions */
|
|
|
2
|
|
|
3 #include "Python.h"
|
|
|
4 #include "Python-ast.h"
|
|
|
5
|
|
|
6 #include "node.h"
|
|
|
7 #include "code.h"
|
|
|
8
|
|
|
9 #include "asdl.h"
|
|
|
10 #include "ast.h"
|
|
|
11
|
|
|
12 #include <ctype.h>
|
|
|
13
|
|
|
14 #ifdef HAVE_LANGINFO_H
|
|
|
15 #include <langinfo.h> /* CODESET */
|
|
|
16 #endif
|
|
|
17
|
|
|
18 /* The default encoding used by the platform file system APIs
|
|
|
19 Can remain NULL for all platforms that don't have such a concept
|
|
|
20
|
|
|
21 Don't forget to modify PyUnicode_DecodeFSDefault() if you touch any of the
|
|
|
22 values for Py_FileSystemDefaultEncoding!
|
|
|
23 */
|
|
|
24 #ifdef HAVE_MBCS
|
|
|
25 const char *Py_FileSystemDefaultEncoding = "mbcs";
|
|
|
26 int Py_HasFileSystemDefaultEncoding = 1;
|
|
|
27 #elif defined(__APPLE__)
|
|
|
28 const char *Py_FileSystemDefaultEncoding = "utf-8";
|
|
|
29 int Py_HasFileSystemDefaultEncoding = 1;
|
|
|
30 #else
|
|
|
31 const char *Py_FileSystemDefaultEncoding = NULL; /* set by initfsencoding() */
|
|
|
32 int Py_HasFileSystemDefaultEncoding = 0;
|
|
|
33 #endif
|
|
|
34
|
|
|
35 _Py_IDENTIFIER(fileno);
|
|
|
36 _Py_IDENTIFIER(flush);
|
|
|
37
|
|
|
38 static PyObject *
|
|
|
39 builtin___build_class__(PyObject *self, PyObject *args, PyObject *kwds)
|
|
|
40 {
|
|
|
41 PyObject *func, *name, *bases, *mkw, *meta, *winner, *prep, *ns, *cell;
|
|
|
42 PyObject *cls = NULL;
|
|
|
43 Py_ssize_t nargs;
|
|
|
44 int isclass;
|
|
|
45 _Py_IDENTIFIER(__prepare__);
|
|
|
46
|
|
|
47 assert(args != NULL);
|
|
|
48 if (!PyTuple_Check(args)) {
|
|
|
49 PyErr_SetString(PyExc_TypeError,
|
|
|
50 "__build_class__: args is not a tuple");
|
|
|
51 return NULL;
|
|
|
52 }
|
|
|
53 nargs = PyTuple_GET_SIZE(args);
|
|
|
54 if (nargs < 2) {
|
|
|
55 PyErr_SetString(PyExc_TypeError,
|
|
|
56 "__build_class__: not enough arguments");
|
|
|
57 return NULL;
|
|
|
58 }
|
|
|
59 func = PyTuple_GET_ITEM(args, 0); /* Better be callable */
|
|
|
60 name = PyTuple_GET_ITEM(args, 1);
|
|
|
61 if (!PyUnicode_Check(name)) {
|
|
|
62 PyErr_SetString(PyExc_TypeError,
|
|
|
63 "__build_class__: name is not a string");
|
|
|
64 return NULL;
|
|
|
65 }
|
|
|
66 bases = PyTuple_GetSlice(args, 2, nargs);
|
|
|
67 if (bases == NULL)
|
|
|
68 return NULL;
|
|
|
69
|
|
|
70 if (kwds == NULL) {
|
|
|
71 meta = NULL;
|
|
|
72 mkw = NULL;
|
|
|
73 }
|
|
|
74 else {
|
|
|
75 mkw = PyDict_Copy(kwds); /* Don't modify kwds passed in! */
|
|
|
76 if (mkw == NULL) {
|
|
|
77 Py_DECREF(bases);
|
|
|
78 return NULL;
|
|
|
79 }
|
|
|
80 meta = PyDict_GetItemString(mkw, "metaclass");
|
|
|
81 if (meta != NULL) {
|
|
|
82 Py_INCREF(meta);
|
|
|
83 if (PyDict_DelItemString(mkw, "metaclass") < 0) {
|
|
|
84 Py_DECREF(meta);
|
|
|
85 Py_DECREF(mkw);
|
|
|
86 Py_DECREF(bases);
|
|
|
87 return NULL;
|
|
|
88 }
|
|
|
89 /* metaclass is explicitly given, check if it's indeed a class */
|
|
|
90 isclass = PyType_Check(meta);
|
|
|
91 }
|
|
|
92 }
|
|
|
93 if (meta == NULL) {
|
|
|
94 /* if there are no bases, use type: */
|
|
|
95 if (PyTuple_GET_SIZE(bases) == 0) {
|
|
|
96 meta = (PyObject *) (&PyType_Type);
|
|
|
97 }
|
|
|
98 /* else get the type of the first base */
|
|
|
99 else {
|
|
|
100 PyObject *base0 = PyTuple_GET_ITEM(bases, 0);
|
|
|
101 meta = (PyObject *) (base0->ob_type);
|
|
|
102 }
|
|
|
103 Py_INCREF(meta);
|
|
|
104 isclass = 1; /* meta is really a class */
|
|
|
105 }
|
|
|
106
|
|
|
107 if (isclass) {
|
|
|
108 /* meta is really a class, so check for a more derived
|
|
|
109 metaclass, or possible metaclass conflicts: */
|
|
|
110 winner = (PyObject *)_PyType_CalculateMetaclass((PyTypeObject *)meta,
|
|
|
111 bases);
|
|
|
112 if (winner == NULL) {
|
|
|
113 Py_DECREF(meta);
|
|
|
114 Py_XDECREF(mkw);
|
|
|
115 Py_DECREF(bases);
|
|
|
116 return NULL;
|
|
|
117 }
|
|
|
118 if (winner != meta) {
|
|
|
119 Py_DECREF(meta);
|
|
|
120 meta = winner;
|
|
|
121 Py_INCREF(meta);
|
|
|
122 }
|
|
|
123 }
|
|
|
124 /* else: meta is not a class, so we cannot do the metaclass
|
|
|
125 calculation, so we will use the explicitly given object as it is */
|
|
|
126 prep = _PyObject_GetAttrId(meta, &PyId___prepare__);
|
|
|
127 if (prep == NULL) {
|
|
|
128 if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
|
|
|
129 PyErr_Clear();
|
|
|
130 ns = PyDict_New();
|
|
|
131 }
|
|
|
132 else {
|
|
|
133 Py_DECREF(meta);
|
|
|
134 Py_XDECREF(mkw);
|
|
|
135 Py_DECREF(bases);
|
|
|
136 return NULL;
|
|
|
137 }
|
|
|
138 }
|
|
|
139 else {
|
|
|
140 PyObject *pargs = PyTuple_Pack(2, name, bases);
|
|
|
141 if (pargs == NULL) {
|
|
|
142 Py_DECREF(prep);
|
|
|
143 Py_DECREF(meta);
|
|
|
144 Py_XDECREF(mkw);
|
|
|
145 Py_DECREF(bases);
|
|
|
146 return NULL;
|
|
|
147 }
|
|
|
148 ns = PyEval_CallObjectWithKeywords(prep, pargs, mkw);
|
|
|
149 Py_DECREF(pargs);
|
|
|
150 Py_DECREF(prep);
|
|
|
151 }
|
|
|
152 if (ns == NULL) {
|
|
|
153 Py_DECREF(meta);
|
|
|
154 Py_XDECREF(mkw);
|
|
|
155 Py_DECREF(bases);
|
|
|
156 return NULL;
|
|
|
157 }
|
|
|
158 cell = PyObject_CallFunctionObjArgs(func, ns, NULL);
|
|
|
159 if (cell != NULL) {
|
|
|
160 PyObject *margs;
|
|
|
161 margs = PyTuple_Pack(3, name, bases, ns);
|
|
|
162 if (margs != NULL) {
|
|
|
163 cls = PyEval_CallObjectWithKeywords(meta, margs, mkw);
|
|
|
164 Py_DECREF(margs);
|
|
|
165 }
|
|
|
166 if (cls != NULL && PyCell_Check(cell)) {
|
|
|
167 Py_INCREF(cls);
|
|
|
168 PyCell_SET(cell, cls);
|
|
|
169 }
|
|
|
170 Py_DECREF(cell);
|
|
|
171 }
|
|
|
172 Py_DECREF(ns);
|
|
|
173 Py_DECREF(meta);
|
|
|
174 Py_XDECREF(mkw);
|
|
|
175 Py_DECREF(bases);
|
|
|
176 return cls;
|
|
|
177 }
|
|
|
178
|
|
|
179 PyDoc_STRVAR(build_class_doc,
|
|
|
180 "__build_class__(func, name, *bases, metaclass=None, **kwds) -> class\n\
|
|
|
181 \n\
|
|
|
182 Internal helper function used by the class statement.");
|
|
|
183
|
|
|
184 static PyObject *
|
|
|
185 builtin___import__(PyObject *self, PyObject *args, PyObject *kwds)
|
|
|
186 {
|
|
|
187 static char *kwlist[] = {"name", "globals", "locals", "fromlist",
|
|
|
188 "level", 0};
|
|
|
189 PyObject *name, *globals = NULL, *locals = NULL, *fromlist = NULL;
|
|
|
190 int level = -1;
|
|
|
191
|
|
|
192 if (!PyArg_ParseTupleAndKeywords(args, kwds, "U|OOOi:__import__",
|
|
|
193 kwlist, &name, &globals, &locals, &fromlist, &level))
|
|
|
194 return NULL;
|
|
|
195 return PyImport_ImportModuleLevelObject(name, globals, locals,
|
|
|
196 fromlist, level);
|
|
|
197 }
|
|
|
198
|
|
|
199 PyDoc_STRVAR(import_doc,
|
|
|
200 "__import__(name, globals={}, locals={}, fromlist=[], level=-1) -> module\n\
|
|
|
201 \n\
|
|
|
202 Import a module. Because this function is meant for use by the Python\n\
|
|
|
203 interpreter and not for general use it is better to use\n\
|
|
|
204 importlib.import_module() to programmatically import a module.\n\
|
|
|
205 \n\
|
|
|
206 The globals argument is only used to determine the context;\n\
|
|
|
207 they are not modified. The locals argument is unused. The fromlist\n\
|
|
|
208 should be a list of names to emulate ``from name import ...'', or an\n\
|
|
|
209 empty list to emulate ``import name''.\n\
|
|
|
210 When importing a module from a package, note that __import__('A.B', ...)\n\
|
|
|
211 returns package A when fromlist is empty, but its submodule B when\n\
|
|
|
212 fromlist is not empty. Level is used to determine whether to perform \n\
|
|
|
213 absolute or relative imports. -1 is the original strategy of attempting\n\
|
|
|
214 both absolute and relative imports, 0 is absolute, a positive number\n\
|
|
|
215 is the number of parent directories to search relative to the current module.");
|
|
|
216
|
|
|
217
|
|
|
218 static PyObject *
|
|
|
219 builtin_abs(PyObject *self, PyObject *v)
|
|
|
220 {
|
|
|
221 return PyNumber_Absolute(v);
|
|
|
222 }
|
|
|
223
|
|
|
224 PyDoc_STRVAR(abs_doc,
|
|
|
225 "abs(number) -> number\n\
|
|
|
226 \n\
|
|
|
227 Return the absolute value of the argument.");
|
|
|
228
|
|
|
229 static PyObject *
|
|
|
230 builtin_all(PyObject *self, PyObject *v)
|
|
|
231 {
|
|
|
232 PyObject *it, *item;
|
|
|
233 PyObject *(*iternext)(PyObject *);
|
|
|
234 int cmp;
|
|
|
235
|
|
|
236 it = PyObject_GetIter(v);
|
|
|
237 if (it == NULL)
|
|
|
238 return NULL;
|
|
|
239 iternext = *Py_TYPE(it)->tp_iternext;
|
|
|
240
|
|
|
241 for (;;) {
|
|
|
242 item = iternext(it);
|
|
|
243 if (item == NULL)
|
|
|
244 break;
|
|
|
245 cmp = PyObject_IsTrue(item);
|
|
|
246 Py_DECREF(item);
|
|
|
247 if (cmp < 0) {
|
|
|
248 Py_DECREF(it);
|
|
|
249 return NULL;
|
|
|
250 }
|
|
|
251 if (cmp == 0) {
|
|
|
252 Py_DECREF(it);
|
|
|
253 Py_RETURN_FALSE;
|
|
|
254 }
|
|
|
255 }
|
|
|
256 Py_DECREF(it);
|
|
|
257 if (PyErr_Occurred()) {
|
|
|
258 if (PyErr_ExceptionMatches(PyExc_StopIteration))
|
|
|
259 PyErr_Clear();
|
|
|
260 else
|
|
|
261 return NULL;
|
|
|
262 }
|
|
|
263 Py_RETURN_TRUE;
|
|
|
264 }
|
|
|
265
|
|
|
266 PyDoc_STRVAR(all_doc,
|
|
|
267 "all(iterable) -> bool\n\
|
|
|
268 \n\
|
|
|
269 Return True if bool(x) is True for all values x in the iterable.");
|
|
|
270
|
|
|
271 static PyObject *
|
|
|
272 builtin_any(PyObject *self, PyObject *v)
|
|
|
273 {
|
|
|
274 PyObject *it, *item;
|
|
|
275 PyObject *(*iternext)(PyObject *);
|
|
|
276 int cmp;
|
|
|
277
|
|
|
278 it = PyObject_GetIter(v);
|
|
|
279 if (it == NULL)
|
|
|
280 return NULL;
|
|
|
281 iternext = *Py_TYPE(it)->tp_iternext;
|
|
|
282
|
|
|
283 for (;;) {
|
|
|
284 item = iternext(it);
|
|
|
285 if (item == NULL)
|
|
|
286 break;
|
|
|
287 cmp = PyObject_IsTrue(item);
|
|
|
288 Py_DECREF(item);
|
|
|
289 if (cmp < 0) {
|
|
|
290 Py_DECREF(it);
|
|
|
291 return NULL;
|
|
|
292 }
|
|
|
293 if (cmp == 1) {
|
|
|
294 Py_DECREF(it);
|
|
|
295 Py_RETURN_TRUE;
|
|
|
296 }
|
|
|
297 }
|
|
|
298 Py_DECREF(it);
|
|
|
299 if (PyErr_Occurred()) {
|
|
|
300 if (PyErr_ExceptionMatches(PyExc_StopIteration))
|
|
|
301 PyErr_Clear();
|
|
|
302 else
|
|
|
303 return NULL;
|
|
|
304 }
|
|
|
305 Py_RETURN_FALSE;
|
|
|
306 }
|
|
|
307
|
|
|
308 PyDoc_STRVAR(any_doc,
|
|
|
309 "any(iterable) -> bool\n\
|
|
|
310 \n\
|
|
|
311 Return True if bool(x) is True for any x in the iterable.");
|
|
|
312
|
|
|
313 static PyObject *
|
|
|
314 builtin_ascii(PyObject *self, PyObject *v)
|
|
|
315 {
|
|
|
316 return PyObject_ASCII(v);
|
|
|
317 }
|
|
|
318
|
|
|
319 PyDoc_STRVAR(ascii_doc,
|
|
|
320 "ascii(object) -> string\n\
|
|
|
321 \n\
|
|
|
322 As repr(), return a string containing a printable representation of an\n\
|
|
|
323 object, but escape the non-ASCII characters in the string returned by\n\
|
|
|
324 repr() using \\x, \\u or \\U escapes. This generates a string similar\n\
|
|
|
325 to that returned by repr() in Python 2.");
|
|
|
326
|
|
|
327
|
|
|
328 static PyObject *
|
|
|
329 builtin_bin(PyObject *self, PyObject *v)
|
|
|
330 {
|
|
|
331 return PyNumber_ToBase(v, 2);
|
|
|
332 }
|
|
|
333
|
|
|
334 PyDoc_STRVAR(bin_doc,
|
|
|
335 "bin(number) -> string\n\
|
|
|
336 \n\
|
|
|
337 Return the binary representation of an integer.");
|
|
|
338
|
|
|
339
|
|
|
340 static PyObject *
|
|
|
341 builtin_callable(PyObject *self, PyObject *v)
|
|
|
342 {
|
|
|
343 return PyBool_FromLong((long)PyCallable_Check(v));
|
|
|
344 }
|
|
|
345
|
|
|
346 PyDoc_STRVAR(callable_doc,
|
|
|
347 "callable(object) -> bool\n\
|
|
|
348 \n\
|
|
|
349 Return whether the object is callable (i.e., some kind of function).\n\
|
|
|
350 Note that classes are callable, as are instances of classes with a\n\
|
|
|
351 __call__() method.");
|
|
|
352
|
|
|
353
|
|
|
354 typedef struct {
|
|
|
355 PyObject_HEAD
|
|
|
356 PyObject *func;
|
|
|
357 PyObject *it;
|
|
|
358 } filterobject;
|
|
|
359
|
|
|
360 static PyObject *
|
|
|
361 filter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|
|
362 {
|
|
|
363 PyObject *func, *seq;
|
|
|
364 PyObject *it;
|
|
|
365 filterobject *lz;
|
|
|
366
|
|
|
367 if (type == &PyFilter_Type && !_PyArg_NoKeywords("filter()", kwds))
|
|
|
368 return NULL;
|
|
|
369
|
|
|
370 if (!PyArg_UnpackTuple(args, "filter", 2, 2, &func, &seq))
|
|
|
371 return NULL;
|
|
|
372
|
|
|
373 /* Get iterator. */
|
|
|
374 it = PyObject_GetIter(seq);
|
|
|
375 if (it == NULL)
|
|
|
376 return NULL;
|
|
|
377
|
|
|
378 /* create filterobject structure */
|
|
|
379 lz = (filterobject *)type->tp_alloc(type, 0);
|
|
|
380 if (lz == NULL) {
|
|
|
381 Py_DECREF(it);
|
|
|
382 return NULL;
|
|
|
383 }
|
|
|
384 Py_INCREF(func);
|
|
|
385 lz->func = func;
|
|
|
386 lz->it = it;
|
|
|
387
|
|
|
388 return (PyObject *)lz;
|
|
|
389 }
|
|
|
390
|
|
|
391 static void
|
|
|
392 filter_dealloc(filterobject *lz)
|
|
|
393 {
|
|
|
394 PyObject_GC_UnTrack(lz);
|
|
|
395 Py_XDECREF(lz->func);
|
|
|
396 Py_XDECREF(lz->it);
|
|
|
397 Py_TYPE(lz)->tp_free(lz);
|
|
|
398 }
|
|
|
399
|
|
|
400 static int
|
|
|
401 filter_traverse(filterobject *lz, visitproc visit, void *arg)
|
|
|
402 {
|
|
|
403 Py_VISIT(lz->it);
|
|
|
404 Py_VISIT(lz->func);
|
|
|
405 return 0;
|
|
|
406 }
|
|
|
407
|
|
|
408 static PyObject *
|
|
|
409 filter_next(filterobject *lz)
|
|
|
410 {
|
|
|
411 PyObject *item;
|
|
|
412 PyObject *it = lz->it;
|
|
|
413 long ok;
|
|
|
414 PyObject *(*iternext)(PyObject *);
|
|
|
415
|
|
|
416 iternext = *Py_TYPE(it)->tp_iternext;
|
|
|
417 for (;;) {
|
|
|
418 item = iternext(it);
|
|
|
419 if (item == NULL)
|
|
|
420 return NULL;
|
|
|
421
|
|
|
422 if (lz->func == Py_None || lz->func == (PyObject *)&PyBool_Type) {
|
|
|
423 ok = PyObject_IsTrue(item);
|
|
|
424 } else {
|
|
|
425 PyObject *good;
|
|
|
426 good = PyObject_CallFunctionObjArgs(lz->func,
|
|
|
427 item, NULL);
|
|
|
428 if (good == NULL) {
|
|
|
429 Py_DECREF(item);
|
|
|
430 return NULL;
|
|
|
431 }
|
|
|
432 ok = PyObject_IsTrue(good);
|
|
|
433 Py_DECREF(good);
|
|
|
434 }
|
|
|
435 if (ok)
|
|
|
436 return item;
|
|
|
437 Py_DECREF(item);
|
|
|
438 }
|
|
|
439 }
|
|
|
440
|
|
|
441 PyDoc_STRVAR(filter_doc,
|
|
|
442 "filter(function or None, iterable) --> filter object\n\
|
|
|
443 \n\
|
|
|
444 Return an iterator yielding those items of iterable for which function(item)\n\
|
|
|
445 is true. If function is None, return the items that are true.");
|
|
|
446
|
|
|
447 PyTypeObject PyFilter_Type = {
|
|
|
448 PyVarObject_HEAD_INIT(&PyType_Type, 0)
|
|
|
449 "filter", /* tp_name */
|
|
|
450 sizeof(filterobject), /* tp_basicsize */
|
|
|
451 0, /* tp_itemsize */
|
|
|
452 /* methods */
|
|
|
453 (destructor)filter_dealloc, /* tp_dealloc */
|
|
|
454 0, /* tp_print */
|
|
|
455 0, /* tp_getattr */
|
|
|
456 0, /* tp_setattr */
|
|
|
457 0, /* tp_reserved */
|
|
|
458 0, /* tp_repr */
|
|
|
459 0, /* tp_as_number */
|
|
|
460 0, /* tp_as_sequence */
|
|
|
461 0, /* tp_as_mapping */
|
|
|
462 0, /* tp_hash */
|
|
|
463 0, /* tp_call */
|
|
|
464 0, /* tp_str */
|
|
|
465 PyObject_GenericGetAttr, /* tp_getattro */
|
|
|
466 0, /* tp_setattro */
|
|
|
467 0, /* tp_as_buffer */
|
|
|
468 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
|
|
|
469 Py_TPFLAGS_BASETYPE, /* tp_flags */
|
|
|
470 filter_doc, /* tp_doc */
|
|
|
471 (traverseproc)filter_traverse, /* tp_traverse */
|
|
|
472 0, /* tp_clear */
|
|
|
473 0, /* tp_richcompare */
|
|
|
474 0, /* tp_weaklistoffset */
|
|
|
475 PyObject_SelfIter, /* tp_iter */
|
|
|
476 (iternextfunc)filter_next, /* tp_iternext */
|
|
|
477 0, /* tp_methods */
|
|
|
478 0, /* tp_members */
|
|
|
479 0, /* tp_getset */
|
|
|
480 0, /* tp_base */
|
|
|
481 0, /* tp_dict */
|
|
|
482 0, /* tp_descr_get */
|
|
|
483 0, /* tp_descr_set */
|
|
|
484 0, /* tp_dictoffset */
|
|
|
485 0, /* tp_init */
|
|
|
486 PyType_GenericAlloc, /* tp_alloc */
|
|
|
487 filter_new, /* tp_new */
|
|
|
488 PyObject_GC_Del, /* tp_free */
|
|
|
489 };
|
|
|
490
|
|
|
491
|
|
|
492 static PyObject *
|
|
|
493 builtin_format(PyObject *self, PyObject *args)
|
|
|
494 {
|
|
|
495 PyObject *value;
|
|
|
496 PyObject *format_spec = NULL;
|
|
|
497
|
|
|
498 if (!PyArg_ParseTuple(args, "O|U:format", &value, &format_spec))
|
|
|
499 return NULL;
|
|
|
500
|
|
|
501 return PyObject_Format(value, format_spec);
|
|
|
502 }
|
|
|
503
|
|
|
504 PyDoc_STRVAR(format_doc,
|
|
|
505 "format(value[, format_spec]) -> string\n\
|
|
|
506 \n\
|
|
|
507 Returns value.__format__(format_spec)\n\
|
|
|
508 format_spec defaults to \"\"");
|
|
|
509
|
|
|
510 static PyObject *
|
|
|
511 builtin_chr(PyObject *self, PyObject *args)
|
|
|
512 {
|
|
|
513 int x;
|
|
|
514
|
|
|
515 if (!PyArg_ParseTuple(args, "i:chr", &x))
|
|
|
516 return NULL;
|
|
|
517
|
|
|
518 return PyUnicode_FromOrdinal(x);
|
|
|
519 }
|
|
|
520
|
|
|
521 PyDoc_STRVAR(chr_doc,
|
|
|
522 "chr(i) -> Unicode character\n\
|
|
|
523 \n\
|
|
|
524 Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.");
|
|
|
525
|
|
|
526
|
|
|
527 static char *
|
|
|
528 source_as_string(PyObject *cmd, char *funcname, char *what, PyCompilerFlags *cf)
|
|
|
529 {
|
|
|
530 char *str;
|
|
|
531 Py_ssize_t size;
|
|
|
532
|
|
|
533 if (PyUnicode_Check(cmd)) {
|
|
|
534 cf->cf_flags |= PyCF_IGNORE_COOKIE;
|
|
|
535 str = PyUnicode_AsUTF8AndSize(cmd, &size);
|
|
|
536 if (str == NULL)
|
|
|
537 return NULL;
|
|
|
538 }
|
|
|
539 else if (!PyObject_CheckReadBuffer(cmd)) {
|
|
|
540 PyErr_Format(PyExc_TypeError,
|
|
|
541 "%s() arg 1 must be a %s object",
|
|
|
542 funcname, what);
|
|
|
543 return NULL;
|
|
|
544 }
|
|
|
545 else if (PyObject_AsReadBuffer(cmd, (const void **)&str, &size) < 0) {
|
|
|
546 return NULL;
|
|
|
547 }
|
|
|
548
|
|
|
549 if (strlen(str) != size) {
|
|
|
550 PyErr_SetString(PyExc_TypeError,
|
|
|
551 "source code string cannot contain null bytes");
|
|
|
552 return NULL;
|
|
|
553 }
|
|
|
554 return str;
|
|
|
555 }
|
|
|
556
|
|
|
557 static PyObject *
|
|
|
558 builtin_compile(PyObject *self, PyObject *args, PyObject *kwds)
|
|
|
559 {
|
|
|
560 char *str;
|
|
|
561 PyObject *filename_obj;
|
|
|
562 char *filename;
|
|
|
563 char *startstr;
|
|
|
564 int mode = -1;
|
|
|
565 int dont_inherit = 0;
|
|
|
566 int supplied_flags = 0;
|
|
|
567 int optimize = -1;
|
|
|
568 int is_ast;
|
|
|
569 PyCompilerFlags cf;
|
|
|
570 PyObject *cmd;
|
|
|
571 static char *kwlist[] = {"source", "filename", "mode", "flags",
|
|
|
572 "dont_inherit", "optimize", NULL};
|
|
|
573 int start[] = {Py_file_input, Py_eval_input, Py_single_input};
|
|
|
574 PyObject *result;
|
|
|
575
|
|
|
576 if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&s|iii:compile", kwlist,
|
|
|
577 &cmd,
|
|
|
578 PyUnicode_FSConverter, &filename_obj,
|
|
|
579 &startstr, &supplied_flags,
|
|
|
580 &dont_inherit, &optimize))
|
|
|
581 return NULL;
|
|
|
582
|
|
|
583 filename = PyBytes_AS_STRING(filename_obj);
|
|
|
584 cf.cf_flags = supplied_flags | PyCF_SOURCE_IS_UTF8;
|
|
|
585
|
|
|
586 if (supplied_flags &
|
|
|
587 ~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_DONT_IMPLY_DEDENT | PyCF_ONLY_AST))
|
|
|
588 {
|
|
|
589 PyErr_SetString(PyExc_ValueError,
|
|
|
590 "compile(): unrecognised flags");
|
|
|
591 goto error;
|
|
|
592 }
|
|
|
593 /* XXX Warn if (supplied_flags & PyCF_MASK_OBSOLETE) != 0? */
|
|
|
594
|
|
|
595 if (optimize < -1 || optimize > 2) {
|
|
|
596 PyErr_SetString(PyExc_ValueError,
|
|
|
597 "compile(): invalid optimize value");
|
|
|
598 goto error;
|
|
|
599 }
|
|
|
600
|
|
|
601 if (!dont_inherit) {
|
|
|
602 PyEval_MergeCompilerFlags(&cf);
|
|
|
603 }
|
|
|
604
|
|
|
605 if (strcmp(startstr, "exec") == 0)
|
|
|
606 mode = 0;
|
|
|
607 else if (strcmp(startstr, "eval") == 0)
|
|
|
608 mode = 1;
|
|
|
609 else if (strcmp(startstr, "single") == 0)
|
|
|
610 mode = 2;
|
|
|
611 else {
|
|
|
612 PyErr_SetString(PyExc_ValueError,
|
|
|
613 "compile() arg 3 must be 'exec', 'eval' or 'single'");
|
|
|
614 goto error;
|
|
|
615 }
|
|
|
616
|
|
|
617 is_ast = PyAST_Check(cmd);
|
|
|
618 if (is_ast == -1)
|
|
|
619 goto error;
|
|
|
620 if (is_ast) {
|
|
|
621 if (supplied_flags & PyCF_ONLY_AST) {
|
|
|
622 Py_INCREF(cmd);
|
|
|
623 result = cmd;
|
|
|
624 }
|
|
|
625 else {
|
|
|
626 PyArena *arena;
|
|
|
627 mod_ty mod;
|
|
|
628
|
|
|
629 arena = PyArena_New();
|
|
|
630 mod = PyAST_obj2mod(cmd, arena, mode);
|
|
|
631 if (mod == NULL) {
|
|
|
632 PyArena_Free(arena);
|
|
|
633 goto error;
|
|
|
634 }
|
|
|
635 if (!PyAST_Validate(mod)) {
|
|
|
636 PyArena_Free(arena);
|
|
|
637 goto error;
|
|
|
638 }
|
|
|
639 result = (PyObject*)PyAST_CompileEx(mod, filename,
|
|
|
640 &cf, optimize, arena);
|
|
|
641 PyArena_Free(arena);
|
|
|
642 }
|
|
|
643 goto finally;
|
|
|
644 }
|
|
|
645
|
|
|
646 str = source_as_string(cmd, "compile", "string, bytes, AST or code", &cf);
|
|
|
647 if (str == NULL)
|
|
|
648 goto error;
|
|
|
649
|
|
|
650 result = Py_CompileStringExFlags(str, filename, start[mode], &cf, optimize);
|
|
|
651 goto finally;
|
|
|
652
|
|
|
653 error:
|
|
|
654 result = NULL;
|
|
|
655 finally:
|
|
|
656 Py_DECREF(filename_obj);
|
|
|
657 return result;
|
|
|
658 }
|
|
|
659
|
|
|
660 PyDoc_STRVAR(compile_doc,
|
|
|
661 "compile(source, filename, mode[, flags[, dont_inherit]]) -> code object\n\
|
|
|
662 \n\
|
|
|
663 Compile the source string (a Python module, statement or expression)\n\
|
|
|
664 into a code object that can be executed by exec() or eval().\n\
|
|
|
665 The filename will be used for run-time error messages.\n\
|
|
|
666 The mode must be 'exec' to compile a module, 'single' to compile a\n\
|
|
|
667 single (interactive) statement, or 'eval' to compile an expression.\n\
|
|
|
668 The flags argument, if present, controls which future statements influence\n\
|
|
|
669 the compilation of the code.\n\
|
|
|
670 The dont_inherit argument, if non-zero, stops the compilation inheriting\n\
|
|
|
671 the effects of any future statements in effect in the code calling\n\
|
|
|
672 compile; if absent or zero these statements do influence the compilation,\n\
|
|
|
673 in addition to any features explicitly specified.");
|
|
|
674
|
|
|
675 static PyObject *
|
|
|
676 builtin_dir(PyObject *self, PyObject *args)
|
|
|
677 {
|
|
|
678 PyObject *arg = NULL;
|
|
|
679
|
|
|
680 if (!PyArg_UnpackTuple(args, "dir", 0, 1, &arg))
|
|
|
681 return NULL;
|
|
|
682 return PyObject_Dir(arg);
|
|
|
683 }
|
|
|
684
|
|
|
685 PyDoc_STRVAR(dir_doc,
|
|
|
686 "dir([object]) -> list of strings\n"
|
|
|
687 "\n"
|
|
|
688 "If called without an argument, return the names in the current scope.\n"
|
|
|
689 "Else, return an alphabetized list of names comprising (some of) the attributes\n"
|
|
|
690 "of the given object, and of attributes reachable from it.\n"
|
|
|
691 "If the object supplies a method named __dir__, it will be used; otherwise\n"
|
|
|
692 "the default dir() logic is used and returns:\n"
|
|
|
693 " for a module object: the module's attributes.\n"
|
|
|
694 " for a class object: its attributes, and recursively the attributes\n"
|
|
|
695 " of its bases.\n"
|
|
|
696 " for any other object: its attributes, its class's attributes, and\n"
|
|
|
697 " recursively the attributes of its class's base classes.");
|
|
|
698
|
|
|
699 static PyObject *
|
|
|
700 builtin_divmod(PyObject *self, PyObject *args)
|
|
|
701 {
|
|
|
702 PyObject *v, *w;
|
|
|
703
|
|
|
704 if (!PyArg_UnpackTuple(args, "divmod", 2, 2, &v, &w))
|
|
|
705 return NULL;
|
|
|
706 return PyNumber_Divmod(v, w);
|
|
|
707 }
|
|
|
708
|
|
|
709 PyDoc_STRVAR(divmod_doc,
|
|
|
710 "divmod(x, y) -> (div, mod)\n\
|
|
|
711 \n\
|
|
|
712 Return the tuple ((x-x%y)/y, x%y). Invariant: div*y + mod == x.");
|
|
|
713
|
|
|
714
|
|
|
715 static PyObject *
|
|
|
716 builtin_eval(PyObject *self, PyObject *args)
|
|
|
717 {
|
|
|
718 PyObject *cmd, *result, *tmp = NULL;
|
|
|
719 PyObject *globals = Py_None, *locals = Py_None;
|
|
|
720 char *str;
|
|
|
721 PyCompilerFlags cf;
|
|
|
722
|
|
|
723 if (!PyArg_UnpackTuple(args, "eval", 1, 3, &cmd, &globals, &locals))
|
|
|
724 return NULL;
|
|
|
725 if (locals != Py_None && !PyMapping_Check(locals)) {
|
|
|
726 PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
|
|
|
727 return NULL;
|
|
|
728 }
|
|
|
729 if (globals != Py_None && !PyDict_Check(globals)) {
|
|
|
730 PyErr_SetString(PyExc_TypeError, PyMapping_Check(globals) ?
|
|
|
731 "globals must be a real dict; try eval(expr, {}, mapping)"
|
|
|
732 : "globals must be a dict");
|
|
|
733 return NULL;
|
|
|
734 }
|
|
|
735 if (globals == Py_None) {
|
|
|
736 globals = PyEval_GetGlobals();
|
|
|
737 if (locals == Py_None)
|
|
|
738 locals = PyEval_GetLocals();
|
|
|
739 }
|
|
|
740 else if (locals == Py_None)
|
|
|
741 locals = globals;
|
|
|
742
|
|
|
743 if (globals == NULL || locals == NULL) {
|
|
|
744 PyErr_SetString(PyExc_TypeError,
|
|
|
745 "eval must be given globals and locals "
|
|
|
746 "when called without a frame");
|
|
|
747 return NULL;
|
|
|
748 }
|
|
|
749
|
|
|
750 if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
|
|
|
751 if (PyDict_SetItemString(globals, "__builtins__",
|
|
|
752 PyEval_GetBuiltins()) != 0)
|
|
|
753 return NULL;
|
|
|
754 }
|
|
|
755
|
|
|
756 if (PyCode_Check(cmd)) {
|
|
|
757 if (PyCode_GetNumFree((PyCodeObject *)cmd) > 0) {
|
|
|
758 PyErr_SetString(PyExc_TypeError,
|
|
|
759 "code object passed to eval() may not contain free variables");
|
|
|
760 return NULL;
|
|
|
761 }
|
|
|
762 return PyEval_EvalCode(cmd, globals, locals);
|
|
|
763 }
|
|
|
764
|
|
|
765 cf.cf_flags = PyCF_SOURCE_IS_UTF8;
|
|
|
766 str = source_as_string(cmd, "eval", "string, bytes or code", &cf);
|
|
|
767 if (str == NULL)
|
|
|
768 return NULL;
|
|
|
769
|
|
|
770 while (*str == ' ' || *str == '\t')
|
|
|
771 str++;
|
|
|
772
|
|
|
773 (void)PyEval_MergeCompilerFlags(&cf);
|
|
|
774 result = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);
|
|
|
775 Py_XDECREF(tmp);
|
|
|
776 return result;
|
|
|
777 }
|
|
|
778
|
|
|
779 PyDoc_STRVAR(eval_doc,
|
|
|
780 "eval(source[, globals[, locals]]) -> value\n\
|
|
|
781 \n\
|
|
|
782 Evaluate the source in the context of globals and locals.\n\
|
|
|
783 The source may be a string representing a Python expression\n\
|
|
|
784 or a code object as returned by compile().\n\
|
|
|
785 The globals must be a dictionary and locals can be any mapping,\n\
|
|
|
786 defaulting to the current globals and locals.\n\
|
|
|
787 If only globals is given, locals defaults to it.\n");
|
|
|
788
|
|
|
789 static PyObject *
|
|
|
790 builtin_exec(PyObject *self, PyObject *args)
|
|
|
791 {
|
|
|
792 PyObject *v;
|
|
|
793 PyObject *prog, *globals = Py_None, *locals = Py_None;
|
|
|
794
|
|
|
795 if (!PyArg_UnpackTuple(args, "exec", 1, 3, &prog, &globals, &locals))
|
|
|
796 return NULL;
|
|
|
797
|
|
|
798 if (globals == Py_None) {
|
|
|
799 globals = PyEval_GetGlobals();
|
|
|
800 if (locals == Py_None) {
|
|
|
801 locals = PyEval_GetLocals();
|
|
|
802 }
|
|
|
803 if (!globals || !locals) {
|
|
|
804 PyErr_SetString(PyExc_SystemError,
|
|
|
805 "globals and locals cannot be NULL");
|
|
|
806 return NULL;
|
|
|
807 }
|
|
|
808 }
|
|
|
809 else if (locals == Py_None)
|
|
|
810 locals = globals;
|
|
|
811
|
|
|
812 if (!PyDict_Check(globals)) {
|
|
|
813 PyErr_Format(PyExc_TypeError, "exec() arg 2 must be a dict, not %.100s",
|
|
|
814 globals->ob_type->tp_name);
|
|
|
815 return NULL;
|
|
|
816 }
|
|
|
817 if (!PyMapping_Check(locals)) {
|
|
|
818 PyErr_Format(PyExc_TypeError,
|
|
|
819 "arg 3 must be a mapping or None, not %.100s",
|
|
|
820 locals->ob_type->tp_name);
|
|
|
821 return NULL;
|
|
|
822 }
|
|
|
823 if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
|
|
|
824 if (PyDict_SetItemString(globals, "__builtins__",
|
|
|
825 PyEval_GetBuiltins()) != 0)
|
|
|
826 return NULL;
|
|
|
827 }
|
|
|
828
|
|
|
829 if (PyCode_Check(prog)) {
|
|
|
830 if (PyCode_GetNumFree((PyCodeObject *)prog) > 0) {
|
|
|
831 PyErr_SetString(PyExc_TypeError,
|
|
|
832 "code object passed to exec() may not "
|
|
|
833 "contain free variables");
|
|
|
834 return NULL;
|
|
|
835 }
|
|
|
836 v = PyEval_EvalCode(prog, globals, locals);
|
|
|
837 }
|
|
|
838 else {
|
|
|
839 char *str;
|
|
|
840 PyCompilerFlags cf;
|
|
|
841 cf.cf_flags = PyCF_SOURCE_IS_UTF8;
|
|
|
842 str = source_as_string(prog, "exec",
|
|
|
843 "string, bytes or code", &cf);
|
|
|
844 if (str == NULL)
|
|
|
845 return NULL;
|
|
|
846 if (PyEval_MergeCompilerFlags(&cf))
|
|
|
847 v = PyRun_StringFlags(str, Py_file_input, globals,
|
|
|
848 locals, &cf);
|
|
|
849 else
|
|
|
850 v = PyRun_String(str, Py_file_input, globals, locals);
|
|
|
851 }
|
|
|
852 if (v == NULL)
|
|
|
853 return NULL;
|
|
|
854 Py_DECREF(v);
|
|
|
855 Py_RETURN_NONE;
|
|
|
856 }
|
|
|
857
|
|
|
858 PyDoc_STRVAR(exec_doc,
|
|
|
859 "exec(object[, globals[, locals]])\n\
|
|
|
860 \n\
|
|
|
861 Read and execute code from an object, which can be a string or a code\n\
|
|
|
862 object.\n\
|
|
|
863 The globals and locals are dictionaries, defaulting to the current\n\
|
|
|
864 globals and locals. If only globals is given, locals defaults to it.");
|
|
|
865
|
|
|
866
|
|
|
867 static PyObject *
|
|
|
868 builtin_getattr(PyObject *self, PyObject *args)
|
|
|
869 {
|
|
|
870 PyObject *v, *result, *dflt = NULL;
|
|
|
871 PyObject *name;
|
|
|
872
|
|
|
873 if (!PyArg_UnpackTuple(args, "getattr", 2, 3, &v, &name, &dflt))
|
|
|
874 return NULL;
|
|
|
875
|
|
|
876 if (!PyUnicode_Check(name)) {
|
|
|
877 PyErr_SetString(PyExc_TypeError,
|
|
|
878 "getattr(): attribute name must be string");
|
|
|
879 return NULL;
|
|
|
880 }
|
|
|
881 result = PyObject_GetAttr(v, name);
|
|
|
882 if (result == NULL && dflt != NULL &&
|
|
|
883 PyErr_ExceptionMatches(PyExc_AttributeError))
|
|
|
884 {
|
|
|
885 PyErr_Clear();
|
|
|
886 Py_INCREF(dflt);
|
|
|
887 result = dflt;
|
|
|
888 }
|
|
|
889 return result;
|
|
|
890 }
|
|
|
891
|
|
|
892 PyDoc_STRVAR(getattr_doc,
|
|
|
893 "getattr(object, name[, default]) -> value\n\
|
|
|
894 \n\
|
|
|
895 Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.\n\
|
|
|
896 When a default argument is given, it is returned when the attribute doesn't\n\
|
|
|
897 exist; without it, an exception is raised in that case.");
|
|
|
898
|
|
|
899
|
|
|
900 static PyObject *
|
|
|
901 builtin_globals(PyObject *self)
|
|
|
902 {
|
|
|
903 PyObject *d;
|
|
|
904
|
|
|
905 d = PyEval_GetGlobals();
|
|
|
906 Py_XINCREF(d);
|
|
|
907 return d;
|
|
|
908 }
|
|
|
909
|
|
|
910 PyDoc_STRVAR(globals_doc,
|
|
|
911 "globals() -> dictionary\n\
|
|
|
912 \n\
|
|
|
913 Return the dictionary containing the current scope's global variables.");
|
|
|
914
|
|
|
915
|
|
|
916 static PyObject *
|
|
|
917 builtin_hasattr(PyObject *self, PyObject *args)
|
|
|
918 {
|
|
|
919 PyObject *v;
|
|
|
920 PyObject *name;
|
|
|
921
|
|
|
922 if (!PyArg_UnpackTuple(args, "hasattr", 2, 2, &v, &name))
|
|
|
923 return NULL;
|
|
|
924 if (!PyUnicode_Check(name)) {
|
|
|
925 PyErr_SetString(PyExc_TypeError,
|
|
|
926 "hasattr(): attribute name must be string");
|
|
|
927 return NULL;
|
|
|
928 }
|
|
|
929 v = PyObject_GetAttr(v, name);
|
|
|
930 if (v == NULL) {
|
|
|
931 if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
|
|
|
932 PyErr_Clear();
|
|
|
933 Py_RETURN_FALSE;
|
|
|
934 }
|
|
|
935 return NULL;
|
|
|
936 }
|
|
|
937 Py_DECREF(v);
|
|
|
938 Py_RETURN_TRUE;
|
|
|
939 }
|
|
|
940
|
|
|
941 PyDoc_STRVAR(hasattr_doc,
|
|
|
942 "hasattr(object, name) -> bool\n\
|
|
|
943 \n\
|
|
|
944 Return whether the object has an attribute with the given name.\n\
|
|
|
945 (This is done by calling getattr(object, name) and catching AttributeError.)");
|
|
|
946
|
|
|
947
|
|
|
948 static PyObject *
|
|
|
949 builtin_id(PyObject *self, PyObject *v)
|
|
|
950 {
|
|
|
951 return PyLong_FromVoidPtr(v);
|
|
|
952 }
|
|
|
953
|
|
|
954 PyDoc_STRVAR(id_doc,
|
|
|
955 "id(object) -> integer\n\
|
|
|
956 \n\
|
|
|
957 Return the identity of an object. This is guaranteed to be unique among\n\
|
|
|
958 simultaneously existing objects. (Hint: it's the object's memory address.)");
|
|
|
959
|
|
|
960
|
|
|
961 /* map object ************************************************************/
|
|
|
962
|
|
|
963 typedef struct {
|
|
|
964 PyObject_HEAD
|
|
|
965 PyObject *iters;
|
|
|
966 PyObject *func;
|
|
|
967 } mapobject;
|
|
|
968
|
|
|
969 static PyObject *
|
|
|
970 map_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|
|
971 {
|
|
|
972 PyObject *it, *iters, *func;
|
|
|
973 mapobject *lz;
|
|
|
974 Py_ssize_t numargs, i;
|
|
|
975
|
|
|
976 if (type == &PyMap_Type && !_PyArg_NoKeywords("map()", kwds))
|
|
|
977 return NULL;
|
|
|
978
|
|
|
979 numargs = PyTuple_Size(args);
|
|
|
980 if (numargs < 2) {
|
|
|
981 PyErr_SetString(PyExc_TypeError,
|
|
|
982 "map() must have at least two arguments.");
|
|
|
983 return NULL;
|
|
|
984 }
|
|
|
985
|
|
|
986 iters = PyTuple_New(numargs-1);
|
|
|
987 if (iters == NULL)
|
|
|
988 return NULL;
|
|
|
989
|
|
|
990 for (i=1 ; i<numargs ; i++) {
|
|
|
991 /* Get iterator. */
|
|
|
992 it = PyObject_GetIter(PyTuple_GET_ITEM(args, i));
|
|
|
993 if (it == NULL) {
|
|
|
994 Py_DECREF(iters);
|
|
|
995 return NULL;
|
|
|
996 }
|
|
|
997 PyTuple_SET_ITEM(iters, i-1, it);
|
|
|
998 }
|
|
|
999
|
|
|
1000 /* create mapobject structure */
|
|
|
1001 lz = (mapobject *)type->tp_alloc(type, 0);
|
|
|
1002 if (lz == NULL) {
|
|
|
1003 Py_DECREF(iters);
|
|
|
1004 return NULL;
|
|
|
1005 }
|
|
|
1006 lz->iters = iters;
|
|
|
1007 func = PyTuple_GET_ITEM(args, 0);
|
|
|
1008 Py_INCREF(func);
|
|
|
1009 lz->func = func;
|
|
|
1010
|
|
|
1011 return (PyObject *)lz;
|
|
|
1012 }
|
|
|
1013
|
|
|
1014 static void
|
|
|
1015 map_dealloc(mapobject *lz)
|
|
|
1016 {
|
|
|
1017 PyObject_GC_UnTrack(lz);
|
|
|
1018 Py_XDECREF(lz->iters);
|
|
|
1019 Py_XDECREF(lz->func);
|
|
|
1020 Py_TYPE(lz)->tp_free(lz);
|
|
|
1021 }
|
|
|
1022
|
|
|
1023 static int
|
|
|
1024 map_traverse(mapobject *lz, visitproc visit, void *arg)
|
|
|
1025 {
|
|
|
1026 Py_VISIT(lz->iters);
|
|
|
1027 Py_VISIT(lz->func);
|
|
|
1028 return 0;
|
|
|
1029 }
|
|
|
1030
|
|
|
1031 static PyObject *
|
|
|
1032 map_next(mapobject *lz)
|
|
|
1033 {
|
|
|
1034 PyObject *val;
|
|
|
1035 PyObject *argtuple;
|
|
|
1036 PyObject *result;
|
|
|
1037 Py_ssize_t numargs, i;
|
|
|
1038
|
|
|
1039 numargs = PyTuple_Size(lz->iters);
|
|
|
1040 argtuple = PyTuple_New(numargs);
|
|
|
1041 if (argtuple == NULL)
|
|
|
1042 return NULL;
|
|
|
1043
|
|
|
1044 for (i=0 ; i<numargs ; i++) {
|
|
|
1045 val = PyIter_Next(PyTuple_GET_ITEM(lz->iters, i));
|
|
|
1046 if (val == NULL) {
|
|
|
1047 Py_DECREF(argtuple);
|
|
|
1048 return NULL;
|
|
|
1049 }
|
|
|
1050 PyTuple_SET_ITEM(argtuple, i, val);
|
|
|
1051 }
|
|
|
1052 result = PyObject_Call(lz->func, argtuple, NULL);
|
|
|
1053 Py_DECREF(argtuple);
|
|
|
1054 return result;
|
|
|
1055 }
|
|
|
1056
|
|
|
1057 PyDoc_STRVAR(map_doc,
|
|
|
1058 "map(func, *iterables) --> map object\n\
|
|
|
1059 \n\
|
|
|
1060 Make an iterator that computes the function using arguments from\n\
|
|
|
1061 each of the iterables. Stops when the shortest iterable is exhausted.");
|
|
|
1062
|
|
|
1063 PyTypeObject PyMap_Type = {
|
|
|
1064 PyVarObject_HEAD_INIT(&PyType_Type, 0)
|
|
|
1065 "map", /* tp_name */
|
|
|
1066 sizeof(mapobject), /* tp_basicsize */
|
|
|
1067 0, /* tp_itemsize */
|
|
|
1068 /* methods */
|
|
|
1069 (destructor)map_dealloc, /* tp_dealloc */
|
|
|
1070 0, /* tp_print */
|
|
|
1071 0, /* tp_getattr */
|
|
|
1072 0, /* tp_setattr */
|
|
|
1073 0, /* tp_reserved */
|
|
|
1074 0, /* tp_repr */
|
|
|
1075 0, /* tp_as_number */
|
|
|
1076 0, /* tp_as_sequence */
|
|
|
1077 0, /* tp_as_mapping */
|
|
|
1078 0, /* tp_hash */
|
|
|
1079 0, /* tp_call */
|
|
|
1080 0, /* tp_str */
|
|
|
1081 PyObject_GenericGetAttr, /* tp_getattro */
|
|
|
1082 0, /* tp_setattro */
|
|
|
1083 0, /* tp_as_buffer */
|
|
|
1084 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
|
|
|
1085 Py_TPFLAGS_BASETYPE, /* tp_flags */
|
|
|
1086 map_doc, /* tp_doc */
|
|
|
1087 (traverseproc)map_traverse, /* tp_traverse */
|
|
|
1088 0, /* tp_clear */
|
|
|
1089 0, /* tp_richcompare */
|
|
|
1090 0, /* tp_weaklistoffset */
|
|
|
1091 PyObject_SelfIter, /* tp_iter */
|
|
|
1092 (iternextfunc)map_next, /* tp_iternext */
|
|
|
1093 0, /* tp_methods */
|
|
|
1094 0, /* tp_members */
|
|
|
1095 0, /* tp_getset */
|
|
|
1096 0, /* tp_base */
|
|
|
1097 0, /* tp_dict */
|
|
|
1098 0, /* tp_descr_get */
|
|
|
1099 0, /* tp_descr_set */
|
|
|
1100 0, /* tp_dictoffset */
|
|
|
1101 0, /* tp_init */
|
|
|
1102 PyType_GenericAlloc, /* tp_alloc */
|
|
|
1103 map_new, /* tp_new */
|
|
|
1104 PyObject_GC_Del, /* tp_free */
|
|
|
1105 };
|
|
|
1106
|
|
|
1107 static PyObject *
|
|
|
1108 builtin_next(PyObject *self, PyObject *args)
|
|
|
1109 {
|
|
|
1110 PyObject *it, *res;
|
|
|
1111 PyObject *def = NULL;
|
|
|
1112
|
|
|
1113 if (!PyArg_UnpackTuple(args, "next", 1, 2, &it, &def))
|
|
|
1114 return NULL;
|
|
|
1115 if (!PyIter_Check(it)) {
|
|
|
1116 PyErr_Format(PyExc_TypeError,
|
|
|
1117 "'%.200s' object is not an iterator",
|
|
|
1118 it->ob_type->tp_name);
|
|
|
1119 return NULL;
|
|
|
1120 }
|
|
|
1121
|
|
|
1122 res = (*it->ob_type->tp_iternext)(it);
|
|
|
1123 if (res != NULL) {
|
|
|
1124 return res;
|
|
|
1125 } else if (def != NULL) {
|
|
|
1126 if (PyErr_Occurred()) {
|
|
|
1127 if(!PyErr_ExceptionMatches(PyExc_StopIteration))
|
|
|
1128 return NULL;
|
|
|
1129 PyErr_Clear();
|
|
|
1130 }
|
|
|
1131 Py_INCREF(def);
|
|
|
1132 return def;
|
|
|
1133 } else if (PyErr_Occurred()) {
|
|
|
1134 return NULL;
|
|
|
1135 } else {
|
|
|
1136 PyErr_SetNone(PyExc_StopIteration);
|
|
|
1137 return NULL;
|
|
|
1138 }
|
|
|
1139 }
|
|
|
1140
|
|
|
1141 PyDoc_STRVAR(next_doc,
|
|
|
1142 "next(iterator[, default])\n\
|
|
|
1143 \n\
|
|
|
1144 Return the next item from the iterator. If default is given and the iterator\n\
|
|
|
1145 is exhausted, it is returned instead of raising StopIteration.");
|
|
|
1146
|
|
|
1147
|
|
|
1148 static PyObject *
|
|
|
1149 builtin_setattr(PyObject *self, PyObject *args)
|
|
|
1150 {
|
|
|
1151 PyObject *v;
|
|
|
1152 PyObject *name;
|
|
|
1153 PyObject *value;
|
|
|
1154
|
|
|
1155 if (!PyArg_UnpackTuple(args, "setattr", 3, 3, &v, &name, &value))
|
|
|
1156 return NULL;
|
|
|
1157 if (PyObject_SetAttr(v, name, value) != 0)
|
|
|
1158 return NULL;
|
|
|
1159 Py_INCREF(Py_None);
|
|
|
1160 return Py_None;
|
|
|
1161 }
|
|
|
1162
|
|
|
1163 PyDoc_STRVAR(setattr_doc,
|
|
|
1164 "setattr(object, name, value)\n\
|
|
|
1165 \n\
|
|
|
1166 Set a named attribute on an object; setattr(x, 'y', v) is equivalent to\n\
|
|
|
1167 ``x.y = v''.");
|
|
|
1168
|
|
|
1169
|
|
|
1170 static PyObject *
|
|
|
1171 builtin_delattr(PyObject *self, PyObject *args)
|
|
|
1172 {
|
|
|
1173 PyObject *v;
|
|
|
1174 PyObject *name;
|
|
|
1175
|
|
|
1176 if (!PyArg_UnpackTuple(args, "delattr", 2, 2, &v, &name))
|
|
|
1177 return NULL;
|
|
|
1178 if (PyObject_SetAttr(v, name, (PyObject *)NULL) != 0)
|
|
|
1179 return NULL;
|
|
|
1180 Py_INCREF(Py_None);
|
|
|
1181 return Py_None;
|
|
|
1182 }
|
|
|
1183
|
|
|
1184 PyDoc_STRVAR(delattr_doc,
|
|
|
1185 "delattr(object, name)\n\
|
|
|
1186 \n\
|
|
|
1187 Delete a named attribute on an object; delattr(x, 'y') is equivalent to\n\
|
|
|
1188 ``del x.y''.");
|
|
|
1189
|
|
|
1190
|
|
|
1191 static PyObject *
|
|
|
1192 builtin_hash(PyObject *self, PyObject *v)
|
|
|
1193 {
|
|
|
1194 Py_hash_t x;
|
|
|
1195
|
|
|
1196 x = PyObject_Hash(v);
|
|
|
1197 if (x == -1)
|
|
|
1198 return NULL;
|
|
|
1199 return PyLong_FromSsize_t(x);
|
|
|
1200 }
|
|
|
1201
|
|
|
1202 PyDoc_STRVAR(hash_doc,
|
|
|
1203 "hash(object) -> integer\n\
|
|
|
1204 \n\
|
|
|
1205 Return a hash value for the object. Two objects with the same value have\n\
|
|
|
1206 the same hash value. The reverse is not necessarily true, but likely.");
|
|
|
1207
|
|
|
1208
|
|
|
1209 static PyObject *
|
|
|
1210 builtin_hex(PyObject *self, PyObject *v)
|
|
|
1211 {
|
|
|
1212 return PyNumber_ToBase(v, 16);
|
|
|
1213 }
|
|
|
1214
|
|
|
1215 PyDoc_STRVAR(hex_doc,
|
|
|
1216 "hex(number) -> string\n\
|
|
|
1217 \n\
|
|
|
1218 Return the hexadecimal representation of an integer.");
|
|
|
1219
|
|
|
1220
|
|
|
1221 static PyObject *
|
|
|
1222 builtin_iter(PyObject *self, PyObject *args)
|
|
|
1223 {
|
|
|
1224 PyObject *v, *w = NULL;
|
|
|
1225
|
|
|
1226 if (!PyArg_UnpackTuple(args, "iter", 1, 2, &v, &w))
|
|
|
1227 return NULL;
|
|
|
1228 if (w == NULL)
|
|
|
1229 return PyObject_GetIter(v);
|
|
|
1230 if (!PyCallable_Check(v)) {
|
|
|
1231 PyErr_SetString(PyExc_TypeError,
|
|
|
1232 "iter(v, w): v must be callable");
|
|
|
1233 return NULL;
|
|
|
1234 }
|
|
|
1235 return PyCallIter_New(v, w);
|
|
|
1236 }
|
|
|
1237
|
|
|
1238 PyDoc_STRVAR(iter_doc,
|
|
|
1239 "iter(iterable) -> iterator\n\
|
|
|
1240 iter(callable, sentinel) -> iterator\n\
|
|
|
1241 \n\
|
|
|
1242 Get an iterator from an object. In the first form, the argument must\n\
|
|
|
1243 supply its own iterator, or be a sequence.\n\
|
|
|
1244 In the second form, the callable is called until it returns the sentinel.");
|
|
|
1245
|
|
|
1246
|
|
|
1247 static PyObject *
|
|
|
1248 builtin_len(PyObject *self, PyObject *v)
|
|
|
1249 {
|
|
|
1250 Py_ssize_t res;
|
|
|
1251
|
|
|
1252 res = PyObject_Size(v);
|
|
|
1253 if (res < 0 && PyErr_Occurred())
|
|
|
1254 return NULL;
|
|
|
1255 return PyLong_FromSsize_t(res);
|
|
|
1256 }
|
|
|
1257
|
|
|
1258 PyDoc_STRVAR(len_doc,
|
|
|
1259 "len(object) -> integer\n\
|
|
|
1260 \n\
|
|
|
1261 Return the number of items of a sequence or mapping.");
|
|
|
1262
|
|
|
1263
|
|
|
1264 static PyObject *
|
|
|
1265 builtin_locals(PyObject *self)
|
|
|
1266 {
|
|
|
1267 PyObject *d;
|
|
|
1268
|
|
|
1269 d = PyEval_GetLocals();
|
|
|
1270 Py_XINCREF(d);
|
|
|
1271 return d;
|
|
|
1272 }
|
|
|
1273
|
|
|
1274 PyDoc_STRVAR(locals_doc,
|
|
|
1275 "locals() -> dictionary\n\
|
|
|
1276 \n\
|
|
|
1277 Update and return a dictionary containing the current scope's local variables.");
|
|
|
1278
|
|
|
1279
|
|
|
1280 static PyObject *
|
|
|
1281 min_max(PyObject *args, PyObject *kwds, int op)
|
|
|
1282 {
|
|
|
1283 PyObject *v, *it, *item, *val, *maxitem, *maxval, *keyfunc=NULL;
|
|
|
1284 const char *name = op == Py_LT ? "min" : "max";
|
|
|
1285
|
|
|
1286 if (PyTuple_Size(args) > 1)
|
|
|
1287 v = args;
|
|
|
1288 else if (!PyArg_UnpackTuple(args, (char *)name, 1, 1, &v))
|
|
|
1289 return NULL;
|
|
|
1290
|
|
|
1291 if (kwds != NULL && PyDict_Check(kwds) && PyDict_Size(kwds)) {
|
|
|
1292 keyfunc = PyDict_GetItemString(kwds, "key");
|
|
|
1293 if (PyDict_Size(kwds)!=1 || keyfunc == NULL) {
|
|
|
1294 PyErr_Format(PyExc_TypeError,
|
|
|
1295 "%s() got an unexpected keyword argument", name);
|
|
|
1296 return NULL;
|
|
|
1297 }
|
|
|
1298 Py_INCREF(keyfunc);
|
|
|
1299 }
|
|
|
1300
|
|
|
1301 it = PyObject_GetIter(v);
|
|
|
1302 if (it == NULL) {
|
|
|
1303 Py_XDECREF(keyfunc);
|
|
|
1304 return NULL;
|
|
|
1305 }
|
|
|
1306
|
|
|
1307 maxitem = NULL; /* the result */
|
|
|
1308 maxval = NULL; /* the value associated with the result */
|
|
|
1309 while (( item = PyIter_Next(it) )) {
|
|
|
1310 /* get the value from the key function */
|
|
|
1311 if (keyfunc != NULL) {
|
|
|
1312 val = PyObject_CallFunctionObjArgs(keyfunc, item, NULL);
|
|
|
1313 if (val == NULL)
|
|
|
1314 goto Fail_it_item;
|
|
|
1315 }
|
|
|
1316 /* no key function; the value is the item */
|
|
|
1317 else {
|
|
|
1318 val = item;
|
|
|
1319 Py_INCREF(val);
|
|
|
1320 }
|
|
|
1321
|
|
|
1322 /* maximum value and item are unset; set them */
|
|
|
1323 if (maxval == NULL) {
|
|
|
1324 maxitem = item;
|
|
|
1325 maxval = val;
|
|
|
1326 }
|
|
|
1327 /* maximum value and item are set; update them as necessary */
|
|
|
1328 else {
|
|
|
1329 int cmp = PyObject_RichCompareBool(val, maxval, op);
|
|
|
1330 if (cmp < 0)
|
|
|
1331 goto Fail_it_item_and_val;
|
|
|
1332 else if (cmp > 0) {
|
|
|
1333 Py_DECREF(maxval);
|
|
|
1334 Py_DECREF(maxitem);
|
|
|
1335 maxval = val;
|
|
|
1336 maxitem = item;
|
|
|
1337 }
|
|
|
1338 else {
|
|
|
1339 Py_DECREF(item);
|
|
|
1340 Py_DECREF(val);
|
|
|
1341 }
|
|
|
1342 }
|
|
|
1343 }
|
|
|
1344 if (PyErr_Occurred())
|
|
|
1345 goto Fail_it;
|
|
|
1346 if (maxval == NULL) {
|
|
|
1347 PyErr_Format(PyExc_ValueError,
|
|
|
1348 "%s() arg is an empty sequence", name);
|
|
|
1349 assert(maxitem == NULL);
|
|
|
1350 }
|
|
|
1351 else
|
|
|
1352 Py_DECREF(maxval);
|
|
|
1353 Py_DECREF(it);
|
|
|
1354 Py_XDECREF(keyfunc);
|
|
|
1355 return maxitem;
|
|
|
1356
|
|
|
1357 Fail_it_item_and_val:
|
|
|
1358 Py_DECREF(val);
|
|
|
1359 Fail_it_item:
|
|
|
1360 Py_DECREF(item);
|
|
|
1361 Fail_it:
|
|
|
1362 Py_XDECREF(maxval);
|
|
|
1363 Py_XDECREF(maxitem);
|
|
|
1364 Py_DECREF(it);
|
|
|
1365 Py_XDECREF(keyfunc);
|
|
|
1366 return NULL;
|
|
|
1367 }
|
|
|
1368
|
|
|
1369 static PyObject *
|
|
|
1370 builtin_min(PyObject *self, PyObject *args, PyObject *kwds)
|
|
|
1371 {
|
|
|
1372 return min_max(args, kwds, Py_LT);
|
|
|
1373 }
|
|
|
1374
|
|
|
1375 PyDoc_STRVAR(min_doc,
|
|
|
1376 "min(iterable[, key=func]) -> value\n\
|
|
|
1377 min(a, b, c, ...[, key=func]) -> value\n\
|
|
|
1378 \n\
|
|
|
1379 With a single iterable argument, return its smallest item.\n\
|
|
|
1380 With two or more arguments, return the smallest argument.");
|
|
|
1381
|
|
|
1382
|
|
|
1383 static PyObject *
|
|
|
1384 builtin_max(PyObject *self, PyObject *args, PyObject *kwds)
|
|
|
1385 {
|
|
|
1386 return min_max(args, kwds, Py_GT);
|
|
|
1387 }
|
|
|
1388
|
|
|
1389 PyDoc_STRVAR(max_doc,
|
|
|
1390 "max(iterable[, key=func]) -> value\n\
|
|
|
1391 max(a, b, c, ...[, key=func]) -> value\n\
|
|
|
1392 \n\
|
|
|
1393 With a single iterable argument, return its largest item.\n\
|
|
|
1394 With two or more arguments, return the largest argument.");
|
|
|
1395
|
|
|
1396
|
|
|
1397 static PyObject *
|
|
|
1398 builtin_oct(PyObject *self, PyObject *v)
|
|
|
1399 {
|
|
|
1400 return PyNumber_ToBase(v, 8);
|
|
|
1401 }
|
|
|
1402
|
|
|
1403 PyDoc_STRVAR(oct_doc,
|
|
|
1404 "oct(number) -> string\n\
|
|
|
1405 \n\
|
|
|
1406 Return the octal representation of an integer.");
|
|
|
1407
|
|
|
1408
|
|
|
1409 static PyObject *
|
|
|
1410 builtin_ord(PyObject *self, PyObject* obj)
|
|
|
1411 {
|
|
|
1412 long ord;
|
|
|
1413 Py_ssize_t size;
|
|
|
1414
|
|
|
1415 if (PyBytes_Check(obj)) {
|
|
|
1416 size = PyBytes_GET_SIZE(obj);
|
|
|
1417 if (size == 1) {
|
|
|
1418 ord = (long)((unsigned char)*PyBytes_AS_STRING(obj));
|
|
|
1419 return PyLong_FromLong(ord);
|
|
|
1420 }
|
|
|
1421 }
|
|
|
1422 else if (PyUnicode_Check(obj)) {
|
|
|
1423 if (PyUnicode_READY(obj) == -1)
|
|
|
1424 return NULL;
|
|
|
1425 size = PyUnicode_GET_LENGTH(obj);
|
|
|
1426 if (size == 1) {
|
|
|
1427 ord = (long)PyUnicode_READ_CHAR(obj, 0);
|
|
|
1428 return PyLong_FromLong(ord);
|
|
|
1429 }
|
|
|
1430 }
|
|
|
1431 else if (PyByteArray_Check(obj)) {
|
|
|
1432 /* XXX Hopefully this is temporary */
|
|
|
1433 size = PyByteArray_GET_SIZE(obj);
|
|
|
1434 if (size == 1) {
|
|
|
1435 ord = (long)((unsigned char)*PyByteArray_AS_STRING(obj));
|
|
|
1436 return PyLong_FromLong(ord);
|
|
|
1437 }
|
|
|
1438 }
|
|
|
1439 else {
|
|
|
1440 PyErr_Format(PyExc_TypeError,
|
|
|
1441 "ord() expected string of length 1, but " \
|
|
|
1442 "%.200s found", obj->ob_type->tp_name);
|
|
|
1443 return NULL;
|
|
|
1444 }
|
|
|
1445
|
|
|
1446 PyErr_Format(PyExc_TypeError,
|
|
|
1447 "ord() expected a character, "
|
|
|
1448 "but string of length %zd found",
|
|
|
1449 size);
|
|
|
1450 return NULL;
|
|
|
1451 }
|
|
|
1452
|
|
|
1453 PyDoc_VAR(ord_doc) = PyDoc_STR(
|
|
|
1454 "ord(c) -> integer\n\
|
|
|
1455 \n\
|
|
|
1456 Return the integer ordinal of a one-character string."
|
|
|
1457 )
|
|
|
1458 #ifndef Py_UNICODE_WIDE
|
|
|
1459 PyDoc_STR(
|
|
|
1460 "\nA valid surrogate pair is also accepted."
|
|
|
1461 )
|
|
|
1462 #endif
|
|
|
1463 ;
|
|
|
1464
|
|
|
1465
|
|
|
1466 static PyObject *
|
|
|
1467 builtin_pow(PyObject *self, PyObject *args)
|
|
|
1468 {
|
|
|
1469 PyObject *v, *w, *z = Py_None;
|
|
|
1470
|
|
|
1471 if (!PyArg_UnpackTuple(args, "pow", 2, 3, &v, &w, &z))
|
|
|
1472 return NULL;
|
|
|
1473 return PyNumber_Power(v, w, z);
|
|
|
1474 }
|
|
|
1475
|
|
|
1476 PyDoc_STRVAR(pow_doc,
|
|
|
1477 "pow(x, y[, z]) -> number\n\
|
|
|
1478 \n\
|
|
|
1479 With two arguments, equivalent to x**y. With three arguments,\n\
|
|
|
1480 equivalent to (x**y) % z, but may be more efficient (e.g. for longs).");
|
|
|
1481
|
|
|
1482
|
|
|
1483
|
|
|
1484 static PyObject *
|
|
|
1485 builtin_print(PyObject *self, PyObject *args, PyObject *kwds)
|
|
|
1486 {
|
|
|
1487 static char *kwlist[] = {"sep", "end", "file", 0};
|
|
|
1488 static PyObject *dummy_args;
|
|
|
1489 PyObject *sep = NULL, *end = NULL, *file = NULL;
|
|
|
1490 int i, err;
|
|
|
1491
|
|
|
1492 if (dummy_args == NULL) {
|
|
|
1493 if (!(dummy_args = PyTuple_New(0)))
|
|
|
1494 return NULL;
|
|
|
1495 }
|
|
|
1496 if (!PyArg_ParseTupleAndKeywords(dummy_args, kwds, "|OOO:print",
|
|
|
1497 kwlist, &sep, &end, &file))
|
|
|
1498 return NULL;
|
|
|
1499 if (file == NULL || file == Py_None) {
|
|
|
1500 file = PySys_GetObject("stdout");
|
|
|
1501 /* sys.stdout may be None when FILE* stdout isn't connected */
|
|
|
1502 if (file == Py_None)
|
|
|
1503 Py_RETURN_NONE;
|
|
|
1504 }
|
|
|
1505
|
|
|
1506 if (sep == Py_None) {
|
|
|
1507 sep = NULL;
|
|
|
1508 }
|
|
|
1509 else if (sep && !PyUnicode_Check(sep)) {
|
|
|
1510 PyErr_Format(PyExc_TypeError,
|
|
|
1511 "sep must be None or a string, not %.200s",
|
|
|
1512 sep->ob_type->tp_name);
|
|
|
1513 return NULL;
|
|
|
1514 }
|
|
|
1515 if (end == Py_None) {
|
|
|
1516 end = NULL;
|
|
|
1517 }
|
|
|
1518 else if (end && !PyUnicode_Check(end)) {
|
|
|
1519 PyErr_Format(PyExc_TypeError,
|
|
|
1520 "end must be None or a string, not %.200s",
|
|
|
1521 end->ob_type->tp_name);
|
|
|
1522 return NULL;
|
|
|
1523 }
|
|
|
1524
|
|
|
1525 for (i = 0; i < PyTuple_Size(args); i++) {
|
|
|
1526 if (i > 0) {
|
|
|
1527 if (sep == NULL)
|
|
|
1528 err = PyFile_WriteString(" ", file);
|
|
|
1529 else
|
|
|
1530 err = PyFile_WriteObject(sep, file,
|
|
|
1531 Py_PRINT_RAW);
|
|
|
1532 if (err)
|
|
|
1533 return NULL;
|
|
|
1534 }
|
|
|
1535 err = PyFile_WriteObject(PyTuple_GetItem(args, i), file,
|
|
|
1536 Py_PRINT_RAW);
|
|
|
1537 if (err)
|
|
|
1538 return NULL;
|
|
|
1539 }
|
|
|
1540
|
|
|
1541 if (end == NULL)
|
|
|
1542 err = PyFile_WriteString("\n", file);
|
|
|
1543 else
|
|
|
1544 err = PyFile_WriteObject(end, file, Py_PRINT_RAW);
|
|
|
1545 if (err)
|
|
|
1546 return NULL;
|
|
|
1547
|
|
|
1548 Py_RETURN_NONE;
|
|
|
1549 }
|
|
|
1550
|
|
|
1551 PyDoc_STRVAR(print_doc,
|
|
|
1552 "print(value, ..., sep=' ', end='\\n', file=sys.stdout)\n\
|
|
|
1553 \n\
|
|
|
1554 Prints the values to a stream, or to sys.stdout by default.\n\
|
|
|
1555 Optional keyword arguments:\n\
|
|
|
1556 file: a file-like object (stream); defaults to the current sys.stdout.\n\
|
|
|
1557 sep: string inserted between values, default a space.\n\
|
|
|
1558 end: string appended after the last value, default a newline.");
|
|
|
1559
|
|
|
1560
|
|
|
1561 static PyObject *
|
|
|
1562 builtin_input(PyObject *self, PyObject *args)
|
|
|
1563 {
|
|
|
1564 PyObject *promptarg = NULL;
|
|
|
1565 PyObject *fin = PySys_GetObject("stdin");
|
|
|
1566 PyObject *fout = PySys_GetObject("stdout");
|
|
|
1567 PyObject *ferr = PySys_GetObject("stderr");
|
|
|
1568 PyObject *tmp;
|
|
|
1569 long fd;
|
|
|
1570 int tty;
|
|
|
1571
|
|
|
1572 /* Parse arguments */
|
|
|
1573 if (!PyArg_UnpackTuple(args, "input", 0, 1, &promptarg))
|
|
|
1574 return NULL;
|
|
|
1575
|
|
|
1576 /* Check that stdin/out/err are intact */
|
|
|
1577 if (fin == NULL || fin == Py_None) {
|
|
|
1578 PyErr_SetString(PyExc_RuntimeError,
|
|
|
1579 "input(): lost sys.stdin");
|
|
|
1580 return NULL;
|
|
|
1581 }
|
|
|
1582 if (fout == NULL || fout == Py_None) {
|
|
|
1583 PyErr_SetString(PyExc_RuntimeError,
|
|
|
1584 "input(): lost sys.stdout");
|
|
|
1585 return NULL;
|
|
|
1586 }
|
|
|
1587 if (ferr == NULL || ferr == Py_None) {
|
|
|
1588 PyErr_SetString(PyExc_RuntimeError,
|
|
|
1589 "input(): lost sys.stderr");
|
|
|
1590 return NULL;
|
|
|
1591 }
|
|
|
1592
|
|
|
1593 /* First of all, flush stderr */
|
|
|
1594 tmp = _PyObject_CallMethodId(ferr, &PyId_flush, "");
|
|
|
1595 if (tmp == NULL)
|
|
|
1596 PyErr_Clear();
|
|
|
1597 else
|
|
|
1598 Py_DECREF(tmp);
|
|
|
1599
|
|
|
1600 /* We should only use (GNU) readline if Python's sys.stdin and
|
|
|
1601 sys.stdout are the same as C's stdin and stdout, because we
|
|
|
1602 need to pass it those. */
|
|
|
1603 tmp = _PyObject_CallMethodId(fin, &PyId_fileno, "");
|
|
|
1604 if (tmp == NULL) {
|
|
|
1605 PyErr_Clear();
|
|
|
1606 tty = 0;
|
|
|
1607 }
|
|
|
1608 else {
|
|
|
1609 fd = PyLong_AsLong(tmp);
|
|
|
1610 Py_DECREF(tmp);
|
|
|
1611 if (fd < 0 && PyErr_Occurred())
|
|
|
1612 return NULL;
|
|
|
1613 tty = fd == fileno(stdin) && isatty(fd);
|
|
|
1614 }
|
|
|
1615 if (tty) {
|
|
|
1616 tmp = _PyObject_CallMethodId(fout, &PyId_fileno, "");
|
|
|
1617 if (tmp == NULL)
|
|
|
1618 PyErr_Clear();
|
|
|
1619 else {
|
|
|
1620 fd = PyLong_AsLong(tmp);
|
|
|
1621 Py_DECREF(tmp);
|
|
|
1622 if (fd < 0 && PyErr_Occurred())
|
|
|
1623 return NULL;
|
|
|
1624 tty = fd == fileno(stdout) && isatty(fd);
|
|
|
1625 }
|
|
|
1626 }
|
|
|
1627
|
|
|
1628 /* If we're interactive, use (GNU) readline */
|
|
|
1629 if (tty) {
|
|
|
1630 PyObject *po = NULL;
|
|
|
1631 char *prompt;
|
|
|
1632 char *s = NULL;
|
|
|
1633 PyObject *stdin_encoding = NULL, *stdin_errors = NULL;
|
|
|
1634 PyObject *stdout_encoding = NULL, *stdout_errors = NULL;
|
|
|
1635 char *stdin_encoding_str, *stdin_errors_str;
|
|
|
1636 PyObject *result;
|
|
|
1637 size_t len;
|
|
|
1638 _Py_IDENTIFIER(encoding);
|
|
|
1639 _Py_IDENTIFIER(errors);
|
|
|
1640
|
|
|
1641 stdin_encoding = _PyObject_GetAttrId(fin, &PyId_encoding);
|
|
|
1642 stdin_errors = _PyObject_GetAttrId(fin, &PyId_errors);
|
|
|
1643 if (!stdin_encoding || !stdin_errors)
|
|
|
1644 /* stdin is a text stream, so it must have an
|
|
|
1645 encoding. */
|
|
|
1646 goto _readline_errors;
|
|
|
1647 stdin_encoding_str = _PyUnicode_AsString(stdin_encoding);
|
|
|
1648 stdin_errors_str = _PyUnicode_AsString(stdin_errors);
|
|
|
1649 if (!stdin_encoding_str || !stdin_errors_str)
|
|
|
1650 goto _readline_errors;
|
|
|
1651 tmp = _PyObject_CallMethodId(fout, &PyId_flush, "");
|
|
|
1652 if (tmp == NULL)
|
|
|
1653 PyErr_Clear();
|
|
|
1654 else
|
|
|
1655 Py_DECREF(tmp);
|
|
|
1656 if (promptarg != NULL) {
|
|
|
1657 /* We have a prompt, encode it as stdout would */
|
|
|
1658 char *stdout_encoding_str, *stdout_errors_str;
|
|
|
1659 PyObject *stringpo;
|
|
|
1660 stdout_encoding = _PyObject_GetAttrId(fout, &PyId_encoding);
|
|
|
1661 stdout_errors = _PyObject_GetAttrId(fout, &PyId_errors);
|
|
|
1662 if (!stdout_encoding || !stdout_errors)
|
|
|
1663 goto _readline_errors;
|
|
|
1664 stdout_encoding_str = _PyUnicode_AsString(stdout_encoding);
|
|
|
1665 stdout_errors_str = _PyUnicode_AsString(stdout_errors);
|
|
|
1666 if (!stdout_encoding_str || !stdout_errors_str)
|
|
|
1667 goto _readline_errors;
|
|
|
1668 stringpo = PyObject_Str(promptarg);
|
|
|
1669 if (stringpo == NULL)
|
|
|
1670 goto _readline_errors;
|
|
|
1671 po = PyUnicode_AsEncodedString(stringpo,
|
|
|
1672 stdout_encoding_str, stdout_errors_str);
|
|
|
1673 Py_CLEAR(stdout_encoding);
|
|
|
1674 Py_CLEAR(stdout_errors);
|
|
|
1675 Py_CLEAR(stringpo);
|
|
|
1676 if (po == NULL)
|
|
|
1677 goto _readline_errors;
|
|
|
1678 prompt = PyBytes_AsString(po);
|
|
|
1679 if (prompt == NULL)
|
|
|
1680 goto _readline_errors;
|
|
|
1681 }
|
|
|
1682 else {
|
|
|
1683 po = NULL;
|
|
|
1684 prompt = "";
|
|
|
1685 }
|
|
|
1686 s = PyOS_Readline(stdin, stdout, prompt);
|
|
|
1687 if (s == NULL) {
|
|
|
1688 if (!PyErr_Occurred())
|
|
|
1689 PyErr_SetNone(PyExc_KeyboardInterrupt);
|
|
|
1690 goto _readline_errors;
|
|
|
1691 }
|
|
|
1692
|
|
|
1693 len = strlen(s);
|
|
|
1694 if (len == 0) {
|
|
|
1695 PyErr_SetNone(PyExc_EOFError);
|
|
|
1696 result = NULL;
|
|
|
1697 }
|
|
|
1698 else {
|
|
|
1699 if (len > PY_SSIZE_T_MAX) {
|
|
|
1700 PyErr_SetString(PyExc_OverflowError,
|
|
|
1701 "input: input too long");
|
|
|
1702 result = NULL;
|
|
|
1703 }
|
|
|
1704 else {
|
|
|
1705 len--; /* strip trailing '\n' */
|
|
|
1706 if (len != 0 && s[len-1] == '\r')
|
|
|
1707 len--; /* strip trailing '\r' */
|
|
|
1708 result = PyUnicode_Decode(s, len, stdin_encoding_str,
|
|
|
1709 stdin_errors_str);
|
|
|
1710 }
|
|
|
1711 }
|
|
|
1712 Py_DECREF(stdin_encoding);
|
|
|
1713 Py_DECREF(stdin_errors);
|
|
|
1714 Py_XDECREF(po);
|
|
|
1715 PyMem_FREE(s);
|
|
|
1716 return result;
|
|
|
1717 _readline_errors:
|
|
|
1718 Py_XDECREF(stdin_encoding);
|
|
|
1719 Py_XDECREF(stdout_encoding);
|
|
|
1720 Py_XDECREF(stdin_errors);
|
|
|
1721 Py_XDECREF(stdout_errors);
|
|
|
1722 Py_XDECREF(po);
|
|
|
1723 return NULL;
|
|
|
1724 }
|
|
|
1725
|
|
|
1726 /* Fallback if we're not interactive */
|
|
|
1727 if (promptarg != NULL) {
|
|
|
1728 if (PyFile_WriteObject(promptarg, fout, Py_PRINT_RAW) != 0)
|
|
|
1729 return NULL;
|
|
|
1730 }
|
|
|
1731 tmp = _PyObject_CallMethodId(fout, &PyId_flush, "");
|
|
|
1732 if (tmp == NULL)
|
|
|
1733 PyErr_Clear();
|
|
|
1734 else
|
|
|
1735 Py_DECREF(tmp);
|
|
|
1736 return PyFile_GetLine(fin, -1);
|
|
|
1737 }
|
|
|
1738
|
|
|
1739 PyDoc_STRVAR(input_doc,
|
|
|
1740 "input([prompt]) -> string\n\
|
|
|
1741 \n\
|
|
|
1742 Read a string from standard input. The trailing newline is stripped.\n\
|
|
|
1743 If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.\n\
|
|
|
1744 On Unix, GNU readline is used if enabled. The prompt string, if given,\n\
|
|
|
1745 is printed without a trailing newline before reading.");
|
|
|
1746
|
|
|
1747
|
|
|
1748 static PyObject *
|
|
|
1749 builtin_repr(PyObject *self, PyObject *v)
|
|
|
1750 {
|
|
|
1751 return PyObject_Repr(v);
|
|
|
1752 }
|
|
|
1753
|
|
|
1754 PyDoc_STRVAR(repr_doc,
|
|
|
1755 "repr(object) -> string\n\
|
|
|
1756 \n\
|
|
|
1757 Return the canonical string representation of the object.\n\
|
|
|
1758 For most object types, eval(repr(object)) == object.");
|
|
|
1759
|
|
|
1760
|
|
|
1761 static PyObject *
|
|
|
1762 builtin_round(PyObject *self, PyObject *args, PyObject *kwds)
|
|
|
1763 {
|
|
|
1764 static PyObject *round_str = NULL;
|
|
|
1765 PyObject *ndigits = NULL;
|
|
|
1766 static char *kwlist[] = {"number", "ndigits", 0};
|
|
|
1767 PyObject *number, *round;
|
|
|
1768
|
|
|
1769 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:round",
|
|
|
1770 kwlist, &number, &ndigits))
|
|
|
1771 return NULL;
|
|
|
1772
|
|
|
1773 if (Py_TYPE(number)->tp_dict == NULL) {
|
|
|
1774 if (PyType_Ready(Py_TYPE(number)) < 0)
|
|
|
1775 return NULL;
|
|
|
1776 }
|
|
|
1777
|
|
|
1778 if (round_str == NULL) {
|
|
|
1779 round_str = PyUnicode_InternFromString("__round__");
|
|
|
1780 if (round_str == NULL)
|
|
|
1781 return NULL;
|
|
|
1782 }
|
|
|
1783
|
|
|
1784 round = _PyType_Lookup(Py_TYPE(number), round_str);
|
|
|
1785 if (round == NULL) {
|
|
|
1786 PyErr_Format(PyExc_TypeError,
|
|
|
1787 "type %.100s doesn't define __round__ method",
|
|
|
1788 Py_TYPE(number)->tp_name);
|
|
|
1789 return NULL;
|
|
|
1790 }
|
|
|
1791
|
|
|
1792 if (ndigits == NULL)
|
|
|
1793 return PyObject_CallFunction(round, "O", number);
|
|
|
1794 else
|
|
|
1795 return PyObject_CallFunction(round, "OO", number, ndigits);
|
|
|
1796 }
|
|
|
1797
|
|
|
1798 PyDoc_STRVAR(round_doc,
|
|
|
1799 "round(number[, ndigits]) -> number\n\
|
|
|
1800 \n\
|
|
|
1801 Round a number to a given precision in decimal digits (default 0 digits).\n\
|
|
|
1802 This returns an int when called with one argument, otherwise the\n\
|
|
|
1803 same type as the number. ndigits may be negative.");
|
|
|
1804
|
|
|
1805
|
|
|
1806 static PyObject *
|
|
|
1807 builtin_sorted(PyObject *self, PyObject *args, PyObject *kwds)
|
|
|
1808 {
|
|
|
1809 PyObject *newlist, *v, *seq, *keyfunc=NULL, *newargs;
|
|
|
1810 PyObject *callable;
|
|
|
1811 static char *kwlist[] = {"iterable", "key", "reverse", 0};
|
|
|
1812 int reverse;
|
|
|
1813 _Py_IDENTIFIER(sort);
|
|
|
1814
|
|
|
1815 /* args 1-3 should match listsort in Objects/listobject.c */
|
|
|
1816 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|Oi:sorted",
|
|
|
1817 kwlist, &seq, &keyfunc, &reverse))
|
|
|
1818 return NULL;
|
|
|
1819
|
|
|
1820 newlist = PySequence_List(seq);
|
|
|
1821 if (newlist == NULL)
|
|
|
1822 return NULL;
|
|
|
1823
|
|
|
1824 callable = _PyObject_GetAttrId(newlist, &PyId_sort);
|
|
|
1825 if (callable == NULL) {
|
|
|
1826 Py_DECREF(newlist);
|
|
|
1827 return NULL;
|
|
|
1828 }
|
|
|
1829
|
|
|
1830 newargs = PyTuple_GetSlice(args, 1, 4);
|
|
|
1831 if (newargs == NULL) {
|
|
|
1832 Py_DECREF(newlist);
|
|
|
1833 Py_DECREF(callable);
|
|
|
1834 return NULL;
|
|
|
1835 }
|
|
|
1836
|
|
|
1837 v = PyObject_Call(callable, newargs, kwds);
|
|
|
1838 Py_DECREF(newargs);
|
|
|
1839 Py_DECREF(callable);
|
|
|
1840 if (v == NULL) {
|
|
|
1841 Py_DECREF(newlist);
|
|
|
1842 return NULL;
|
|
|
1843 }
|
|
|
1844 Py_DECREF(v);
|
|
|
1845 return newlist;
|
|
|
1846 }
|
|
|
1847
|
|
|
1848 PyDoc_STRVAR(sorted_doc,
|
|
|
1849 "sorted(iterable, key=None, reverse=False) --> new sorted list");
|
|
|
1850
|
|
|
1851 static PyObject *
|
|
|
1852 builtin_vars(PyObject *self, PyObject *args)
|
|
|
1853 {
|
|
|
1854 PyObject *v = NULL;
|
|
|
1855 PyObject *d;
|
|
|
1856
|
|
|
1857 if (!PyArg_UnpackTuple(args, "vars", 0, 1, &v))
|
|
|
1858 return NULL;
|
|
|
1859 if (v == NULL) {
|
|
|
1860 d = PyEval_GetLocals();
|
|
|
1861 if (d == NULL) {
|
|
|
1862 if (!PyErr_Occurred())
|
|
|
1863 PyErr_SetString(PyExc_SystemError,
|
|
|
1864 "vars(): no locals!?");
|
|
|
1865 }
|
|
|
1866 else
|
|
|
1867 Py_INCREF(d);
|
|
|
1868 }
|
|
|
1869 else {
|
|
|
1870 _Py_IDENTIFIER(__dict__);
|
|
|
1871 d = _PyObject_GetAttrId(v, &PyId___dict__);
|
|
|
1872 if (d == NULL) {
|
|
|
1873 PyErr_SetString(PyExc_TypeError,
|
|
|
1874 "vars() argument must have __dict__ attribute");
|
|
|
1875 return NULL;
|
|
|
1876 }
|
|
|
1877 }
|
|
|
1878 return d;
|
|
|
1879 }
|
|
|
1880
|
|
|
1881 PyDoc_STRVAR(vars_doc,
|
|
|
1882 "vars([object]) -> dictionary\n\
|
|
|
1883 \n\
|
|
|
1884 Without arguments, equivalent to locals().\n\
|
|
|
1885 With an argument, equivalent to object.__dict__.");
|
|
|
1886
|
|
|
1887 static PyObject*
|
|
|
1888 builtin_sum(PyObject *self, PyObject *args)
|
|
|
1889 {
|
|
|
1890 PyObject *seq;
|
|
|
1891 PyObject *result = NULL;
|
|
|
1892 PyObject *temp, *item, *iter;
|
|
|
1893
|
|
|
1894 if (!PyArg_UnpackTuple(args, "sum", 1, 2, &seq, &result))
|
|
|
1895 return NULL;
|
|
|
1896
|
|
|
1897 iter = PyObject_GetIter(seq);
|
|
|
1898 if (iter == NULL)
|
|
|
1899 return NULL;
|
|
|
1900
|
|
|
1901 if (result == NULL) {
|
|
|
1902 result = PyLong_FromLong(0);
|
|
|
1903 if (result == NULL) {
|
|
|
1904 Py_DECREF(iter);
|
|
|
1905 return NULL;
|
|
|
1906 }
|
|
|
1907 } else {
|
|
|
1908 /* reject string values for 'start' parameter */
|
|
|
1909 if (PyUnicode_Check(result)) {
|
|
|
1910 PyErr_SetString(PyExc_TypeError,
|
|
|
1911 "sum() can't sum strings [use ''.join(seq) instead]");
|
|
|
1912 Py_DECREF(iter);
|
|
|
1913 return NULL;
|
|
|
1914 }
|
|
|
1915 if (PyBytes_Check(result)) {
|
|
|
1916 PyErr_SetString(PyExc_TypeError,
|
|
|
1917 "sum() can't sum bytes [use b''.join(seq) instead]");
|
|
|
1918 Py_DECREF(iter);
|
|
|
1919 return NULL;
|
|
|
1920 }
|
|
|
1921 if (PyByteArray_Check(result)) {
|
|
|
1922 PyErr_SetString(PyExc_TypeError,
|
|
|
1923 "sum() can't sum bytearray [use b''.join(seq) instead]");
|
|
|
1924 Py_DECREF(iter);
|
|
|
1925 return NULL;
|
|
|
1926 }
|
|
|
1927
|
|
|
1928 Py_INCREF(result);
|
|
|
1929 }
|
|
|
1930
|
|
|
1931 #ifndef SLOW_SUM
|
|
|
1932 /* Fast addition by keeping temporary sums in C instead of new Python objects.
|
|
|
1933 Assumes all inputs are the same type. If the assumption fails, default
|
|
|
1934 to the more general routine.
|
|
|
1935 */
|
|
|
1936 if (PyLong_CheckExact(result)) {
|
|
|
1937 int overflow;
|
|
|
1938 long i_result = PyLong_AsLongAndOverflow(result, &overflow);
|
|
|
1939 /* If this already overflowed, don't even enter the loop. */
|
|
|
1940 if (overflow == 0) {
|
|
|
1941 Py_DECREF(result);
|
|
|
1942 result = NULL;
|
|
|
1943 }
|
|
|
1944 while(result == NULL) {
|
|
|
1945 item = PyIter_Next(iter);
|
|
|
1946 if (item == NULL) {
|
|
|
1947 Py_DECREF(iter);
|
|
|
1948 if (PyErr_Occurred())
|
|
|
1949 return NULL;
|
|
|
1950 return PyLong_FromLong(i_result);
|
|
|
1951 }
|
|
|
1952 if (PyLong_CheckExact(item)) {
|
|
|
1953 long b = PyLong_AsLongAndOverflow(item, &overflow);
|
|
|
1954 long x = i_result + b;
|
|
|
1955 if (overflow == 0 && ((x^i_result) >= 0 || (x^b) >= 0)) {
|
|
|
1956 i_result = x;
|
|
|
1957 Py_DECREF(item);
|
|
|
1958 continue;
|
|
|
1959 }
|
|
|
1960 }
|
|
|
1961 /* Either overflowed or is not an int. Restore real objects and process normally */
|
|
|
1962 result = PyLong_FromLong(i_result);
|
|
|
1963 temp = PyNumber_Add(result, item);
|
|
|
1964 Py_DECREF(result);
|
|
|
1965 Py_DECREF(item);
|
|
|
1966 result = temp;
|
|
|
1967 if (result == NULL) {
|
|
|
1968 Py_DECREF(iter);
|
|
|
1969 return NULL;
|
|
|
1970 }
|
|
|
1971 }
|
|
|
1972 }
|
|
|
1973
|
|
|
1974 if (PyFloat_CheckExact(result)) {
|
|
|
1975 double f_result = PyFloat_AS_DOUBLE(result);
|
|
|
1976 Py_DECREF(result);
|
|
|
1977 result = NULL;
|
|
|
1978 while(result == NULL) {
|
|
|
1979 item = PyIter_Next(iter);
|
|
|
1980 if (item == NULL) {
|
|
|
1981 Py_DECREF(iter);
|
|
|
1982 if (PyErr_Occurred())
|
|
|
1983 return NULL;
|
|
|
1984 return PyFloat_FromDouble(f_result);
|
|
|
1985 }
|
|
|
1986 if (PyFloat_CheckExact(item)) {
|
|
|
1987 PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0)
|
|
|
1988 f_result += PyFloat_AS_DOUBLE(item);
|
|
|
1989 PyFPE_END_PROTECT(f_result)
|
|
|
1990 Py_DECREF(item);
|
|
|
1991 continue;
|
|
|
1992 }
|
|
|
1993 if (PyLong_CheckExact(item)) {
|
|
|
1994 long value;
|
|
|
1995 int overflow;
|
|
|
1996 value = PyLong_AsLongAndOverflow(item, &overflow);
|
|
|
1997 if (!overflow) {
|
|
|
1998 PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0)
|
|
|
1999 f_result += (double)value;
|
|
|
2000 PyFPE_END_PROTECT(f_result)
|
|
|
2001 Py_DECREF(item);
|
|
|
2002 continue;
|
|
|
2003 }
|
|
|
2004 }
|
|
|
2005 result = PyFloat_FromDouble(f_result);
|
|
|
2006 temp = PyNumber_Add(result, item);
|
|
|
2007 Py_DECREF(result);
|
|
|
2008 Py_DECREF(item);
|
|
|
2009 result = temp;
|
|
|
2010 if (result == NULL) {
|
|
|
2011 Py_DECREF(iter);
|
|
|
2012 return NULL;
|
|
|
2013 }
|
|
|
2014 }
|
|
|
2015 }
|
|
|
2016 #endif
|
|
|
2017
|
|
|
2018 for(;;) {
|
|
|
2019 item = PyIter_Next(iter);
|
|
|
2020 if (item == NULL) {
|
|
|
2021 /* error, or end-of-sequence */
|
|
|
2022 if (PyErr_Occurred()) {
|
|
|
2023 Py_DECREF(result);
|
|
|
2024 result = NULL;
|
|
|
2025 }
|
|
|
2026 break;
|
|
|
2027 }
|
|
|
2028 /* It's tempting to use PyNumber_InPlaceAdd instead of
|
|
|
2029 PyNumber_Add here, to avoid quadratic running time
|
|
|
2030 when doing 'sum(list_of_lists, [])'. However, this
|
|
|
2031 would produce a change in behaviour: a snippet like
|
|
|
2032
|
|
|
2033 empty = []
|
|
|
2034 sum([[x] for x in range(10)], empty)
|
|
|
2035
|
|
|
2036 would change the value of empty. */
|
|
|
2037 temp = PyNumber_Add(result, item);
|
|
|
2038 Py_DECREF(result);
|
|
|
2039 Py_DECREF(item);
|
|
|
2040 result = temp;
|
|
|
2041 if (result == NULL)
|
|
|
2042 break;
|
|
|
2043 }
|
|
|
2044 Py_DECREF(iter);
|
|
|
2045 return result;
|
|
|
2046 }
|
|
|
2047
|
|
|
2048 PyDoc_STRVAR(sum_doc,
|
|
|
2049 "sum(iterable[, start]) -> value\n\
|
|
|
2050 \n\
|
|
|
2051 Returns the sum of an iterable of numbers (NOT strings) plus the value\n\
|
|
|
2052 of parameter 'start' (which defaults to 0). When the iterable is\n\
|
|
|
2053 empty, returns start.");
|
|
|
2054
|
|
|
2055
|
|
|
2056 static PyObject *
|
|
|
2057 builtin_isinstance(PyObject *self, PyObject *args)
|
|
|
2058 {
|
|
|
2059 PyObject *inst;
|
|
|
2060 PyObject *cls;
|
|
|
2061 int retval;
|
|
|
2062
|
|
|
2063 if (!PyArg_UnpackTuple(args, "isinstance", 2, 2, &inst, &cls))
|
|
|
2064 return NULL;
|
|
|
2065
|
|
|
2066 retval = PyObject_IsInstance(inst, cls);
|
|
|
2067 if (retval < 0)
|
|
|
2068 return NULL;
|
|
|
2069 return PyBool_FromLong(retval);
|
|
|
2070 }
|
|
|
2071
|
|
|
2072 PyDoc_STRVAR(isinstance_doc,
|
|
|
2073 "isinstance(object, class-or-type-or-tuple) -> bool\n\
|
|
|
2074 \n\
|
|
|
2075 Return whether an object is an instance of a class or of a subclass thereof.\n\
|
|
|
2076 With a type as second argument, return whether that is the object's type.\n\
|
|
|
2077 The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for\n\
|
|
|
2078 isinstance(x, A) or isinstance(x, B) or ... (etc.).");
|
|
|
2079
|
|
|
2080
|
|
|
2081 static PyObject *
|
|
|
2082 builtin_issubclass(PyObject *self, PyObject *args)
|
|
|
2083 {
|
|
|
2084 PyObject *derived;
|
|
|
2085 PyObject *cls;
|
|
|
2086 int retval;
|
|
|
2087
|
|
|
2088 if (!PyArg_UnpackTuple(args, "issubclass", 2, 2, &derived, &cls))
|
|
|
2089 return NULL;
|
|
|
2090
|
|
|
2091 retval = PyObject_IsSubclass(derived, cls);
|
|
|
2092 if (retval < 0)
|
|
|
2093 return NULL;
|
|
|
2094 return PyBool_FromLong(retval);
|
|
|
2095 }
|
|
|
2096
|
|
|
2097 PyDoc_STRVAR(issubclass_doc,
|
|
|
2098 "issubclass(C, B) -> bool\n\
|
|
|
2099 \n\
|
|
|
2100 Return whether class C is a subclass (i.e., a derived class) of class B.\n\
|
|
|
2101 When using a tuple as the second argument issubclass(X, (A, B, ...)),\n\
|
|
|
2102 is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.).");
|
|
|
2103
|
|
|
2104
|
|
|
2105 typedef struct {
|
|
|
2106 PyObject_HEAD
|
|
|
2107 Py_ssize_t tuplesize;
|
|
|
2108 PyObject *ittuple; /* tuple of iterators */
|
|
|
2109 PyObject *result;
|
|
|
2110 } zipobject;
|
|
|
2111
|
|
|
2112 static PyObject *
|
|
|
2113 zip_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|
|
2114 {
|
|
|
2115 zipobject *lz;
|
|
|
2116 Py_ssize_t i;
|
|
|
2117 PyObject *ittuple; /* tuple of iterators */
|
|
|
2118 PyObject *result;
|
|
|
2119 Py_ssize_t tuplesize = PySequence_Length(args);
|
|
|
2120
|
|
|
2121 if (type == &PyZip_Type && !_PyArg_NoKeywords("zip()", kwds))
|
|
|
2122 return NULL;
|
|
|
2123
|
|
|
2124 /* args must be a tuple */
|
|
|
2125 assert(PyTuple_Check(args));
|
|
|
2126
|
|
|
2127 /* obtain iterators */
|
|
|
2128 ittuple = PyTuple_New(tuplesize);
|
|
|
2129 if (ittuple == NULL)
|
|
|
2130 return NULL;
|
|
|
2131 for (i=0; i < tuplesize; ++i) {
|
|
|
2132 PyObject *item = PyTuple_GET_ITEM(args, i);
|
|
|
2133 PyObject *it = PyObject_GetIter(item);
|
|
|
2134 if (it == NULL) {
|
|
|
2135 if (PyErr_ExceptionMatches(PyExc_TypeError))
|
|
|
2136 PyErr_Format(PyExc_TypeError,
|
|
|
2137 "zip argument #%zd must support iteration",
|
|
|
2138 i+1);
|
|
|
2139 Py_DECREF(ittuple);
|
|
|
2140 return NULL;
|
|
|
2141 }
|
|
|
2142 PyTuple_SET_ITEM(ittuple, i, it);
|
|
|
2143 }
|
|
|
2144
|
|
|
2145 /* create a result holder */
|
|
|
2146 result = PyTuple_New(tuplesize);
|
|
|
2147 if (result == NULL) {
|
|
|
2148 Py_DECREF(ittuple);
|
|
|
2149 return NULL;
|
|
|
2150 }
|
|
|
2151 for (i=0 ; i < tuplesize ; i++) {
|
|
|
2152 Py_INCREF(Py_None);
|
|
|
2153 PyTuple_SET_ITEM(result, i, Py_None);
|
|
|
2154 }
|
|
|
2155
|
|
|
2156 /* create zipobject structure */
|
|
|
2157 lz = (zipobject *)type->tp_alloc(type, 0);
|
|
|
2158 if (lz == NULL) {
|
|
|
2159 Py_DECREF(ittuple);
|
|
|
2160 Py_DECREF(result);
|
|
|
2161 return NULL;
|
|
|
2162 }
|
|
|
2163 lz->ittuple = ittuple;
|
|
|
2164 lz->tuplesize = tuplesize;
|
|
|
2165 lz->result = result;
|
|
|
2166
|
|
|
2167 return (PyObject *)lz;
|
|
|
2168 }
|
|
|
2169
|
|
|
2170 static void
|
|
|
2171 zip_dealloc(zipobject *lz)
|
|
|
2172 {
|
|
|
2173 PyObject_GC_UnTrack(lz);
|
|
|
2174 Py_XDECREF(lz->ittuple);
|
|
|
2175 Py_XDECREF(lz->result);
|
|
|
2176 Py_TYPE(lz)->tp_free(lz);
|
|
|
2177 }
|
|
|
2178
|
|
|
2179 static int
|
|
|
2180 zip_traverse(zipobject *lz, visitproc visit, void *arg)
|
|
|
2181 {
|
|
|
2182 Py_VISIT(lz->ittuple);
|
|
|
2183 Py_VISIT(lz->result);
|
|
|
2184 return 0;
|
|
|
2185 }
|
|
|
2186
|
|
|
2187 static PyObject *
|
|
|
2188 zip_next(zipobject *lz)
|
|
|
2189 {
|
|
|
2190 Py_ssize_t i;
|
|
|
2191 Py_ssize_t tuplesize = lz->tuplesize;
|
|
|
2192 PyObject *result = lz->result;
|
|
|
2193 PyObject *it;
|
|
|
2194 PyObject *item;
|
|
|
2195 PyObject *olditem;
|
|
|
2196
|
|
|
2197 if (tuplesize == 0)
|
|
|
2198 return NULL;
|
|
|
2199 if (Py_REFCNT(result) == 1) {
|
|
|
2200 Py_INCREF(result);
|
|
|
2201 for (i=0 ; i < tuplesize ; i++) {
|
|
|
2202 it = PyTuple_GET_ITEM(lz->ittuple, i);
|
|
|
2203 item = (*Py_TYPE(it)->tp_iternext)(it);
|
|
|
2204 if (item == NULL) {
|
|
|
2205 Py_DECREF(result);
|
|
|
2206 return NULL;
|
|
|
2207 }
|
|
|
2208 olditem = PyTuple_GET_ITEM(result, i);
|
|
|
2209 PyTuple_SET_ITEM(result, i, item);
|
|
|
2210 Py_DECREF(olditem);
|
|
|
2211 }
|
|
|
2212 } else {
|
|
|
2213 result = PyTuple_New(tuplesize);
|
|
|
2214 if (result == NULL)
|
|
|
2215 return NULL;
|
|
|
2216 for (i=0 ; i < tuplesize ; i++) {
|
|
|
2217 it = PyTuple_GET_ITEM(lz->ittuple, i);
|
|
|
2218 item = (*Py_TYPE(it)->tp_iternext)(it);
|
|
|
2219 if (item == NULL) {
|
|
|
2220 Py_DECREF(result);
|
|
|
2221 return NULL;
|
|
|
2222 }
|
|
|
2223 PyTuple_SET_ITEM(result, i, item);
|
|
|
2224 }
|
|
|
2225 }
|
|
|
2226 return result;
|
|
|
2227 }
|
|
|
2228
|
|
|
2229 PyDoc_STRVAR(zip_doc,
|
|
|
2230 "zip(iter1 [,iter2 [...]]) --> zip object\n\
|
|
|
2231 \n\
|
|
|
2232 Return a zip object whose .__next__() method returns a tuple where\n\
|
|
|
2233 the i-th element comes from the i-th iterable argument. The .__next__()\n\
|
|
|
2234 method continues until the shortest iterable in the argument sequence\n\
|
|
|
2235 is exhausted and then it raises StopIteration.");
|
|
|
2236
|
|
|
2237 PyTypeObject PyZip_Type = {
|
|
|
2238 PyVarObject_HEAD_INIT(&PyType_Type, 0)
|
|
|
2239 "zip", /* tp_name */
|
|
|
2240 sizeof(zipobject), /* tp_basicsize */
|
|
|
2241 0, /* tp_itemsize */
|
|
|
2242 /* methods */
|
|
|
2243 (destructor)zip_dealloc, /* tp_dealloc */
|
|
|
2244 0, /* tp_print */
|
|
|
2245 0, /* tp_getattr */
|
|
|
2246 0, /* tp_setattr */
|
|
|
2247 0, /* tp_reserved */
|
|
|
2248 0, /* tp_repr */
|
|
|
2249 0, /* tp_as_number */
|
|
|
2250 0, /* tp_as_sequence */
|
|
|
2251 0, /* tp_as_mapping */
|
|
|
2252 0, /* tp_hash */
|
|
|
2253 0, /* tp_call */
|
|
|
2254 0, /* tp_str */
|
|
|
2255 PyObject_GenericGetAttr, /* tp_getattro */
|
|
|
2256 0, /* tp_setattro */
|
|
|
2257 0, /* tp_as_buffer */
|
|
|
2258 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
|
|
|
2259 Py_TPFLAGS_BASETYPE, /* tp_flags */
|
|
|
2260 zip_doc, /* tp_doc */
|
|
|
2261 (traverseproc)zip_traverse, /* tp_traverse */
|
|
|
2262 0, /* tp_clear */
|
|
|
2263 0, /* tp_richcompare */
|
|
|
2264 0, /* tp_weaklistoffset */
|
|
|
2265 PyObject_SelfIter, /* tp_iter */
|
|
|
2266 (iternextfunc)zip_next, /* tp_iternext */
|
|
|
2267 0, /* tp_methods */
|
|
|
2268 0, /* tp_members */
|
|
|
2269 0, /* tp_getset */
|
|
|
2270 0, /* tp_base */
|
|
|
2271 0, /* tp_dict */
|
|
|
2272 0, /* tp_descr_get */
|
|
|
2273 0, /* tp_descr_set */
|
|
|
2274 0, /* tp_dictoffset */
|
|
|
2275 0, /* tp_init */
|
|
|
2276 PyType_GenericAlloc, /* tp_alloc */
|
|
|
2277 zip_new, /* tp_new */
|
|
|
2278 PyObject_GC_Del, /* tp_free */
|
|
|
2279 };
|
|
|
2280
|
|
|
2281
|
|
|
2282 static PyMethodDef builtin_methods[] = {
|
|
|
2283 {"__build_class__", (PyCFunction)builtin___build_class__,
|
|
|
2284 METH_VARARGS | METH_KEYWORDS, build_class_doc},
|
|
|
2285 {"__import__", (PyCFunction)builtin___import__, METH_VARARGS | METH_KEYWORDS, import_doc},
|
|
|
2286 {"abs", builtin_abs, METH_O, abs_doc},
|
|
|
2287 {"all", builtin_all, METH_O, all_doc},
|
|
|
2288 {"any", builtin_any, METH_O, any_doc},
|
|
|
2289 {"ascii", builtin_ascii, METH_O, ascii_doc},
|
|
|
2290 {"bin", builtin_bin, METH_O, bin_doc},
|
|
|
2291 {"callable", builtin_callable, METH_O, callable_doc},
|
|
|
2292 {"chr", builtin_chr, METH_VARARGS, chr_doc},
|
|
|
2293 {"compile", (PyCFunction)builtin_compile, METH_VARARGS | METH_KEYWORDS, compile_doc},
|
|
|
2294 {"delattr", builtin_delattr, METH_VARARGS, delattr_doc},
|
|
|
2295 {"dir", builtin_dir, METH_VARARGS, dir_doc},
|
|
|
2296 {"divmod", builtin_divmod, METH_VARARGS, divmod_doc},
|
|
|
2297 {"eval", builtin_eval, METH_VARARGS, eval_doc},
|
|
|
2298 {"exec", builtin_exec, METH_VARARGS, exec_doc},
|
|
|
2299 {"format", builtin_format, METH_VARARGS, format_doc},
|
|
|
2300 {"getattr", builtin_getattr, METH_VARARGS, getattr_doc},
|
|
|
2301 {"globals", (PyCFunction)builtin_globals, METH_NOARGS, globals_doc},
|
|
|
2302 {"hasattr", builtin_hasattr, METH_VARARGS, hasattr_doc},
|
|
|
2303 {"hash", builtin_hash, METH_O, hash_doc},
|
|
|
2304 {"hex", builtin_hex, METH_O, hex_doc},
|
|
|
2305 {"id", builtin_id, METH_O, id_doc},
|
|
|
2306 {"input", builtin_input, METH_VARARGS, input_doc},
|
|
|
2307 {"isinstance", builtin_isinstance, METH_VARARGS, isinstance_doc},
|
|
|
2308 {"issubclass", builtin_issubclass, METH_VARARGS, issubclass_doc},
|
|
|
2309 {"iter", builtin_iter, METH_VARARGS, iter_doc},
|
|
|
2310 {"len", builtin_len, METH_O, len_doc},
|
|
|
2311 {"locals", (PyCFunction)builtin_locals, METH_NOARGS, locals_doc},
|
|
|
2312 {"max", (PyCFunction)builtin_max, METH_VARARGS | METH_KEYWORDS, max_doc},
|
|
|
2313 {"min", (PyCFunction)builtin_min, METH_VARARGS | METH_KEYWORDS, min_doc},
|
|
|
2314 {"next", (PyCFunction)builtin_next, METH_VARARGS, next_doc},
|
|
|
2315 {"oct", builtin_oct, METH_O, oct_doc},
|
|
|
2316 {"ord", builtin_ord, METH_O, ord_doc},
|
|
|
2317 {"pow", builtin_pow, METH_VARARGS, pow_doc},
|
|
|
2318 {"print", (PyCFunction)builtin_print, METH_VARARGS | METH_KEYWORDS, print_doc},
|
|
|
2319 {"repr", builtin_repr, METH_O, repr_doc},
|
|
|
2320 {"round", (PyCFunction)builtin_round, METH_VARARGS | METH_KEYWORDS, round_doc},
|
|
|
2321 {"setattr", builtin_setattr, METH_VARARGS, setattr_doc},
|
|
|
2322 {"sorted", (PyCFunction)builtin_sorted, METH_VARARGS | METH_KEYWORDS, sorted_doc},
|
|
|
2323 {"sum", builtin_sum, METH_VARARGS, sum_doc},
|
|
|
2324 {"vars", builtin_vars, METH_VARARGS, vars_doc},
|
|
|
2325 {NULL, NULL},
|
|
|
2326 };
|
|
|
2327
|
|
|
2328 PyDoc_STRVAR(builtin_doc,
|
|
|
2329 "Built-in functions, exceptions, and other objects.\n\
|
|
|
2330 \n\
|
|
|
2331 Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices.");
|
|
|
2332
|
|
|
2333 static struct PyModuleDef builtinsmodule = {
|
|
|
2334 PyModuleDef_HEAD_INIT,
|
|
|
2335 "builtins",
|
|
|
2336 builtin_doc,
|
|
|
2337 -1, /* multiple "initialization" just copies the module dict. */
|
|
|
2338 builtin_methods,
|
|
|
2339 NULL,
|
|
|
2340 NULL,
|
|
|
2341 NULL,
|
|
|
2342 NULL
|
|
|
2343 };
|
|
|
2344
|
|
|
2345
|
|
|
2346 PyObject *
|
|
|
2347 _PyBuiltin_Init(void)
|
|
|
2348 {
|
|
|
2349 PyObject *mod, *dict, *debug;
|
|
|
2350 mod = PyModule_Create(&builtinsmodule);
|
|
|
2351 if (mod == NULL)
|
|
|
2352 return NULL;
|
|
|
2353 dict = PyModule_GetDict(mod);
|
|
|
2354
|
|
|
2355 #ifdef Py_TRACE_REFS
|
|
|
2356 /* "builtins" exposes a number of statically allocated objects
|
|
|
2357 * that, before this code was added in 2.3, never showed up in
|
|
|
2358 * the list of "all objects" maintained by Py_TRACE_REFS. As a
|
|
|
2359 * result, programs leaking references to None and False (etc)
|
|
|
2360 * couldn't be diagnosed by examining sys.getobjects(0).
|
|
|
2361 */
|
|
|
2362 #define ADD_TO_ALL(OBJECT) _Py_AddToAllObjects((PyObject *)(OBJECT), 0)
|
|
|
2363 #else
|
|
|
2364 #define ADD_TO_ALL(OBJECT) (void)0
|
|
|
2365 #endif
|
|
|
2366
|
|
|
2367 #define SETBUILTIN(NAME, OBJECT) \
|
|
|
2368 if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0) \
|
|
|
2369 return NULL; \
|
|
|
2370 ADD_TO_ALL(OBJECT)
|
|
|
2371
|
|
|
2372 SETBUILTIN("None", Py_None);
|
|
|
2373 SETBUILTIN("Ellipsis", Py_Ellipsis);
|
|
|
2374 SETBUILTIN("NotImplemented", Py_NotImplemented);
|
|
|
2375 SETBUILTIN("False", Py_False);
|
|
|
2376 SETBUILTIN("True", Py_True);
|
|
|
2377 SETBUILTIN("bool", &PyBool_Type);
|
|
|
2378 SETBUILTIN("memoryview", &PyMemoryView_Type);
|
|
|
2379 SETBUILTIN("bytearray", &PyByteArray_Type);
|
|
|
2380 SETBUILTIN("bytes", &PyBytes_Type);
|
|
|
2381 SETBUILTIN("classmethod", &PyClassMethod_Type);
|
|
|
2382 SETBUILTIN("complex", &PyComplex_Type);
|
|
|
2383 SETBUILTIN("dict", &PyDict_Type);
|
|
|
2384 SETBUILTIN("enumerate", &PyEnum_Type);
|
|
|
2385 SETBUILTIN("filter", &PyFilter_Type);
|
|
|
2386 SETBUILTIN("float", &PyFloat_Type);
|
|
|
2387 SETBUILTIN("frozenset", &PyFrozenSet_Type);
|
|
|
2388 SETBUILTIN("property", &PyProperty_Type);
|
|
|
2389 SETBUILTIN("int", &PyLong_Type);
|
|
|
2390 SETBUILTIN("list", &PyList_Type);
|
|
|
2391 SETBUILTIN("map", &PyMap_Type);
|
|
|
2392 SETBUILTIN("object", &PyBaseObject_Type);
|
|
|
2393 SETBUILTIN("range", &PyRange_Type);
|
|
|
2394 SETBUILTIN("reversed", &PyReversed_Type);
|
|
|
2395 SETBUILTIN("set", &PySet_Type);
|
|
|
2396 SETBUILTIN("slice", &PySlice_Type);
|
|
|
2397 SETBUILTIN("staticmethod", &PyStaticMethod_Type);
|
|
|
2398 SETBUILTIN("str", &PyUnicode_Type);
|
|
|
2399 SETBUILTIN("super", &PySuper_Type);
|
|
|
2400 SETBUILTIN("tuple", &PyTuple_Type);
|
|
|
2401 SETBUILTIN("type", &PyType_Type);
|
|
|
2402 SETBUILTIN("zip", &PyZip_Type);
|
|
|
2403 debug = PyBool_FromLong(Py_OptimizeFlag == 0);
|
|
|
2404 if (PyDict_SetItemString(dict, "__debug__", debug) < 0) {
|
|
|
2405 Py_XDECREF(debug);
|
|
|
2406 return NULL;
|
|
|
2407 }
|
|
|
2408 Py_XDECREF(debug);
|
|
|
2409
|
|
|
2410 return mod;
|
|
|
2411 #undef ADD_TO_ALL
|
|
|
2412 #undef SETBUILTIN
|
|
|
2413 }
|
