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