Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

bltinmodule.c

Last change on this file was 391, checked in by dmik, 11 years ago
python: Merge vendor 2.7.6 to trunk.
Property svn:eol-style set to `native`
File size: 87.0 KB

Rev	Line
[2]	1	/* Built-in functions */
	2
	3	#include "Python.h"
	4	#include "Python-ast.h"
	5
	6	#include "node.h"
	7	#include "code.h"
	8	#include "eval.h"
	9
	10	#include <ctype.h>
[391]	11	#include <float.h> /* for DBL_MANT_DIG and friends */
[2]	12
	13	#ifdef RISCOS
	14	#include "unixstuff.h"
	15	#endif
	16
	17	/* The default encoding used by the platform file system APIs
	18	Can remain NULL for all platforms that don't have such a concept
	19	*/
	20	#if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)
	21	const char *Py_FileSystemDefaultEncoding = "mbcs";
	22	#elif defined(__APPLE__)
	23	const char *Py_FileSystemDefaultEncoding = "utf-8";
	24	#else
	25	const char Py_FileSystemDefaultEncoding = NULL; / use default */
	26	#endif
	27
	28	/* Forward */
	29	static PyObject filterstring(PyObject , PyObject *);
	30	#ifdef Py_USING_UNICODE
	31	static PyObject filterunicode(PyObject , PyObject *);
	32	#endif
	33	static PyObject filtertuple (PyObject , PyObject *);
	34
	35	static PyObject *
	36	builtin___import__(PyObject self, PyObject args, PyObject *kwds)
	37	{
[391]	38	static char *kwlist[] = {"name", "globals", "locals", "fromlist",
	39	"level", 0};
	40	char *name;
	41	PyObject *globals = NULL;
	42	PyObject *locals = NULL;
	43	PyObject *fromlist = NULL;
	44	int level = -1;
[2]	45
[391]	46	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s\|OOOi:__import__",
	47	kwlist, &name, &globals, &locals, &fromlist, &level))
	48	return NULL;
	49	return PyImport_ImportModuleLevel(name, globals, locals,
	50	fromlist, level);
[2]	51	}
	52
	53	PyDoc_STRVAR(import_doc,
	54	"__import__(name, globals={}, locals={}, fromlist=[], level=-1) -> module\n\
	55	\n\
[391]	56	Import a module. Because this function is meant for use by the Python\n\
	57	interpreter and not for general use it is better to use\n\
	58	importlib.import_module() to programmatically import a module.\n\
	59	\n\
	60	The globals argument is only used to determine the context;\n\
	61	they are not modified. The locals argument is unused. The fromlist\n\
[2]	62	should be a list of names to emulate ``from name import ...'', or an\n\
	63	empty list to emulate ``import name''.\n\
	64	When importing a module from a package, note that __import__('A.B', ...)\n\
	65	returns package A when fromlist is empty, but its submodule B when\n\
	66	fromlist is not empty. Level is used to determine whether to perform \n\
	67	absolute or relative imports. -1 is the original strategy of attempting\n\
	68	both absolute and relative imports, 0 is absolute, a positive number\n\
	69	is the number of parent directories to search relative to the current module.");
	70
	71
	72	static PyObject *
	73	builtin_abs(PyObject self, PyObject v)
	74	{
[391]	75	return PyNumber_Absolute(v);
[2]	76	}
	77
	78	PyDoc_STRVAR(abs_doc,
	79	"abs(number) -> number\n\
	80	\n\
	81	Return the absolute value of the argument.");
	82
	83	static PyObject *
	84	builtin_all(PyObject self, PyObject v)
	85	{
[391]	86	PyObject it, item;
	87	PyObject (iternext)(PyObject *);
	88	int cmp;
[2]	89
[391]	90	it = PyObject_GetIter(v);
	91	if (it == NULL)
	92	return NULL;
	93	iternext = *Py_TYPE(it)->tp_iternext;
[2]	94
[391]	95	for (;;) {
	96	item = iternext(it);
	97	if (item == NULL)
	98	break;
	99	cmp = PyObject_IsTrue(item);
	100	Py_DECREF(item);
	101	if (cmp < 0) {
	102	Py_DECREF(it);
	103	return NULL;
	104	}
	105	if (cmp == 0) {
	106	Py_DECREF(it);
	107	Py_RETURN_FALSE;
	108	}
	109	}
	110	Py_DECREF(it);
	111	if (PyErr_Occurred()) {
	112	if (PyErr_ExceptionMatches(PyExc_StopIteration))
	113	PyErr_Clear();
	114	else
	115	return NULL;
	116	}
	117	Py_RETURN_TRUE;
[2]	118	}
	119
	120	PyDoc_STRVAR(all_doc,
	121	"all(iterable) -> bool\n\
	122	\n\
[391]	123	Return True if bool(x) is True for all values x in the iterable.\n\
	124	If the iterable is empty, return True.");
[2]	125
	126	static PyObject *
	127	builtin_any(PyObject self, PyObject v)
	128	{
[391]	129	PyObject it, item;
	130	PyObject (iternext)(PyObject *);
	131	int cmp;
[2]	132
[391]	133	it = PyObject_GetIter(v);
	134	if (it == NULL)
	135	return NULL;
	136	iternext = *Py_TYPE(it)->tp_iternext;
[2]	137
[391]	138	for (;;) {
	139	item = iternext(it);
	140	if (item == NULL)
	141	break;
	142	cmp = PyObject_IsTrue(item);
	143	Py_DECREF(item);
	144	if (cmp < 0) {
	145	Py_DECREF(it);
	146	return NULL;
	147	}
	148	if (cmp == 1) {
	149	Py_DECREF(it);
	150	Py_RETURN_TRUE;
	151	}
	152	}
	153	Py_DECREF(it);
	154	if (PyErr_Occurred()) {
	155	if (PyErr_ExceptionMatches(PyExc_StopIteration))
	156	PyErr_Clear();
	157	else
	158	return NULL;
	159	}
	160	Py_RETURN_FALSE;
[2]	161	}
	162
	163	PyDoc_STRVAR(any_doc,
	164	"any(iterable) -> bool\n\
	165	\n\
[391]	166	Return True if bool(x) is True for any x in the iterable.\n\
	167	If the iterable is empty, return False.");
