Python/bltinmodule.c

   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 mappping,\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_INCREF(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_INCREF(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_Check(fin) && PyFile_Check(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