1 /* Built-in functions */
4 #include "Python-ast.h"
13 #include "unixstuff.h"
16 /* The default encoding used by the platform file system APIs
17 Can remain NULL for all platforms that don't have such a concept
19 #if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)
20 const char *Py_FileSystemDefaultEncoding
= "mbcs";
21 #elif defined(__APPLE__)
22 const char *Py_FileSystemDefaultEncoding
= "utf-8";
24 const char *Py_FileSystemDefaultEncoding
= NULL
; /* use default */
28 static PyObject
*filterstring(PyObject
*, PyObject
*);
29 #ifdef Py_USING_UNICODE
30 static PyObject
*filterunicode(PyObject
*, PyObject
*);
32 static PyObject
*filtertuple (PyObject
*, PyObject
*);
35 builtin___import__(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
37 static char *kwlist
[] = {"name", "globals", "locals", "fromlist",
40 PyObject
*globals
= NULL
;
41 PyObject
*locals
= NULL
;
42 PyObject
*fromlist
= NULL
;
45 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "s|OOOi:__import__",
46 kwlist
, &name
, &globals
, &locals
, &fromlist
, &level
))
48 return PyImport_ImportModuleLevel(name
, globals
, locals
,
52 PyDoc_STRVAR(import_doc
,
53 "__import__(name, globals={}, locals={}, fromlist=[], level=-1) -> module\n\
55 Import a module. The globals are only used to determine the context;\n\
56 they are not modified. The locals are currently unused. The fromlist\n\
57 should be a list of names to emulate ``from name import ...'', or an\n\
58 empty list to emulate ``import name''.\n\
59 When importing a module from a package, note that __import__('A.B', ...)\n\
60 returns package A when fromlist is empty, but its submodule B when\n\
61 fromlist is not empty. Level is used to determine whether to perform \n\
62 absolute or relative imports. -1 is the original strategy of attempting\n\
63 both absolute and relative imports, 0 is absolute, a positive number\n\
64 is the number of parent directories to search relative to the current module.");
68 builtin_abs(PyObject
*self
, PyObject
*v
)
70 return PyNumber_Absolute(v
);
74 "abs(number) -> number\n\
76 Return the absolute value of the argument.");
79 builtin_all(PyObject
*self
, PyObject
*v
)
82 PyObject
*(*iternext
)(PyObject
*);
85 it
= PyObject_GetIter(v
);
88 iternext
= *Py_TYPE(it
)->tp_iternext
;
94 cmp
= PyObject_IsTrue(item
);
106 if (PyErr_Occurred()) {
107 if (PyErr_ExceptionMatches(PyExc_StopIteration
))
115 PyDoc_STRVAR(all_doc
,
116 "all(iterable) -> bool\n\
118 Return True if bool(x) is True for all values x in the iterable.");
121 builtin_any(PyObject
*self
, PyObject
*v
)
124 PyObject
*(*iternext
)(PyObject
*);
127 it
= PyObject_GetIter(v
);
130 iternext
= *Py_TYPE(it
)->tp_iternext
;
136 cmp
= PyObject_IsTrue(item
);
148 if (PyErr_Occurred()) {
149 if (PyErr_ExceptionMatches(PyExc_StopIteration
))
157 PyDoc_STRVAR(any_doc
,
158 "any(iterable) -> bool\n\
160 Return True if bool(x) is True for any x in the iterable.");
163 builtin_apply(PyObject
*self
, PyObject
*args
)
165 PyObject
*func
, *alist
= NULL
, *kwdict
= NULL
;
166 PyObject
*t
= NULL
, *retval
= NULL
;
168 if (PyErr_WarnPy3k("apply() not supported in 3.x; "
169 "use func(*args, **kwargs)", 1) < 0)
172 if (!PyArg_UnpackTuple(args
, "apply", 1, 3, &func
, &alist
, &kwdict
))
175 if (!PyTuple_Check(alist
)) {
176 if (!PySequence_Check(alist
)) {
177 PyErr_Format(PyExc_TypeError
,
178 "apply() arg 2 expected sequence, found %s",
179 alist
->ob_type
->tp_name
);
182 t
= PySequence_Tuple(alist
);
188 if (kwdict
!= NULL
&& !PyDict_Check(kwdict
)) {
189 PyErr_Format(PyExc_TypeError
,
190 "apply() arg 3 expected dictionary, found %s",
191 kwdict
->ob_type
->tp_name
);
194 retval
= PyEval_CallObjectWithKeywords(func
, alist
, kwdict
);
200 PyDoc_STRVAR(apply_doc
,
201 "apply(object[, args[, kwargs]]) -> value\n\
203 Call a callable object with positional arguments taken from the tuple args,\n\
204 and keyword arguments taken from the optional dictionary kwargs.\n\
205 Note that classes are callable, as are instances with a __call__() method.\n\
207 Deprecated since release 2.3. Instead, use the extended call syntax:\n\
208 function(*args, **keywords).");
212 builtin_bin(PyObject
*self
, PyObject
*v
)
214 return PyNumber_ToBase(v
, 2);
217 PyDoc_STRVAR(bin_doc
,
218 "bin(number) -> string\n\
220 Return the binary representation of an integer or long integer.");
224 builtin_callable(PyObject
*self
, PyObject
*v
)
226 if (PyErr_WarnPy3k("callable() not supported in 3.x; "
227 "use hasattr(o, '__call__')", 1) < 0)
229 return PyBool_FromLong((long)PyCallable_Check(v
));
232 PyDoc_STRVAR(callable_doc
,
233 "callable(object) -> bool\n\
235 Return whether the object is callable (i.e., some kind of function).\n\
236 Note that classes are callable, as are instances with a __call__() method.");
240 builtin_filter(PyObject
*self
, PyObject
*args
)
242 PyObject
*func
, *seq
, *result
, *it
, *arg
;
243 Py_ssize_t len
; /* guess for result list size */
244 register Py_ssize_t j
;
246 if (!PyArg_UnpackTuple(args
, "filter", 2, 2, &func
, &seq
))
249 /* Strings and tuples return a result of the same type. */
250 if (PyString_Check(seq
))
251 return filterstring(func
, seq
);
252 #ifdef Py_USING_UNICODE
253 if (PyUnicode_Check(seq
))
254 return filterunicode(func
, seq
);
256 if (PyTuple_Check(seq
))
257 return filtertuple(func
, seq
);
259 /* Pre-allocate argument list tuple. */
260 arg
= PyTuple_New(1);
265 it
= PyObject_GetIter(seq
);
269 /* Guess a result list size. */
270 len
= _PyObject_LengthHint(seq
, 8);
274 /* Get a result list. */
275 if (PyList_Check(seq
) && seq
->ob_refcnt
== 1) {
276 /* Eww - can modify the list in-place. */
281 result
= PyList_New(len
);
286 /* Build the result list. */
292 item
= PyIter_Next(it
);
294 if (PyErr_Occurred())
299 if (func
== (PyObject
*)&PyBool_Type
|| func
== Py_None
) {
300 ok
= PyObject_IsTrue(item
);
304 PyTuple_SET_ITEM(arg
, 0, item
);
305 good
= PyObject_Call(func
, arg
, NULL
);
306 PyTuple_SET_ITEM(arg
, 0, NULL
);
311 ok
= PyObject_IsTrue(good
);
316 PyList_SET_ITEM(result
, j
, item
);
318 int status
= PyList_Append(result
, item
);
330 /* Cut back result list if len is too big. */
331 if (j
< len
&& PyList_SetSlice(result
, j
, len
, NULL
) < 0)
347 PyDoc_STRVAR(filter_doc
,
348 "filter(function or None, sequence) -> list, tuple, or string\n"
350 "Return those items of sequence for which function(item) is true. If\n"
351 "function is None, return the items that are true. If sequence is a tuple\n"
352 "or string, return the same type, else return a list.");
355 builtin_format(PyObject
*self
, PyObject
*args
)
358 PyObject
*format_spec
= NULL
;
360 if (!PyArg_ParseTuple(args
, "O|O:format", &value
, &format_spec
))
363 return PyObject_Format(value
, format_spec
);
366 PyDoc_STRVAR(format_doc
,
367 "format(value[, format_spec]) -> string\n\
369 Returns value.__format__(format_spec)\n\
370 format_spec defaults to \"\"");
373 builtin_chr(PyObject
*self
, PyObject
*args
)
378 if (!PyArg_ParseTuple(args
, "l:chr", &x
))
380 if (x
< 0 || x
>= 256) {
381 PyErr_SetString(PyExc_ValueError
,
382 "chr() arg not in range(256)");
386 return PyString_FromStringAndSize(s
, 1);
389 PyDoc_STRVAR(chr_doc
,
390 "chr(i) -> character\n\
392 Return a string of one character with ordinal i; 0 <= i < 256.");
395 #ifdef Py_USING_UNICODE
397 builtin_unichr(PyObject
*self
, PyObject
*args
)
401 if (!PyArg_ParseTuple(args
, "i:unichr", &x
))
404 return PyUnicode_FromOrdinal(x
);
407 PyDoc_STRVAR(unichr_doc
,
408 "unichr(i) -> Unicode character\n\
410 Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.");
415 builtin_cmp(PyObject
*self
, PyObject
*args
)
420 if (!PyArg_UnpackTuple(args
, "cmp", 2, 2, &a
, &b
))
422 if (PyObject_Cmp(a
, b
, &c
) < 0)
424 return PyInt_FromLong((long)c
);
427 PyDoc_STRVAR(cmp_doc
,
428 "cmp(x, y) -> integer\n\
430 Return negative if x<y, zero if x==y, positive if x>y.");
434 builtin_coerce(PyObject
*self
, PyObject
*args
)
439 if (PyErr_WarnPy3k("coerce() not supported in 3.x", 1) < 0)
442 if (!PyArg_UnpackTuple(args
, "coerce", 2, 2, &v
, &w
))
444 if (PyNumber_Coerce(&v
, &w
) < 0)
446 res
= PyTuple_Pack(2, v
, w
);
452 PyDoc_STRVAR(coerce_doc
,
453 "coerce(x, y) -> (x1, y1)\n\
455 Return a tuple consisting of the two numeric arguments converted to\n\
456 a common type, using the same rules as used by arithmetic operations.\n\
457 If coercion is not possible, raise TypeError.");
460 builtin_compile(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
466 int dont_inherit
= 0;
467 int supplied_flags
= 0;
469 PyObject
*result
= NULL
, *cmd
, *tmp
= NULL
;
471 static char *kwlist
[] = {"source", "filename", "mode", "flags",
472 "dont_inherit", NULL
};
473 int start
[] = {Py_file_input
, Py_eval_input
, Py_single_input
};
475 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "Oss|ii:compile",
476 kwlist
, &cmd
, &filename
, &startstr
,
477 &supplied_flags
, &dont_inherit
))
480 cf
.cf_flags
= supplied_flags
;
483 ~(PyCF_MASK
| PyCF_MASK_OBSOLETE
| PyCF_DONT_IMPLY_DEDENT
| PyCF_ONLY_AST
))
485 PyErr_SetString(PyExc_ValueError
,
486 "compile(): unrecognised flags");
489 /* XXX Warn if (supplied_flags & PyCF_MASK_OBSOLETE) != 0? */
492 PyEval_MergeCompilerFlags(&cf
);
495 if (strcmp(startstr
, "exec") == 0)
497 else if (strcmp(startstr
, "eval") == 0)
499 else if (strcmp(startstr
, "single") == 0)
502 PyErr_SetString(PyExc_ValueError
,
503 "compile() arg 3 must be 'exec', 'eval' or 'single'");
507 if (PyAST_Check(cmd
)) {
508 if (supplied_flags
& PyCF_ONLY_AST
) {
516 arena
= PyArena_New();
517 mod
= PyAST_obj2mod(cmd
, arena
, mode
);
522 result
= (PyObject
*)PyAST_Compile(mod
, filename
,
529 #ifdef Py_USING_UNICODE
530 if (PyUnicode_Check(cmd
)) {
531 tmp
= PyUnicode_AsUTF8String(cmd
);
535 cf
.cf_flags
|= PyCF_SOURCE_IS_UTF8
;
539 if (PyObject_AsReadBuffer(cmd
, (const void **)&str
, &length
))
541 if ((size_t)length
!= strlen(str
)) {
542 PyErr_SetString(PyExc_TypeError
,
543 "compile() expected string without null bytes");
546 result
= Py_CompileStringFlags(str
, filename
, start
[mode
], &cf
);
552 PyDoc_STRVAR(compile_doc
,
553 "compile(source, filename, mode[, flags[, dont_inherit]]) -> code object\n\
555 Compile the source string (a Python module, statement or expression)\n\
556 into a code object that can be executed by the exec statement or eval().\n\
557 The filename will be used for run-time error messages.\n\
558 The mode must be 'exec' to compile a module, 'single' to compile a\n\
559 single (interactive) statement, or 'eval' to compile an expression.\n\
560 The flags argument, if present, controls which future statements influence\n\
561 the compilation of the code.\n\
562 The dont_inherit argument, if non-zero, stops the compilation inheriting\n\
563 the effects of any future statements in effect in the code calling\n\
564 compile; if absent or zero these statements do influence the compilation,\n\
565 in addition to any features explicitly specified.");
568 builtin_dir(PyObject
*self
, PyObject
*args
)
570 PyObject
*arg
= NULL
;
572 if (!PyArg_UnpackTuple(args
, "dir", 0, 1, &arg
))
574 return PyObject_Dir(arg
);
577 PyDoc_STRVAR(dir_doc
,
578 "dir([object]) -> list of strings\n"
580 "If called without an argument, return the names in the current scope.\n"
581 "Else, return an alphabetized list of names comprising (some of) the attributes\n"
582 "of the given object, and of attributes reachable from it.\n"
583 "If the object supplies a method named __dir__, it will be used; otherwise\n"
584 "the default dir() logic is used and returns:\n"
585 " for a module object: the module's attributes.\n"
586 " for a class object: its attributes, and recursively the attributes\n"
588 " for any other object: its attributes, its class's attributes, and\n"
589 " recursively the attributes of its class's base classes.");
592 builtin_divmod(PyObject
*self
, PyObject
*args
)
596 if (!PyArg_UnpackTuple(args
, "divmod", 2, 2, &v
, &w
))
598 return PyNumber_Divmod(v
, w
);
601 PyDoc_STRVAR(divmod_doc
,
602 "divmod(x, y) -> (div, mod)\n\
604 Return the tuple ((x-x%y)/y, x%y). Invariant: div*y + mod == x.");
608 builtin_eval(PyObject
*self
, PyObject
*args
)
610 PyObject
*cmd
, *result
, *tmp
= NULL
;
611 PyObject
*globals
= Py_None
, *locals
= Py_None
;
615 if (!PyArg_UnpackTuple(args
, "eval", 1, 3, &cmd
, &globals
, &locals
))
617 if (locals
!= Py_None
&& !PyMapping_Check(locals
)) {
618 PyErr_SetString(PyExc_TypeError
, "locals must be a mapping");
621 if (globals
!= Py_None
&& !PyDict_Check(globals
)) {
622 PyErr_SetString(PyExc_TypeError
, PyMapping_Check(globals
) ?
623 "globals must be a real dict; try eval(expr, {}, mapping)"
624 : "globals must be a dict");
627 if (globals
== Py_None
) {
628 globals
= PyEval_GetGlobals();
629 if (locals
== Py_None
)
630 locals
= PyEval_GetLocals();
632 else if (locals
== Py_None
)
635 if (globals
== NULL
|| locals
== NULL
) {
636 PyErr_SetString(PyExc_TypeError
,
637 "eval must be given globals and locals "
638 "when called without a frame");
642 if (PyDict_GetItemString(globals
, "__builtins__") == NULL
) {
643 if (PyDict_SetItemString(globals
, "__builtins__",
644 PyEval_GetBuiltins()) != 0)
648 if (PyCode_Check(cmd
)) {
649 if (PyCode_GetNumFree((PyCodeObject
*)cmd
) > 0) {
650 PyErr_SetString(PyExc_TypeError
,
651 "code object passed to eval() may not contain free variables");
654 return PyEval_EvalCode((PyCodeObject
*) cmd
, globals
, locals
);
657 if (!PyString_Check(cmd
) &&
658 !PyUnicode_Check(cmd
)) {
659 PyErr_SetString(PyExc_TypeError
,
660 "eval() arg 1 must be a string or code object");
665 #ifdef Py_USING_UNICODE
666 if (PyUnicode_Check(cmd
)) {
667 tmp
= PyUnicode_AsUTF8String(cmd
);
671 cf
.cf_flags
|= PyCF_SOURCE_IS_UTF8
;
674 if (PyString_AsStringAndSize(cmd
, &str
, NULL
)) {
678 while (*str
== ' ' || *str
== '\t')
681 (void)PyEval_MergeCompilerFlags(&cf
);
682 result
= PyRun_StringFlags(str
, Py_eval_input
, globals
, locals
, &cf
);
687 PyDoc_STRVAR(eval_doc
,
688 "eval(source[, globals[, locals]]) -> value\n\
690 Evaluate the source in the context of globals and locals.\n\
691 The source may be a string representing a Python expression\n\
692 or a code object as returned by compile().\n\
693 The globals must be a dictionary and locals can be any mapping,\n\
694 defaulting to the current globals and locals.\n\
695 If only globals is given, locals defaults to it.\n");
699 builtin_execfile(PyObject
*self
, PyObject
*args
)
702 PyObject
*globals
= Py_None
, *locals
= Py_None
;
708 if (PyErr_WarnPy3k("execfile() not supported in 3.x; use exec()",
712 if (!PyArg_ParseTuple(args
, "s|O!O:execfile",
714 &PyDict_Type
, &globals
,
717 if (locals
!= Py_None
&& !PyMapping_Check(locals
)) {
718 PyErr_SetString(PyExc_TypeError
, "locals must be a mapping");
721 if (globals
== Py_None
) {
722 globals
= PyEval_GetGlobals();
723 if (locals
== Py_None
)
724 locals
= PyEval_GetLocals();
726 else if (locals
== Py_None
)
728 if (PyDict_GetItemString(globals
, "__builtins__") == NULL
) {
729 if (PyDict_SetItemString(globals
, "__builtins__",
730 PyEval_GetBuiltins()) != 0)
735 /* Test for existence or directory. */
740 if ((d
= dirstat(filename
))!=nil
) {
742 werrstr("is a directory");
748 #elif defined(RISCOS)
749 if (object_exists(filename
)) {
755 #else /* standard Posix */
758 if (stat(filename
, &s
) == 0) {
759 if (S_ISDIR(s
.st_mode
))
760 # if defined(PYOS_OS2) && defined(PYCC_VACPP)
772 Py_BEGIN_ALLOW_THREADS
773 fp
= fopen(filename
, "r" PY_STDIOTEXTMODE
);
782 PyErr_SetFromErrnoWithFilename(PyExc_IOError
, filename
);
786 if (PyEval_MergeCompilerFlags(&cf
))
787 res
= PyRun_FileExFlags(fp
, filename
, Py_file_input
, globals
,
790 res
= PyRun_FileEx(fp
, filename
, Py_file_input
, globals
,
795 PyDoc_STRVAR(execfile_doc
,
796 "execfile(filename[, globals[, locals]])\n\
798 Read and execute a Python script from a file.\n\
799 The globals and locals are dictionaries, defaulting to the current\n\
800 globals and locals. If only globals is given, locals defaults to it.");
804 builtin_getattr(PyObject
*self
, PyObject
*args
)
806 PyObject
*v
, *result
, *dflt
= NULL
;
809 if (!PyArg_UnpackTuple(args
, "getattr", 2, 3, &v
, &name
, &dflt
))
811 #ifdef Py_USING_UNICODE
812 if (PyUnicode_Check(name
)) {
813 name
= _PyUnicode_AsDefaultEncodedString(name
, NULL
);
819 if (!PyString_Check(name
)) {
820 PyErr_SetString(PyExc_TypeError
,
821 "getattr(): attribute name must be string");
824 result
= PyObject_GetAttr(v
, name
);
825 if (result
== NULL
&& dflt
!= NULL
&&
826 PyErr_ExceptionMatches(PyExc_AttributeError
))
835 PyDoc_STRVAR(getattr_doc
,
836 "getattr(object, name[, default]) -> value\n\
838 Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.\n\
839 When a default argument is given, it is returned when the attribute doesn't\n\
840 exist; without it, an exception is raised in that case.");
844 builtin_globals(PyObject
*self
)
848 d
= PyEval_GetGlobals();
853 PyDoc_STRVAR(globals_doc
,
854 "globals() -> dictionary\n\
856 Return the dictionary containing the current scope's global variables.");
860 builtin_hasattr(PyObject
*self
, PyObject
*args
)
865 if (!PyArg_UnpackTuple(args
, "hasattr", 2, 2, &v
, &name
))
867 #ifdef Py_USING_UNICODE
868 if (PyUnicode_Check(name
)) {
869 name
= _PyUnicode_AsDefaultEncodedString(name
, NULL
);
875 if (!PyString_Check(name
)) {
876 PyErr_SetString(PyExc_TypeError
,
877 "hasattr(): attribute name must be string");
880 v
= PyObject_GetAttr(v
, name
);
882 if (!PyErr_ExceptionMatches(PyExc_Exception
))
895 PyDoc_STRVAR(hasattr_doc
,
896 "hasattr(object, name) -> bool\n\
898 Return whether the object has an attribute with the given name.\n\
899 (This is done by calling getattr(object, name) and catching exceptions.)");
903 builtin_id(PyObject
*self
, PyObject
*v
)
905 return PyLong_FromVoidPtr(v
);
909 "id(object) -> integer\n\
911 Return the identity of an object. This is guaranteed to be unique among\n\
912 simultaneously existing objects. (Hint: it's the object's memory address.)");
916 builtin_map(PyObject
*self
, PyObject
*args
)
919 PyObject
*it
; /* the iterator object */
920 int saw_StopIteration
; /* bool: did the iterator end? */
923 PyObject
*func
, *result
;
924 sequence
*seqs
= NULL
, *sqp
;
928 n
= PyTuple_Size(args
);
930 PyErr_SetString(PyExc_TypeError
,
931 "map() requires at least two args");
935 func
= PyTuple_GetItem(args
, 0);
938 if (func
== Py_None
) {
939 if (PyErr_WarnPy3k("map(None, ...) not supported in 3.x; "
940 "use list(...)", 1) < 0)
943 /* map(None, S) is the same as list(S). */
944 return PySequence_List(PyTuple_GetItem(args
, 1));
948 /* Get space for sequence descriptors. Must NULL out the iterator
949 * pointers so that jumping to Fail_2 later doesn't see trash.
951 if ((seqs
= PyMem_NEW(sequence
, n
)) == NULL
) {
955 for (i
= 0; i
< n
; ++i
) {
956 seqs
[i
].it
= (PyObject
*)NULL
;
957 seqs
[i
].saw_StopIteration
= 0;
960 /* Do a first pass to obtain iterators for the arguments, and set len
961 * to the largest of their lengths.
964 for (i
= 0, sqp
= seqs
; i
< n
; ++i
, ++sqp
) {
969 curseq
= PyTuple_GetItem(args
, i
+1);
970 sqp
->it
= PyObject_GetIter(curseq
);
971 if (sqp
->it
== NULL
) {
972 static char errmsg
[] =
973 "argument %d to map() must support iteration";
974 char errbuf
[sizeof(errmsg
) + 25];
975 PyOS_snprintf(errbuf
, sizeof(errbuf
), errmsg
, i
+2);
976 PyErr_SetString(PyExc_TypeError
, errbuf
);
981 curlen
= _PyObject_LengthHint(curseq
, 8);
986 /* Get space for the result list. */
987 if ((result
= (PyObject
*) PyList_New(len
)) == NULL
)
990 /* Iterate over the sequences until all have stopped. */
992 PyObject
*alist
, *item
=NULL
, *value
;
995 if (func
== Py_None
&& n
== 1)
997 else if ((alist
= PyTuple_New(n
)) == NULL
)
1000 for (j
= 0, sqp
= seqs
; j
< n
; ++j
, ++sqp
) {
1001 if (sqp
->saw_StopIteration
) {
1006 item
= PyIter_Next(sqp
->it
);
1010 if (PyErr_Occurred()) {
1016 sqp
->saw_StopIteration
= 1;
1020 PyTuple_SET_ITEM(alist
, j
, item
);
1028 if (numactive
== 0) {
1033 if (func
== Py_None
)
1036 value
= PyEval_CallObject(func
, alist
);
1042 int status
= PyList_Append(result
, value
);
1047 else if (PyList_SetItem(result
, i
, value
) < 0)
1051 if (i
< len
&& PyList_SetSlice(result
, i
, len
, NULL
) < 0)
1062 for (i
= 0; i
< n
; ++i
)
1063 Py_XDECREF(seqs
[i
].it
);
1068 PyDoc_STRVAR(map_doc
,
1069 "map(function, sequence[, sequence, ...]) -> list\n\
1071 Return a list of the results of applying the function to the items of\n\
1072 the argument sequence(s). If more than one sequence is given, the\n\
1073 function is called with an argument list consisting of the corresponding\n\
1074 item of each sequence, substituting None for missing values when not all\n\
1075 sequences have the same length. If the function is None, return a list of\n\
1076 the items of the sequence (or a list of tuples if more than one sequence).");
1080 builtin_next(PyObject
*self
, PyObject
*args
)
1083 PyObject
*def
= NULL
;
1085 if (!PyArg_UnpackTuple(args
, "next", 1, 2, &it
, &def
))
1087 if (!PyIter_Check(it
)) {
1088 PyErr_Format(PyExc_TypeError
,
1089 "%.200s object is not an iterator",
1090 it
->ob_type
->tp_name
);
1094 res
= (*it
->ob_type
->tp_iternext
)(it
);
1097 } else if (def
!= NULL
) {
1098 if (PyErr_Occurred()) {
1099 if (!PyErr_ExceptionMatches(PyExc_StopIteration
))
1105 } else if (PyErr_Occurred()) {
1108 PyErr_SetNone(PyExc_StopIteration
);
1113 PyDoc_STRVAR(next_doc
,
1114 "next(iterator[, default])\n\
1116 Return the next item from the iterator. If default is given and the iterator\n\
1117 is exhausted, it is returned instead of raising StopIteration.");
1121 builtin_setattr(PyObject
*self
, PyObject
*args
)
1127 if (!PyArg_UnpackTuple(args
, "setattr", 3, 3, &v
, &name
, &value
))
1129 if (PyObject_SetAttr(v
, name
, value
) != 0)
1135 PyDoc_STRVAR(setattr_doc
,
1136 "setattr(object, name, value)\n\
1138 Set a named attribute on an object; setattr(x, 'y', v) is equivalent to\n\
1143 builtin_delattr(PyObject
*self
, PyObject
*args
)
1148 if (!PyArg_UnpackTuple(args
, "delattr", 2, 2, &v
, &name
))
1150 if (PyObject_SetAttr(v
, name
, (PyObject
*)NULL
) != 0)
1156 PyDoc_STRVAR(delattr_doc
,
1157 "delattr(object, name)\n\
1159 Delete a named attribute on an object; delattr(x, 'y') is equivalent to\n\
1164 builtin_hash(PyObject
*self
, PyObject
*v
)
1168 x
= PyObject_Hash(v
);
1171 return PyInt_FromLong(x
);
1174 PyDoc_STRVAR(hash_doc
,
1175 "hash(object) -> integer\n\
1177 Return a hash value for the object. Two objects with the same value have\n\
1178 the same hash value. The reverse is not necessarily true, but likely.");
1182 builtin_hex(PyObject
*self
, PyObject
*v
)
1184 PyNumberMethods
*nb
;
1187 if ((nb
= v
->ob_type
->tp_as_number
) == NULL
||
1188 nb
->nb_hex
== NULL
) {
1189 PyErr_SetString(PyExc_TypeError
,
1190 "hex() argument can't be converted to hex");
1193 res
= (*nb
->nb_hex
)(v
);
1194 if (res
&& !PyString_Check(res
)) {
1195 PyErr_Format(PyExc_TypeError
,
1196 "__hex__ returned non-string (type %.200s)",
1197 res
->ob_type
->tp_name
);
1204 PyDoc_STRVAR(hex_doc
,
1205 "hex(number) -> string\n\
1207 Return the hexadecimal representation of an integer or long integer.");
1210 static PyObject
*builtin_raw_input(PyObject
*, PyObject
*);
1213 builtin_input(PyObject
*self
, PyObject
*args
)
1218 PyObject
*globals
, *locals
;
1221 line
= builtin_raw_input(self
, args
);
1224 if (!PyArg_Parse(line
, "s;embedded '\\0' in input line", &str
))
1226 while (*str
== ' ' || *str
== '\t')
1228 globals
= PyEval_GetGlobals();
1229 locals
= PyEval_GetLocals();
1230 if (PyDict_GetItemString(globals
, "__builtins__") == NULL
) {
1231 if (PyDict_SetItemString(globals
, "__builtins__",
1232 PyEval_GetBuiltins()) != 0)
1236 PyEval_MergeCompilerFlags(&cf
);
1237 res
= PyRun_StringFlags(str
, Py_eval_input
, globals
, locals
, &cf
);
1242 PyDoc_STRVAR(input_doc
,
1243 "input([prompt]) -> value\n\
1245 Equivalent to eval(raw_input(prompt)).");
1249 builtin_intern(PyObject
*self
, PyObject
*args
)
1252 if (!PyArg_ParseTuple(args
, "S:intern", &s
))
1254 if (!PyString_CheckExact(s
)) {
1255 PyErr_SetString(PyExc_TypeError
,
1256 "can't intern subclass of string");
1260 PyString_InternInPlace(&s
);
1264 PyDoc_STRVAR(intern_doc
,
1265 "intern(string) -> string\n\
1267 ``Intern'' the given string. This enters the string in the (global)\n\
1268 table of interned strings whose purpose is to speed up dictionary lookups.\n\
1269 Return the string itself or the previously interned string object with the\n\
1274 builtin_iter(PyObject
*self
, PyObject
*args
)
1276 PyObject
*v
, *w
= NULL
;
1278 if (!PyArg_UnpackTuple(args
, "iter", 1, 2, &v
, &w
))
1281 return PyObject_GetIter(v
);
1282 if (!PyCallable_Check(v
)) {
1283 PyErr_SetString(PyExc_TypeError
,
1284 "iter(v, w): v must be callable");
1287 return PyCallIter_New(v
, w
);
1290 PyDoc_STRVAR(iter_doc
,
1291 "iter(collection) -> iterator\n\
1292 iter(callable, sentinel) -> iterator\n\
1294 Get an iterator from an object. In the first form, the argument must\n\
1295 supply its own iterator, or be a sequence.\n\
1296 In the second form, the callable is called until it returns the sentinel.");
1300 builtin_len(PyObject
*self
, PyObject
*v
)
1304 res
= PyObject_Size(v
);
1305 if (res
< 0 && PyErr_Occurred())
1307 return PyInt_FromSsize_t(res
);
1310 PyDoc_STRVAR(len_doc
,
1311 "len(object) -> integer\n\
1313 Return the number of items of a sequence or mapping.");
1317 builtin_locals(PyObject
*self
)
1321 d
= PyEval_GetLocals();
1326 PyDoc_STRVAR(locals_doc
,
1327 "locals() -> dictionary\n\
1329 Update and return a dictionary containing the current scope's local variables.");
1333 min_max(PyObject
*args
, PyObject
*kwds
, int op
)
1335 PyObject
*v
, *it
, *item
, *val
, *maxitem
, *maxval
, *keyfunc
=NULL
;
1336 const char *name
= op
== Py_LT
? "min" : "max";
1338 if (PyTuple_Size(args
) > 1)
1340 else if (!PyArg_UnpackTuple(args
, (char *)name
, 1, 1, &v
))
1343 if (kwds
!= NULL
&& PyDict_Check(kwds
) && PyDict_Size(kwds
)) {
1344 keyfunc
= PyDict_GetItemString(kwds
, "key");
1345 if (PyDict_Size(kwds
)!=1 || keyfunc
== NULL
) {
1346 PyErr_Format(PyExc_TypeError
,
1347 "%s() got an unexpected keyword argument", name
);
1353 it
= PyObject_GetIter(v
);
1355 Py_XDECREF(keyfunc
);
1359 maxitem
= NULL
; /* the result */
1360 maxval
= NULL
; /* the value associated with the result */
1361 while (( item
= PyIter_Next(it
) )) {
1362 /* get the value from the key function */
1363 if (keyfunc
!= NULL
) {
1364 val
= PyObject_CallFunctionObjArgs(keyfunc
, item
, NULL
);
1368 /* no key function; the value is the item */
1374 /* maximum value and item are unset; set them */
1375 if (maxval
== NULL
) {
1379 /* maximum value and item are set; update them as necessary */
1381 int cmp
= PyObject_RichCompareBool(val
, maxval
, op
);
1383 goto Fail_it_item_and_val
;
1396 if (PyErr_Occurred())
1398 if (maxval
== NULL
) {
1399 PyErr_Format(PyExc_ValueError
,
1400 "%s() arg is an empty sequence", name
);
1401 assert(maxitem
== NULL
);
1406 Py_XDECREF(keyfunc
);
1409 Fail_it_item_and_val
:
1415 Py_XDECREF(maxitem
);
1417 Py_XDECREF(keyfunc
);
1422 builtin_min(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
1424 return min_max(args
, kwds
, Py_LT
);
1427 PyDoc_STRVAR(min_doc
,
1428 "min(iterable[, key=func]) -> value\n\
1429 min(a, b, c, ...[, key=func]) -> value\n\
1431 With a single iterable argument, return its smallest item.\n\
1432 With two or more arguments, return the smallest argument.");
1436 builtin_max(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
1438 return min_max(args
, kwds
, Py_GT
);
1441 PyDoc_STRVAR(max_doc
,
1442 "max(iterable[, key=func]) -> value\n\
1443 max(a, b, c, ...[, key=func]) -> value\n\
1445 With a single iterable argument, return its largest item.\n\
1446 With two or more arguments, return the largest argument.");
1450 builtin_oct(PyObject
*self
, PyObject
*v
)
1452 PyNumberMethods
*nb
;
1455 if (v
== NULL
|| (nb
= v
->ob_type
->tp_as_number
) == NULL
||
1456 nb
->nb_oct
== NULL
) {
1457 PyErr_SetString(PyExc_TypeError
,
1458 "oct() argument can't be converted to oct");
1461 res
= (*nb
->nb_oct
)(v
);
1462 if (res
&& !PyString_Check(res
)) {
1463 PyErr_Format(PyExc_TypeError
,
1464 "__oct__ returned non-string (type %.200s)",
1465 res
->ob_type
->tp_name
);
1472 PyDoc_STRVAR(oct_doc
,
1473 "oct(number) -> string\n\
1475 Return the octal representation of an integer or long integer.");
1479 builtin_open(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
1481 return PyObject_Call((PyObject
*)&PyFile_Type
, args
, kwds
);
1484 PyDoc_STRVAR(open_doc
,
1485 "open(name[, mode[, buffering]]) -> file object\n\
1487 Open a file using the file() type, returns a file object. This is the\n\
1488 preferred way to open a file.");
1492 builtin_ord(PyObject
*self
, PyObject
* obj
)
1497 if (PyString_Check(obj
)) {
1498 size
= PyString_GET_SIZE(obj
);
1500 ord
= (long)((unsigned char)*PyString_AS_STRING(obj
));
1501 return PyInt_FromLong(ord
);
1503 } else if (PyByteArray_Check(obj
)) {
1504 size
= PyByteArray_GET_SIZE(obj
);
1506 ord
= (long)((unsigned char)*PyByteArray_AS_STRING(obj
));
1507 return PyInt_FromLong(ord
);
1510 #ifdef Py_USING_UNICODE
1511 } else if (PyUnicode_Check(obj
)) {
1512 size
= PyUnicode_GET_SIZE(obj
);
1514 ord
= (long)*PyUnicode_AS_UNICODE(obj
);
1515 return PyInt_FromLong(ord
);
1519 PyErr_Format(PyExc_TypeError
,
1520 "ord() expected string of length 1, but " \
1521 "%.200s found", obj
->ob_type
->tp_name
);
1525 PyErr_Format(PyExc_TypeError
,
1526 "ord() expected a character, "
1527 "but string of length %zd found",
1532 PyDoc_STRVAR(ord_doc
,
1533 "ord(c) -> integer\n\
1535 Return the integer ordinal of a one-character string.");
1539 builtin_pow(PyObject
*self
, PyObject
*args
)
1541 PyObject
*v
, *w
, *z
= Py_None
;
1543 if (!PyArg_UnpackTuple(args
, "pow", 2, 3, &v
, &w
, &z
))
1545 return PyNumber_Power(v
, w
, z
);
1548 PyDoc_STRVAR(pow_doc
,
1549 "pow(x, y[, z]) -> number\n\
1551 With two arguments, equivalent to x**y. With three arguments,\n\
1552 equivalent to (x**y) % z, but may be more efficient (e.g. for longs).");
1556 builtin_print(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
1558 static char *kwlist
[] = {"sep", "end", "file", 0};
1559 static PyObject
*dummy_args
;
1560 PyObject
*sep
= NULL
, *end
= NULL
, *file
= NULL
;
1563 if (dummy_args
== NULL
) {
1564 if (!(dummy_args
= PyTuple_New(0)))
1567 if (!PyArg_ParseTupleAndKeywords(dummy_args
, kwds
, "|OOO:print",
1568 kwlist
, &sep
, &end
, &file
))
1570 if (file
== NULL
|| file
== Py_None
) {
1571 file
= PySys_GetObject("stdout");
1572 /* sys.stdout may be None when FILE* stdout isn't connected */
1573 if (file
== Py_None
)
1577 if (sep
&& sep
!= Py_None
&& !PyString_Check(sep
) &&
1578 !PyUnicode_Check(sep
)) {
1579 PyErr_Format(PyExc_TypeError
,
1580 "sep must be None, str or unicode, not %.200s",
1581 sep
->ob_type
->tp_name
);
1584 if (end
&& end
!= Py_None
&& !PyString_Check(end
) &&
1585 !PyUnicode_Check(end
)) {
1586 PyErr_Format(PyExc_TypeError
,
1587 "end must be None, str or unicode, not %.200s",
1588 end
->ob_type
->tp_name
);
1592 for (i
= 0; i
< PyTuple_Size(args
); i
++) {
1594 if (sep
== NULL
|| sep
== Py_None
)
1595 err
= PyFile_WriteString(" ", file
);
1597 err
= PyFile_WriteObject(sep
, file
,
1602 err
= PyFile_WriteObject(PyTuple_GetItem(args
, i
), file
,
1608 if (end
== NULL
|| end
== Py_None
)
1609 err
= PyFile_WriteString("\n", file
);
1611 err
= PyFile_WriteObject(end
, file
, Py_PRINT_RAW
);
1618 PyDoc_STRVAR(print_doc
,
1619 "print(value, ..., sep=' ', end='\\n', file=sys.stdout)\n\
1621 Prints the values to a stream, or to sys.stdout by default.\n\
1622 Optional keyword arguments:\n\
1623 file: a file-like object (stream); defaults to the current sys.stdout.\n\
1624 sep: string inserted between values, default a space.\n\
1625 end: string appended after the last value, default a newline.");
1628 /* Return number of items in range (lo, hi, step), when arguments are
1629 * PyInt or PyLong objects. step > 0 required. Return a value < 0 if
1630 * & only if the true value is too large to fit in a signed long.
1631 * Arguments MUST return 1 with either PyInt_Check() or
1632 * PyLong_Check(). Return -1 when there is an error.
1635 get_len_of_range_longs(PyObject
*lo
, PyObject
*hi
, PyObject
*step
)
1637 /* -------------------------------------------------------------
1638 Algorithm is equal to that of get_len_of_range(), but it operates
1639 on PyObjects (which are assumed to be PyLong or PyInt objects).
1640 ---------------------------------------------------------------*/
1642 PyObject
*diff
= NULL
;
1643 PyObject
*one
= NULL
;
1644 PyObject
*tmp1
= NULL
, *tmp2
= NULL
, *tmp3
= NULL
;
1645 /* holds sub-expression evaluations */
1647 /* if (lo >= hi), return length of 0. */
1648 if (PyObject_Compare(lo
, hi
) >= 0)
1651 if ((one
= PyLong_FromLong(1L)) == NULL
)
1654 if ((tmp1
= PyNumber_Subtract(hi
, lo
)) == NULL
)
1657 if ((diff
= PyNumber_Subtract(tmp1
, one
)) == NULL
)
1660 if ((tmp2
= PyNumber_FloorDivide(diff
, step
)) == NULL
)
1663 if ((tmp3
= PyNumber_Add(tmp2
, one
)) == NULL
)
1666 n
= PyLong_AsLong(tmp3
);
1667 if (PyErr_Occurred()) { /* Check for Overflow */
1688 /* An extension of builtin_range() that handles the case when PyLong
1689 * arguments are given. */
1691 handle_range_longs(PyObject
*self
, PyObject
*args
)
1694 PyObject
*ihigh
= NULL
;
1695 PyObject
*istep
= NULL
;
1697 PyObject
*curnum
= NULL
;
1703 PyObject
*zero
= PyLong_FromLong(0);
1708 if (!PyArg_UnpackTuple(args
, "range", 1, 3, &ilow
, &ihigh
, &istep
)) {
1713 /* Figure out which way we were called, supply defaults, and be
1714 * sure to incref everything so that the decrefs at the end
1717 assert(ilow
!= NULL
);
1718 if (ihigh
== NULL
) {
1719 /* only 1 arg -- it's the upper limit */
1723 assert(ihigh
!= NULL
);
1726 /* ihigh correct now; do ilow */
1731 /* ilow and ihigh correct now; do istep */
1732 if (istep
== NULL
) {
1733 istep
= PyLong_FromLong(1L);
1741 if (!PyInt_Check(ilow
) && !PyLong_Check(ilow
)) {
1742 PyErr_Format(PyExc_TypeError
,
1743 "range() integer start argument expected, got %s.",
1744 ilow
->ob_type
->tp_name
);
1748 if (!PyInt_Check(ihigh
) && !PyLong_Check(ihigh
)) {
1749 PyErr_Format(PyExc_TypeError
,
1750 "range() integer end argument expected, got %s.",
1751 ihigh
->ob_type
->tp_name
);
1755 if (!PyInt_Check(istep
) && !PyLong_Check(istep
)) {
1756 PyErr_Format(PyExc_TypeError
,
1757 "range() integer step argument expected, got %s.",
1758 istep
->ob_type
->tp_name
);
1762 if (PyObject_Cmp(istep
, zero
, &cmp_result
) == -1)
1764 if (cmp_result
== 0) {
1765 PyErr_SetString(PyExc_ValueError
,
1766 "range() step argument must not be zero");
1771 bign
= get_len_of_range_longs(ilow
, ihigh
, istep
);
1773 PyObject
*neg_istep
= PyNumber_Negative(istep
);
1774 if (neg_istep
== NULL
)
1776 bign
= get_len_of_range_longs(ihigh
, ilow
, neg_istep
);
1777 Py_DECREF(neg_istep
);
1781 if (bign
< 0 || (long)n
!= bign
) {
1782 PyErr_SetString(PyExc_OverflowError
,
1783 "range() result has too many items");
1794 for (i
= 0; i
< n
; i
++) {
1795 PyObject
*w
= PyNumber_Long(curnum
);
1800 PyList_SET_ITEM(v
, i
, w
);
1802 tmp_num
= PyNumber_Add(curnum
, istep
);
1803 if (tmp_num
== NULL
)
1826 /* Return number of items in range/xrange (lo, hi, step). step > 0
1827 * required. Return a value < 0 if & only if the true value is too
1828 * large to fit in a signed long.
1831 get_len_of_range(long lo
, long hi
, long step
)
1833 /* -------------------------------------------------------------
1834 If lo >= hi, the range is empty.
1835 Else if n values are in the range, the last one is
1836 lo + (n-1)*step, which must be <= hi-1. Rearranging,
1837 n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives
1838 the proper value. Since lo < hi in this case, hi-lo-1 >= 0, so
1839 the RHS is non-negative and so truncation is the same as the
1840 floor. Letting M be the largest positive long, the worst case
1841 for the RHS numerator is hi=M, lo=-M-1, and then
1842 hi-lo-1 = M-(-M-1)-1 = 2*M. Therefore unsigned long has enough
1843 precision to compute the RHS exactly.
1844 ---------------------------------------------------------------*/
1847 unsigned long uhi
= (unsigned long)hi
;
1848 unsigned long ulo
= (unsigned long)lo
;
1849 unsigned long diff
= uhi
- ulo
- 1;
1850 n
= (long)(diff
/ (unsigned long)step
+ 1);
1856 builtin_range(PyObject
*self
, PyObject
*args
)
1858 long ilow
= 0, ihigh
= 0, istep
= 1;
1864 if (PyTuple_Size(args
) <= 1) {
1865 if (!PyArg_ParseTuple(args
,
1866 "l;range() requires 1-3 int arguments",
1869 return handle_range_longs(self
, args
);
1873 if (!PyArg_ParseTuple(args
,
1874 "ll|l;range() requires 1-3 int arguments",
1875 &ilow
, &ihigh
, &istep
)) {
1877 return handle_range_longs(self
, args
);
1881 PyErr_SetString(PyExc_ValueError
,
1882 "range() step argument must not be zero");
1886 bign
= get_len_of_range(ilow
, ihigh
, istep
);
1888 bign
= get_len_of_range(ihigh
, ilow
, -istep
);
1890 if (bign
< 0 || (long)n
!= bign
) {
1891 PyErr_SetString(PyExc_OverflowError
,
1892 "range() result has too many items");
1898 for (i
= 0; i
< n
; i
++) {
1899 PyObject
*w
= PyInt_FromLong(ilow
);
1904 PyList_SET_ITEM(v
, i
, w
);
1910 PyDoc_STRVAR(range_doc
,
1911 "range([start,] stop[, step]) -> list of integers\n\
1913 Return a list containing an arithmetic progression of integers.\n\
1914 range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.\n\
1915 When step is given, it specifies the increment (or decrement).\n\
1916 For example, range(4) returns [0, 1, 2, 3]. The end point is omitted!\n\
1917 These are exactly the valid indices for a list of 4 elements.");
1921 builtin_raw_input(PyObject
*self
, PyObject
*args
)
1924 PyObject
*fin
= PySys_GetObject("stdin");
1925 PyObject
*fout
= PySys_GetObject("stdout");
1927 if (!PyArg_UnpackTuple(args
, "[raw_]input", 0, 1, &v
))
1931 PyErr_SetString(PyExc_RuntimeError
, "[raw_]input: lost sys.stdin");
1935 PyErr_SetString(PyExc_RuntimeError
, "[raw_]input: lost sys.stdout");
1938 if (PyFile_SoftSpace(fout
, 0)) {
1939 if (PyFile_WriteString(" ", fout
) != 0)
1942 if (PyFile_AsFile(fin
) && PyFile_AsFile(fout
)
1943 && isatty(fileno(PyFile_AsFile(fin
)))
1944 && isatty(fileno(PyFile_AsFile(fout
)))) {
1950 po
= PyObject_Str(v
);
1953 prompt
= PyString_AsString(po
);
1961 s
= PyOS_Readline(PyFile_AsFile(fin
), PyFile_AsFile(fout
),
1965 if (!PyErr_Occurred())
1966 PyErr_SetNone(PyExc_KeyboardInterrupt
);
1970 PyErr_SetNone(PyExc_EOFError
);
1973 else { /* strip trailing '\n' */
1974 size_t len
= strlen(s
);
1975 if (len
> PY_SSIZE_T_MAX
) {
1976 PyErr_SetString(PyExc_OverflowError
,
1977 "[raw_]input: input too long");
1981 result
= PyString_FromStringAndSize(s
, len
-1);
1988 if (PyFile_WriteObject(v
, fout
, Py_PRINT_RAW
) != 0)
1991 return PyFile_GetLine(fin
, -1);
1994 PyDoc_STRVAR(raw_input_doc
,
1995 "raw_input([prompt]) -> string\n\
1997 Read a string from standard input. The trailing newline is stripped.\n\
1998 If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.\n\
1999 On Unix, GNU readline is used if enabled. The prompt string, if given,\n\
2000 is printed without a trailing newline before reading.");
2004 builtin_reduce(PyObject
*self
, PyObject
*args
)
2006 static PyObject
*functools_reduce
= NULL
;
2008 if (PyErr_WarnPy3k("reduce() not supported in 3.x; "
2009 "use functools.reduce()", 1) < 0)
2012 if (functools_reduce
== NULL
) {
2013 PyObject
*functools
= PyImport_ImportModule("functools");
2014 if (functools
== NULL
)
2016 functools_reduce
= PyObject_GetAttrString(functools
, "reduce");
2017 Py_DECREF(functools
);
2018 if (functools_reduce
== NULL
)
2021 return PyObject_Call(functools_reduce
, args
, NULL
);
2024 PyDoc_STRVAR(reduce_doc
,
2025 "reduce(function, sequence[, initial]) -> value\n\
2027 Apply a function of two arguments cumulatively to the items of a sequence,\n\
2028 from left to right, so as to reduce the sequence to a single value.\n\
2029 For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates\n\
2030 ((((1+2)+3)+4)+5). If initial is present, it is placed before the items\n\
2031 of the sequence in the calculation, and serves as a default when the\n\
2032 sequence is empty.");
2036 builtin_reload(PyObject
*self
, PyObject
*v
)
2038 if (PyErr_WarnPy3k("In 3.x, reload() is renamed to imp.reload()",
2042 return PyImport_ReloadModule(v
);
2045 PyDoc_STRVAR(reload_doc
,
2046 "reload(module) -> module\n\
2048 Reload the module. The module must have been successfully imported before.");
2052 builtin_repr(PyObject
*self
, PyObject
*v
)
2054 return PyObject_Repr(v
);
2057 PyDoc_STRVAR(repr_doc
,
2058 "repr(object) -> string\n\
2060 Return the canonical string representation of the object.\n\
2061 For most object types, eval(repr(object)) == object.");
2065 builtin_round(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
2071 static char *kwlist
[] = {"number", "ndigits", 0};
2073 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "d|i:round",
2074 kwlist
, &number
, &ndigits
))
2085 number
= floor(number
+ 0.5);
2087 number
= ceil(number
- 0.5);
2092 return PyFloat_FromDouble(number
);
2095 PyDoc_STRVAR(round_doc
,
2096 "round(number[, ndigits]) -> floating point number\n\
2098 Round a number to a given precision in decimal digits (default 0 digits).\n\
2099 This always returns a floating point number. Precision may be negative.");
2102 builtin_sorted(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
2104 PyObject
*newlist
, *v
, *seq
, *compare
=NULL
, *keyfunc
=NULL
, *newargs
;
2106 static char *kwlist
[] = {"iterable", "cmp", "key", "reverse", 0};
2109 /* args 1-4 should match listsort in Objects/listobject.c */
2110 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "O|OOi:sorted",
2111 kwlist
, &seq
, &compare
, &keyfunc
, &reverse
))
2114 newlist
= PySequence_List(seq
);
2115 if (newlist
== NULL
)
2118 callable
= PyObject_GetAttrString(newlist
, "sort");
2119 if (callable
== NULL
) {
2124 newargs
= PyTuple_GetSlice(args
, 1, 4);
2125 if (newargs
== NULL
) {
2127 Py_DECREF(callable
);
2131 v
= PyObject_Call(callable
, newargs
, kwds
);
2133 Py_DECREF(callable
);
2142 PyDoc_STRVAR(sorted_doc
,
2143 "sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list");
2146 builtin_vars(PyObject
*self
, PyObject
*args
)
2151 if (!PyArg_UnpackTuple(args
, "vars", 0, 1, &v
))
2154 d
= PyEval_GetLocals();
2156 if (!PyErr_Occurred())
2157 PyErr_SetString(PyExc_SystemError
,
2158 "vars(): no locals!?");
2164 d
= PyObject_GetAttrString(v
, "__dict__");
2166 PyErr_SetString(PyExc_TypeError
,
2167 "vars() argument must have __dict__ attribute");
2174 PyDoc_STRVAR(vars_doc
,
2175 "vars([object]) -> dictionary\n\
2177 Without arguments, equivalent to locals().\n\
2178 With an argument, equivalent to object.__dict__.");
2182 builtin_sum(PyObject
*self
, PyObject
*args
)
2185 PyObject
*result
= NULL
;
2186 PyObject
*temp
, *item
, *iter
;
2188 if (!PyArg_UnpackTuple(args
, "sum", 1, 2, &seq
, &result
))
2191 iter
= PyObject_GetIter(seq
);
2195 if (result
== NULL
) {
2196 result
= PyInt_FromLong(0);
2197 if (result
== NULL
) {
2202 /* reject string values for 'start' parameter */
2203 if (PyObject_TypeCheck(result
, &PyBaseString_Type
)) {
2204 PyErr_SetString(PyExc_TypeError
,
2205 "sum() can't sum strings [use ''.join(seq) instead]");
2213 /* Fast addition by keeping temporary sums in C instead of new Python objects.
2214 Assumes all inputs are the same type. If the assumption fails, default
2215 to the more general routine.
2217 if (PyInt_CheckExact(result
)) {
2218 long i_result
= PyInt_AS_LONG(result
);
2221 while(result
== NULL
) {
2222 item
= PyIter_Next(iter
);
2225 if (PyErr_Occurred())
2227 return PyInt_FromLong(i_result
);
2229 if (PyInt_CheckExact(item
)) {
2230 long b
= PyInt_AS_LONG(item
);
2231 long x
= i_result
+ b
;
2232 if ((x
^i_result
) >= 0 || (x
^b
) >= 0) {
2238 /* Either overflowed or is not an int. Restore real objects and process normally */
2239 result
= PyInt_FromLong(i_result
);
2240 temp
= PyNumber_Add(result
, item
);
2244 if (result
== NULL
) {
2251 if (PyFloat_CheckExact(result
)) {
2252 double f_result
= PyFloat_AS_DOUBLE(result
);
2255 while(result
== NULL
) {
2256 item
= PyIter_Next(iter
);
2259 if (PyErr_Occurred())
2261 return PyFloat_FromDouble(f_result
);
2263 if (PyFloat_CheckExact(item
)) {
2264 PyFPE_START_PROTECT("add", Py_DECREF(item
); Py_DECREF(iter
); return 0)
2265 f_result
+= PyFloat_AS_DOUBLE(item
);
2266 PyFPE_END_PROTECT(f_result
)
2270 if (PyInt_CheckExact(item
)) {
2271 PyFPE_START_PROTECT("add", Py_DECREF(item
); Py_DECREF(iter
); return 0)
2272 f_result
+= (double)PyInt_AS_LONG(item
);
2273 PyFPE_END_PROTECT(f_result
)
2277 result
= PyFloat_FromDouble(f_result
);
2278 temp
= PyNumber_Add(result
, item
);
2282 if (result
== NULL
) {
2291 item
= PyIter_Next(iter
);
2293 /* error, or end-of-sequence */
2294 if (PyErr_Occurred()) {
2300 temp
= PyNumber_Add(result
, item
);
2311 PyDoc_STRVAR(sum_doc
,
2312 "sum(sequence[, start]) -> value\n\
2314 Returns the sum of a sequence of numbers (NOT strings) plus the value\n\
2315 of parameter 'start' (which defaults to 0). When the sequence is\n\
2316 empty, returns start.");
2320 builtin_isinstance(PyObject
*self
, PyObject
*args
)
2326 if (!PyArg_UnpackTuple(args
, "isinstance", 2, 2, &inst
, &cls
))
2329 retval
= PyObject_IsInstance(inst
, cls
);
2332 return PyBool_FromLong(retval
);
2335 PyDoc_STRVAR(isinstance_doc
,
2336 "isinstance(object, class-or-type-or-tuple) -> bool\n\
2338 Return whether an object is an instance of a class or of a subclass thereof.\n\
2339 With a type as second argument, return whether that is the object's type.\n\
2340 The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for\n\
2341 isinstance(x, A) or isinstance(x, B) or ... (etc.).");
2345 builtin_issubclass(PyObject
*self
, PyObject
*args
)
2351 if (!PyArg_UnpackTuple(args
, "issubclass", 2, 2, &derived
, &cls
))
2354 retval
= PyObject_IsSubclass(derived
, cls
);
2357 return PyBool_FromLong(retval
);
2360 PyDoc_STRVAR(issubclass_doc
,
2361 "issubclass(C, B) -> bool\n\
2363 Return whether class C is a subclass (i.e., a derived class) of class B.\n\
2364 When using a tuple as the second argument issubclass(X, (A, B, ...)),\n\
2365 is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.).");
2369 builtin_zip(PyObject
*self
, PyObject
*args
)
2372 const Py_ssize_t itemsize
= PySequence_Length(args
);
2374 PyObject
*itlist
; /* tuple of iterators */
2375 Py_ssize_t len
; /* guess at result length */
2378 return PyList_New(0);
2380 /* args must be a tuple */
2381 assert(PyTuple_Check(args
));
2383 /* Guess at result length: the shortest of the input lengths.
2384 If some argument refuses to say, we refuse to guess too, lest
2385 an argument like xrange(sys.maxint) lead us astray.*/
2386 len
= -1; /* unknown */
2387 for (i
= 0; i
< itemsize
; ++i
) {
2388 PyObject
*item
= PyTuple_GET_ITEM(args
, i
);
2389 Py_ssize_t thislen
= _PyObject_LengthHint(item
, -1);
2394 else if (len
< 0 || thislen
< len
)
2398 /* allocate result list */
2400 len
= 10; /* arbitrary */
2401 if ((ret
= PyList_New(len
)) == NULL
)
2404 /* obtain iterators */
2405 itlist
= PyTuple_New(itemsize
);
2408 for (i
= 0; i
< itemsize
; ++i
) {
2409 PyObject
*item
= PyTuple_GET_ITEM(args
, i
);
2410 PyObject
*it
= PyObject_GetIter(item
);
2412 if (PyErr_ExceptionMatches(PyExc_TypeError
))
2413 PyErr_Format(PyExc_TypeError
,
2414 "zip argument #%zd must support iteration",
2416 goto Fail_ret_itlist
;
2418 PyTuple_SET_ITEM(itlist
, i
, it
);
2421 /* build result into ret list */
2422 for (i
= 0; ; ++i
) {
2424 PyObject
*next
= PyTuple_New(itemsize
);
2426 goto Fail_ret_itlist
;
2428 for (j
= 0; j
< itemsize
; j
++) {
2429 PyObject
*it
= PyTuple_GET_ITEM(itlist
, j
);
2430 PyObject
*item
= PyIter_Next(it
);
2432 if (PyErr_Occurred()) {
2440 PyTuple_SET_ITEM(next
, j
, item
);
2444 PyList_SET_ITEM(ret
, i
, next
);
2446 int status
= PyList_Append(ret
, next
);
2450 goto Fail_ret_itlist
;
2455 if (ret
!= NULL
&& i
< len
) {
2456 /* The list is too big. */
2457 if (PyList_SetSlice(ret
, i
, len
, NULL
) < 0)
2470 PyDoc_STRVAR(zip_doc
,
2471 "zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]\n\
2473 Return a list of tuples, where each tuple contains the i-th element\n\
2474 from each of the argument sequences. The returned list is truncated\n\
2475 in length to the length of the shortest argument sequence.");
2478 static PyMethodDef builtin_methods
[] = {
2479 {"__import__", (PyCFunction
)builtin___import__
, METH_VARARGS
| METH_KEYWORDS
, import_doc
},
2480 {"abs", builtin_abs
, METH_O
, abs_doc
},
2481 {"all", builtin_all
, METH_O
, all_doc
},
2482 {"any", builtin_any
, METH_O
, any_doc
},
2483 {"apply", builtin_apply
, METH_VARARGS
, apply_doc
},
2484 {"bin", builtin_bin
, METH_O
, bin_doc
},
2485 {"callable", builtin_callable
, METH_O
, callable_doc
},
2486 {"chr", builtin_chr
, METH_VARARGS
, chr_doc
},
2487 {"cmp", builtin_cmp
, METH_VARARGS
, cmp_doc
},
2488 {"coerce", builtin_coerce
, METH_VARARGS
, coerce_doc
},
2489 {"compile", (PyCFunction
)builtin_compile
, METH_VARARGS
| METH_KEYWORDS
, compile_doc
},
2490 {"delattr", builtin_delattr
, METH_VARARGS
, delattr_doc
},
2491 {"dir", builtin_dir
, METH_VARARGS
, dir_doc
},
2492 {"divmod", builtin_divmod
, METH_VARARGS
, divmod_doc
},
2493 {"eval", builtin_eval
, METH_VARARGS
, eval_doc
},
2494 {"execfile", builtin_execfile
, METH_VARARGS
, execfile_doc
},
2495 {"filter", builtin_filter
, METH_VARARGS
, filter_doc
},
2496 {"format", builtin_format
, METH_VARARGS
, format_doc
},
2497 {"getattr", builtin_getattr
, METH_VARARGS
, getattr_doc
},
2498 {"globals", (PyCFunction
)builtin_globals
, METH_NOARGS
, globals_doc
},
2499 {"hasattr", builtin_hasattr
, METH_VARARGS
, hasattr_doc
},
2500 {"hash", builtin_hash
, METH_O
, hash_doc
},
2501 {"hex", builtin_hex
, METH_O
, hex_doc
},
2502 {"id", builtin_id
, METH_O
, id_doc
},
2503 {"input", builtin_input
, METH_VARARGS
, input_doc
},
2504 {"intern", builtin_intern
, METH_VARARGS
, intern_doc
},
2505 {"isinstance", builtin_isinstance
, METH_VARARGS
, isinstance_doc
},
2506 {"issubclass", builtin_issubclass
, METH_VARARGS
, issubclass_doc
},
2507 {"iter", builtin_iter
, METH_VARARGS
, iter_doc
},
2508 {"len", builtin_len
, METH_O
, len_doc
},
2509 {"locals", (PyCFunction
)builtin_locals
, METH_NOARGS
, locals_doc
},
2510 {"map", builtin_map
, METH_VARARGS
, map_doc
},
2511 {"max", (PyCFunction
)builtin_max
, METH_VARARGS
| METH_KEYWORDS
, max_doc
},
2512 {"min", (PyCFunction
)builtin_min
, METH_VARARGS
| METH_KEYWORDS
, min_doc
},
2513 {"next", builtin_next
, METH_VARARGS
, next_doc
},
2514 {"oct", builtin_oct
, METH_O
, oct_doc
},
2515 {"open", (PyCFunction
)builtin_open
, METH_VARARGS
| METH_KEYWORDS
, open_doc
},
2516 {"ord", builtin_ord
, METH_O
, ord_doc
},
2517 {"pow", builtin_pow
, METH_VARARGS
, pow_doc
},
2518 {"print", (PyCFunction
)builtin_print
, METH_VARARGS
| METH_KEYWORDS
, print_doc
},
2519 {"range", builtin_range
, METH_VARARGS
, range_doc
},
2520 {"raw_input", builtin_raw_input
, METH_VARARGS
, raw_input_doc
},
2521 {"reduce", builtin_reduce
, METH_VARARGS
, reduce_doc
},
2522 {"reload", builtin_reload
, METH_O
, reload_doc
},
2523 {"repr", builtin_repr
, METH_O
, repr_doc
},
2524 {"round", (PyCFunction
)builtin_round
, METH_VARARGS
| METH_KEYWORDS
, round_doc
},
2525 {"setattr", builtin_setattr
, METH_VARARGS
, setattr_doc
},
2526 {"sorted", (PyCFunction
)builtin_sorted
, METH_VARARGS
| METH_KEYWORDS
, sorted_doc
},
2527 {"sum", builtin_sum
, METH_VARARGS
, sum_doc
},
2528 #ifdef Py_USING_UNICODE
2529 {"unichr", builtin_unichr
, METH_VARARGS
, unichr_doc
},
2531 {"vars", builtin_vars
, METH_VARARGS
, vars_doc
},
2532 {"zip", builtin_zip
, METH_VARARGS
, zip_doc
},
2536 PyDoc_STRVAR(builtin_doc
,
2537 "Built-in functions, exceptions, and other objects.\n\
2539 Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices.");
2542 _PyBuiltin_Init(void)
2544 PyObject
*mod
, *dict
, *debug
;
2545 mod
= Py_InitModule4("__builtin__", builtin_methods
,
2546 builtin_doc
, (PyObject
*)NULL
,
2547 PYTHON_API_VERSION
);
2550 dict
= PyModule_GetDict(mod
);
2552 #ifdef Py_TRACE_REFS
2553 /* __builtin__ exposes a number of statically allocated objects
2554 * that, before this code was added in 2.3, never showed up in
2555 * the list of "all objects" maintained by Py_TRACE_REFS. As a
2556 * result, programs leaking references to None and False (etc)
2557 * couldn't be diagnosed by examining sys.getobjects(0).
2559 #define ADD_TO_ALL(OBJECT) _Py_AddToAllObjects((PyObject *)(OBJECT), 0)
2561 #define ADD_TO_ALL(OBJECT) (void)0
2564 #define SETBUILTIN(NAME, OBJECT) \
2565 if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0) \
2569 SETBUILTIN("None", Py_None
);
2570 SETBUILTIN("Ellipsis", Py_Ellipsis
);
2571 SETBUILTIN("NotImplemented", Py_NotImplemented
);
2572 SETBUILTIN("False", Py_False
);
2573 SETBUILTIN("True", Py_True
);
2574 SETBUILTIN("basestring", &PyBaseString_Type
);
2575 SETBUILTIN("bool", &PyBool_Type
);
2576 SETBUILTIN("memoryview", &PyMemoryView_Type
);
2577 SETBUILTIN("bytearray", &PyByteArray_Type
);
2578 SETBUILTIN("bytes", &PyString_Type
);
2579 SETBUILTIN("buffer", &PyBuffer_Type
);
2580 SETBUILTIN("classmethod", &PyClassMethod_Type
);
2581 #ifndef WITHOUT_COMPLEX
2582 SETBUILTIN("complex", &PyComplex_Type
);
2584 SETBUILTIN("dict", &PyDict_Type
);
2585 SETBUILTIN("enumerate", &PyEnum_Type
);
2586 SETBUILTIN("file", &PyFile_Type
);
2587 SETBUILTIN("float", &PyFloat_Type
);
2588 SETBUILTIN("frozenset", &PyFrozenSet_Type
);
2589 SETBUILTIN("property", &PyProperty_Type
);
2590 SETBUILTIN("int", &PyInt_Type
);
2591 SETBUILTIN("list", &PyList_Type
);
2592 SETBUILTIN("long", &PyLong_Type
);
2593 SETBUILTIN("object", &PyBaseObject_Type
);
2594 SETBUILTIN("reversed", &PyReversed_Type
);
2595 SETBUILTIN("set", &PySet_Type
);
2596 SETBUILTIN("slice", &PySlice_Type
);
2597 SETBUILTIN("staticmethod", &PyStaticMethod_Type
);
2598 SETBUILTIN("str", &PyString_Type
);
2599 SETBUILTIN("super", &PySuper_Type
);
2600 SETBUILTIN("tuple", &PyTuple_Type
);
2601 SETBUILTIN("type", &PyType_Type
);
2602 SETBUILTIN("xrange", &PyRange_Type
);
2603 #ifdef Py_USING_UNICODE
2604 SETBUILTIN("unicode", &PyUnicode_Type
);
2606 debug
= PyBool_FromLong(Py_OptimizeFlag
== 0);
2607 if (PyDict_SetItemString(dict
, "__debug__", debug
) < 0) {
2618 /* Helper for filter(): filter a tuple through a function */
2621 filtertuple(PyObject
*func
, PyObject
*tuple
)
2625 Py_ssize_t len
= PyTuple_Size(tuple
);
2628 if (PyTuple_CheckExact(tuple
))
2631 tuple
= PyTuple_New(0);
2635 if ((result
= PyTuple_New(len
)) == NULL
)
2638 for (i
= j
= 0; i
< len
; ++i
) {
2639 PyObject
*item
, *good
;
2642 if (tuple
->ob_type
->tp_as_sequence
&&
2643 tuple
->ob_type
->tp_as_sequence
->sq_item
) {
2644 item
= tuple
->ob_type
->tp_as_sequence
->sq_item(tuple
, i
);
2648 PyErr_SetString(PyExc_TypeError
, "filter(): unsubscriptable tuple");
2651 if (func
== Py_None
) {
2656 PyObject
*arg
= PyTuple_Pack(1, item
);
2661 good
= PyEval_CallObject(func
, arg
);
2668 ok
= PyObject_IsTrue(good
);
2671 if (PyTuple_SetItem(result
, j
++, item
) < 0)
2678 if (_PyTuple_Resize(&result
, j
) < 0)
2689 /* Helper for filter(): filter a string through a function */
2692 filterstring(PyObject
*func
, PyObject
*strobj
)
2696 Py_ssize_t len
= PyString_Size(strobj
);
2697 Py_ssize_t outlen
= len
;
2699 if (func
== Py_None
) {
2700 /* If it's a real string we can return the original,
2701 * as no character is ever false and __getitem__
2702 * does return this character. If it's a subclass
2703 * we must go through the __getitem__ loop */
2704 if (PyString_CheckExact(strobj
)) {
2709 if ((result
= PyString_FromStringAndSize(NULL
, len
)) == NULL
)
2712 for (i
= j
= 0; i
< len
; ++i
) {
2716 item
= (*strobj
->ob_type
->tp_as_sequence
->sq_item
)(strobj
, i
);
2719 if (func
==Py_None
) {
2722 PyObject
*arg
, *good
;
2723 arg
= PyTuple_Pack(1, item
);
2728 good
= PyEval_CallObject(func
, arg
);
2734 ok
= PyObject_IsTrue(good
);
2739 if (!PyString_Check(item
)) {
2740 PyErr_SetString(PyExc_TypeError
, "can't filter str to str:"
2741 " __getitem__ returned different type");
2745 reslen
= PyString_GET_SIZE(item
);
2747 PyString_AS_STRING(result
)[j
++] =
2748 PyString_AS_STRING(item
)[0];
2750 /* do we need more space? */
2751 Py_ssize_t need
= j
;
2753 /* calculate space requirements while checking for overflow */
2754 if (need
> PY_SSIZE_T_MAX
- reslen
) {
2761 if (need
> PY_SSIZE_T_MAX
- len
) {
2773 need
= need
- i
- 1;
2776 assert(outlen
>= 0);
2778 if (need
> outlen
) {
2779 /* overallocate, to avoid reallocations */
2780 if (outlen
> PY_SSIZE_T_MAX
/ 2) {
2785 if (need
<2*outlen
) {
2788 if (_PyString_Resize(&result
, need
)) {
2795 PyString_AS_STRING(result
) + j
,
2796 PyString_AS_STRING(item
),
2806 _PyString_Resize(&result
, j
);
2815 #ifdef Py_USING_UNICODE
2816 /* Helper for filter(): filter a Unicode object through a function */
2819 filterunicode(PyObject
*func
, PyObject
*strobj
)
2822 register Py_ssize_t i
, j
;
2823 Py_ssize_t len
= PyUnicode_GetSize(strobj
);
2824 Py_ssize_t outlen
= len
;
2826 if (func
== Py_None
) {
2827 /* If it's a real string we can return the original,
2828 * as no character is ever false and __getitem__
2829 * does return this character. If it's a subclass
2830 * we must go through the __getitem__ loop */
2831 if (PyUnicode_CheckExact(strobj
)) {
2836 if ((result
= PyUnicode_FromUnicode(NULL
, len
)) == NULL
)
2839 for (i
= j
= 0; i
< len
; ++i
) {
2840 PyObject
*item
, *arg
, *good
;
2843 item
= (*strobj
->ob_type
->tp_as_sequence
->sq_item
)(strobj
, i
);
2846 if (func
== Py_None
) {
2849 arg
= PyTuple_Pack(1, item
);
2854 good
= PyEval_CallObject(func
, arg
);
2860 ok
= PyObject_IsTrue(good
);
2865 if (!PyUnicode_Check(item
)) {
2866 PyErr_SetString(PyExc_TypeError
,
2867 "can't filter unicode to unicode:"
2868 " __getitem__ returned different type");
2872 reslen
= PyUnicode_GET_SIZE(item
);
2874 PyUnicode_AS_UNICODE(result
)[j
++] =
2875 PyUnicode_AS_UNICODE(item
)[0];
2877 /* do we need more space? */
2878 Py_ssize_t need
= j
+ reslen
+ len
- i
- 1;
2880 /* check that didnt overflow */
2881 if ((j
> PY_SSIZE_T_MAX
- reslen
) ||
2882 ((j
+ reslen
) > PY_SSIZE_T_MAX
- len
) ||
2883 ((j
+ reslen
+ len
) < i
) ||
2884 ((j
+ reslen
+ len
- i
) <= 0)) {
2890 assert(outlen
>= 0);
2892 if (need
> outlen
) {
2894 to avoid reallocations */
2895 if (need
< 2 * outlen
) {
2896 if (outlen
> PY_SSIZE_T_MAX
/ 2) {
2904 if (PyUnicode_Resize(
2905 &result
, need
) < 0) {
2911 memcpy(PyUnicode_AS_UNICODE(result
) + j
,
2912 PyUnicode_AS_UNICODE(item
),
2913 reslen
*sizeof(Py_UNICODE
));
2921 PyUnicode_Resize(&result
, j
);