[2]	168
	169	static PyObject *
	170	builtin_apply(PyObject self, PyObject args)
	171	{
[391]	172	PyObject func, alist = NULL, *kwdict = NULL;
	173	PyObject t = NULL, retval = NULL;
[2]	174
[391]	175	if (PyErr_WarnPy3k("apply() not supported in 3.x; "
	176	"use func(args, *kwargs)", 1) < 0)
	177	return NULL;
[2]	178
[391]	179	if (!PyArg_UnpackTuple(args, "apply", 1, 3, &func, &alist, &kwdict))
	180	return NULL;
	181	if (alist != NULL) {
	182	if (!PyTuple_Check(alist)) {
	183	if (!PySequence_Check(alist)) {
	184	PyErr_Format(PyExc_TypeError,
	185	"apply() arg 2 expected sequence, found %s",
	186	alist->ob_type->tp_name);
	187	return NULL;
	188	}
	189	t = PySequence_Tuple(alist);
	190	if (t == NULL)
	191	return NULL;
	192	alist = t;
	193	}
	194	}
	195	if (kwdict != NULL && !PyDict_Check(kwdict)) {
	196	PyErr_Format(PyExc_TypeError,
	197	"apply() arg 3 expected dictionary, found %s",
	198	kwdict->ob_type->tp_name);
	199	goto finally;
	200	}
	201	retval = PyEval_CallObjectWithKeywords(func, alist, kwdict);
[2]	202	finally:
[391]	203	Py_XDECREF(t);
	204	return retval;
[2]	205	}
	206
	207	PyDoc_STRVAR(apply_doc,
	208	"apply(object[, args[, kwargs]]) -> value\n\
	209	\n\
	210	Call a callable object with positional arguments taken from the tuple args,\n\
	211	and keyword arguments taken from the optional dictionary kwargs.\n\
	212	Note that classes are callable, as are instances with a __call__() method.\n\
	213	\n\
	214	Deprecated since release 2.3. Instead, use the extended call syntax:\n\
	215	function(args, *keywords).");
	216
	217
	218	static PyObject *
	219	builtin_bin(PyObject self, PyObject v)
	220	{
[391]	221	return PyNumber_ToBase(v, 2);
[2]	222	}
	223
	224	PyDoc_STRVAR(bin_doc,
	225	"bin(number) -> string\n\
	226	\n\
	227	Return the binary representation of an integer or long integer.");
	228
	229
	230	static PyObject *
	231	builtin_callable(PyObject self, PyObject v)
	232	{
[391]	233	return PyBool_FromLong((long)PyCallable_Check(v));
[2]	234	}
	235
	236	PyDoc_STRVAR(callable_doc,
	237	"callable(object) -> bool\n\
	238	\n\
	239	Return whether the object is callable (i.e., some kind of function).\n\
	240	Note that classes are callable, as are instances with a __call__() method.");
	241
	242
	243	static PyObject *
	244	builtin_filter(PyObject self, PyObject args)
	245	{
[391]	246	PyObject func, seq, result, it, *arg;
	247	Py_ssize_t len; /* guess for result list size */
	248	register Py_ssize_t j;
[2]	249
[391]	250	if (!PyArg_UnpackTuple(args, "filter", 2, 2, &func, &seq))
	251	return NULL;
[2]	252
[391]	253	/* Strings and tuples return a result of the same type. */
	254	if (PyString_Check(seq))
	255	return filterstring(func, seq);
[2]	256	#ifdef Py_USING_UNICODE
[391]	257	if (PyUnicode_Check(seq))
	258	return filterunicode(func, seq);
[2]	259	#endif
[391]	260	if (PyTuple_Check(seq))
	261	return filtertuple(func, seq);
[2]	262
[391]	263	/* Pre-allocate argument list tuple. */
	264	arg = PyTuple_New(1);
	265	if (arg == NULL)
	266	return NULL;
[2]	267
[391]	268	/* Get iterator. */
	269	it = PyObject_GetIter(seq);
	270	if (it == NULL)
	271	goto Fail_arg;
[2]	272
[391]	273	/* Guess a result list size. */
	274	len = _PyObject_LengthHint(seq, 8);
	275	if (len == -1)
	276	goto Fail_it;
[2]	277
[391]	278	/* Get a result list. */
	279	if (PyList_Check(seq) && seq->ob_refcnt == 1) {
	280	/* Eww - can modify the list in-place. */
	281	Py_INCREF(seq);
	282	result = seq;
	283	}
	284	else {
	285	result = PyList_New(len);
	286	if (result == NULL)
	287	goto Fail_it;
	288	}
[2]	289
[391]	290	/* Build the result list. */
	291	j = 0;
	292	for (;;) {
	293	PyObject *item;
	294	int ok;
[2]	295
[391]	296	item = PyIter_Next(it);
	297	if (item == NULL) {
	298	if (PyErr_Occurred())
	299	goto Fail_result_it;
	300	break;
	301	}
[2]	302
[391]	303	if (func == (PyObject *)&PyBool_Type \|\| func == Py_None) {
	304	ok = PyObject_IsTrue(item);
	305	}
	306	else {
	307	PyObject *good;
	308	PyTuple_SET_ITEM(arg, 0, item);
	309	good = PyObject_Call(func, arg, NULL);
	310	PyTuple_SET_ITEM(arg, 0, NULL);
	311	if (good == NULL) {
	312	Py_DECREF(item);
	313	goto Fail_result_it;
	314	}
	315	ok = PyObject_IsTrue(good);
	316	Py_DECREF(good);
	317	}
	318	if (ok > 0) {
	319	if (j < len)
	320	PyList_SET_ITEM(result, j, item);
	321	else {
	322	int status = PyList_Append(result, item);
	323	Py_DECREF(item);
	324	if (status < 0)
	325	goto Fail_result_it;
	326	}
	327	++j;
	328	}
	329	else {
	330	Py_DECREF(item);
	331	if (ok < 0)
	332	goto Fail_result_it;
	333	}
	334	}
[2]	335
	336
[391]	337	/* Cut back result list if len is too big. */
	338	if (j < len && PyList_SetSlice(result, j, len, NULL) < 0)
	339	goto Fail_result_it;
[2]	340
[391]	341	Py_DECREF(it);
	342	Py_DECREF(arg);
	343	return result;
[2]	344
	345	Fail_result_it:
[391]	346	Py_DECREF(result);
[2]	347	Fail_it:
[391]	348	Py_DECREF(it);
[2]	349	Fail_arg:
[391]	350	Py_DECREF(arg);
	351	return NULL;
[2]	352	}
	353
	354	PyDoc_STRVAR(filter_doc,
	355	"filter(function or None, sequence) -> list, tuple, or string\n"
	356	"\n"
	357	"Return those items of sequence for which function(item) is true. If\n"
	358	"function is None, return the items that are true. If sequence is a tuple\n"
	359	"or string, return the same type, else return a list.");
	360
	361	static PyObject *
	362	builtin_format(PyObject self, PyObject args)
	363	{
[391]	364	PyObject *value;
	365	PyObject *format_spec = NULL;
[2]	366
[391]	367	if (!PyArg_ParseTuple(args, "O\|O:format", &value, &format_spec))
	368	return NULL;
[2]	369
[391]	370	return PyObject_Format(value, format_spec);
[2]	371	}
	372
	373	PyDoc_STRVAR(format_doc,
	374	"format(value[, format_spec]) -> string\n\
	375	\n\
	376	Returns value.__format__(format_spec)\n\
	377	format_spec defaults to \"\"");
	378
	379	static PyObject *
	380	builtin_chr(PyObject self, PyObject args)
	381	{
[391]	382	long x;
	383	char s[1];
[2]	384
[391]	385	if (!PyArg_ParseTuple(args, "l:chr", &x))
	386	return NULL;
	387	if (x < 0 \|\| x >= 256) {
	388	PyErr_SetString(PyExc_ValueError,
	389	"chr() arg not in range(256)");
	390	return NULL;
	391	}
	392	s[0] = (char)x;
	393	return PyString_FromStringAndSize(s, 1);
[2]	394	}
	395
	396	PyDoc_STRVAR(chr_doc,
	397	"chr(i) -> character\n\
	398	\n\
	399	Return a string of one character with ordinal i; 0 <= i < 256.");
	400
	401
	402	#ifdef Py_USING_UNICODE
	403	static PyObject *
	404	builtin_unichr(PyObject self, PyObject args)
	405	{
[391]	406	int x;
[2]	407
[391]	408	if (!PyArg_ParseTuple(args, "i:unichr", &x))
	409	return NULL;
[2]	410
[391]	411	return PyUnicode_FromOrdinal(x);
[2]	412	}
	413
	414	PyDoc_STRVAR(unichr_doc,
	415	"unichr(i) -> Unicode character\n\
	416	\n\
	417	Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.");
	418	#endif
	419
	420
	421	static PyObject *
	422	builtin_cmp(PyObject self, PyObject args)
	423	{
[391]	424	PyObject a, b;
	425	int c;
[2]	426
[391]	427	if (!PyArg_UnpackTuple(args, "cmp", 2, 2, &a, &b))
	428	return NULL;
	429	if (PyObject_Cmp(a, b, &c) < 0)
	430	return NULL;
	431	return PyInt_FromLong((long)c);
[2]	432	}
	433
	434	PyDoc_STRVAR(cmp_doc,
	435	"cmp(x, y) -> integer\n\
	436	\n\
	437	Return negative if x<y, zero if x==y, positive if x>y.");
	438
	439
	440	static PyObject *
	441	builtin_coerce(PyObject self, PyObject args)
	442	{
[391]	443	PyObject v, w;
	444	PyObject *res;
[2]	445
[391]	446	if (PyErr_WarnPy3k("coerce() not supported in 3.x", 1) < 0)
	447	return NULL;
[2]	448
[391]	449	if (!PyArg_UnpackTuple(args, "coerce", 2, 2, &v, &w))
	450	return NULL;
	451	if (PyNumber_Coerce(&v, &w) < 0)
	452	return NULL;
	453	res = PyTuple_Pack(2, v, w);
	454	Py_DECREF(v);
	455	Py_DECREF(w);
	456	return res;
[2]	457	}
	458
	459	PyDoc_STRVAR(coerce_doc,
	460	"coerce(x, y) -> (x1, y1)\n\
	461	\n\
	462	Return a tuple consisting of the two numeric arguments converted to\n\
	463	a common type, using the same rules as used by arithmetic operations.\n\
	464	If coercion is not possible, raise TypeError.");
	465
	466	static PyObject *
	467	builtin_compile(PyObject self, PyObject args, PyObject *kwds)
	468	{
[391]	469	char *str;
	470	char *filename;
	471	char *startstr;
	472	int mode = -1;
	473	int dont_inherit = 0;
	474	int supplied_flags = 0;
	475	int is_ast;
	476	PyCompilerFlags cf;
	477	PyObject result = NULL, cmd, *tmp = NULL;
	478	Py_ssize_t length;
	479	static char *kwlist[] = {"source", "filename", "mode", "flags",
	480	"dont_inherit", NULL};
	481	int start[] = {Py_file_input, Py_eval_input, Py_single_input};
[2]	482
[391]	483	if (!PyArg_ParseTupleAndKeywords(args, kwds, "Oss\|ii:compile",
	484	kwlist, &cmd, &filename, &startstr,
	485	&supplied_flags, &dont_inherit))
	486	return NULL;
[2]	487
[391]	488	cf.cf_flags = supplied_flags;
[2]	489
[391]	490	if (supplied_flags &
	491	~(PyCF_MASK \| PyCF_MASK_OBSOLETE \| PyCF_DONT_IMPLY_DEDENT \| PyCF_ONLY_AST))
	492	{
	493	PyErr_SetString(PyExc_ValueError,
	494	"compile(): unrecognised flags");
	495	return NULL;
	496	}
	497	/* XXX Warn if (supplied_flags & PyCF_MASK_OBSOLETE) != 0? */
[2]	498
[391]	499	if (!dont_inherit) {
	500	PyEval_MergeCompilerFlags(&cf);
	501	}
[2]	502
[391]	503	if (strcmp(startstr, "exec") == 0)
	504	mode = 0;
	505	else if (strcmp(startstr, "eval") == 0)
	506	mode = 1;
	507	else if (strcmp(startstr, "single") == 0)
	508	mode = 2;
	509	else {
	510	PyErr_SetString(PyExc_ValueError,
	511	"compile() arg 3 must be 'exec', 'eval' or 'single'");
	512	return NULL;
	513	}
[2]	514
[391]	515	is_ast = PyAST_Check(cmd);
	516	if (is_ast == -1)
	517	return NULL;
	518	if (is_ast) {
	519	if (supplied_flags & PyCF_ONLY_AST) {
	520	Py_INCREF(cmd);
	521	result = cmd;
	522	}
	523	else {
	524	PyArena *arena;
	525	mod_ty mod;
[2]	526
[391]	527	arena = PyArena_New();
	528	if (arena == NULL)
	529	return NULL;
	530	mod = PyAST_obj2mod(cmd, arena, mode);
	531	if (mod == NULL) {
	532	PyArena_Free(arena);
	533	return NULL;
	534	}
	535	result = (PyObject*)PyAST_Compile(mod, filename,
	536	&cf, arena);
	537	PyArena_Free(arena);
	538	}
	539	return result;
	540	}
[2]	541
	542	#ifdef Py_USING_UNICODE
[391]	543	if (PyUnicode_Check(cmd)) {
	544	tmp = PyUnicode_AsUTF8String(cmd);
	545	if (tmp == NULL)
	546	return NULL;
	547	cmd = tmp;
	548	cf.cf_flags \|= PyCF_SOURCE_IS_UTF8;
	549	}
[2]	550	#endif
	551
[391]	552	if (PyObject_AsReadBuffer(cmd, (const void **)&str, &length))
	553	goto cleanup;
	554	if ((size_t)length != strlen(str)) {
	555	PyErr_SetString(PyExc_TypeError,
	556	"compile() expected string without null bytes");
	557	goto cleanup;
	558	}
	559	result = Py_CompileStringFlags(str, filename, start[mode], &cf);
[2]	560	cleanup:
[391]	561	Py_XDECREF(tmp);
	562	return result;
[2]	563	}
	564
	565	PyDoc_STRVAR(compile_doc,
	566	"compile(source, filename, mode[, flags[, dont_inherit]]) -> code object\n\
	567	\n\
	568	Compile the source string (a Python module, statement or expression)\n\
	569	into a code object that can be executed by the exec statement or eval().\n\
	570	The filename will be used for run-time error messages.\n\
	571	The mode must be 'exec' to compile a module, 'single' to compile a\n\
	572	single (interactive) statement, or 'eval' to compile an expression.\n\
	573	The flags argument, if present, controls which future statements influence\n\
	574	the compilation of the code.\n\
	575	The dont_inherit argument, if non-zero, stops the compilation inheriting\n\
	576	the effects of any future statements in effect in the code calling\n\
	577	compile; if absent or zero these statements do influence the compilation,\n\
	578	in addition to any features explicitly specified.");
	579
	580	static PyObject *
	581	builtin_dir(PyObject self, PyObject args)
	582	{
[391]	583	PyObject *arg = NULL;
[2]	584
[391]	585	if (!PyArg_UnpackTuple(args, "dir", 0, 1, &arg))
	586	return NULL;
	587	return PyObject_Dir(arg);
[2]	588	}
	589
	590	PyDoc_STRVAR(dir_doc,
	591	"dir([object]) -> list of strings\n"
	592	"\n"
	593	"If called without an argument, return the names in the current scope.\n"
	594	"Else, return an alphabetized list of names comprising (some of) the attributes\n"
	595	"of the given object, and of attributes reachable from it.\n"
	596	"If the object supplies a method named __dir__, it will be used; otherwise\n"
	597	"the default dir() logic is used and returns:\n"
	598	" for a module object: the module's attributes.\n"
	599	" for a class object: its attributes, and recursively the attributes\n"
	600	" of its bases.\n"
	601	" for any other object: its attributes, its class's attributes, and\n"
	602	" recursively the attributes of its class's base classes.");
	603
	604	static PyObject *
	605	builtin_divmod(PyObject self, PyObject args)
	606	{
[391]	607	PyObject v, w;
[2]	608
[391]	609	if (!PyArg_UnpackTuple(args, "divmod", 2, 2, &v, &w))
	610	return NULL;
	611	return PyNumber_Divmod(v, w);
[2]	612	}
	613
	614	PyDoc_STRVAR(divmod_doc,
[391]	615	"divmod(x, y) -> (quotient, remainder)\n\
[2]	616	\n\
	617	Return the tuple ((x-x%y)/y, x%y). Invariant: div*y + mod == x.");
	618
	619
	620	static PyObject *
	621	builtin_eval(PyObject self, PyObject args)
	622	{
[391]	623	PyObject cmd, result, *tmp = NULL;
	624	PyObject globals = Py_None, locals = Py_None;
	625	char *str;
	626	PyCompilerFlags cf;
[2]	627
[391]	628	if (!PyArg_UnpackTuple(args, "eval", 1, 3, &cmd, &globals, &locals))
	629	return NULL;
	630	if (locals != Py_None && !PyMapping_Check(locals)) {
	631	PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
	632	return NULL;
	633	}
	634	if (globals != Py_None && !PyDict_Check(globals)) {
	635	PyErr_SetString(PyExc_TypeError, PyMapping_Check(globals) ?
	636	"globals must be a real dict; try eval(expr, {}, mapping)"
	637	: "globals must be a dict");
	638	return NULL;
	639	}
	640	if (globals == Py_None) {
	641	globals = PyEval_GetGlobals();
	642	if (locals == Py_None)
	643	locals = PyEval_GetLocals();
	644	}
	645	else if (locals == Py_None)
	646	locals = globals;
[2]	647
[391]	648	if (globals == NULL \|\| locals == NULL) {
	649	PyErr_SetString(PyExc_TypeError,
	650	"eval must be given globals and locals "
	651	"when called without a frame");
	652	return NULL;
	653	}
[2]	654
[391]	655	if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
	656	if (PyDict_SetItemString(globals, "__builtins__",
	657	PyEval_GetBuiltins()) != 0)
	658	return NULL;
	659	}
[2]	660
[391]	661	if (PyCode_Check(cmd)) {
	662	if (PyCode_GetNumFree((PyCodeObject *)cmd) > 0) {
	663	PyErr_SetString(PyExc_TypeError,
	664	"code object passed to eval() may not contain free variables");
	665	return NULL;
	666	}
	667	return PyEval_EvalCode((PyCodeObject *) cmd, globals, locals);
	668	}
[2]	669
[391]	670	if (!PyString_Check(cmd) &&
	671	!PyUnicode_Check(cmd)) {
	672	PyErr_SetString(PyExc_TypeError,
	673	"eval() arg 1 must be a string or code object");
	674	return NULL;
	675	}
	676	cf.cf_flags = 0;
[2]	677
	678	#ifdef Py_USING_UNICODE
[391]	679	if (PyUnicode_Check(cmd)) {
	680	tmp = PyUnicode_AsUTF8String(cmd);
	681	if (tmp == NULL)
	682	return NULL;
	683	cmd = tmp;
	684	cf.cf_flags \|= PyCF_SOURCE_IS_UTF8;
	685	}
[2]	686	#endif
[391]	687	if (PyString_AsStringAndSize(cmd, &str, NULL)) {
	688	Py_XDECREF(tmp);
	689	return NULL;
	690	}
	691	while (str == ' ' \|\| str == '\t')
	692	str++;
[2]	693
[391]	694	(void)PyEval_MergeCompilerFlags(&cf);
	695	result = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);
	696	Py_XDECREF(tmp);
	697	return result;
[2]	698	}
	699
	700	PyDoc_STRVAR(eval_doc,
	701	"eval(source[, globals[, locals]]) -> value\n\
	702	\n\
	703	Evaluate the source in the context of globals and locals.\n\
	704	The source may be a string representing a Python expression\n\
	705	or a code object as returned by compile().\n\
	706	The globals must be a dictionary and locals can be any mapping,\n\
	707	defaulting to the current globals and locals.\n\
	708	If only globals is given, locals defaults to it.\n");
	709
	710
	711	static PyObject *
	712	builtin_execfile(PyObject self, PyObject args)
	713	{
[391]	714	char *filename;
	715	PyObject globals = Py_None, locals = Py_None;
	716	PyObject *res;
	717	FILE* fp = NULL;
	718	PyCompilerFlags cf;
	719	int exists;
[2]	720
[391]	721	if (PyErr_WarnPy3k("execfile() not supported in 3.x; use exec()",
	722	1) < 0)
	723	return NULL;
[2]	724
[391]	725	if (!PyArg_ParseTuple(args, "s\|O!O:execfile",
	726	&filename,
	727	&PyDict_Type, &globals,
	728	&locals))
	729	return NULL;
	730	if (locals != Py_None && !PyMapping_Check(locals)) {
	731	PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
	732	return NULL;
	733	}
	734	if (globals == Py_None) {
	735	globals = PyEval_GetGlobals();
	736	if (locals == Py_None)
	737	locals = PyEval_GetLocals();
	738	}
	739	else if (locals == Py_None)
	740	locals = globals;
	741	if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
	742	if (PyDict_SetItemString(globals, "__builtins__",
	743	PyEval_GetBuiltins()) != 0)
	744	return NULL;
	745	}
[2]	746
[391]	747	exists = 0;
	748	/* Test for existence or directory. */
[2]	749	#if defined(PLAN9)
[391]	750	{
	751	Dir *d;
[2]	752
[391]	753	if ((d = dirstat(filename))!=nil) {
	754	if(d->mode & DMDIR)
	755	werrstr("is a directory");
	756	else
	757	exists = 1;
	758	free(d);
	759	}
	760	}
[2]	761	#elif defined(RISCOS)
[391]	762	if (object_exists(filename)) {
	763	if (isdir(filename))
	764	errno = EISDIR;
	765	else
	766	exists = 1;
	767	}
	768	#else /* standard Posix */
	769	{
	770	struct stat s;
	771	if (stat(filename, &s) == 0) {
	772	if (S_ISDIR(s.st_mode))
	773	# if defined(PYOS_OS2) && defined(PYCC_VACPP)
	774	errno = EOS2ERR;
	775	# else
	776	errno = EISDIR;
	777	# endif
	778	else
	779	exists = 1;
	780	}
	781	}
[2]	782	#endif
	783
[391]	784	if (exists) {
	785	Py_BEGIN_ALLOW_THREADS
	786	fp = fopen(filename, "r" PY_STDIOTEXTMODE);
	787	Py_END_ALLOW_THREADS
[2]	788
[391]	789	if (fp == NULL) {
	790	exists = 0;
[2]	791	}
[391]	792	}
[2]	793
[391]	794	if (!exists) {
	795	PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
	796	return NULL;
	797	}
	798	cf.cf_flags = 0;
	799	if (PyEval_MergeCompilerFlags(&cf))
	800	res = PyRun_FileExFlags(fp, filename, Py_file_input, globals,
	801	locals, 1, &cf);
	802	else
	803	res = PyRun_FileEx(fp, filename, Py_file_input, globals,
	804	locals, 1);
	805	return res;
