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>

    11 

    12 #ifdef RISCOS

    13 #include "unixstuff.h"

    14 #endif

    15 

    16 /* The default encoding used by the platform file system APIs

    17    Can remain NULL for all platforms that don't have such a concept

    18 */

    19 #if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)

    20 const char *Py_FileSystemDefaultEncoding = "mbcs";

    21 #elif defined(__APPLE__)

    22 const char *Py_FileSystemDefaultEncoding = "utf-8";

    23 #else

    24 const char *Py_FileSystemDefaultEncoding = NULL; /* use default */

    25 #endif

    26 

    27 /* Forward */

    28 static PyObject *filterstring(PyObject *, PyObject *);

    29 #ifdef Py_USING_UNICODE

    30 static PyObject *filterunicode(PyObject *, PyObject *);

    31 #endif

    32 static PyObject *filtertuple (PyObject *, PyObject *);

    33 

    34 static PyObject *

    35 builtin___import__(PyObject *self, PyObject *args, PyObject *kwds)

    36 {

    37 	static char *kwlist[] = {"name", "globals", "locals", "fromlist",

    38 				 "level", 0};

    39 	char *name;

    40 	PyObject *globals = NULL;

    41 	PyObject *locals = NULL;

    42 	PyObject *fromlist = NULL;

    43 	int level = -1;

    44 

    45 	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|OOOi:__import__",

    46 			kwlist, &name, &globals, &locals, &fromlist, &level))

    47 		return NULL;

    48 	return PyImport_ImportModuleLevel(name, globals, locals,

    49 					  fromlist, level);

    50 }

    51 

    52 PyDoc_STRVAR(import_doc,

    53 "__import__(name, globals={}, locals={}, fromlist=[], level=-1) -> module\n\

    54 \n\

    55 Import a module.  The globals are only used to determine the context;\n\

    56 they are not modified.  The locals are currently unused.  The fromlist\n\

    57 should be a list of names to emulate ``from name import ...'', or an\n\

    58 empty list to emulate ``import name''.\n\

    59 When importing a module from a package, note that __import__('A.B', ...)\n\

    60 returns package A when fromlist is empty, but its submodule B when\n\

    61 fromlist is not empty.  Level is used to determine whether to perform \n\

    62 absolute or relative imports.  -1 is the original strategy of attempting\n\

    63 both absolute and relative imports, 0 is absolute, a positive number\n\

    64 is the number of parent directories to search relative to the current module.");

    65 

    66 

    67 static PyObject *

    68 builtin_abs(PyObject *self, PyObject *v)

    69 {

    70 	return PyNumber_Absolute(v);

    71 }

    72 

    73 PyDoc_STRVAR(abs_doc,

    74 "abs(number) -> number\n\

    75 \n\

    76 Return the absolute value of the argument.");

    77 

    78 static PyObject *

    79 builtin_all(PyObject *self, PyObject *v)

    80 {

    81 	PyObject *it, *item;

    82 	PyObject *(*iternext)(PyObject *);

    83 	int cmp;

    84 

    85 	it = PyObject_GetIter(v);

    86 	if (it == NULL)

    87 		return NULL;

    88 	iternext = *Py_TYPE(it)->tp_iternext;

    89 

    90 	for (;;) {

    91 		item = iternext(it);

    92 		if (item == NULL)

    93 			break;

    94 		cmp = PyObject_IsTrue(item);

    95 		Py_DECREF(item);

    96 		if (cmp < 0) {

    97 			Py_DECREF(it);

    98 			return NULL;

    99 		}

   100 		if (cmp == 0) {

   101 			Py_DECREF(it);

   102 			Py_RETURN_FALSE;

   103 		}

   104 	}

   105 	Py_DECREF(it);

   106 	if (PyErr_Occurred()) {

   107 		if (PyErr_ExceptionMatches(PyExc_StopIteration))

   108 			PyErr_Clear();

   109 		else

   110 			return NULL;

   111 	}

   112 	Py_RETURN_TRUE;

   113 }

   114 

   115 PyDoc_STRVAR(all_doc,

   116 "all(iterable) -> bool\n\

   117 \n\

   118 Return True if bool(x) is True for all values x in the iterable.");

   119 

   120 static PyObject *

   121 builtin_any(PyObject *self, PyObject *v)

   122 {

   123 	PyObject *it, *item;

   124 	PyObject *(*iternext)(PyObject *);

   125 	int cmp;

   126 

   127 	it = PyObject_GetIter(v);

   128 	if (it == NULL)

   129 		return NULL;

   130 	iternext = *Py_TYPE(it)->tp_iternext;

   131 

   132 	for (;;) {

   133 		item = iternext(it);

   134 		if (item == NULL)

   135 			break;

   136 		cmp = PyObject_IsTrue(item);

   137 		Py_DECREF(item);

   138 		if (cmp < 0) {

   139 			Py_DECREF(it);

   140 			return NULL;

   141 		}

   142 		if (cmp == 1) {

   143 			Py_DECREF(it);

   144 			Py_RETURN_TRUE;

   145 		}

   146 	}

   147 	Py_DECREF(it);

   148 	if (PyErr_Occurred()) {

   149 		if (PyErr_ExceptionMatches(PyExc_StopIteration))

   150 			PyErr_Clear();

   151 		else

   152 			return NULL;

   153 	}

   154 	Py_RETURN_FALSE;

   155 }

   156 

   157 PyDoc_STRVAR(any_doc,

   158 "any(iterable) -> bool\n\

   159 \n\

   160 Return True if bool(x) is True for any x in the iterable.");

   161 

   162 static PyObject *

   163 builtin_apply(PyObject *self, PyObject *args)

   164 {

   165 	PyObject *func, *alist = NULL, *kwdict = NULL;

   166 	PyObject *t = NULL, *retval = NULL;

   167 

   168 	if (PyErr_WarnPy3k("apply() not supported in 3.x; "

   169 			   "use func(*args, **kwargs)", 1) < 0)

   170 		return NULL;

   171 

   172 	if (!PyArg_UnpackTuple(args, "apply", 1, 3, &func, &alist, &kwdict))

   173 		return NULL;

   174 	if (alist != NULL) {

   175 		if (!PyTuple_Check(alist)) {

   176 			if (!PySequence_Check(alist)) {

   177 				PyErr_Format(PyExc_TypeError,

   178 				     "apply() arg 2 expected sequence, found %s",

   179 					     alist->ob_type->tp_name);

   180 				return NULL;

   181 			}

   182 			t = PySequence_Tuple(alist);

   183 			if (t == NULL)

   184 				return NULL;

   185 			alist = t;

   186 		}

   187 	}

   188 	if (kwdict != NULL && !PyDict_Check(kwdict)) {

   189 		PyErr_Format(PyExc_TypeError,

   190 			     "apply() arg 3 expected dictionary, found %s",

   191 			     kwdict->ob_type->tp_name);

   192 		goto finally;

   193 	}

   194 	retval = PyEval_CallObjectWithKeywords(func, alist, kwdict);

   195   finally:

   196 	Py_XDECREF(t);

   197 	return retval;

   198 }

   199 

   200 PyDoc_STRVAR(apply_doc,

   201 "apply(object[, args[, kwargs]]) -> value\n\

   202 \n\

   203 Call a callable object with positional arguments taken from the tuple args,\n\

   204 and keyword arguments taken from the optional dictionary kwargs.\n\

   205 Note that classes are callable, as are instances with a __call__() method.\n\

   206 \n\

   207 Deprecated since release 2.3. Instead, use the extended call syntax:\n\

   208     function(*args, **keywords).");

   209 

   210 

   211 static PyObject *

   212 builtin_bin(PyObject *self, PyObject *v)

   213 {

   214         return PyNumber_ToBase(v, 2);

   215 }

   216 

   217 PyDoc_STRVAR(bin_doc,

   218 "bin(number) -> string\n\

   219 \n\

   220 Return the binary representation of an integer or long integer.");

   221 

   222 

   223 static PyObject *

   224 builtin_callable(PyObject *self, PyObject *v)

   225 {

   226 	if (PyErr_WarnPy3k("callable() not supported in 3.x; "

   227 			   "use hasattr(o, '__call__')", 1) < 0)

   228 		return NULL;

   229 	return PyBool_FromLong((long)PyCallable_Check(v));

   230 }

   231 

   232 PyDoc_STRVAR(callable_doc,

   233 "callable(object) -> bool\n\

   234 \n\

   235 Return whether the object is callable (i.e., some kind of function).\n\

   236 Note that classes are callable, as are instances with a __call__() method.");

   237 

   238 

   239 static PyObject *

   240 builtin_filter(PyObject *self, PyObject *args)

   241 {

   242 	PyObject *func, *seq, *result, *it, *arg;

   243 	Py_ssize_t len;   /* guess for result list size */

   244 	register Py_ssize_t j;

   245 

   246 	if (!PyArg_UnpackTuple(args, "filter", 2, 2, &func, &seq))

   247 		return NULL;

   248 

   249 	/* Strings and tuples return a result of the same type. */

   250 	if (PyString_Check(seq))

   251 		return filterstring(func, seq);

   252 #ifdef Py_USING_UNICODE

   253 	if (PyUnicode_Check(seq))

   254 		return filterunicode(func, seq);

   255 #endif

   256 	if (PyTuple_Check(seq))

   257 		return filtertuple(func, seq);

   258 

   259 	/* Pre-allocate argument list tuple. */

   260 	arg = PyTuple_New(1);

   261 	if (arg == NULL)

   262 		return NULL;

   263 

   264 	/* Get iterator. */

   265 	it = PyObject_GetIter(seq);

   266 	if (it == NULL)

   267 		goto Fail_arg;

   268 

   269 	/* Guess a result list size. */

   270 	len = _PyObject_LengthHint(seq, 8);

   271 

   272 	/* Get a result list. */

   273 	if (PyList_Check(seq) && seq->ob_refcnt == 1) {

   274 		/* Eww - can modify the list in-place. */

   275 		Py_INCREF(seq);

   276 		result = seq;

   277 	}

   278 	else {

   279 		result = PyList_New(len);

   280 		if (result == NULL)

   281 			goto Fail_it;

   282 	}

   283 

   284 	/* Build the result list. */

   285 	j = 0;

   286 	for (;;) {

   287 		PyObject *item;

   288 		int ok;

   289 

   290 		item = PyIter_Next(it);

   291 		if (item == NULL) {

   292 			if (PyErr_Occurred())

   293 				goto Fail_result_it;

   294 			break;

   295 		}

   296 

   297 		if (func == (PyObject *)&PyBool_Type || func == Py_None) {

   298 			ok = PyObject_IsTrue(item);

   299 		}

   300 		else {

   301 			PyObject *good;

   302 			PyTuple_SET_ITEM(arg, 0, item);

   303 			good = PyObject_Call(func, arg, NULL);

   304 			PyTuple_SET_ITEM(arg, 0, NULL);

   305 			if (good == NULL) {

   306 				Py_DECREF(item);

   307 				goto Fail_result_it;

   308 			}

   309 			ok = PyObject_IsTrue(good);

   310 			Py_DECREF(good);

   311 		}

   312 		if (ok) {

   313 			if (j < len)

   314 				PyList_SET_ITEM(result, j, item);

   315 			else {

   316 				int status = PyList_Append(result, item);

   317 				Py_DECREF(item);

   318 				if (status < 0)

   319 					goto Fail_result_it;

   320 			}

   321 			++j;

   322 		}

   323 		else

   324 			Py_DECREF(item);

   325 	}

   326 

   327 

   328 	/* Cut back result list if len is too big. */

   329 	if (j < len && PyList_SetSlice(result, j, len, NULL) < 0)

   330 		goto Fail_result_it;

   331 

   332 	Py_DECREF(it);

   333 	Py_DECREF(arg);

   334 	return result;

   335 

   336 Fail_result_it:

   337 	Py_DECREF(result);

   338 Fail_it:

   339 	Py_DECREF(it);

   340 Fail_arg:

   341 	Py_DECREF(arg);

   342 	return NULL;

   343 }

   344 

   345 PyDoc_STRVAR(filter_doc,

   346 "filter(function or None, sequence) -> list, tuple, or string\n"

   347 "\n"

   348 "Return those items of sequence for which function(item) is true.  If\n"

   349 "function is None, return the items that are true.  If sequence is a tuple\n"

   350 "or string, return the same type, else return a list.");

   351 

   352 static PyObject *

   353 builtin_format(PyObject *self, PyObject *args)

   354 {

   355 	PyObject *value;

   356 	PyObject *format_spec = NULL;

   357 

   358 	if (!PyArg_ParseTuple(args, "O|O:format", &value, &format_spec))

   359 		return NULL;

   360 

   361 	return PyObject_Format(value, format_spec);

   362 }

   363 

   364 PyDoc_STRVAR(format_doc,

   365 "format(value[, format_spec]) -> string\n\

   366 \n\

   367 Returns value.__format__(format_spec)\n\

   368 format_spec defaults to \"\"");

   369 

   370 static PyObject *

   371 builtin_chr(PyObject *self, PyObject *args)

   372 {

   373 	long x;

   374 	char s[1];

   375 

   376 	if (!PyArg_ParseTuple(args, "l:chr", &x))

   377 		return NULL;

   378 	if (x < 0 || x >= 256) {

   379 		PyErr_SetString(PyExc_ValueError,

   380 				"chr() arg not in range(256)");

   381 		return NULL;

   382 	}

   383 	s[0] = (char)x;

   384 	return PyString_FromStringAndSize(s, 1);

   385 }

   386 

   387 PyDoc_STRVAR(chr_doc,

   388 "chr(i) -> character\n\

   389 \n\

   390 Return a string of one character with ordinal i; 0 <= i < 256.");

   391 

   392 

   393 #ifdef Py_USING_UNICODE

   394 static PyObject *

   395 builtin_unichr(PyObject *self, PyObject *args)

   396 {

   397 	int x;

   398 

   399 	if (!PyArg_ParseTuple(args, "i:unichr", &x))

   400 		return NULL;

   401 

   402 	return PyUnicode_FromOrdinal(x);

   403 }

   404 

   405 PyDoc_STRVAR(unichr_doc,

   406 "unichr(i) -> Unicode character\n\

   407 \n\

   408 Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.");

   409 #endif

   410 

   411 

   412 static PyObject *

   413 builtin_cmp(PyObject *self, PyObject *args)

   414 {

   415 	PyObject *a, *b;

   416 	int c;

   417 

   418 	if (!PyArg_UnpackTuple(args, "cmp", 2, 2, &a, &b))

   419 		return NULL;

   420 	if (PyObject_Cmp(a, b, &c) < 0)

   421 		return NULL;

   422 	return PyInt_FromLong((long)c);

   423 }

   424 

   425 PyDoc_STRVAR(cmp_doc,

   426 "cmp(x, y) -> integer\n\

   427 \n\

   428 Return negative if x<y, zero if x==y, positive if x>y.");

   429 

   430 

   431 static PyObject *

   432 builtin_coerce(PyObject *self, PyObject *args)

   433 {

   434 	PyObject *v, *w;

   435 	PyObject *res;

   436 

   437 	if (PyErr_WarnPy3k("coerce() not supported in 3.x", 1) < 0)

   438 		return NULL;

   439 

   440 	if (!PyArg_UnpackTuple(args, "coerce", 2, 2, &v, &w))

   441 		return NULL;

   442 	if (PyNumber_Coerce(&v, &w) < 0)

   443 		return NULL;

   444 	res = PyTuple_Pack(2, v, w);

   445 	Py_DECREF(v);

   446 	Py_DECREF(w);

   447 	return res;

   448 }

   449 

   450 PyDoc_STRVAR(coerce_doc,

   451 "coerce(x, y) -> (x1, y1)\n\

   452 \n\

   453 Return a tuple consisting of the two numeric arguments converted to\n\

   454 a common type, using the same rules as used by arithmetic operations.\n\

   455 If coercion is not possible, raise TypeError.");

   456 

   457 static PyObject *

   458 builtin_compile(PyObject *self, PyObject *args, PyObject *kwds)

   459 {

   460 	char *str;

   461 	char *filename;

   462 	char *startstr;

   463 	int mode = -1;

   464 	int dont_inherit = 0;

   465 	int supplied_flags = 0;

   466 	PyCompilerFlags cf;

   467 	PyObject *result = NULL, *cmd, *tmp = NULL;

   468 	Py_ssize_t length;

   469 	static char *kwlist[] = {"source", "filename", "mode", "flags",

   470 				 "dont_inherit", NULL};

   471 	int start[] = {Py_file_input, Py_eval_input, Py_single_input};

   472 

   473 	if (!PyArg_ParseTupleAndKeywords(args, kwds, "Oss|ii:compile",

   474 					 kwlist, &cmd, &filename, &startstr,

   475 					 &supplied_flags, &dont_inherit))

   476 		return NULL;

   477 

   478 	cf.cf_flags = supplied_flags;

   479 

   480 	if (supplied_flags &

   481 	    ~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_DONT_IMPLY_DEDENT | PyCF_ONLY_AST))

   482 	{

   483 		PyErr_SetString(PyExc_ValueError,

   484 				"compile(): unrecognised flags");

   485 		return NULL;

   486 	}

   487 	/* XXX Warn if (supplied_flags & PyCF_MASK_OBSOLETE) != 0? */

   488 

   489 	if (!dont_inherit) {

   490 		PyEval_MergeCompilerFlags(&cf);

   491 	}

   492 

   493 	if (strcmp(startstr, "exec") == 0)

   494 		mode = 0;

   495 	else if (strcmp(startstr, "eval") == 0)

   496 		mode = 1;

   497 	else if (strcmp(startstr, "single") == 0)

   498 		mode = 2;

   499 	else {

   500 		PyErr_SetString(PyExc_ValueError,

   501 				"compile() arg 3 must be 'exec', 'eval' or 'single'");

   502 		return NULL;

   503 	}

   504 

   505 	if (PyAST_Check(cmd)) {

   506 		if (supplied_flags & PyCF_ONLY_AST) {

   507 			Py_INCREF(cmd);

   508 			result = cmd;

   509 		}

   510 		else {

   511 			PyArena *arena;

   512 			mod_ty mod;

   513 

   514 			arena = PyArena_New();

   515 			mod = PyAST_obj2mod(cmd, arena, mode);

   516 			if (mod == NULL) {

   517 				PyArena_Free(arena);

   518 				return NULL;

   519 			}

   520 			result = (PyObject*)PyAST_Compile(mod, filename,

   521 							  &cf, arena);

   522 			PyArena_Free(arena);

   523 		}

   524 		return result;

   525 	}

   526 

   527 #ifdef Py_USING_UNICODE

   528 	if (PyUnicode_Check(cmd)) {

   529 		tmp = PyUnicode_AsUTF8String(cmd);

   530 		if (tmp == NULL)

   531 			return NULL;

   532 		cmd = tmp;

   533 		cf.cf_flags |= PyCF_SOURCE_IS_UTF8;

   534 	}

   535 #endif

   536 

   537 	if (PyObject_AsReadBuffer(cmd, (const void **)&str, &length))

   538 		goto cleanup;

   539 	if ((size_t)length != strlen(str)) {

   540 		PyErr_SetString(PyExc_TypeError,

   541 				"compile() expected string without null bytes");

   542 		goto cleanup;

   543 	}

   544 	result = Py_CompileStringFlags(str, filename, start[mode], &cf);

   545 cleanup:

   546 	Py_XDECREF(tmp);

   547 	return result;

   548 }

   549 

   550 PyDoc_STRVAR(compile_doc,

   551 "compile(source, filename, mode[, flags[, dont_inherit]]) -> code object\n\

   552 \n\

   553 Compile the source string (a Python module, statement or expression)\n\

   554 into a code object that can be executed by the exec statement or eval().\n\

   555 The filename will be used for run-time error messages.\n\

   556 The mode must be 'exec' to compile a module, 'single' to compile a\n\

   557 single (interactive) statement, or 'eval' to compile an expression.\n\

   558 The flags argument, if present, controls which future statements influence\n\

   559 the compilation of the code.\n\

   560 The dont_inherit argument, if non-zero, stops the compilation inheriting\n\

   561 the effects of any future statements in effect in the code calling\n\

   562 compile; if absent or zero these statements do influence the compilation,\n\

   563 in addition to any features explicitly specified.");

   564 

   565 static PyObject *

   566 builtin_dir(PyObject *self, PyObject *args)

   567 {

   568 	PyObject *arg = NULL;

   569 

   570 	if (!PyArg_UnpackTuple(args, "dir", 0, 1, &arg))

   571 		return NULL;

   572 	return PyObject_Dir(arg);

   573 }

   574 

   575 PyDoc_STRVAR(dir_doc,

   576 "dir([object]) -> list of strings\n"

   577 "\n"

   578 "If called without an argument, return the names in the current scope.\n"

   579 "Else, return an alphabetized list of names comprising (some of) the attributes\n"

   580 "of the given object, and of attributes reachable from it.\n"

   581 "If the object supplies a method named __dir__, it will be used; otherwise\n"

   582 "the default dir() logic is used and returns:\n"

   583 "  for a module object: the module's attributes.\n"

   584 "  for a class object:  its attributes, and recursively the attributes\n"

   585 "    of its bases.\n"

   586 "  for any other object: its attributes, its class's attributes, and\n"

   587 "    recursively the attributes of its class's base classes.");

   588 

   589 static PyObject *

   590 builtin_divmod(PyObject *self, PyObject *args)

   591 {

   592 	PyObject *v, *w;

   593 

   594 	if (!PyArg_UnpackTuple(args, "divmod", 2, 2, &v, &w))

   595 		return NULL;

   596 	return PyNumber_Divmod(v, w);

   597 }

   598 

   599 PyDoc_STRVAR(divmod_doc,

   600 "divmod(x, y) -> (div, mod)\n\

   601 \n\

   602 Return the tuple ((x-x%y)/y, x%y).  Invariant: div*y + mod == x.");

   603 

   604 

   605 static PyObject *

   606 builtin_eval(PyObject *self, PyObject *args)

   607 {

   608 	PyObject *cmd, *result, *tmp = NULL;

   609 	PyObject *globals = Py_None, *locals = Py_None;

   610 	char *str;

   611 	PyCompilerFlags cf;

   612 

   613 	if (!PyArg_UnpackTuple(args, "eval", 1, 3, &cmd, &globals, &locals))

   614 		return NULL;

   615 	if (locals != Py_None && !PyMapping_Check(locals)) {

   616 		PyErr_SetString(PyExc_TypeError, "locals must be a mapping");

   617 		return NULL;

   618 	}

   619 	if (globals != Py_None && !PyDict_Check(globals)) {

   620 		PyErr_SetString(PyExc_TypeError, PyMapping_Check(globals) ?

   621 			"globals must be a real dict; try eval(expr, {}, mapping)"

   622 			: "globals must be a dict");

   623 		return NULL;

   624 	}

   625 	if (globals == Py_None) {

   626 		globals = PyEval_GetGlobals();

   627 		if (locals == Py_None)

   628 			locals = PyEval_GetLocals();

   629 	}

   630 	else if (locals == Py_None)

   631 		locals = globals;

   632 

   633 	if (globals == NULL || locals == NULL) {

   634 		PyErr_SetString(PyExc_TypeError, 

   635 			"eval must be given globals and locals "

   636 			"when called without a frame");

   637 		return NULL;

   638 	}

   639 

   640 	if (PyDict_GetItemString(globals, "__builtins__") == NULL) {

   641 		if (PyDict_SetItemString(globals, "__builtins__",

   642 					 PyEval_GetBuiltins()) != 0)

   643 			return NULL;

   644 	}

   645 

   646 	if (PyCode_Check(cmd)) {

   647 		if (PyCode_GetNumFree((PyCodeObject *)cmd) > 0) {

   648 			PyErr_SetString(PyExc_TypeError,

   649 		"code object passed to eval() may not contain free variables");

   650 			return NULL;

   651 		}

   652 		return PyEval_EvalCode((PyCodeObject *) cmd, globals, locals);

   653 	}

   654 

   655 	if (!PyString_Check(cmd) &&

   656 	    !PyUnicode_Check(cmd)) {

   657 		PyErr_SetString(PyExc_TypeError,

   658 			   "eval() arg 1 must be a string or code object");

   659 		return NULL;

   660 	}

   661 	cf.cf_flags = 0;

   662 

   663 #ifdef Py_USING_UNICODE

   664 	if (PyUnicode_Check(cmd)) {

   665 		tmp = PyUnicode_AsUTF8String(cmd);

   666 		if (tmp == NULL)

   667 			return NULL;

   668 		cmd = tmp;

   669 		cf.cf_flags |= PyCF_SOURCE_IS_UTF8;

   670 	}

   671 #endif

   672 	if (PyString_AsStringAndSize(cmd, &str, NULL)) {

   673 		Py_XDECREF(tmp);

   674 		return NULL;

   675 	}

   676 	while (*str == ' ' || *str == '\t')

   677 		str++;

   678 

   679 	(void)PyEval_MergeCompilerFlags(&cf);

   680 	result = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);

   681 	Py_XDECREF(tmp);

   682 	return result;

   683 }

   684 

   685 PyDoc_STRVAR(eval_doc,

   686 "eval(source[, globals[, locals]]) -> value\n\

   687 \n\

   688 Evaluate the source in the context of globals and locals.\n\

   689 The source may be a string representing a Python expression\n\

   690 or a code object as returned by compile().\n\

   691 The globals must be a dictionary and locals can be any mapping,\n\

   692 defaulting to the current globals and locals.\n\

   693 If only globals is given, locals defaults to it.\n");

   694 

   695 

   696 static PyObject *

   697 builtin_execfile(PyObject *self, PyObject *args)

   698 {

   699 	char *filename;

   700 	PyObject *globals = Py_None, *locals = Py_None;

   701 	PyObject *res;

   702 	FILE* fp = NULL;

   703 	PyCompilerFlags cf;

   704 	int exists;

   705 

   706 	if (PyErr_WarnPy3k("execfile() not supported in 3.x; use exec()",

   707 			   1) < 0)

   708 		return NULL;

   709 

   710 	if (!PyArg_ParseTuple(args, "s|O!O:execfile",

   711 			&filename,

   712 			&PyDict_Type, &globals,

   713 			&locals))

   714 		return NULL;

   715 	if (locals != Py_None && !PyMapping_Check(locals)) {

   716 		PyErr_SetString(PyExc_TypeError, "locals must be a mapping");

   717 		return NULL;

   718 	}

   719 	if (globals == Py_None) {

   720 		globals = PyEval_GetGlobals();

   721 		if (locals == Py_None)

   722 			locals = PyEval_GetLocals();

   723 	}

   724 	else if (locals == Py_None)

   725 		locals = globals;

   726 	if (PyDict_GetItemString(globals, "__builtins__") == NULL) {

   727 		if (PyDict_SetItemString(globals, "__builtins__",

   728 					 PyEval_GetBuiltins()) != 0)

   729 			return NULL;

   730 	}

   731 

   732 	exists = 0;

   733 	/* Test for existence or directory. */

   734 #if defined(PLAN9)

   735 	{

   736 		Dir *d;

   737 

   738 		if ((d = dirstat(filename))!=nil) {

   739 			if(d->mode & DMDIR)

   740 				werrstr("is a directory");

   741 			else

   742 				exists = 1;

   743 			free(d);

   744 		}

   745 	}

   746 #elif defined(RISCOS)

   747 	if (object_exists(filename)) {

   748 		if (isdir(filename))

   749 			errno = EISDIR;

   750 		else

   751 			exists = 1;

   752 	}

   753 #else	/* standard Posix */

   754 	{

   755 		struct stat s;

   756 		if (stat(filename, &s) == 0) {

   757 			if (S_ISDIR(s.st_mode))

   758 #				if defined(PYOS_OS2) && defined(PYCC_VACPP)

   759 					errno = EOS2ERR;

   760 #				else

   761 					errno = EISDIR;

   762 #				endif

   763 			else

   764 				exists = 1;

   765 		}

   766 	}

   767 #endif

   768 

   769         if (exists) {

   770 		Py_BEGIN_ALLOW_THREADS

   771 		fp = fopen(filename, "r" PY_STDIOTEXTMODE);

   772 		Py_END_ALLOW_THREADS

   773 

   774 		if (fp == NULL) {

   775 			exists = 0;

   776 		}

   777         }

   778 

   779 	if (!exists) {

   780 		PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);

   781 		return NULL;

   782 	}

   783 	cf.cf_flags = 0;

   784 	if (PyEval_MergeCompilerFlags(&cf))

   785 		res = PyRun_FileExFlags(fp, filename, Py_file_input, globals,

   786 				   locals, 1, &cf);

   787 	else

   788 		res = PyRun_FileEx(fp, filename, Py_file_input, globals,

   789 				   locals, 1);

   790 	return res;

   791 }

   792 

   793 PyDoc_STRVAR(execfile_doc,

   794 "execfile(filename[, globals[, locals]])\n\

   795 \n\

   796 Read and execute a Python script from a file.\n\

   797 The globals and locals are dictionaries, defaulting to the current\n\

   798 globals and locals.  If only globals is given, locals defaults to it.");

   799 

   800 

   801 static PyObject *

   802 builtin_getattr(PyObject *self, PyObject *args)

   803 {

   804 	PyObject *v, *result, *dflt = NULL;

   805 	PyObject *name;

   806 

   807 	if (!PyArg_UnpackTuple(args, "getattr", 2, 3, &v, &name, &dflt))

   808 		return NULL;

   809 #ifdef Py_USING_UNICODE

   810 	if (PyUnicode_Check(name)) {

   811 		name = _PyUnicode_AsDefaultEncodedString(name, NULL);

   812 		if (name == NULL)

   813 			return NULL;

   814 	}

   815 #endif

   816 

   817 	if (!PyString_Check(name)) {

   818 		PyErr_SetString(PyExc_TypeError,

   819 				"getattr(): attribute name must be string");

   820 		return NULL;

   821 	}

   822 	result = PyObject_GetAttr(v, name);

   823 	if (result == NULL && dflt != NULL &&

   824 	    PyErr_ExceptionMatches(PyExc_AttributeError))

   825 	{

   826 		PyErr_Clear();

   827 		Py_INCREF(dflt);

   828 		result = dflt;

   829 	}

   830 	return result;

   831 }

   832 

   833 PyDoc_STRVAR(getattr_doc,

   834 "getattr(object, name[, default]) -> value\n\

   835 \n\

   836 Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.\n\

   837 When a default argument is given, it is returned when the attribute doesn't\n\

   838 exist; without it, an exception is raised in that case.");

   839 

   840 

   841 static PyObject *

   842 builtin_globals(PyObject *self)

   843 {

   844 	PyObject *d;

   845 

   846 	d = PyEval_GetGlobals();

   847 	Py_XINCREF(d);

   848 	return d;

   849 }

   850 

   851 PyDoc_STRVAR(globals_doc,

   852 "globals() -> dictionary\n\

   853 \n\

   854 Return the dictionary containing the current scope's global variables.");

   855 

   856 

   857 static PyObject *

   858 builtin_hasattr(PyObject *self, PyObject *args)

   859 {

   860 	PyObject *v;

   861 	PyObject *name;

   862 

   863 	if (!PyArg_UnpackTuple(args, "hasattr", 2, 2, &v, &name))

   864 		return NULL;

   865 #ifdef Py_USING_UNICODE

   866 	if (PyUnicode_Check(name)) {

   867 		name = _PyUnicode_AsDefaultEncodedString(name, NULL);

   868 		if (name == NULL)

   869 			return NULL;

   870 	}

   871 #endif

   872 

   873 	if (!PyString_Check(name)) {

   874 		PyErr_SetString(PyExc_TypeError,

   875 				"hasattr(): attribute name must be string");

   876 		return NULL;

   877 	}

   878 	v = PyObject_GetAttr(v, name);

   879 	if (v == NULL) {

   880 		if (!PyErr_ExceptionMatches(PyExc_Exception))

   881 			return NULL;

   882 		else {

   883 			PyErr_Clear();

   884 			Py_INCREF(Py_False);

   885 			return Py_False;

   886 		}

   887 	}

   888 	Py_DECREF(v);

   889 	Py_INCREF(Py_True);

   890 	return Py_True;

   891 }

   892 

   893 PyDoc_STRVAR(hasattr_doc,

   894 "hasattr(object, name) -> bool\n\

   895 \n\

   896 Return whether the object has an attribute with the given name.\n\

   897 (This is done by calling getattr(object, name) and catching exceptions.)");

   898 

   899 

   900 static PyObject *

   901 builtin_id(PyObject *self, PyObject *v)

   902 {

   903 	return PyLong_FromVoidPtr(v);

   904 }

   905 

   906 PyDoc_STRVAR(id_doc,

   907 "id(object) -> integer\n\

   908 \n\

   909 Return the identity of an object.  This is guaranteed to be unique among\n\

   910 simultaneously existing objects.  (Hint: it's the object's memory address.)");

   911 

   912 

   913 static PyObject *

   914 builtin_map(PyObject *self, PyObject *args)

   915 {

   916 	typedef struct {

   917 		PyObject *it;	/* the iterator object */

   918 		int saw_StopIteration;  /* bool:  did the iterator end? */

   919 	} sequence;

   920 

   921 	PyObject *func, *result;

   922 	sequence *seqs = NULL, *sqp;

   923 	Py_ssize_t n, len;

   924 	register int i, j;

   925 

   926 	n = PyTuple_Size(args);

   927 	if (n < 2) {

   928 		PyErr_SetString(PyExc_TypeError,

   929 				"map() requires at least two args");

   930 		return NULL;

   931 	}

   932 

   933 	func = PyTuple_GetItem(args, 0);

   934 	n--;

   935 

   936 	if (func == Py_None) {

   937 		if (PyErr_WarnPy3k("map(None, ...) not supported in 3.x; "

   938 				   "use list(...)", 1) < 0)

   939 			return NULL;

   940 		if (n == 1) {

   941 			/* map(None, S) is the same as list(S). */

   942 			return PySequence_List(PyTuple_GetItem(args, 1));

   943 		}

   944 	}

   945 

   946 	/* Get space for sequence descriptors.  Must NULL out the iterator

   947 	 * pointers so that jumping to Fail_2 later doesn't see trash.

   948 	 */

   949 	if ((seqs = PyMem_NEW(sequence, n)) == NULL) {

   950 		PyErr_NoMemory();

   951 		return NULL;

   952 	}

   953 	for (i = 0; i < n; ++i) {

   954 		seqs[i].it = (PyObject*)NULL;

   955 		seqs[i].saw_StopIteration = 0;

   956 	}

   957 

   958 	/* Do a first pass to obtain iterators for the arguments, and set len

   959 	 * to the largest of their lengths.

   960 	 */

   961 	len = 0;

   962 	for (i = 0, sqp = seqs; i < n; ++i, ++sqp) {

   963 		PyObject *curseq;

   964 		Py_ssize_t curlen;

   965 

   966 		/* Get iterator. */

   967 		curseq = PyTuple_GetItem(args, i+1);

   968 		sqp->it = PyObject_GetIter(curseq);

   969 		if (sqp->it == NULL) {

   970 			static char errmsg[] =

   971 			    "argument %d to map() must support iteration";

   972 			char errbuf[sizeof(errmsg) + 25];

   973 			PyOS_snprintf(errbuf, sizeof(errbuf), errmsg, i+2);

   974 			PyErr_SetString(PyExc_TypeError, errbuf);

   975 			goto Fail_2;

   976 		}

   977 

   978 		/* Update len. */

   979 		curlen = _PyObject_LengthHint(curseq, 8);

   980 		if (curlen > len)

   981 			len = curlen;

   982 	}

   983 

   984 	/* Get space for the result list. */

   985 	if ((result = (PyObject *) PyList_New(len)) == NULL)

   986 		goto Fail_2;

   987 

   988 	/* Iterate over the sequences until all have stopped. */

   989 	for (i = 0; ; ++i) {

   990 		PyObject *alist, *item=NULL, *value;

   991 		int numactive = 0;

   992 

   993 		if (func == Py_None && n == 1)

   994 			alist = NULL;

   995 		else if ((alist = PyTuple_New(n)) == NULL)

   996 			goto Fail_1;

   997 

   998 		for (j = 0, sqp = seqs; j < n; ++j, ++sqp) {

   999 			if (sqp->saw_StopIteration) {

  1000 				Py_INCREF(Py_None);

  1001 				item = Py_None;

  1002 			}

  1003 			else {

  1004 				item = PyIter_Next(sqp->it);

  1005 				if (item)

  1006 					++numactive;

  1007 				else {

  1008 					if (PyErr_Occurred()) {

  1009 						Py_XDECREF(alist);

  1010 						goto Fail_1;

  1011 					}

  1012 					Py_INCREF(Py_None);

  1013 					item = Py_None;

  1014 					sqp->saw_StopIteration = 1;

  1015 				}

  1016 			}

  1017 			if (alist)

  1018 				PyTuple_SET_ITEM(alist, j, item);

  1019 			else

  1020 				break;

  1021 		}

  1022 

  1023 		if (!alist)

  1024 			alist = item;

  1025 

  1026 		if (numactive == 0) {

  1027 			Py_DECREF(alist);

  1028 			break;

  1029 		}

  1030 

  1031 		if (func == Py_None)

  1032 			value = alist;

  1033 		else {

  1034 			value = PyEval_CallObject(func, alist);

  1035 			Py_DECREF(alist);

  1036 			if (value == NULL)

  1037 				goto Fail_1;

  1038 		}

  1039 		if (i >= len) {

  1040 			int status = PyList_Append(result, value);

  1041 			Py_DECREF(value);

  1042 			if (status < 0)

  1043 				goto Fail_1;

  1044 		}

  1045 		else if (PyList_SetItem(result, i, value) < 0)

  1046 		 	goto Fail_1;

  1047 	}

  1048 

  1049 	if (i < len && PyList_SetSlice(result, i, len, NULL) < 0)

  1050 		goto Fail_1;

  1051 

  1052 	goto Succeed;

  1053 

  1054 Fail_1:

  1055 	Py_DECREF(result);

  1056 Fail_2:

  1057 	result = NULL;

  1058 Succeed:

  1059 	assert(seqs);

  1060 	for (i = 0; i < n; ++i)

  1061 		Py_XDECREF(seqs[i].it);

  1062 	PyMem_DEL(seqs);

  1063 	return result;

  1064 }

  1065 

  1066 PyDoc_STRVAR(map_doc,

  1067 "map(function, sequence[, sequence, ...]) -> list\n\

  1068 \n\

  1069 Return a list of the results of applying the function to the items of\n\

  1070 the argument sequence(s).  If more than one sequence is given, the\n\

  1071 function is called with an argument list consisting of the corresponding\n\

  1072 item of each sequence, substituting None for missing values when not all\n\

  1073 sequences have the same length.  If the function is None, return a list of\n\

  1074 the items of the sequence (or a list of tuples if more than one sequence).");

  1075 

  1076 

  1077 static PyObject *

  1078 builtin_next(PyObject *self, PyObject *args)

  1079 {

  1080 	PyObject *it, *res;

  1081 	PyObject *def = NULL;

  1082 

  1083 	if (!PyArg_UnpackTuple(args, "next", 1, 2, &it, &def))

  1084 		return NULL;

  1085 	if (!PyIter_Check(it)) {

  1086 		PyErr_Format(PyExc_TypeError,

  1087 			"%.200s object is not an iterator",

  1088 			it->ob_type->tp_name);

  1089 		return NULL;

  1090 	}

  1091 	

  1092 	res = (*it->ob_type->tp_iternext)(it);

  1093 	if (res != NULL) {

  1094 		return res;

  1095 	} else if (def != NULL) {

  1096 		if (PyErr_Occurred()) {

  1097 			if (!PyErr_ExceptionMatches(PyExc_StopIteration))

  1098 				return NULL;

  1099 			PyErr_Clear();

  1100 		}

  1101 		Py_INCREF(def);

  1102 		return def;

  1103 	} else if (PyErr_Occurred()) {

  1104 		return NULL;

  1105 	} else {

  1106 		PyErr_SetNone(PyExc_StopIteration);

  1107 		return NULL;

  1108 	}

  1109 }

  1110 

  1111 PyDoc_STRVAR(next_doc,

  1112 "next(iterator[, default])\n\

  1113 \n\

  1114 Return the next item from the iterator. If default is given and the iterator\n\

  1115 is exhausted, it is returned instead of raising StopIteration.");

  1116 

  1117 

  1118 static PyObject *

  1119 builtin_setattr(PyObject *self, PyObject *args)

  1120 {

  1121 	PyObject *v;

  1122 	PyObject *name;

  1123 	PyObject *value;

  1124 

  1125 	if (!PyArg_UnpackTuple(args, "setattr", 3, 3, &v, &name, &value))

  1126 		return NULL;

  1127 	if (PyObject_SetAttr(v, name, value) != 0)

  1128 		return NULL;

  1129 	Py_INCREF(Py_None);

  1130 	return Py_None;

  1131 }

  1132 

  1133 PyDoc_STRVAR(setattr_doc,

  1134 "setattr(object, name, value)\n\

  1135 \n\