add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Python/bltinmodule.c (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Python/bltinmodule.c+2620−0

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