[2]	806	}
	807
	808	PyDoc_STRVAR(execfile_doc,
	809	"execfile(filename[, globals[, locals]])\n\
	810	\n\
	811	Read and execute a Python script from a file.\n\
	812	The globals and locals are dictionaries, defaulting to the current\n\
	813	globals and locals. If only globals is given, locals defaults to it.");
	814
	815
	816	static PyObject *
	817	builtin_getattr(PyObject self, PyObject args)
	818	{
[391]	819	PyObject v, result, *dflt = NULL;
	820	PyObject *name;
[2]	821
[391]	822	if (!PyArg_UnpackTuple(args, "getattr", 2, 3, &v, &name, &dflt))
	823	return NULL;
[2]	824	#ifdef Py_USING_UNICODE
[391]	825	if (PyUnicode_Check(name)) {
	826	name = _PyUnicode_AsDefaultEncodedString(name, NULL);
	827	if (name == NULL)
	828	return NULL;
	829	}
[2]	830	#endif
	831
[391]	832	if (!PyString_Check(name)) {
	833	PyErr_SetString(PyExc_TypeError,
	834	"getattr(): attribute name must be string");
	835	return NULL;
	836	}
	837	result = PyObject_GetAttr(v, name);
	838	if (result == NULL && dflt != NULL &&
	839	PyErr_ExceptionMatches(PyExc_AttributeError))
	840	{
	841	PyErr_Clear();
	842	Py_INCREF(dflt);
	843	result = dflt;
	844	}
	845	return result;
[2]	846	}
	847
	848	PyDoc_STRVAR(getattr_doc,
	849	"getattr(object, name[, default]) -> value\n\
	850	\n\
	851	Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.\n\
	852	When a default argument is given, it is returned when the attribute doesn't\n\
	853	exist; without it, an exception is raised in that case.");
	854
	855
	856	static PyObject *
	857	builtin_globals(PyObject *self)
	858	{
[391]	859	PyObject *d;
[2]	860
[391]	861	d = PyEval_GetGlobals();
	862	Py_XINCREF(d);
	863	return d;
[2]	864	}
	865
	866	PyDoc_STRVAR(globals_doc,
	867	"globals() -> dictionary\n\
	868	\n\
	869	Return the dictionary containing the current scope's global variables.");
	870
	871
	872	static PyObject *
	873	builtin_hasattr(PyObject self, PyObject args)
	874	{
[391]	875	PyObject *v;
	876	PyObject *name;
[2]	877
[391]	878	if (!PyArg_UnpackTuple(args, "hasattr", 2, 2, &v, &name))
	879	return NULL;
[2]	880	#ifdef Py_USING_UNICODE
[391]	881	if (PyUnicode_Check(name)) {
	882	name = _PyUnicode_AsDefaultEncodedString(name, NULL);
	883	if (name == NULL)
	884	return NULL;
	885	}
[2]	886	#endif
	887
[391]	888	if (!PyString_Check(name)) {
	889	PyErr_SetString(PyExc_TypeError,
	890	"hasattr(): attribute name must be string");
	891	return NULL;
	892	}
	893	v = PyObject_GetAttr(v, name);
	894	if (v == NULL) {
	895	if (!PyErr_ExceptionMatches(PyExc_Exception))
	896	return NULL;
	897	else {
	898	PyErr_Clear();
	899	Py_INCREF(Py_False);
	900	return Py_False;
	901	}
	902	}
	903	Py_DECREF(v);
	904	Py_INCREF(Py_True);
	905	return Py_True;
[2]	906	}
	907
	908	PyDoc_STRVAR(hasattr_doc,
	909	"hasattr(object, name) -> bool\n\
	910	\n\
	911	Return whether the object has an attribute with the given name.\n\
	912	(This is done by calling getattr(object, name) and catching exceptions.)");
	913
	914
	915	static PyObject *
	916	builtin_id(PyObject self, PyObject v)
	917	{
[391]	918	return PyLong_FromVoidPtr(v);
[2]	919	}
	920
	921	PyDoc_STRVAR(id_doc,
	922	"id(object) -> integer\n\
	923	\n\
	924	Return the identity of an object. This is guaranteed to be unique among\n\
	925	simultaneously existing objects. (Hint: it's the object's memory address.)");
	926
	927
	928	static PyObject *
	929	builtin_map(PyObject self, PyObject args)
	930	{
[391]	931	typedef struct {
	932	PyObject it; / the iterator object */
	933	int saw_StopIteration; /* bool: did the iterator end? */
	934	} sequence;
[2]	935
[391]	936	PyObject func, result;
	937	sequence seqs = NULL, sqp;
	938	Py_ssize_t n, len;
	939	register int i, j;
[2]	940
[391]	941	n = PyTuple_Size(args);
	942	if (n < 2) {
	943	PyErr_SetString(PyExc_TypeError,
	944	"map() requires at least two args");
	945	return NULL;
	946	}
[2]	947
[391]	948	func = PyTuple_GetItem(args, 0);
	949	n--;
[2]	950
[391]	951	if (func == Py_None) {
	952	if (PyErr_WarnPy3k("map(None, ...) not supported in 3.x; "
	953	"use list(...)", 1) < 0)
	954	return NULL;
	955	if (n == 1) {
	956	/* map(None, S) is the same as list(S). */
	957	return PySequence_List(PyTuple_GetItem(args, 1));
	958	}
	959	}
[2]	960
[391]	961	/* Get space for sequence descriptors. Must NULL out the iterator
	962	* pointers so that jumping to Fail_2 later doesn't see trash.
	963	*/
	964	if ((seqs = PyMem_NEW(sequence, n)) == NULL) {
	965	PyErr_NoMemory();
	966	return NULL;
	967	}
	968	for (i = 0; i < n; ++i) {
	969	seqs[i].it = (PyObject*)NULL;
	970	seqs[i].saw_StopIteration = 0;
	971	}
[2]	972
[391]	973	/* Do a first pass to obtain iterators for the arguments, and set len
	974	* to the largest of their lengths.
	975	*/
	976	len = 0;
	977	for (i = 0, sqp = seqs; i < n; ++i, ++sqp) {
	978	PyObject *curseq;
	979	Py_ssize_t curlen;
[2]	980
[391]	981	/* Get iterator. */
	982	curseq = PyTuple_GetItem(args, i+1);
	983	sqp->it = PyObject_GetIter(curseq);
	984	if (sqp->it == NULL) {
	985	static char errmsg[] =
	986	"argument %d to map() must support iteration";
	987	char errbuf[sizeof(errmsg) + 25];
	988	PyOS_snprintf(errbuf, sizeof(errbuf), errmsg, i+2);
	989	PyErr_SetString(PyExc_TypeError, errbuf);
	990	goto Fail_2;
	991	}
[2]	992
[391]	993	/* Update len. */
	994	curlen = _PyObject_LengthHint(curseq, 8);
	995	if (curlen > len)
	996	len = curlen;
	997	}
[2]	998
[391]	999	/* Get space for the result list. */
	1000	if ((result = (PyObject *) PyList_New(len)) == NULL)
	1001	goto Fail_2;
[2]	1002
[391]	1003	/* Iterate over the sequences until all have stopped. */
	1004	for (i = 0; ; ++i) {
	1005	PyObject alist, item=NULL, *value;
	1006	int numactive = 0;
[2]	1007
[391]	1008	if (func == Py_None && n == 1)
	1009	alist = NULL;
	1010	else if ((alist = PyTuple_New(n)) == NULL)
	1011	goto Fail_1;
[2]	1012
[391]	1013	for (j = 0, sqp = seqs; j < n; ++j, ++sqp) {
	1014	if (sqp->saw_StopIteration) {
	1015	Py_INCREF(Py_None);
	1016	item = Py_None;
	1017	}
	1018	else {
	1019	item = PyIter_Next(sqp->it);
	1020	if (item)
	1021	++numactive;
	1022	else {
	1023	if (PyErr_Occurred()) {
	1024	Py_XDECREF(alist);
	1025	goto Fail_1;
	1026	}
	1027	Py_INCREF(Py_None);
	1028	item = Py_None;
	1029	sqp->saw_StopIteration = 1;
	1030	}
	1031	}
	1032	if (alist)
	1033	PyTuple_SET_ITEM(alist, j, item);
	1034	else
	1035	break;
	1036	}
[2]	1037
[391]	1038	if (!alist)
	1039	alist = item;
[2]	1040
[391]	1041	if (numactive == 0) {
	1042	Py_DECREF(alist);
	1043	break;
	1044	}
[2]	1045
[391]	1046	if (func == Py_None)
	1047	value = alist;
	1048	else {
	1049	value = PyEval_CallObject(func, alist);
	1050	Py_DECREF(alist);
	1051	if (value == NULL)
	1052	goto Fail_1;
	1053	}
	1054	if (i >= len) {
	1055	int status = PyList_Append(result, value);
	1056	Py_DECREF(value);
	1057	if (status < 0)
	1058	goto Fail_1;
	1059	}
	1060	else if (PyList_SetItem(result, i, value) < 0)
	1061	goto Fail_1;
	1062	}
[2]	1063
[391]	1064	if (i < len && PyList_SetSlice(result, i, len, NULL) < 0)
	1065	goto Fail_1;
[2]	1066
[391]	1067	goto Succeed;
[2]	1068
	1069	Fail_1:
[391]	1070	Py_DECREF(result);
[2]	1071	Fail_2:
[391]	1072	result = NULL;
[2]	1073	Succeed:
[391]	1074	assert(seqs);
	1075	for (i = 0; i < n; ++i)
	1076	Py_XDECREF(seqs[i].it);
	1077	PyMem_DEL(seqs);
	1078	return result;
[2]	1079	}
	1080
	1081	PyDoc_STRVAR(map_doc,
	1082	"map(function, sequence[, sequence, ...]) -> list\n\
	1083	\n\
	1084	Return a list of the results of applying the function to the items of\n\
	1085	the argument sequence(s). If more than one sequence is given, the\n\
	1086	function is called with an argument list consisting of the corresponding\n\
	1087	item of each sequence, substituting None for missing values when not all\n\
	1088	sequences have the same length. If the function is None, return a list of\n\
	1089	the items of the sequence (or a list of tuples if more than one sequence).");
	1090
	1091
	1092	static PyObject *
	1093	builtin_next(PyObject self, PyObject args)
	1094	{
[391]	1095	PyObject it, res;
	1096	PyObject *def = NULL;
[2]	1097
[391]	1098	if (!PyArg_UnpackTuple(args, "next", 1, 2, &it, &def))
	1099	return NULL;
	1100	if (!PyIter_Check(it)) {
	1101	PyErr_Format(PyExc_TypeError,
	1102	"%.200s object is not an iterator",
	1103	it->ob_type->tp_name);
	1104	return NULL;
	1105	}
	1106
	1107	res = (*it->ob_type->tp_iternext)(it);
	1108	if (res != NULL) {
	1109	return res;
	1110	} else if (def != NULL) {
	1111	if (PyErr_Occurred()) {
	1112	if (!PyErr_ExceptionMatches(PyExc_StopIteration))
	1113	return NULL;
	1114	PyErr_Clear();
	1115	}
	1116	Py_INCREF(def);
	1117	return def;
	1118	} else if (PyErr_Occurred()) {
	1119	return NULL;
	1120	} else {
	1121	PyErr_SetNone(PyExc_StopIteration);
	1122	return NULL;
	1123	}
[2]	1124	}
	1125
	1126	PyDoc_STRVAR(next_doc,
	1127	"next(iterator[, default])\n\
	1128	\n\
	1129	Return the next item from the iterator. If default is given and the iterator\n\
	1130	is exhausted, it is returned instead of raising StopIteration.");
	1131
	1132
	1133	static PyObject *
	1134	builtin_setattr(PyObject self, PyObject args)
	1135	{
[391]	1136	PyObject *v;
	1137	PyObject *name;
	1138	PyObject *value;
[2]	1139
[391]	1140	if (!PyArg_UnpackTuple(args, "setattr", 3, 3, &v, &name, &value))
	1141	return NULL;
	1142	if (PyObject_SetAttr(v, name, value) != 0)
	1143	return NULL;
	1144	Py_INCREF(Py_None);
	1145	return Py_None;
[2]	1146	}
	1147
	1148	PyDoc_STRVAR(setattr_doc,
	1149	"setattr(object, name, value)\n\
	1150	\n\
	1151	Set a named attribute on an object; setattr(x, 'y', v) is equivalent to\n\
	1152	``x.y = v''.");
	1153
	1154
	1155	static PyObject *
	1156	builtin_delattr(PyObject self, PyObject args)
	1157	{
[391]	1158	PyObject *v;
	1159	PyObject *name;
[2]	1160
[391]	1161	if (!PyArg_UnpackTuple(args, "delattr", 2, 2, &v, &name))
	1162	return NULL;
	1163	if (PyObject_SetAttr(v, name, (PyObject *)NULL) != 0)
	1164	return NULL;
	1165	Py_INCREF(Py_None);
	1166	return Py_None;
[2]	1167	}
	1168
	1169	PyDoc_STRVAR(delattr_doc,
	1170	"delattr(object, name)\n\
	1171	\n\
	1172	Delete a named attribute on an object; delattr(x, 'y') is equivalent to\n\
	1173	``del x.y''.");
	1174
	1175
	1176	static PyObject *
	1177	builtin_hash(PyObject self, PyObject v)
	1178	{
[391]	1179	long x;
[2]	1180
[391]	1181	x = PyObject_Hash(v);
	1182	if (x == -1)
	1183	return NULL;
	1184	return PyInt_FromLong(x);
[2]	1185	}
	1186
	1187	PyDoc_STRVAR(hash_doc,
	1188	"hash(object) -> integer\n\
	1189	\n\
	1190	Return a hash value for the object. Two objects with the same value have\n\
	1191	the same hash value. The reverse is not necessarily true, but likely.");
	1192
	1193
	1194	static PyObject *
	1195	builtin_hex(PyObject self, PyObject v)
	1196	{
[391]	1197	PyNumberMethods *nb;
	1198	PyObject *res;
[2]	1199
[391]	1200	if ((nb = v->ob_type->tp_as_number) == NULL \|\|
	1201	nb->nb_hex == NULL) {
	1202	PyErr_SetString(PyExc_TypeError,
	1203	"hex() argument can't be converted to hex");
	1204	return NULL;
	1205	}
	1206	res = (*nb->nb_hex)(v);
	1207	if (res && !PyString_Check(res)) {
	1208	PyErr_Format(PyExc_TypeError,
	1209	"__hex__ returned non-string (type %.200s)",
	1210	res->ob_type->tp_name);
	1211	Py_DECREF(res);
	1212	return NULL;
	1213	}
	1214	return res;
[2]	1215	}
	1216
	1217	PyDoc_STRVAR(hex_doc,
	1218	"hex(number) -> string\n\
	1219	\n\
	1220	Return the hexadecimal representation of an integer or long integer.");
	1221
	1222
	1223	static PyObject builtin_raw_input(PyObject , PyObject *);
	1224
	1225	static PyObject *
	1226	builtin_input(PyObject self, PyObject args)
	1227	{
[391]	1228	PyObject *line;
	1229	char *str;
	1230	PyObject *res;
	1231	PyObject globals, locals;
	1232	PyCompilerFlags cf;
[2]	1233
[391]	1234	line = builtin_raw_input(self, args);
	1235	if (line == NULL)
	1236	return line;
	1237	if (!PyArg_Parse(line, "s;embedded '\\0' in input line", &str))
	1238	return NULL;
	1239	while (str == ' ' \|\| str == '\t')
	1240	str++;
	1241	globals = PyEval_GetGlobals();
	1242	locals = PyEval_GetLocals();
	1243	if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
	1244	if (PyDict_SetItemString(globals, "__builtins__",
	1245	PyEval_GetBuiltins()) != 0)
	1246	return NULL;
	1247	}
	1248	cf.cf_flags = 0;
	1249	PyEval_MergeCompilerFlags(&cf);
	1250	res = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);
	1251	Py_DECREF(line);
	1252	return res;
[2]	1253	}
	1254
	1255	PyDoc_STRVAR(input_doc,
	1256	"input([prompt]) -> value\n\
	1257	\n\
	1258	Equivalent to eval(raw_input(prompt)).");
	1259
	1260
	1261	static PyObject *
	1262	builtin_intern(PyObject self, PyObject args)
	1263	{
[391]	1264	PyObject *s;
	1265	if (!PyArg_ParseTuple(args, "S:intern", &s))
	1266	return NULL;
	1267	if (!PyString_CheckExact(s)) {
	1268	PyErr_SetString(PyExc_TypeError,
	1269	"can't intern subclass of string");
	1270	return NULL;
	1271	}
	1272	Py_INCREF(s);
	1273	PyString_InternInPlace(&s);
	1274	return s;
[2]	1275	}
	1276
	1277	PyDoc_STRVAR(intern_doc,
	1278	"intern(string) -> string\n\
	1279	\n\
	1280	``Intern'' the given string. This enters the string in the (global)\n\
	1281	table of interned strings whose purpose is to speed up dictionary lookups.\n\
	1282	Return the string itself or the previously interned string object with the\n\
	1283	same value.");
	1284
	1285
	1286	static PyObject *
	1287	builtin_iter(PyObject self, PyObject args)
	1288	{
[391]	1289	PyObject v, w = NULL;
[2]	1290
[391]	1291	if (!PyArg_UnpackTuple(args, "iter", 1, 2, &v, &w))
	1292	return NULL;
	1293	if (w == NULL)
	1294	return PyObject_GetIter(v);
	1295	if (!PyCallable_Check(v)) {
	1296	PyErr_SetString(PyExc_TypeError,
	1297	"iter(v, w): v must be callable");
	1298	return NULL;
	1299	}
	1300	return PyCallIter_New(v, w);
[2]	1301	}
	1302
	1303	PyDoc_STRVAR(iter_doc,
	1304	"iter(collection) -> iterator\n\
	1305	iter(callable, sentinel) -> iterator\n\
	1306	\n\
	1307	Get an iterator from an object. In the first form, the argument must\n\
	1308	supply its own iterator, or be a sequence.\n\
	1309	In the second form, the callable is called until it returns the sentinel.");
	1310
	1311
	1312	static PyObject *
	1313	builtin_len(PyObject self, PyObject v)
	1314	{
[391]	1315	Py_ssize_t res;
[2]	1316
[391]	1317	res = PyObject_Size(v);
	1318	if (res < 0 && PyErr_Occurred())
	1319	return NULL;
	1320	return PyInt_FromSsize_t(res);
[2]	1321	}
	1322
	1323	PyDoc_STRVAR(len_doc,
	1324	"len(object) -> integer\n\
	1325	\n\
	1326	Return the number of items of a sequence or mapping.");
	1327
	1328
	1329	static PyObject *
	1330	builtin_locals(PyObject *self)
	1331	{
[391]	1332	PyObject *d;
[2]	1333
[391]	1334	d = PyEval_GetLocals();
	1335	Py_XINCREF(d);
	1336	return d;
[2]	1337	}
	1338
	1339	PyDoc_STRVAR(locals_doc,
	1340	"locals() -> dictionary\n\
	1341	\n\
	1342	Update and return a dictionary containing the current scope's local variables.");
	1343
	1344
	1345	static PyObject *
	1346	min_max(PyObject args, PyObject kwds, int op)
	1347	{
[391]	1348	PyObject v, it, item, val, maxitem, maxval, *keyfunc=NULL;
	1349	const char *name = op == Py_LT ? "min" : "max";
[2]	1350
[391]	1351	if (PyTuple_Size(args) > 1)
	1352	v = args;
	1353	else if (!PyArg_UnpackTuple(args, (char *)name, 1, 1, &v))
	1354	return NULL;
[2]	1355
[391]	1356	if (kwds != NULL && PyDict_Check(kwds) && PyDict_Size(kwds)) {
	1357	keyfunc = PyDict_GetItemString(kwds, "key");
	1358	if (PyDict_Size(kwds)!=1 \|\| keyfunc == NULL) {
	1359	PyErr_Format(PyExc_TypeError,
	1360	"%s() got an unexpected keyword argument", name);
	1361	return NULL;
	1362	}
	1363	Py_INCREF(keyfunc);
	1364	}
[2]	1365
[391]	1366	it = PyObject_GetIter(v);
	1367	if (it == NULL) {
	1368	Py_XDECREF(keyfunc);
	1369	return NULL;
	1370	}
[2]	1371
[391]	1372	maxitem = NULL; /* the result */
	1373	maxval = NULL; /* the value associated with the result */
	1374	while (( item = PyIter_Next(it) )) {
	1375	/* get the value from the key function */
	1376	if (keyfunc != NULL) {
	1377	val = PyObject_CallFunctionObjArgs(keyfunc, item, NULL);
	1378	if (val == NULL)
	1379	goto Fail_it_item;
	1380	}
	1381	/* no key function; the value is the item */
	1382	else {
	1383	val = item;
	1384	Py_INCREF(val);
	1385	}
[2]	1386
[391]	1387	/* maximum value and item are unset; set them */
	1388	if (maxval == NULL) {
	1389	maxitem = item;
	1390	maxval = val;
	1391	}
	1392	/* maximum value and item are set; update them as necessary */
	1393	else {
	1394	int cmp = PyObject_RichCompareBool(val, maxval, op);
	1395	if (cmp < 0)
	1396	goto Fail_it_item_and_val;
	1397	else if (cmp > 0) {
	1398	Py_DECREF(maxval);
	1399	Py_DECREF(maxitem);
	1400	maxval = val;
	1401	maxitem = item;
	1402	}
	1403	else {
	1404	Py_DECREF(item);
	1405	Py_DECREF(val);
	1406	}
	1407	}
	1408	}
	1409	if (PyErr_Occurred())
	1410	goto Fail_it;
	1411	if (maxval == NULL) {
	1412	PyErr_Format(PyExc_ValueError,
	1413	"%s() arg is an empty sequence", name);
	1414	assert(maxitem == NULL);
	1415	}
	1416	else
	1417	Py_DECREF(maxval);
	1418	Py_DECREF(it);
	1419	Py_XDECREF(keyfunc);
	1420	return maxitem;
[2]	1421
	1422	Fail_it_item_and_val:
[391]	1423	Py_DECREF(val);
[2]	1424	Fail_it_item:
[391]	1425	Py_DECREF(item);
[2]	1426	Fail_it:
[391]	1427	Py_XDECREF(maxval);
	1428	Py_XDECREF(maxitem);
	1429	Py_DECREF(it);
	1430	Py_XDECREF(keyfunc);
	1431	return NULL;
[2]	1432	}
	1433
	1434	static PyObject *
	1435	builtin_min(PyObject self, PyObject args, PyObject *kwds)
	1436	{
[391]	1437	return min_max(args, kwds, Py_LT);
[2]	1438	}
	1439
	1440	PyDoc_STRVAR(min_doc,
	1441	"min(iterable[, key=func]) -> value\n\
	1442	min(a, b, c, ...[, key=func]) -> value\n\
	1443	\n\
	1444	With a single iterable argument, return its smallest item.\n\
	1445	With two or more arguments, return the smallest argument.");
	1446
	1447
	1448	static PyObject *
	1449	builtin_max(PyObject self, PyObject args, PyObject *kwds)
	1450	{
[391]	1451	return min_max(args, kwds, Py_GT);
[2]	1452	}
	1453
	1454	PyDoc_STRVAR(max_doc,
	1455	"max(iterable[, key=func]) -> value\n\
	1456	max(a, b, c, ...[, key=func]) -> value\n\
	1457	\n\
	1458	With a single iterable argument, return its largest item.\n\
	1459	With two or more arguments, return the largest argument.");
	1460
	1461
	1462	static PyObject *
	1463	builtin_oct(PyObject self, PyObject v)
	1464	{
[391]	1465	PyNumberMethods *nb;
	1466	PyObject *res;
[2]	1467
[391]	1468	if (v == NULL \|\| (nb = v->ob_type->tp_as_number) == NULL \|\|
	1469	nb->nb_oct == NULL) {
	1470	PyErr_SetString(PyExc_TypeError,
	1471	"oct() argument can't be converted to oct");
	1472	return NULL;
	1473	}
	1474	res = (*nb->nb_oct)(v);
	1475	if (res && !PyString_Check(res)) {
	1476	PyErr_Format(PyExc_TypeError,
	1477	"__oct__ returned non-string (type %.200s)",
	1478	res->ob_type->tp_name);
	1479	Py_DECREF(res);
	1480	return NULL;
	1481	}
	1482	return res;
[2]	1483	}
	1484
	1485	PyDoc_STRVAR(oct_doc,
	1486	"oct(number) -> string\n\
	1487	\n\
	1488	Return the octal representation of an integer or long integer.");
	1489
	1490
	1491	static PyObject *
	1492	builtin_open(PyObject self, PyObject args, PyObject *kwds)
	1493	{
[391]	1494	return PyObject_Call((PyObject*)&PyFile_Type, args, kwds);
[2]	1495	}
	1496
	1497	PyDoc_STRVAR(open_doc,
	1498	"open(name[, mode[, buffering]]) -> file object\n\
	1499	\n\
	1500	Open a file using the file() type, returns a file object. This is the\n\
[391]	1501	preferred way to open a file. See file.__doc__ for further information.");
[2]	1502
	1503
	1504	static PyObject *
	1505	builtin_ord(PyObject self, PyObject obj)
	1506	{
[391]	1507	long ord;
	1508	Py_ssize_t size;
[2]	1509
[391]	1510	if (PyString_Check(obj)) {
	1511	size = PyString_GET_SIZE(obj);
	1512	if (size == 1) {
	1513	ord = (long)((unsigned char)*PyString_AS_STRING(obj));
	1514	return PyInt_FromLong(ord);
	1515	}
	1516	} else if (PyByteArray_Check(obj)) {
	1517	size = PyByteArray_GET_SIZE(obj);
	1518	if (size == 1) {
	1519	ord = (long)((unsigned char)*PyByteArray_AS_STRING(obj));
	1520	return PyInt_FromLong(ord);
	1521	}
[2]	1522
	1523	#ifdef Py_USING_UNICODE
[391]	1524	} else if (PyUnicode_Check(obj)) {
	1525	size = PyUnicode_GET_SIZE(obj);
	1526	if (size == 1) {
	1527	ord = (long)*PyUnicode_AS_UNICODE(obj);
	1528	return PyInt_FromLong(ord);
	1529	}
[2]	1530	#endif
[391]	1531	} else {
	1532	PyErr_Format(PyExc_TypeError,
	1533	"ord() expected string of length 1, but " \
	1534	"%.200s found", obj->ob_type->tp_name);
	1535	return NULL;
	1536	}
[2]	1537
[391]	1538	PyErr_Format(PyExc_TypeError,
	1539	"ord() expected a character, "
	1540	"but string of length %zd found",
	1541	size);
	1542	return NULL;
[2]	1543	}
	1544
	1545	PyDoc_STRVAR(ord_doc,
	1546	"ord(c) -> integer\n\
	1547	\n\
	1548	Return the integer ordinal of a one-character string.");
	1549
	1550
	1551	static PyObject *
	1552	builtin_pow(PyObject self, PyObject args)
	1553	{
[391]	1554	PyObject v, w, *z = Py_None;
[2]	1555
[391]	1556	if (!PyArg_UnpackTuple(args, "pow", 2, 3, &v, &w, &z))
	1557	return NULL;
	1558	return PyNumber_Power(v, w, z);
[2]	1559	}
	1560
	1561	PyDoc_STRVAR(pow_doc,
	1562	"pow(x, y[, z]) -> number\n\
	1563	\n\
	1564	With two arguments, equivalent to x**y. With three arguments,\n\
	1565	equivalent to (x**y) % z, but may be more efficient (e.g. for longs).");
	1566
	1567
	1568	static PyObject *
	1569	builtin_print(PyObject self, PyObject args, PyObject *kwds)
	1570	{
[391]	1571	static char *kwlist[] = {"sep", "end", "file", 0};
	1572	static PyObject *dummy_args = NULL;
	1573	static PyObject unicode_newline = NULL, unicode_space = NULL;
	1574	static PyObject str_newline = NULL, str_space = NULL;
	1575	PyObject newline, space;
	1576	PyObject sep = NULL, end = NULL, *file = NULL;
	1577	int i, err, use_unicode = 0;
[2]	1578
[391]	1579	if (dummy_args == NULL) {
	1580	if (!(dummy_args = PyTuple_New(0)))
	1581	return NULL;
	1582	}
	1583	if (str_newline == NULL) {
	1584	str_newline = PyString_FromString("\n");
	1585	if (str_newline == NULL)
	1586	return NULL;
	1587	str_space = PyString_FromString(" ");
	1588	if (str_space == NULL) {
	1589	Py_CLEAR(str_newline);
	1590	return NULL;
	1591	}
	1592	#ifdef Py_USING_UNICODE
	1593	unicode_newline = PyUnicode_FromString("\n");
	1594	if (unicode_newline == NULL) {
	1595	Py_CLEAR(str_newline);
	1596	Py_CLEAR(str_space);
	1597	return NULL;
	1598	}
	1599	unicode_space = PyUnicode_FromString(" ");
	1600	if (unicode_space == NULL) {
	1601	Py_CLEAR(str_newline);
	1602	Py_CLEAR(str_space);
	1603	Py_CLEAR(unicode_space);
	1604	return NULL;
	1605	}
	1606	#endif
	1607	}
	1608	if (!PyArg_ParseTupleAndKeywords(dummy_args, kwds, "\|OOO:print",
	1609	kwlist, &sep, &end, &file))
	1610	return NULL;
	1611	if (file == NULL \|\| file == Py_None) {
	1612	file = PySys_GetObject("stdout");
	1613	/* sys.stdout may be None when FILE* stdout isn't connected */
	1614	if (file == Py_None)
	1615	Py_RETURN_NONE;
	1616	}
	1617	if (sep == Py_None) {
	1618	sep = NULL;
	1619	}
	1620	else if (sep) {
	1621	if (PyUnicode_Check(sep)) {
	1622	use_unicode = 1;
	1623	}
	1624	else if (!PyString_Check(sep)) {
	1625	PyErr_Format(PyExc_TypeError,
	1626	"sep must be None, str or unicode, not %.200s",
	1627	sep->ob_type->tp_name);
	1628	return NULL;
	1629	}
	1630	}
	1631	if (end == Py_None)
	1632	end = NULL;
	1633	else if (end) {
	1634	if (PyUnicode_Check(end)) {
	1635	use_unicode = 1;
	1636	}
	1637	else if (!PyString_Check(end)) {
	1638	PyErr_Format(PyExc_TypeError,
	1639	"end must be None, str or unicode, not %.200s",
	1640	end->ob_type->tp_name);
	1641	return NULL;
	1642	}
	1643	}
[2]	1644
[391]	1645	if (!use_unicode) {
	1646	for (i = 0; i < PyTuple_Size(args); i++) {
	1647	if (PyUnicode_Check(PyTuple_GET_ITEM(args, i))) {
	1648	use_unicode = 1;
	1649	break;
	1650	}
	1651	}
	1652	}
	1653	if (use_unicode) {
	1654	newline = unicode_newline;
	1655	space = unicode_space;
	1656	}
	1657	else {
	1658	newline = str_newline;
	1659	space = str_space;
	1660	}
[2]	1661
[391]	1662	for (i = 0; i < PyTuple_Size(args); i++) {
	1663	if (i > 0) {
	1664	if (sep == NULL)
	1665	err = PyFile_WriteObject(space, file,
	1666	Py_PRINT_RAW);
	1667	else
	1668	err = PyFile_WriteObject(sep, file,
	1669	Py_PRINT_RAW);
	1670	if (err)
	1671	return NULL;
	1672	}
	1673	err = PyFile_WriteObject(PyTuple_GetItem(args, i), file,
	1674	Py_PRINT_RAW);
	1675	if (err)
	1676	return NULL;
	1677	}
[2]	1678
[391]	1679	if (end == NULL)
	1680	err = PyFile_WriteObject(newline, file, Py_PRINT_RAW);
	1681	else
	1682	err = PyFile_WriteObject(end, file, Py_PRINT_RAW);
	1683	if (err)
	1684	return NULL;
[2]	1685
[391]	1686	Py_RETURN_NONE;
[2]	1687	}
	1688
	1689	PyDoc_STRVAR(print_doc,
	1690	"print(value, ..., sep=' ', end='\\n', file=sys.stdout)\n\
	1691	\n\
	1692	Prints the values to a stream, or to sys.stdout by default.\n\
	1693	Optional keyword arguments:\n\
	1694	file: a file-like object (stream); defaults to the current sys.stdout.\n\
	1695	sep: string inserted between values, default a space.\n\
	1696	end: string appended after the last value, default a newline.");
	1697
	1698
	1699	/* Return number of items in range (lo, hi, step), when arguments are
	1700	* PyInt or PyLong objects. step > 0 required. Return a value < 0 if
	1701	* & only if the true value is too large to fit in a signed long.
	1702	* Arguments MUST return 1 with either PyInt_Check() or
	1703	* PyLong_Check(). Return -1 when there is an error.
	1704	*/
	1705	static long
	1706	get_len_of_range_longs(PyObject lo, PyObject hi, PyObject *step)
	1707	{
[391]	1708	/* -------------------------------------------------------------
	1709	Algorithm is equal to that of get_len_of_range(), but it operates
	1710	on PyObjects (which are assumed to be PyLong or PyInt objects).
	1711	---------------------------------------------------------------*/
	1712	long n;
	1713	PyObject *diff = NULL;
	1714	PyObject *one = NULL;
	1715	PyObject tmp1 = NULL, tmp2 = NULL, *tmp3 = NULL;
	1716	/* holds sub-expression evaluations */
[2]	1717
[391]	1718	/* if (lo >= hi), return length of 0. */
	1719	if (PyObject_Compare(lo, hi) >= 0)
	1720	return 0;
[2]	1721
[391]	1722	if ((one = PyLong_FromLong(1L)) == NULL)
	1723	goto Fail;
[2]	1724
[391]	1725	if ((tmp1 = PyNumber_Subtract(hi, lo)) == NULL)
	1726	goto Fail;
[2]	1727
[391]	1728	if ((diff = PyNumber_Subtract(tmp1, one)) == NULL)
	1729	goto Fail;
[2]	1730
[391]	1731	if ((tmp2 = PyNumber_FloorDivide(diff, step)) == NULL)
	1732	goto Fail;
[2]	1733
[391]	1734	if ((tmp3 = PyNumber_Add(tmp2, one)) == NULL)
	1735	goto Fail;
[2]	1736
[391]	1737	n = PyLong_AsLong(tmp3);
	1738	if (PyErr_Occurred()) { /* Check for Overflow */
	1739	PyErr_Clear();
	1740	goto Fail;
	1741	}
[2]	1742
[391]	1743	Py_DECREF(tmp3);
	1744	Py_DECREF(tmp2);
	1745	Py_DECREF(diff);
	1746	Py_DECREF(tmp1);
	1747	Py_DECREF(one);
	1748	return n;
[2]	1749
	1750	Fail:
[391]	1751	Py_XDECREF(tmp3);
	1752	Py_XDECREF(tmp2);
	1753	Py_XDECREF(diff);
	1754	Py_XDECREF(tmp1);
	1755	Py_XDECREF(one);
	1756	return -1;
[2]	1757	}
	1758
[391]	1759	/* Helper function for handle_range_longs. If arg is int or long
	1760	object, returns it with incremented reference count. If arg is
	1761	float, raises type error. As a last resort, creates a new int by
	1762	calling arg type's nb_int method if it is defined. Returns NULL
	1763	and sets exception on error.
	1764
	1765	Returns a new reference to an int object. */
	1766	static PyObject *
	1767	get_range_long_argument(PyObject arg, const char name)
	1768	{
	1769	PyObject *v;
	1770	PyNumberMethods *nb;
	1771	if (PyInt_Check(arg) \|\| PyLong_Check(arg)) {
	1772	Py_INCREF(arg);
	1773	return arg;
	1774	}
	1775	if (PyFloat_Check(arg) \|\|
	1776	(nb = Py_TYPE(arg)->tp_as_number) == NULL \|\|
	1777	nb->nb_int == NULL) {
	1778	PyErr_Format(PyExc_TypeError,
	1779	"range() integer %s argument expected, got %s.",
	1780	name, arg->ob_type->tp_name);
	1781	return NULL;
	1782	}
	1783	v = nb->nb_int(arg);
	1784	if (v == NULL)
	1785	return NULL;
	1786	if (PyInt_Check(v) \|\| PyLong_Check(v))
	1787	return v;
	1788	Py_DECREF(v);
	1789	PyErr_SetString(PyExc_TypeError,
	1790	"__int__ should return int object");
	1791	return NULL;
	1792	}
	1793
[2]	1794	/* An extension of builtin_range() that handles the case when PyLong
	1795	* arguments are given. */
	1796	static PyObject *
	1797	handle_range_longs(PyObject self, PyObject args)
	1798	{
[391]	1799	PyObject *ilow = NULL;
	1800	PyObject *ihigh = NULL;
	1801	PyObject *istep = NULL;
[2]	1802
[391]	1803	PyObject *low = NULL;
	1804	PyObject *high = NULL;
	1805	PyObject *step = NULL;
[2]	1806
[391]	1807	PyObject *curnum = NULL;
	1808	PyObject *v = NULL;
	1809	long bign;
	1810	Py_ssize_t i, n;
	1811	int cmp_result;
[2]	1812
[391]	1813	PyObject *zero = PyLong_FromLong(0);
[2]	1814
[391]	1815	if (zero == NULL)
	1816	return NULL;
[2]	1817
[391]	1818	if (!PyArg_UnpackTuple(args, "range", 1, 3, &ilow, &ihigh, &istep)) {
	1819	Py_DECREF(zero);
	1820	return NULL;
	1821	}
[2]	1822
[391]	1823	/* Figure out which way we were called, supply defaults, and be
	1824	* sure to incref everything so that the decrefs at the end
	1825	* are correct. NB: ilow, ihigh and istep are borrowed references.
	1826	*/
	1827	assert(ilow != NULL);
	1828	if (ihigh == NULL) {
	1829	/* only 1 arg -- it's the upper limit */
	1830	ihigh = ilow;
	1831	ilow = NULL;
	1832	}
[2]	1833
[391]	1834	/* convert ihigh if necessary */
	1835	assert(ihigh != NULL);
	1836	high = get_range_long_argument(ihigh, "end");
	1837	if (high == NULL)
	1838	goto Fail;
[2]	1839
[391]	1840	/* ihigh correct now; do ilow */
	1841	if (ilow == NULL) {
	1842	Py_INCREF(zero);
	1843	low = zero;
	1844	}
	1845	else {
	1846	low = get_range_long_argument(ilow, "start");
	1847	if (low == NULL)
	1848	goto Fail;
	1849	}
[2]	1850
[391]	1851	/* ilow and ihigh correct now; do istep */
	1852	if (istep == NULL)
	1853	step = PyLong_FromLong(1);
	1854	else
	1855	step = get_range_long_argument(istep, "step");
	1856	if (step == NULL)
	1857	goto Fail;
[2]	1858
[391]	1859	if (PyObject_Cmp(step, zero, &cmp_result) == -1)
	1860	goto Fail;
[2]	1861
[391]	1862	if (cmp_result == 0) {
	1863	PyErr_SetString(PyExc_ValueError,
	1864	"range() step argument must not be zero");
	1865	goto Fail;
	1866	}
[2]	1867
[391]	1868	if (cmp_result > 0)
	1869	bign = get_len_of_range_longs(low, high, step);
	1870	else {
	1871	PyObject *neg_step = PyNumber_Negative(step);
	1872	if (neg_step == NULL)
	1873	goto Fail;
	1874	bign = get_len_of_range_longs(high, low, neg_step);
	1875	Py_DECREF(neg_step);
	1876	}
[2]	1877
[391]	1878	n = (Py_ssize_t)bign;
	1879	if (bign < 0 \|\| (long)n != bign) {
	1880	PyErr_SetString(PyExc_OverflowError,
	1881	"range() result has too many items");
	1882	goto Fail;
	1883	}
[2]	1884
[391]	1885	v = PyList_New(n);
	1886	if (v == NULL)
	1887	goto Fail;
[2]	1888
[391]	1889	curnum = low;
	1890	Py_INCREF(curnum);
[2]	1891
[391]	1892	for (i = 0; i < n; i++) {
	1893	PyObject *w = PyNumber_Long(curnum);
	1894	PyObject *tmp_num;
	1895	if (w == NULL)
	1896	goto Fail;
[2]	1897
[391]	1898	PyList_SET_ITEM(v, i, w);
[2]	1899
[391]	1900	tmp_num = PyNumber_Add(curnum, step);
	1901	if (tmp_num == NULL)
	1902	goto Fail;
[2]	1903
[391]	1904	Py_DECREF(curnum);
	1905	curnum = tmp_num;
	1906	}
	1907	Py_DECREF(low);
	1908	Py_DECREF(high);
	1909	Py_DECREF(step);
	1910	Py_DECREF(zero);
	1911	Py_DECREF(curnum);
	1912	return v;
[2]	1913
	1914	Fail:
[391]	1915	Py_XDECREF(low);
	1916	Py_XDECREF(high);
	1917	Py_XDECREF(step);
	1918	Py_DECREF(zero);
	1919	Py_XDECREF(curnum);
	1920	Py_XDECREF(v);
	1921	return NULL;
[2]	1922	}
	1923
	1924	/* Return number of items in range/xrange (lo, hi, step). step > 0
	1925	* required. Return a value < 0 if & only if the true value is too
	1926	* large to fit in a signed long.
	1927	*/
	1928	static long
	1929	get_len_of_range(long lo, long hi, long step)
	1930	{
[391]	1931	/* -------------------------------------------------------------
	1932	If lo >= hi, the range is empty.
	1933	Else if n values are in the range, the last one is
	1934	lo + (n-1)*step, which must be <= hi-1. Rearranging,
	1935	n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives
	1936	the proper value. Since lo < hi in this case, hi-lo-1 >= 0, so
	1937	the RHS is non-negative and so truncation is the same as the
	1938	floor. Letting M be the largest positive long, the worst case
	1939	for the RHS numerator is hi=M, lo=-M-1, and then
	1940	hi-lo-1 = M-(-M-1)-1 = 2*M. Therefore unsigned long has enough
	1941	precision to compute the RHS exactly.
	1942	---------------------------------------------------------------*/
	1943	long n = 0;
	1944	if (lo < hi) {
	1945	unsigned long uhi = (unsigned long)hi;
	1946	unsigned long ulo = (unsigned long)lo;
	1947	unsigned long diff = uhi - ulo - 1;
	1948	n = (long)(diff / (unsigned long)step + 1);
	1949	}
	1950	return n;
[2]	1951	}
	1952
	1953	static PyObject *
	1954	builtin_range(PyObject self, PyObject args)
	1955	{
[391]	1956	long ilow = 0, ihigh = 0, istep = 1;
	1957	long bign;
	1958	Py_ssize_t i, n;
[2]	1959
[391]	1960	PyObject *v;
[2]	1961
[391]	1962	if (PyTuple_Size(args) <= 1) {
	1963	if (!PyArg_ParseTuple(args,
	1964	"l;range() requires 1-3 int arguments",
	1965	&ihigh)) {
	1966	PyErr_Clear();
	1967	return handle_range_longs(self, args);
	1968	}
	1969	}
	1970	else {
	1971	if (!PyArg_ParseTuple(args,
	1972	"ll\|l;range() requires 1-3 int arguments",
	1973	&ilow, &ihigh, &istep)) {
	1974	PyErr_Clear();
	1975	return handle_range_longs(self, args);
	1976	}
	1977	}
	1978	if (istep == 0) {
	1979	PyErr_SetString(PyExc_ValueError,
	1980	"range() step argument must not be zero");
	1981	return NULL;
	1982	}
	1983	if (istep > 0)
	1984	bign = get_len_of_range(ilow, ihigh, istep);
	1985	else
	1986	bign = get_len_of_range(ihigh, ilow, -istep);
	1987	n = (Py_ssize_t)bign;
	1988	if (bign < 0 \|\| (long)n != bign) {
	1989	PyErr_SetString(PyExc_OverflowError,
	1990	"range() result has too many items");
	1991	return NULL;
	1992	}
	1993	v = PyList_New(n);
	1994	if (v == NULL)
	1995	return NULL;
	1996	for (i = 0; i < n; i++) {
	1997	PyObject *w = PyInt_FromLong(ilow);
	1998	if (w == NULL) {
	1999	Py_DECREF(v);
	2000	return NULL;
	2001	}
	2002	PyList_SET_ITEM(v, i, w);
	2003	ilow += istep;
	2004	}
	2005	return v;
[2]	2006	}
	2007
	2008	PyDoc_STRVAR(range_doc,
[391]	2009	"range(stop) -> list of integers\n\
	2010	range(start, stop[, step]) -> list of integers\n\
[2]	2011	\n\
	2012	Return a list containing an arithmetic progression of integers.\n\
	2013	range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.\n\
	2014	When step is given, it specifies the increment (or decrement).\n\
	2015	For example, range(4) returns [0, 1, 2, 3]. The end point is omitted!\n\
	2016	These are exactly the valid indices for a list of 4 elements.");
	2017
	2018
	2019	static PyObject *
	2020	builtin_raw_input(PyObject self, PyObject args)
	2021	{
[391]	2022	PyObject *v = NULL;
	2023	PyObject *fin = PySys_GetObject("stdin");
	2024	PyObject *fout = PySys_GetObject("stdout");
[2]	2025
[391]	2026	if (!PyArg_UnpackTuple(args, "[raw_]input", 0, 1, &v))
	2027	return NULL;
[2]	2028
[391]	2029	if (fin == NULL) {
	2030	PyErr_SetString(PyExc_RuntimeError, "[raw_]input: lost sys.stdin");
	2031	return NULL;
	2032	}
	2033	if (fout == NULL) {
	2034	PyErr_SetString(PyExc_RuntimeError, "[raw_]input: lost sys.stdout");
	2035	return NULL;
	2036	}
	2037	if (PyFile_SoftSpace(fout, 0)) {
	2038	if (PyFile_WriteString(" ", fout) != 0)
	2039	return NULL;
	2040	}
	2041	if (PyFile_AsFile(fin) && PyFile_AsFile(fout)
	2042	&& isatty(fileno(PyFile_AsFile(fin)))
	2043	&& isatty(fileno(PyFile_AsFile(fout)))) {
	2044	PyObject *po;
	2045	char *prompt;
	2046	char *s;
	2047	PyObject *result;
	2048	if (v != NULL) {
	2049	po = PyObject_Str(v);
	2050	if (po == NULL)
	2051	return NULL;
	2052	prompt = PyString_AsString(po);
	2053	if (prompt == NULL)
	2054	return NULL;
	2055	}
	2056	else {
	2057	po = NULL;
	2058	prompt = "";
	2059	}
	2060	s = PyOS_Readline(PyFile_AsFile(fin), PyFile_AsFile(fout),
	2061	prompt);
	2062	Py_XDECREF(po);
	2063	if (s == NULL) {
	2064	if (!PyErr_Occurred())
	2065	PyErr_SetNone(PyExc_KeyboardInterrupt);
	2066	return NULL;
	2067	}
	2068	if (*s == '\0') {
	2069	PyErr_SetNone(PyExc_EOFError);
	2070	result = NULL;
	2071	}
	2072	else { /* strip trailing '\n' */
	2073	size_t len = strlen(s);
	2074	if (len > PY_SSIZE_T_MAX) {
	2075	PyErr_SetString(PyExc_OverflowError,
	2076	"[raw_]input: input too long");
	2077	result = NULL;
	2078	}
	2079	else {
	2080	result = PyString_FromStringAndSize(s, len-1);
	2081	}
	2082	}
	2083	PyMem_FREE(s);
	2084	return result;
	2085	}
	2086	if (v != NULL) {
	2087	if (PyFile_WriteObject(v, fout, Py_PRINT_RAW) != 0)
	2088	return NULL;
	2089	}
	2090	return PyFile_GetLine(fin, -1);
[2]	2091	}
	2092
	2093	PyDoc_STRVAR(raw_input_doc,
	2094	"raw_input([prompt]) -> string\n\
	2095	\n\
	2096	Read a string from standard input. The trailing newline is stripped.\n\
	2097	If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.\n\
	2098	On Unix, GNU readline is used if enabled. The prompt string, if given,\n\
	2099	is printed without a trailing newline before reading.");
	2100
	2101
	2102	static PyObject *
	2103	builtin_reduce(PyObject self, PyObject args)
	2104	{
[391]	2105	static PyObject *functools_reduce = NULL;
[2]	2106
[391]	2107	if (PyErr_WarnPy3k("reduce() not supported in 3.x; "
	2108	"use functools.reduce()", 1) < 0)
	2109	return NULL;
[2]	2110
[391]	2111	if (functools_reduce == NULL) {
	2112	PyObject *functools = PyImport_ImportModule("functools");
	2113	if (functools == NULL)
	2114	return NULL;
	2115	functools_reduce = PyObject_GetAttrString(functools, "reduce");
	2116	Py_DECREF(functools);
	2117	if (functools_reduce == NULL)
	2118	return NULL;
	2119	}
	2120	return PyObject_Call(functools_reduce, args, NULL);
[2]	2121	}
	2122
	2123	PyDoc_STRVAR(reduce_doc,
	2124	"reduce(function, sequence[, initial]) -> value\n\
	2125	\n\
	2126	Apply a function of two arguments cumulatively to the items of a sequence,\n\
	2127	from left to right, so as to reduce the sequence to a single value.\n\
	2128	For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates\n\
	2129	((((1+2)+3)+4)+5). If initial is present, it is placed before the items\n\
	2130	of the sequence in the calculation, and serves as a default when the\n\
	2131	sequence is empty.");
	2132
	2133
	2134	static PyObject *
	2135	builtin_reload(PyObject self, PyObject v)
	2136	{
[391]	2137	if (PyErr_WarnPy3k("In 3.x, reload() is renamed to imp.reload()",
	2138	1) < 0)
	2139	return NULL;
[2]	2140
[391]	2141	return PyImport_ReloadModule(v);
[2]	2142	}
	2143
	2144	PyDoc_STRVAR(reload_doc,
	2145	"reload(module) -> module\n\
	2146	\n\
	2147	Reload the module. The module must have been successfully imported before.");
	2148
	2149
	2150	static PyObject *
	2151	builtin_repr(PyObject self, PyObject v)
	2152	{
[391]	2153	return PyObject_Repr(v);
[2]	2154	}
	2155
	2156	PyDoc_STRVAR(repr_doc,
	2157	"repr(object) -> string\n\
	2158	\n\
	2159	Return the canonical string representation of the object.\n\
	2160	For most object types, eval(repr(object)) == object.");
	2161
	2162
	2163	static PyObject *
	2164	builtin_round(PyObject self, PyObject args, PyObject *kwds)
	2165	{
[391]	2166	double x;
	2167	PyObject *o_ndigits = NULL;
	2168	Py_ssize_t ndigits;
	2169	static char *kwlist[] = {"number", "ndigits", 0};
[2]	2170
[391]	2171	if (!PyArg_ParseTupleAndKeywords(args, kwds, "d\|O:round",
	2172	kwlist, &x, &o_ndigits))
	2173	return NULL;
[2]	2174
[391]	2175	if (o_ndigits == NULL) {
	2176	/* second argument defaults to 0 */
	2177	ndigits = 0;
	2178	}
	2179	else {
	2180	/* interpret 2nd argument as a Py_ssize_t; clip on overflow */
	2181	ndigits = PyNumber_AsSsize_t(o_ndigits, NULL);
	2182	if (ndigits == -1 && PyErr_Occurred())
	2183	return NULL;
	2184	}
[2]	2185
[391]	2186	/* nans, infinities and zeros round to themselves */
	2187	if (!Py_IS_FINITE(x) \|\| x == 0.0)
	2188	return PyFloat_FromDouble(x);
	2189
	2190	/* Deal with extreme values for ndigits. For ndigits > NDIGITS_MAX, x
	2191	always rounds to itself. For ndigits < NDIGITS_MIN, x always
	2192	rounds to +-0.0. Here 0.30103 is an upper bound for log10(2). */
	2193	#define NDIGITS_MAX ((int)((DBL_MANT_DIG-DBL_MIN_EXP) * 0.30103))
	2194	#define NDIGITS_MIN (-(int)((DBL_MAX_EXP + 1) * 0.30103))
	2195	if (ndigits > NDIGITS_MAX)
	2196	/* return x */
	2197	return PyFloat_FromDouble(x);
	2198	else if (ndigits < NDIGITS_MIN)
	2199	/* return 0.0, but with sign of x */
	2200	return PyFloat_FromDouble(0.0*x);
	2201	else
	2202	/* finite x, and ndigits is not unreasonably large */
	2203	/* _Py_double_round is defined in floatobject.c */
	2204	return _Py_double_round(x, (int)ndigits);
	2205	#undef NDIGITS_MAX
	2206	#undef NDIGITS_MIN
[2]	2207	}
	2208
	2209	PyDoc_STRVAR(round_doc,
	2210	"round(number[, ndigits]) -> floating point number\n\
	2211	\n\
	2212	Round a number to a given precision in decimal digits (default 0 digits).\n\
	2213	This always returns a floating point number. Precision may be negative.");
	2214
	2215	static PyObject *
	2216	builtin_sorted(PyObject self, PyObject args, PyObject *kwds)
	2217	{
[391]	2218	PyObject newlist, v, seq, compare=NULL, keyfunc=NULL, newargs;
	2219	PyObject *callable;
	2220	static char *kwlist[] = {"iterable", "cmp", "key", "reverse", 0};
	2221	int reverse;
[2]	2222
[391]	2223	/* args 1-4 should match listsort in Objects/listobject.c */
	2224	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O\|OOi:sorted",
	2225	kwlist, &seq, &compare, &keyfunc, &reverse))
	2226	return NULL;
[2]	2227
[391]	2228	newlist = PySequence_List(seq);
	2229	if (newlist == NULL)
	2230	return NULL;
[2]	2231
[391]	2232	callable = PyObject_GetAttrString(newlist, "sort");
	2233	if (callable == NULL) {
	2234	Py_DECREF(newlist);
	2235	return NULL;
	2236	}
[2]	2237
[391]	2238	newargs = PyTuple_GetSlice(args, 1, 4);
	2239	if (newargs == NULL) {
	2240	Py_DECREF(newlist);
	2241	Py_DECREF(callable);
	2242	return NULL;
	2243	}
[2]	2244
[391]	2245	v = PyObject_Call(callable, newargs, kwds);
	2246	Py_DECREF(newargs);
	2247	Py_DECREF(callable);
	2248	if (v == NULL) {
	2249	Py_DECREF(newlist);
	2250	return NULL;
	2251	}
	2252	Py_DECREF(v);
	2253	return newlist;
[2]	2254	}
	2255
	2256	PyDoc_STRVAR(sorted_doc,
	2257	"sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list");
	2258
	2259	static PyObject *
	2260	builtin_vars(PyObject self, PyObject args)
	2261	{
[391]	2262	PyObject *v = NULL;
	2263	PyObject *d;
[2]	2264
[391]	2265	if (!PyArg_UnpackTuple(args, "vars", 0, 1, &v))
	2266	return NULL;
	2267	if (v == NULL) {
	2268	d = PyEval_GetLocals();
	2269	if (d == NULL) {
	2270	if (!PyErr_Occurred())
	2271	PyErr_SetString(PyExc_SystemError,
	2272	"vars(): no locals!?");
	2273	}
	2274	else
	2275	Py_INCREF(d);
	2276	}
	2277	else {
	2278	d = PyObject_GetAttrString(v, "__dict__");
	2279	if (d == NULL) {
	2280	PyErr_SetString(PyExc_TypeError,
	2281	"vars() argument must have __dict__ attribute");
	2282	return NULL;
	2283	}
	2284	}
	2285	return d;
[2]	2286	}
	2287
	2288	PyDoc_STRVAR(vars_doc,
	2289	"vars([object]) -> dictionary\n\
	2290	\n\
	2291	Without arguments, equivalent to locals().\n\
	2292	With an argument, equivalent to object.__dict__.");
	2293
	2294
	2295	static PyObject*
	2296	builtin_sum(PyObject self, PyObject args)
	2297	{
[391]	2298	PyObject *seq;
	2299	PyObject *result = NULL;
	2300	PyObject temp, item, *iter;
[2]	2301
[391]	2302	if (!PyArg_UnpackTuple(args, "sum", 1, 2, &seq, &result))
	2303	return NULL;
[2]	2304
[391]	2305	iter = PyObject_GetIter(seq);
	2306	if (iter == NULL)
	2307	return NULL;
[2]	2308
[391]	2309	if (result == NULL) {
	2310	result = PyInt_FromLong(0);
	2311	if (result == NULL) {
	2312	Py_DECREF(iter);
	2313	return NULL;
	2314	}
	2315	} else {
	2316	/* reject string values for 'start' parameter */
	2317	if (PyObject_TypeCheck(result, &PyBaseString_Type)) {
	2318	PyErr_SetString(PyExc_TypeError,
	2319	"sum() can't sum strings [use ''.join(seq) instead]");
	2320	Py_DECREF(iter);
	2321	return NULL;
	2322	}
	2323	Py_INCREF(result);
	2324	}
[2]	2325
	2326	#ifndef SLOW_SUM
[391]	2327	/* Fast addition by keeping temporary sums in C instead of new Python objects.
	2328	Assumes all inputs are the same type. If the assumption fails, default
	2329	to the more general routine.
	2330	*/
	2331	if (PyInt_CheckExact(result)) {
	2332	long i_result = PyInt_AS_LONG(result);
	2333	Py_DECREF(result);
	2334	result = NULL;
	2335	while(result == NULL) {
	2336	item = PyIter_Next(iter);
	2337	if (item == NULL) {
	2338	Py_DECREF(iter);
	2339	if (PyErr_Occurred())
	2340	return NULL;
	2341	return PyInt_FromLong(i_result);
	2342	}
	2343	if (PyInt_CheckExact(item)) {
	2344	long b = PyInt_AS_LONG(item);
	2345	long x = i_result + b;
	2346	if ((x^i_result) >= 0 \|\| (x^b) >= 0) {
	2347	i_result = x;
	2348	Py_DECREF(item);
	2349	continue;
	2350	}
	2351	}
	2352	/* Either overflowed or is not an int. Restore real objects and process normally */
	2353	result = PyInt_FromLong(i_result);
	2354	temp = PyNumber_Add(result, item);
	2355	Py_DECREF(result);
	2356	Py_DECREF(item);
	2357	result = temp;
	2358	if (result == NULL) {
	2359	Py_DECREF(iter);
	2360	return NULL;
	2361	}
	2362	}
	2363	}
[2]	2364
[391]	2365	if (PyFloat_CheckExact(result)) {
	2366	double f_result = PyFloat_AS_DOUBLE(result);
	2367	Py_DECREF(result);
	2368	result = NULL;
	2369	while(result == NULL) {
	2370	item = PyIter_Next(iter);
	2371	if (item == NULL) {
	2372	Py_DECREF(iter);
	2373	if (PyErr_Occurred())
	2374	return NULL;
	2375	return PyFloat_FromDouble(f_result);
	2376	}
	2377	if (PyFloat_CheckExact(item)) {
	2378	PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0)
	2379	f_result += PyFloat_AS_DOUBLE(item);
	2380	PyFPE_END_PROTECT(f_result)
	2381	Py_DECREF(item);
	2382	continue;
	2383	}
	2384	if (PyInt_CheckExact(item)) {
	2385	PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0)
	2386	f_result += (double)PyInt_AS_LONG(item);
	2387	PyFPE_END_PROTECT(f_result)
	2388	Py_DECREF(item);
	2389	continue;
	2390	}
	2391	result = PyFloat_FromDouble(f_result);
	2392	temp = PyNumber_Add(result, item);
	2393	Py_DECREF(result);
	2394	Py_DECREF(item);
	2395	result = temp;
	2396	if (result == NULL) {
	2397	Py_DECREF(iter);
	2398	return NULL;
	2399	}
	2400	}
	2401	}
[2]	2402	#endif
	2403
[391]	2404	for(;;) {
	2405	item = PyIter_Next(iter);
	2406	if (item == NULL) {
	2407	/* error, or end-of-sequence */
	2408	if (PyErr_Occurred()) {
	2409	Py_DECREF(result);
	2410	result = NULL;
	2411	}
	2412	break;
	2413	}
	2414	/* It's tempting to use PyNumber_InPlaceAdd instead of
	2415	PyNumber_Add here, to avoid quadratic running time
	2416	when doing 'sum(list_of_lists, [])'. However, this
	2417	would produce a change in behaviour: a snippet like
	2418
	2419	empty = []
	2420	sum([[x] for x in range(10)], empty)
	2421
	2422	would change the value of empty. */
	2423	temp = PyNumber_Add(result, item);
	2424	Py_DECREF(result);
	2425	Py_DECREF(item);
	2426	result = temp;
	2427	if (result == NULL)
	2428	break;
	2429	}
	2430	Py_DECREF(iter);
	2431	return result;
[2]	2432	}
	2433
	2434	PyDoc_STRVAR(sum_doc,
	2435	"sum(sequence[, start]) -> value\n\
	2436	\n\
[391]	2437	Return the sum of a sequence of numbers (NOT strings) plus the value\n\
[2]	2438	of parameter 'start' (which defaults to 0). When the sequence is\n\
[391]	2439	empty, return start.");
[2]	2440
	2441
	2442	static PyObject *
	2443	builtin_isinstance(PyObject self, PyObject args)
	2444	{
[391]	2445	PyObject *inst;
	2446	PyObject *cls;
	2447	int retval;
[2]	2448
[391]	2449	if (!PyArg_UnpackTuple(args, "isinstance", 2, 2, &inst, &cls))
	2450	return NULL;
[2]	2451
[391]	2452	retval = PyObject_IsInstance(inst, cls);
	2453	if (retval < 0)
	2454	return NULL;
	2455	return PyBool_FromLong(retval);
[2]	2456	}
	2457
	2458	PyDoc_STRVAR(isinstance_doc,
	2459	"isinstance(object, class-or-type-or-tuple) -> bool\n\
	2460	\n\
	2461	Return whether an object is an instance of a class or of a subclass thereof.\n\
	2462	With a type as second argument, return whether that is the object's type.\n\
	2463	The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for\n\
	2464	isinstance(x, A) or isinstance(x, B) or ... (etc.).");
	2465
	2466
	2467	static PyObject *
	2468	builtin_issubclass(PyObject self, PyObject args)
	2469	{
[391]	2470	PyObject *derived;
	2471	PyObject *cls;
	2472	int retval;
[2]	2473
[391]	2474	if (!PyArg_UnpackTuple(args, "issubclass", 2, 2, &derived, &cls))
	2475	return NULL;
[2]	2476
[391]	2477	retval = PyObject_IsSubclass(derived, cls);
	2478	if (retval < 0)
	2479	return NULL;
	2480	return PyBool_FromLong(retval);
[2]	2481	}
	2482
	2483	PyDoc_STRVAR(issubclass_doc,
	2484	"issubclass(C, B) -> bool\n\
	2485	\n\
	2486	Return whether class C is a subclass (i.e., a derived class) of class B.\n\
	2487	When using a tuple as the second argument issubclass(X, (A, B, ...)),\n\
	2488	is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.).");
	2489
	2490
	2491	static PyObject*
	2492	builtin_zip(PyObject self, PyObject args)
	2493	{
[391]	2494	PyObject *ret;
	2495	const Py_ssize_t itemsize = PySequence_Length(args);
	2496	Py_ssize_t i;
	2497	PyObject itlist; / tuple of iterators */
	2498	Py_ssize_t len; /* guess at result length */
[2]	2499
[391]	2500	if (itemsize == 0)
	2501	return PyList_New(0);
[2]	2502
[391]	2503	/* args must be a tuple */
	2504	assert(PyTuple_Check(args));
[2]	2505
[391]	2506	/* Guess at result length: the shortest of the input lengths.
	2507	If some argument refuses to say, we refuse to guess too, lest
	2508	an argument like xrange(sys.maxint) lead us astray.*/
	2509	len = -1; /* unknown */
	2510	for (i = 0; i < itemsize; ++i) {
	2511	PyObject *item = PyTuple_GET_ITEM(args, i);
	2512	Py_ssize_t thislen = _PyObject_LengthHint(item, -2);
	2513	if (thislen < 0) {
	2514	if (thislen == -1)
	2515	return NULL;
	2516	len = -1;
	2517	break;
	2518	}
	2519	else if (len < 0 \|\| thislen < len)
	2520	len = thislen;
	2521	}
[2]	2522
[391]	2523	/* allocate result list */
	2524	if (len < 0)
	2525	len = 10; /* arbitrary */
	2526	if ((ret = PyList_New(len)) == NULL)
	2527	return NULL;
[2]	2528
[391]	2529	/* obtain iterators */
	2530	itlist = PyTuple_New(itemsize);
	2531	if (itlist == NULL)
	2532	goto Fail_ret;
	2533	for (i = 0; i < itemsize; ++i) {
	2534	PyObject *item = PyTuple_GET_ITEM(args, i);
	2535	PyObject *it = PyObject_GetIter(item);
	2536	if (it == NULL) {
	2537	if (PyErr_ExceptionMatches(PyExc_TypeError))
	2538	PyErr_Format(PyExc_TypeError,
	2539	"zip argument #%zd must support iteration",
	2540	i+1);
	2541	goto Fail_ret_itlist;
	2542	}
	2543	PyTuple_SET_ITEM(itlist, i, it);
	2544	}
[2]	2545
[391]	2546	/* build result into ret list */
	2547	for (i = 0; ; ++i) {
	2548	int j;
	2549	PyObject *next = PyTuple_New(itemsize);
	2550	if (!next)
	2551	goto Fail_ret_itlist;
[2]	2552
[391]	2553	for (j = 0; j < itemsize; j++) {
	2554	PyObject *it = PyTuple_GET_ITEM(itlist, j);
	2555	PyObject *item = PyIter_Next(it);
	2556	if (!item) {
	2557	if (PyErr_Occurred()) {
	2558	Py_DECREF(ret);
	2559	ret = NULL;
	2560	}
	2561	Py_DECREF(next);
	2562	Py_DECREF(itlist);
	2563	goto Done;
	2564	}
	2565	PyTuple_SET_ITEM(next, j, item);
	2566	}
[2]	2567
[391]	2568	if (i < len)
	2569	PyList_SET_ITEM(ret, i, next);
	2570	else {
	2571	int status = PyList_Append(ret, next);
	2572	Py_DECREF(next);
	2573	++len;
	2574	if (status < 0)
	2575	goto Fail_ret_itlist;
	2576	}
	2577	}
[2]	2578
	2579	Done:
[391]	2580	if (ret != NULL && i < len) {
	2581	/* The list is too big. */
	2582	if (PyList_SetSlice(ret, i, len, NULL) < 0)
	2583	return NULL;
	2584	}
	2585	return ret;
[2]	2586
	2587	Fail_ret_itlist:
[391]	2588	Py_DECREF(itlist);
[2]	2589	Fail_ret:
[391]	2590	Py_DECREF(ret);
	2591	return NULL;
[2]	2592	}
	2593
	2594
	2595	PyDoc_STRVAR(zip_doc,
	2596	"zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]\n\
	2597	\n\
	2598	Return a list of tuples, where each tuple contains the i-th element\n\
	2599	from each of the argument sequences. The returned list is truncated\n\
	2600	in length to the length of the shortest argument sequence.");
	2601
	2602
	2603	static PyMethodDef builtin_methods[] = {
[391]	2604	{"__import__", (PyCFunction)builtin___import__, METH_VARARGS \| METH_KEYWORDS, import_doc},
	2605	{"abs", builtin_abs, METH_O, abs_doc},
	2606	{"all", builtin_all, METH_O, all_doc},
	2607	{"any", builtin_any, METH_O, any_doc},
	2608	{"apply", builtin_apply, METH_VARARGS, apply_doc},
	2609	{"bin", builtin_bin, METH_O, bin_doc},
	2610	{"callable", builtin_callable, METH_O, callable_doc},
	2611	{"chr", builtin_chr, METH_VARARGS, chr_doc},
	2612	{"cmp", builtin_cmp, METH_VARARGS, cmp_doc},
	2613	{"coerce", builtin_coerce, METH_VARARGS, coerce_doc},
	2614	{"compile", (PyCFunction)builtin_compile, METH_VARARGS \| METH_KEYWORDS, compile_doc},
	2615	{"delattr", builtin_delattr, METH_VARARGS, delattr_doc},
	2616	{"dir", builtin_dir, METH_VARARGS, dir_doc},
	2617	{"divmod", builtin_divmod, METH_VARARGS, divmod_doc},
	2618	{"eval", builtin_eval, METH_VARARGS, eval_doc},
	2619	{"execfile", builtin_execfile, METH_VARARGS, execfile_doc},
	2620	{"filter", builtin_filter, METH_VARARGS, filter_doc},
	2621	{"format", builtin_format, METH_VARARGS, format_doc},
	2622	{"getattr", builtin_getattr, METH_VARARGS, getattr_doc},
	2623	{"globals", (PyCFunction)builtin_globals, METH_NOARGS, globals_doc},
	2624	{"hasattr", builtin_hasattr, METH_VARARGS, hasattr_doc},
	2625	{"hash", builtin_hash, METH_O, hash_doc},
	2626	{"hex", builtin_hex, METH_O, hex_doc},
	2627	{"id", builtin_id, METH_O, id_doc},
	2628	{"input", builtin_input, METH_VARARGS, input_doc},
	2629	{"intern", builtin_intern, METH_VARARGS, intern_doc},
	2630	{"isinstance", builtin_isinstance, METH_VARARGS, isinstance_doc},
	2631	{"issubclass", builtin_issubclass, METH_VARARGS, issubclass_doc},
	2632	{"iter", builtin_iter, METH_VARARGS, iter_doc},
	2633	{"len", builtin_len, METH_O, len_doc},
	2634	{"locals", (PyCFunction)builtin_locals, METH_NOARGS, locals_doc},
	2635	{"map", builtin_map, METH_VARARGS, map_doc},
	2636	{"max", (PyCFunction)builtin_max, METH_VARARGS \| METH_KEYWORDS, max_doc},
	2637	{"min", (PyCFunction)builtin_min, METH_VARARGS \| METH_KEYWORDS, min_doc},
	2638	{"next", builtin_next, METH_VARARGS, next_doc},
	2639	{"oct", builtin_oct, METH_O, oct_doc},
	2640	{"open", (PyCFunction)builtin_open, METH_VARARGS \| METH_KEYWORDS, open_doc},
	2641	{"ord", builtin_ord, METH_O, ord_doc},
	2642	{"pow", builtin_pow, METH_VARARGS, pow_doc},
	2643	{"print", (PyCFunction)builtin_print, METH_VARARGS \| METH_KEYWORDS, print_doc},
	2644	{"range", builtin_range, METH_VARARGS, range_doc},
	2645	{"raw_input", builtin_raw_input, METH_VARARGS, raw_input_doc},
	2646	{"reduce", builtin_reduce, METH_VARARGS, reduce_doc},
	2647	{"reload", builtin_reload, METH_O, reload_doc},
	2648	{"repr", builtin_repr, METH_O, repr_doc},
	2649	{"round", (PyCFunction)builtin_round, METH_VARARGS \| METH_KEYWORDS, round_doc},
	2650	{"setattr", builtin_setattr, METH_VARARGS, setattr_doc},
	2651	{"sorted", (PyCFunction)builtin_sorted, METH_VARARGS \| METH_KEYWORDS, sorted_doc},
	2652	{"sum", builtin_sum, METH_VARARGS, sum_doc},
[2]	2653	#ifdef Py_USING_UNICODE
[391]	2654	{"unichr", builtin_unichr, METH_VARARGS, unichr_doc},
[2]	2655	#endif
[391]	2656	{"vars", builtin_vars, METH_VARARGS, vars_doc},
	2657	{"zip", builtin_zip, METH_VARARGS, zip_doc},
	2658	{NULL, NULL},
[2]	2659	};
	2660
	2661	PyDoc_STRVAR(builtin_doc,
	2662	"Built-in functions, exceptions, and other objects.\n\
	2663	\n\
	2664	Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices.");
	2665
	2666	PyObject *
	2667	_PyBuiltin_Init(void)
	2668	{
[391]	2669	PyObject mod, dict, *debug;
	2670	mod = Py_InitModule4("__builtin__", builtin_methods,
	2671	builtin_doc, (PyObject *)NULL,
	2672	PYTHON_API_VERSION);
	2673	if (mod == NULL)
	2674	return NULL;
	2675	dict = PyModule_GetDict(mod);
[2]	2676
	2677	#ifdef Py_TRACE_REFS
[391]	2678	/* __builtin__ exposes a number of statically allocated objects
	2679	* that, before this code was added in 2.3, never showed up in
	2680	* the list of "all objects" maintained by Py_TRACE_REFS. As a
	2681	* result, programs leaking references to None and False (etc)
	2682	* couldn't be diagnosed by examining sys.getobjects(0).
	2683	*/
[2]	2684	#define ADD_TO_ALL(OBJECT) _Py_AddToAllObjects((PyObject *)(OBJECT), 0)
	2685	#else
	2686	#define ADD_TO_ALL(OBJECT) (void)0
	2687	#endif
	2688
	2689	#define SETBUILTIN(NAME, OBJECT) \
[391]	2690	if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0) \
	2691	return NULL; \
	2692	ADD_TO_ALL(OBJECT)
[2]	2693
[391]	2694	SETBUILTIN("None", Py_None);
	2695	SETBUILTIN("Ellipsis", Py_Ellipsis);
	2696	SETBUILTIN("NotImplemented", Py_NotImplemented);
	2697	SETBUILTIN("False", Py_False);
	2698	SETBUILTIN("True", Py_True);
	2699	SETBUILTIN("basestring", &PyBaseString_Type);
	2700	SETBUILTIN("bool", &PyBool_Type);
	2701	SETBUILTIN("memoryview", &PyMemoryView_Type);
	2702	SETBUILTIN("bytearray", &PyByteArray_Type);
	2703	SETBUILTIN("bytes", &PyString_Type);
	2704	SETBUILTIN("buffer", &PyBuffer_Type);
	2705	SETBUILTIN("classmethod", &PyClassMethod_Type);
[2]	2706	#ifndef WITHOUT_COMPLEX
[391]	2707	SETBUILTIN("complex", &PyComplex_Type);
[2]	2708	#endif
[391]	2709	SETBUILTIN("dict", &PyDict_Type);
	2710	SETBUILTIN("enumerate", &PyEnum_Type);
	2711	SETBUILTIN("file", &PyFile_Type);
	2712	SETBUILTIN("float", &PyFloat_Type);
	2713	SETBUILTIN("frozenset", &PyFrozenSet_Type);
	2714	SETBUILTIN("property", &PyProperty_Type);
	2715	SETBUILTIN("int", &PyInt_Type);
	2716	SETBUILTIN("list", &PyList_Type);
	2717	SETBUILTIN("long", &PyLong_Type);
	2718	SETBUILTIN("object", &PyBaseObject_Type);
	2719	SETBUILTIN("reversed", &PyReversed_Type);
	2720	SETBUILTIN("set", &PySet_Type);
	2721	SETBUILTIN("slice", &PySlice_Type);
	2722	SETBUILTIN("staticmethod", &PyStaticMethod_Type);
	2723	SETBUILTIN("str", &PyString_Type);
	2724	SETBUILTIN("super", &PySuper_Type);
	2725	SETBUILTIN("tuple", &PyTuple_Type);
	2726	SETBUILTIN("type", &PyType_Type);
	2727	SETBUILTIN("xrange", &PyRange_Type);
[2]	2728	#ifdef Py_USING_UNICODE
[391]	2729	SETBUILTIN("unicode", &PyUnicode_Type);
[2]	2730	#endif
[391]	2731	debug = PyBool_FromLong(Py_OptimizeFlag == 0);
	2732	if (PyDict_SetItemString(dict, "__debug__", debug) < 0) {
	2733	Py_XDECREF(debug);
	2734	return NULL;
	2735	}
	2736	Py_XDECREF(debug);
[2]	2737
[391]	2738	return mod;
[2]	2739	#undef ADD_TO_ALL
	2740	#undef SETBUILTIN
	2741	}
	2742
	2743	/* Helper for filter(): filter a tuple through a function */
	2744
	2745	static PyObject *
	2746	filtertuple(PyObject func, PyObject tuple)
	2747	{
[391]	2748	PyObject *result;
	2749	Py_ssize_t i, j;
	2750	Py_ssize_t len = PyTuple_Size(tuple);
[2]	2751
[391]	2752	if (len == 0) {
	2753	if (PyTuple_CheckExact(tuple))
	2754	Py_INCREF(tuple);
	2755	else
	2756	tuple = PyTuple_New(0);
	2757	return tuple;
	2758	}
[2]	2759
[391]	2760	if ((result = PyTuple_New(len)) == NULL)
	2761	return NULL;
[2]	2762
[391]	2763	for (i = j = 0; i < len; ++i) {
	2764	PyObject item, good;
	2765	int ok;
[2]	2766
[391]	2767	if (tuple->ob_type->tp_as_sequence &&
	2768	tuple->ob_type->tp_as_sequence->sq_item) {
	2769	item = tuple->ob_type->tp_as_sequence->sq_item(tuple, i);
	2770	if (item == NULL)
	2771	goto Fail_1;
	2772	} else {
	2773	PyErr_SetString(PyExc_TypeError, "filter(): unsubscriptable tuple");
	2774	goto Fail_1;
	2775	}
	2776	if (func == Py_None) {
	2777	Py_INCREF(item);
	2778	good = item;
	2779	}
	2780	else {
	2781	PyObject *arg = PyTuple_Pack(1, item);
	2782	if (arg == NULL) {
	2783	Py_DECREF(item);
	2784	goto Fail_1;
	2785	}
	2786	good = PyEval_CallObject(func, arg);
	2787	Py_DECREF(arg);
	2788	if (good == NULL) {
	2789	Py_DECREF(item);
	2790	goto Fail_1;
	2791	}
	2792	}
	2793	ok = PyObject_IsTrue(good);
	2794	Py_DECREF(good);
	2795	if (ok > 0) {
	2796	if (PyTuple_SetItem(result, j++, item) < 0)
	2797	goto Fail_1;
	2798	}
	2799	else {
	2800	Py_DECREF(item);
	2801	if (ok < 0)
	2802	goto Fail_1;
	2803	}
	2804	}
[2]	2805
[391]	2806	if (_PyTuple_Resize(&result, j) < 0)
	2807	return NULL;
[2]	2808
[391]	2809	return result;
[2]	2810
	2811	Fail_1:
[391]	2812	Py_DECREF(result);
	2813	return NULL;
[2]	2814	}
	2815
	2816
	2817	/* Helper for filter(): filter a string through a function */
	2818
	2819	static PyObject *
	2820	filterstring(PyObject func, PyObject strobj)
	2821	{
[391]	2822	PyObject *result;
	2823	Py_ssize_t i, j;
	2824	Py_ssize_t len = PyString_Size(strobj);
	2825	Py_ssize_t outlen = len;
[2]	2826
[391]	2827	if (func == Py_None) {
	2828	/* If it's a real string we can return the original,
	2829	* as no character is ever false and __getitem__
	2830	* does return this character. If it's a subclass
	2831	* we must go through the __getitem__ loop */
	2832	if (PyString_CheckExact(strobj)) {
	2833	Py_INCREF(strobj);
	2834	return strobj;
	2835	}
	2836	}
	2837	if ((result = PyString_FromStringAndSize(NULL, len)) == NULL)
	2838	return NULL;
[2]	2839
[391]	2840	for (i = j = 0; i < len; ++i) {
	2841	PyObject *item;
	2842	int ok;
[2]	2843
[391]	2844	item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
	2845	if (item == NULL)
	2846	goto Fail_1;
	2847	if (func==Py_None) {
	2848	ok = 1;
	2849	} else {
	2850	PyObject arg, good;
	2851	arg = PyTuple_Pack(1, item);
	2852	if (arg == NULL) {
	2853	Py_DECREF(item);
	2854	goto Fail_1;
	2855	}
	2856	good = PyEval_CallObject(func, arg);
	2857	Py_DECREF(arg);
	2858	if (good == NULL) {
	2859	Py_DECREF(item);
	2860	goto Fail_1;
	2861	}
	2862	ok = PyObject_IsTrue(good);
	2863	Py_DECREF(good);
	2864	}
	2865	if (ok > 0) {
	2866	Py_ssize_t reslen;
	2867	if (!PyString_Check(item)) {
	2868	PyErr_SetString(PyExc_TypeError, "can't filter str to str:"
	2869	" __getitem__ returned different type");
	2870	Py_DECREF(item);
	2871	goto Fail_1;
	2872	}
	2873	reslen = PyString_GET_SIZE(item);
	2874	if (reslen == 1) {
	2875	PyString_AS_STRING(result)[j++] =
	2876	PyString_AS_STRING(item)[0];
	2877	} else {
	2878	/* do we need more space? */
	2879	Py_ssize_t need = j;
[2]	2880
[391]	2881	/* calculate space requirements while checking for overflow */
	2882	if (need > PY_SSIZE_T_MAX - reslen) {
	2883	Py_DECREF(item);
	2884	goto Fail_1;
	2885	}
[2]	2886
[391]	2887	need += reslen;
[2]	2888
[391]	2889	if (need > PY_SSIZE_T_MAX - len) {
	2890	Py_DECREF(item);
	2891	goto Fail_1;
	2892	}
[2]	2893
[391]	2894	need += len;
[2]	2895
[391]	2896	if (need <= i) {
	2897	Py_DECREF(item);
	2898	goto Fail_1;
	2899	}
[2]	2900
[391]	2901	need = need - i - 1;
[2]	2902
[391]	2903	assert(need >= 0);
	2904	assert(outlen >= 0);
[2]	2905
[391]	2906	if (need > outlen) {
	2907	/* overallocate, to avoid reallocations */
	2908	if (outlen > PY_SSIZE_T_MAX / 2) {
	2909	Py_DECREF(item);
	2910	return NULL;
	2911	}
[2]	2912
[391]	2913	if (need<2*outlen) {
	2914	need = 2*outlen;
	2915	}
	2916	if (_PyString_Resize(&result, need)) {
	2917	Py_DECREF(item);
	2918	return NULL;
	2919	}
	2920	outlen = need;
	2921	}
	2922	memcpy(
	2923	PyString_AS_STRING(result) + j,
	2924	PyString_AS_STRING(item),
	2925	reslen
	2926	);
	2927	j += reslen;
	2928	}
	2929	}
	2930	Py_DECREF(item);
	2931	if (ok < 0)
	2932	goto Fail_1;
	2933	}
[2]	2934
[391]	2935	if (j < outlen)
	2936	_PyString_Resize(&result, j);
[2]	2937
[391]	2938	return result;
[2]	2939
	2940	Fail_1:
[391]	2941	Py_DECREF(result);
	2942	return NULL;
[2]	2943	}
	2944
	2945	#ifdef Py_USING_UNICODE
	2946	/* Helper for filter(): filter a Unicode object through a function */
	2947
	2948	static PyObject *
	2949	filterunicode(PyObject func, PyObject strobj)
	2950	{
[391]	2951	PyObject *result;
	2952	register Py_ssize_t i, j;
	2953	Py_ssize_t len = PyUnicode_GetSize(strobj);
	2954	Py_ssize_t outlen = len;
[2]	2955
[391]	2956	if (func == Py_None) {
	2957	/* If it's a real string we can return the original,
	2958	* as no character is ever false and __getitem__
	2959	* does return this character. If it's a subclass
	2960	* we must go through the __getitem__ loop */
	2961	if (PyUnicode_CheckExact(strobj)) {
	2962	Py_INCREF(strobj);
	2963	return strobj;
	2964	}
	2965	}
	2966	if ((result = PyUnicode_FromUnicode(NULL, len)) == NULL)
	2967	return NULL;
[2]	2968
[391]	2969	for (i = j = 0; i < len; ++i) {
	2970	PyObject item, arg, *good;
	2971	int ok;
[2]	2972
[391]	2973	item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
	2974	if (item == NULL)
	2975	goto Fail_1;
	2976	if (func == Py_None) {
	2977	ok = 1;
	2978	} else {
	2979	arg = PyTuple_Pack(1, item);
	2980	if (arg == NULL) {
	2981	Py_DECREF(item);
	2982	goto Fail_1;
	2983	}
	2984	good = PyEval_CallObject(func, arg);
	2985	Py_DECREF(arg);
	2986	if (good == NULL) {
	2987	Py_DECREF(item);
	2988	goto Fail_1;
	2989	}
	2990	ok = PyObject_IsTrue(good);
	2991	Py_DECREF(good);
	2992	}
	2993	if (ok > 0) {
	2994	Py_ssize_t reslen;
	2995	if (!PyUnicode_Check(item)) {
	2996	PyErr_SetString(PyExc_TypeError,
	2997	"can't filter unicode to unicode:"
	2998	" __getitem__ returned different type");
	2999	Py_DECREF(item);
	3000	goto Fail_1;
	3001	}
	3002	reslen = PyUnicode_GET_SIZE(item);
	3003	if (reslen == 1)
	3004	PyUnicode_AS_UNICODE(result)[j++] =
	3005	PyUnicode_AS_UNICODE(item)[0];
	3006	else {
	3007	/* do we need more space? */
	3008	Py_ssize_t need = j + reslen + len - i - 1;
[2]	3009
[391]	3010	/* check that didnt overflow */
	3011	if ((j > PY_SSIZE_T_MAX - reslen) \|\|
	3012	((j + reslen) > PY_SSIZE_T_MAX - len) \|\|
	3013	((j + reslen + len) < i) \|\|
	3014	((j + reslen + len - i) <= 0)) {
	3015	Py_DECREF(item);
	3016	return NULL;
	3017	}
[2]	3018
[391]	3019	assert(need >= 0);
	3020	assert(outlen >= 0);
[2]	3021
[391]	3022	if (need > outlen) {
	3023	/* overallocate,
	3024	to avoid reallocations */
	3025	if (need < 2 * outlen) {
	3026	if (outlen > PY_SSIZE_T_MAX / 2) {
	3027	Py_DECREF(item);
	3028	return NULL;
	3029	} else {
	3030	need = 2 * outlen;
	3031	}
	3032	}
[2]	3033
[391]	3034	if (PyUnicode_Resize(
	3035	&result, need) < 0) {
	3036	Py_DECREF(item);
	3037	goto Fail_1;
	3038	}
	3039	outlen = need;
	3040	}
	3041	memcpy(PyUnicode_AS_UNICODE(result) + j,
	3042	PyUnicode_AS_UNICODE(item),
	3043	reslen*sizeof(Py_UNICODE));
	3044	j += reslen;
	3045	}
	3046	}
	3047	Py_DECREF(item);
	3048	if (ok < 0)
	3049	goto Fail_1;
	3050	}
[2]	3051
[391]	3052	if (j < outlen)
	3053	PyUnicode_Resize(&result, j);
	3054
	3055	return result;
	3056
[2]	3057	Fail_1:
[391]	3058	Py_DECREF(result);
	3059	return NULL;
[2]	3060	}
	3061	#endif

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: python/trunk/Python/bltinmodule.c

Download in other formats: