bltinmodule.c revision 8d751616710f480833e87c5b752a4d2aecee58a1
1/*********************************************************** 2Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam, 3The Netherlands. 4 5 All Rights Reserved 6 7Permission to use, copy, modify, and distribute this software and its 8documentation for any purpose and without fee is hereby granted, 9provided that the above copyright notice appear in all copies and that 10both that copyright notice and this permission notice appear in 11supporting documentation, and that the names of Stichting Mathematisch 12Centrum or CWI or Corporation for National Research Initiatives or 13CNRI not be used in advertising or publicity pertaining to 14distribution of the software without specific, written prior 15permission. 16 17While CWI is the initial source for this software, a modified version 18is made available by the Corporation for National Research Initiatives 19(CNRI) at the Internet address ftp://ftp.python.org. 20 21STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH 22REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF 23MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH 24CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 25DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 26PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 27TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 28PERFORMANCE OF THIS SOFTWARE. 29 30******************************************************************/ 31 32/* Built-in functions */ 33 34#include "allobjects.h" 35 36#include "node.h" 37#include "graminit.h" 38#include "bltinmodule.h" 39#include "import.h" 40#include "compile.h" 41#include "eval.h" 42 43#include "mymath.h" 44 45#ifdef HAVE_UNISTD_H 46#include <unistd.h> 47#endif 48 49/* Forward */ 50static object *filterstring PROTO((object *, object *)); 51static object *filtertuple PROTO((object *, object *)); 52 53static object * 54builtin___import__(self, args) 55 object *self; 56 object *args; 57{ 58 char *name; 59 object *globals = NULL; 60 object *locals = NULL; 61 object *fromlist = NULL; 62 63 if (!newgetargs(args, "s|OOO:__import__", 64 &name, &globals, &locals, &fromlist)) 65 return NULL; 66 return import_module(name); 67} 68 69 70static object * 71builtin_abs(self, args) 72 object *self; 73 object *args; 74{ 75 object *v; 76 number_methods *nm; 77 78 if (!newgetargs(args, "O:abs", &v)) 79 return NULL; 80 if ((nm = v->ob_type->tp_as_number) == NULL) { 81 err_setstr(TypeError, "abs() requires numeric argument"); 82 return NULL; 83 } 84 return (*nm->nb_absolute)(v); 85} 86 87static object * 88builtin_apply(self, args) 89 object *self; 90 object *args; 91{ 92 object *func, *alist = NULL, *kwdict = NULL; 93 94 if (!newgetargs(args, "O|OO:apply", &func, &alist, &kwdict)) 95 return NULL; 96 if (alist != NULL && !is_tupleobject(alist)) { 97 err_setstr(TypeError, "apply() 2nd argument must be tuple"); 98 return NULL; 99 } 100 if (kwdict != NULL && !is_dictobject(kwdict)) { 101 err_setstr(TypeError, 102 "apply() 3rd argument must be dictionary"); 103 return NULL; 104 } 105 return PyEval_CallObjectWithKeywords(func, alist, kwdict); 106} 107 108static object * 109builtin_callable(self, args) 110 object *self; 111 object *args; 112{ 113 object *v; 114 115 if (!newgetargs(args, "O:callable", &v)) 116 return NULL; 117 return newintobject((long)callable(v)); 118} 119 120static object * 121builtin_filter(self, args) 122 object *self; 123 object *args; 124{ 125 object *func, *seq, *result; 126 sequence_methods *sqf; 127 int len; 128 register int i, j; 129 130 if (!newgetargs(args, "OO:filter", &func, &seq)) 131 return NULL; 132 133 if (is_stringobject(seq)) { 134 object *r = filterstring(func, seq); 135 return r; 136 } 137 138 if (is_tupleobject(seq)) { 139 object *r = filtertuple(func, seq); 140 return r; 141 } 142 143 if ((sqf = seq->ob_type->tp_as_sequence) == NULL) { 144 err_setstr(TypeError, 145 "argument 2 to filter() must be a sequence type"); 146 goto Fail_2; 147 } 148 149 if ((len = (*sqf->sq_length)(seq)) < 0) 150 goto Fail_2; 151 152 if (is_listobject(seq) && seq->ob_refcnt == 1) { 153 INCREF(seq); 154 result = seq; 155 } 156 else { 157 if ((result = newlistobject(len)) == NULL) 158 goto Fail_2; 159 } 160 161 for (i = j = 0; ; ++i) { 162 object *item, *good; 163 int ok; 164 165 if ((item = (*sqf->sq_item)(seq, i)) == NULL) { 166 if (i < len) 167 goto Fail_1; 168 if (err_occurred() == IndexError) { 169 err_clear(); 170 break; 171 } 172 goto Fail_1; 173 } 174 175 if (func == None) { 176 good = item; 177 INCREF(good); 178 } 179 else { 180 object *arg = mkvalue("(O)", item); 181 if (arg == NULL) 182 goto Fail_1; 183 good = call_object(func, arg); 184 DECREF(arg); 185 if (good == NULL) { 186 DECREF(item); 187 goto Fail_1; 188 } 189 } 190 ok = testbool(good); 191 DECREF(good); 192 if (ok) { 193 if (j < len) { 194 if (setlistitem(result, j++, item) < 0) 195 goto Fail_1; 196 } 197 else { 198 j++; 199 if (addlistitem(result, item) < 0) 200 goto Fail_1; 201 } 202 } else { 203 DECREF(item); 204 } 205 } 206 207 208 if (j < len && setlistslice(result, j, len, NULL) < 0) 209 goto Fail_1; 210 211 return result; 212 213Fail_1: 214 DECREF(result); 215Fail_2: 216 return NULL; 217} 218 219static object * 220builtin_chr(self, args) 221 object *self; 222 object *args; 223{ 224 long x; 225 char s[1]; 226 227 if (!newgetargs(args, "l:chr", &x)) 228 return NULL; 229 if (x < 0 || x >= 256) { 230 err_setstr(ValueError, "chr() arg not in range(256)"); 231 return NULL; 232 } 233 s[0] = x; 234 return newsizedstringobject(s, 1); 235} 236 237static object * 238builtin_cmp(self, args) 239 object *self; 240 object *args; 241{ 242 object *a, *b; 243 244 if (!newgetargs(args, "OO:cmp", &a, &b)) 245 return NULL; 246 return newintobject((long)cmpobject(a, b)); 247} 248 249static object * 250builtin_coerce(self, args) 251 object *self; 252 object *args; 253{ 254 object *v, *w; 255 object *res; 256 257 if (!newgetargs(args, "OO:coerce", &v, &w)) 258 return NULL; 259 if (coerce(&v, &w) < 0) 260 return NULL; 261 res = mkvalue("(OO)", v, w); 262 DECREF(v); 263 DECREF(w); 264 return res; 265} 266 267static object * 268builtin_compile(self, args) 269 object *self; 270 object *args; 271{ 272 char *str; 273 char *filename; 274 char *startstr; 275 int start; 276 277 if (!newgetargs(args, "sss:compile", &str, &filename, &startstr)) 278 return NULL; 279 if (strcmp(startstr, "exec") == 0) 280 start = file_input; 281 else if (strcmp(startstr, "eval") == 0) 282 start = eval_input; 283 else if (strcmp(startstr, "single") == 0) 284 start = single_input; 285 else { 286 err_setstr(ValueError, 287 "compile() mode must be 'exec' or 'eval' or 'single'"); 288 return NULL; 289 } 290 return compile_string(str, filename, start); 291} 292 293#ifndef WITHOUT_COMPLEX 294 295static object * 296builtin_complex(self, args) 297 object *self; 298 object *args; 299{ 300 object *r, *i, *tmp; 301 number_methods *nbr, *nbi; 302 Py_complex cr, ci; 303 304 i = NULL; 305 if (!newgetargs(args, "O|O:complex", &r, &i)) 306 return NULL; 307 if ((nbr = r->ob_type->tp_as_number) == NULL || 308 nbr->nb_float == NULL || (i != NULL && 309 ((nbi = i->ob_type->tp_as_number) == NULL || 310 nbi->nb_float == NULL))) { 311 err_setstr(TypeError, 312 "complex() argument can't be converted to complex"); 313 return NULL; 314 } 315 /* XXX Hack to support classes with __complex__ method */ 316 if (is_instanceobject(r)) { 317 static object *complexstr; 318 object *f; 319 if (complexstr == NULL) { 320 complexstr = PyString_InternFromString("__complex__"); 321 if (complexstr == NULL) 322 return NULL; 323 } 324 f = getattro(r, complexstr); 325 if (f == NULL) 326 err_clear(); 327 else { 328 object *args = mkvalue("()"); 329 if (args == NULL) 330 return NULL; 331 r = call_object(f, args); 332 DECREF(args); 333 if (r == NULL) 334 return NULL; 335 } 336 } 337 if (is_complexobject(r)) 338 cr = ((complexobject*)r)->cval; 339 else { 340 tmp = (*nbr->nb_float)(r); 341 if (tmp == NULL) 342 return NULL; 343 cr.real = getfloatvalue(tmp); 344 DECREF(tmp); 345 cr.imag = 0.; 346 } 347 if (i == NULL) { 348 ci.real = 0.; 349 ci.imag = 0.; 350 } 351 else if (is_complexobject(i)) 352 ci = ((complexobject*)i)->cval; 353 else { 354 tmp = (*nbr->nb_float)(i); 355 if (tmp == NULL) 356 return NULL; 357 ci.real = getfloatvalue(tmp); 358 DECREF(tmp); 359 ci.imag = 0.; 360 } 361 cr.real -= ci.imag; 362 cr.imag += ci.real; 363 return newcomplexobject(cr); 364} 365 366#endif 367 368static object * 369builtin_dir(self, args) 370 object *self; 371 object *args; 372{ 373 object *v = NULL; 374 object *d; 375 376 if (!newgetargs(args, "|O:dir", &v)) 377 return NULL; 378 if (v == NULL) { 379 d = getlocals(); 380 INCREF(d); 381 } 382 else { 383 d = getattr(v, "__dict__"); 384 if (d == NULL) { 385 err_setstr(TypeError, 386 "dir() argument must have __dict__ attribute"); 387 return NULL; 388 } 389 } 390 if (is_dictobject(d)) { 391 v = getdictkeys(d); 392 if (sortlist(v) != 0) { 393 DECREF(v); 394 v = NULL; 395 } 396 } 397 else { 398 v = PyObject_CallMethod(d, "keys", NULL); 399 if (v == NULL) { 400 PyErr_Clear(); 401 v = newlistobject(0); 402 } 403 } 404 DECREF(d); 405 return v; 406} 407 408static object * 409do_divmod(v, w) 410 object *v, *w; 411{ 412 object *res; 413 414 if (is_instanceobject(v) || is_instanceobject(w)) 415 return instancebinop(v, w, "__divmod__", "__rdivmod__", 416 do_divmod); 417 if (v->ob_type->tp_as_number == NULL || 418 w->ob_type->tp_as_number == NULL) { 419 err_setstr(TypeError, 420 "divmod() requires numeric or class instance arguments"); 421 return NULL; 422 } 423 if (coerce(&v, &w) != 0) 424 return NULL; 425 res = (*v->ob_type->tp_as_number->nb_divmod)(v, w); 426 DECREF(v); 427 DECREF(w); 428 return res; 429} 430 431static object * 432builtin_divmod(self, args) 433 object *self; 434 object *args; 435{ 436 object *v, *w; 437 438 if (!newgetargs(args, "OO:divmod", &v, &w)) 439 return NULL; 440 return do_divmod(v, w); 441} 442 443static object * 444builtin_eval(self, args) 445 object *self; 446 object *args; 447{ 448 object *cmd; 449 object *globals = None, *locals = None; 450 char *str; 451 452 if (!newgetargs(args, "O|O!O!:eval", 453 &cmd, 454 &Mappingtype, &globals, 455 &Mappingtype, &locals)) 456 return NULL; 457 if (globals == None) { 458 globals = getglobals(); 459 if (locals == None) 460 locals = getlocals(); 461 } 462 else if (locals == None) 463 locals = globals; 464 if (dictlookup(globals, "__builtins__") == NULL) { 465 if (dictinsert(globals, "__builtins__", getbuiltins()) != 0) 466 return NULL; 467 } 468 if (is_codeobject(cmd)) 469 return eval_code((codeobject *) cmd, globals, locals); 470 if (!is_stringobject(cmd)) { 471 err_setstr(TypeError, 472 "eval() argument 1 must be string or code object"); 473 return NULL; 474 } 475 str = getstringvalue(cmd); 476 if (strlen(str) != getstringsize(cmd)) { 477 err_setstr(ValueError, 478 "embedded '\\0' in string arg"); 479 return NULL; 480 } 481 while (*str == ' ' || *str == '\t') 482 str++; 483 return run_string(str, eval_input, globals, locals); 484} 485 486static object * 487builtin_execfile(self, args) 488 object *self; 489 object *args; 490{ 491 char *filename; 492 object *globals = None, *locals = None; 493 object *res; 494 FILE* fp; 495 496 if (!newgetargs(args, "s|O!O!:execfile", 497 &filename, 498 &Mappingtype, &globals, 499 &Mappingtype, &locals)) 500 return NULL; 501 if (globals == None) { 502 globals = getglobals(); 503 if (locals == None) 504 locals = getlocals(); 505 } 506 else if (locals == None) 507 locals = globals; 508 if (dictlookup(globals, "__builtins__") == NULL) { 509 if (dictinsert(globals, "__builtins__", getbuiltins()) != 0) 510 return NULL; 511 } 512 BGN_SAVE 513 fp = fopen(filename, "r"); 514 END_SAVE 515 if (fp == NULL) { 516 err_errno(IOError); 517 return NULL; 518 } 519 res = run_file(fp, filename, file_input, globals, locals); 520 BGN_SAVE 521 fclose(fp); 522 END_SAVE 523 return res; 524} 525 526static object * 527builtin_float(self, args) 528 object *self; 529 object *args; 530{ 531 object *v; 532 number_methods *nb; 533 534 if (!newgetargs(args, "O:float", &v)) 535 return NULL; 536 if ((nb = v->ob_type->tp_as_number) == NULL || 537 nb->nb_float == NULL) { 538 err_setstr(TypeError, 539 "float() argument can't be converted to float"); 540 return NULL; 541 } 542 return (*nb->nb_float)(v); 543} 544 545static object * 546builtin_getattr(self, args) 547 object *self; 548 object *args; 549{ 550 object *v; 551 object *name; 552 553 if (!newgetargs(args, "OS:getattr", &v, &name)) 554 return NULL; 555 return getattro(v, name); 556} 557 558static object * 559builtin_globals(self, args) 560 object *self; 561 object *args; 562{ 563 object *d; 564 565 if (!newgetargs(args, "")) 566 return NULL; 567 d = getglobals(); 568 INCREF(d); 569 return d; 570} 571 572static object * 573builtin_hasattr(self, args) 574 object *self; 575 object *args; 576{ 577 object *v; 578 object *name; 579 580 if (!newgetargs(args, "OS:hasattr", &v, &name)) 581 return NULL; 582 v = getattro(v, name); 583 if (v == NULL) { 584 err_clear(); 585 return newintobject(0L); 586 } 587 DECREF(v); 588 return newintobject(1L); 589} 590 591static object * 592builtin_id(self, args) 593 object *self; 594 object *args; 595{ 596 object *v; 597 598 if (!newgetargs(args, "O:id", &v)) 599 return NULL; 600 return newintobject((long)v); 601} 602 603static object * 604builtin_map(self, args) 605 object *self; 606 object *args; 607{ 608 typedef struct { 609 object *seq; 610 sequence_methods *sqf; 611 int len; 612 } sequence; 613 614 object *func, *result; 615 sequence *seqs = NULL, *sqp; 616 int n, len; 617 register int i, j; 618 619 n = gettuplesize(args); 620 if (n < 2) { 621 err_setstr(TypeError, "map() requires at least two args"); 622 return NULL; 623 } 624 625 func = gettupleitem(args, 0); 626 n--; 627 628 if ((seqs = NEW(sequence, n)) == NULL) { 629 err_nomem(); 630 goto Fail_2; 631 } 632 633 for (len = 0, i = 0, sqp = seqs; i < n; ++i, ++sqp) { 634 int curlen; 635 636 if ((sqp->seq = gettupleitem(args, i + 1)) == NULL) 637 goto Fail_2; 638 639 if (! (sqp->sqf = sqp->seq->ob_type->tp_as_sequence)) { 640 static char errmsg[] = 641 "argument %d to map() must be a sequence object"; 642 char errbuf[sizeof(errmsg) + 3]; 643 644 sprintf(errbuf, errmsg, i+2); 645 err_setstr(TypeError, errbuf); 646 goto Fail_2; 647 } 648 649 if ((curlen = sqp->len = (*sqp->sqf->sq_length)(sqp->seq)) < 0) 650 goto Fail_2; 651 652 if (curlen > len) 653 len = curlen; 654 } 655 656 if ((result = (object *) newlistobject(len)) == NULL) 657 goto Fail_2; 658 659 /* XXX Special case map(None, single_list) could be more efficient */ 660 for (i = 0; ; ++i) { 661 object *alist, *item=NULL, *value; 662 int any = 0; 663 664 if (func == None && n == 1) 665 alist = NULL; 666 else { 667 if ((alist = newtupleobject(n)) == NULL) 668 goto Fail_1; 669 } 670 671 for (j = 0, sqp = seqs; j < n; ++j, ++sqp) { 672 if (sqp->len < 0) { 673 INCREF(None); 674 item = None; 675 } 676 else { 677 item = (*sqp->sqf->sq_item)(sqp->seq, i); 678 if (item == NULL) { 679 if (i < sqp->len) 680 goto Fail_0; 681 if (err_occurred() == IndexError) { 682 err_clear(); 683 INCREF(None); 684 item = None; 685 sqp->len = -1; 686 } 687 else { 688 goto Fail_0; 689 } 690 } 691 else 692 any = 1; 693 694 } 695 if (!alist) 696 break; 697 if (settupleitem(alist, j, item) < 0) { 698 DECREF(item); 699 goto Fail_0; 700 } 701 continue; 702 703 Fail_0: 704 XDECREF(alist); 705 goto Fail_1; 706 } 707 708 if (!alist) 709 alist = item; 710 711 if (!any) { 712 DECREF(alist); 713 break; 714 } 715 716 if (func == None) 717 value = alist; 718 else { 719 value = call_object(func, alist); 720 DECREF(alist); 721 if (value == NULL) 722 goto Fail_1; 723 } 724 if (i >= len) { 725 if (addlistitem(result, value) < 0) 726 goto Fail_1; 727 } 728 else { 729 if (setlistitem(result, i, value) < 0) 730 goto Fail_1; 731 } 732 } 733 734 DEL(seqs); 735 return result; 736 737Fail_1: 738 DECREF(result); 739Fail_2: 740 if (seqs) DEL(seqs); 741 return NULL; 742} 743 744static object * 745builtin_setattr(self, args) 746 object *self; 747 object *args; 748{ 749 object *v; 750 object *name; 751 object *value; 752 753 if (!newgetargs(args, "OSO:setattr", &v, &name, &value)) 754 return NULL; 755 if (setattro(v, name, value) != 0) 756 return NULL; 757 INCREF(None); 758 return None; 759} 760 761static object * 762builtin_delattr(self, args) 763 object *self; 764 object *args; 765{ 766 object *v; 767 object *name; 768 769 if (!newgetargs(args, "OS:delattr", &v, &name)) 770 return NULL; 771 if (setattro(v, name, (object *)NULL) != 0) 772 return NULL; 773 INCREF(None); 774 return None; 775} 776 777static object * 778builtin_hash(self, args) 779 object *self; 780 object *args; 781{ 782 object *v; 783 long x; 784 785 if (!newgetargs(args, "O:hash", &v)) 786 return NULL; 787 x = hashobject(v); 788 if (x == -1) 789 return NULL; 790 return newintobject(x); 791} 792 793static object * 794builtin_hex(self, args) 795 object *self; 796 object *args; 797{ 798 object *v; 799 number_methods *nb; 800 801 if (!newgetargs(args, "O:hex", &v)) 802 return NULL; 803 804 if ((nb = v->ob_type->tp_as_number) == NULL || 805 nb->nb_hex == NULL) { 806 err_setstr(TypeError, 807 "hex() argument can't be converted to hex"); 808 return NULL; 809 } 810 return (*nb->nb_hex)(v); 811} 812 813static object *builtin_raw_input PROTO((object *, object *)); 814 815static object * 816builtin_input(self, args) 817 object *self; 818 object *args; 819{ 820 object *line; 821 char *str; 822 object *res; 823 object *globals, *locals; 824 825 line = builtin_raw_input(self, args); 826 if (line == NULL) 827 return line; 828 if (!getargs(line, "s;embedded '\\0' in input line", &str)) 829 return NULL; 830 while (*str == ' ' || *str == '\t') 831 str++; 832 globals = getglobals(); 833 locals = getlocals(); 834 if (dictlookup(globals, "__builtins__") == NULL) { 835 if (dictinsert(globals, "__builtins__", getbuiltins()) != 0) 836 return NULL; 837 } 838 res = run_string(str, eval_input, globals, locals); 839 DECREF(line); 840 return res; 841} 842 843static object * 844builtin_int(self, args) 845 object *self; 846 object *args; 847{ 848 object *v; 849 number_methods *nb; 850 851 if (!newgetargs(args, "O:int", &v)) 852 return NULL; 853 if ((nb = v->ob_type->tp_as_number) == NULL || 854 nb->nb_int == NULL) { 855 err_setstr(TypeError, 856 "int() argument can't be converted to int"); 857 return NULL; 858 } 859 return (*nb->nb_int)(v); 860} 861 862static object * 863builtin_len(self, args) 864 object *self; 865 object *args; 866{ 867 object *v; 868 long len; 869 typeobject *tp; 870 871 if (!newgetargs(args, "O:len", &v)) 872 return NULL; 873 tp = v->ob_type; 874 if (tp->tp_as_sequence != NULL) { 875 len = (*tp->tp_as_sequence->sq_length)(v); 876 } 877 else if (tp->tp_as_mapping != NULL) { 878 len = (*tp->tp_as_mapping->mp_length)(v); 879 } 880 else { 881 err_setstr(TypeError, "len() of unsized object"); 882 return NULL; 883 } 884 if (len < 0) 885 return NULL; 886 else 887 return newintobject(len); 888} 889 890static object * 891builtin_list(self, args) 892 object *self; 893 object *args; 894{ 895 object *v; 896 sequence_methods *sqf; 897 898 if (!newgetargs(args, "O:list", &v)) 899 return NULL; 900 if ((sqf = v->ob_type->tp_as_sequence) != NULL) { 901 int n = (*sqf->sq_length)(v); 902 int i; 903 object *l; 904 if (n < 0) 905 return NULL; 906 l = newlistobject(n); 907 if (l == NULL) 908 return NULL; 909 for (i = 0; i < n; i++) { 910 object *item = (*sqf->sq_item)(v, i); 911 if (item == NULL) { 912 DECREF(l); 913 l = NULL; 914 break; 915 } 916 setlistitem(l, i, item); 917 } 918 /* XXX Should support indefinite-length sequences */ 919 return l; 920 } 921 err_setstr(TypeError, "list() argument must be a sequence"); 922 return NULL; 923} 924 925 926static PyObject * 927builtin_slice(self, args) 928 PyObject *self; 929 PyObject *args; 930{ 931 PyObject *start, *stop, *step; 932 933 start = stop = step = NULL; 934 935 if (!PyArg_ParseTuple(args, "O|OO:slice", &start, &stop, &step)) 936 return NULL; 937 938 /*This swapping of stop and start is to maintain compatibility with 939 the range builtin.*/ 940 if (stop == NULL) { 941 stop = start; 942 start = NULL; 943 } 944 return PySlice_New(start, stop, step); 945} 946 947static object * 948builtin_locals(self, args) 949 object *self; 950 object *args; 951{ 952 object *d; 953 954 if (!newgetargs(args, "")) 955 return NULL; 956 d = getlocals(); 957 INCREF(d); 958 return d; 959} 960 961static object * 962builtin_long(self, args) 963 object *self; 964 object *args; 965{ 966 object *v; 967 number_methods *nb; 968 969 if (!newgetargs(args, "O:long", &v)) 970 return NULL; 971 if ((nb = v->ob_type->tp_as_number) == NULL || 972 nb->nb_long == NULL) { 973 err_setstr(TypeError, 974 "long() argument can't be converted to long"); 975 return NULL; 976 } 977 return (*nb->nb_long)(v); 978} 979 980static object * 981min_max(args, sign) 982 object *args; 983 int sign; 984{ 985 int i; 986 object *v, *w, *x; 987 sequence_methods *sq; 988 989 if (gettuplesize(args) > 1) 990 v = args; 991 else if (!newgetargs(args, "O:min/max", &v)) 992 return NULL; 993 sq = v->ob_type->tp_as_sequence; 994 if (sq == NULL) { 995 err_setstr(TypeError, "min() or max() of non-sequence"); 996 return NULL; 997 } 998 w = NULL; 999 for (i = 0; ; i++) { 1000 x = (*sq->sq_item)(v, i); /* Implies INCREF */ 1001 if (x == NULL) { 1002 if (err_occurred() == IndexError) { 1003 err_clear(); 1004 break; 1005 } 1006 XDECREF(w); 1007 return NULL; 1008 } 1009 if (w == NULL) 1010 w = x; 1011 else { 1012 if (cmpobject(x, w) * sign > 0) { 1013 DECREF(w); 1014 w = x; 1015 } 1016 else 1017 DECREF(x); 1018 } 1019 } 1020 if (w == NULL) 1021 err_setstr(ValueError, "min() or max() of empty sequence"); 1022 return w; 1023} 1024 1025static object * 1026builtin_min(self, v) 1027 object *self; 1028 object *v; 1029{ 1030 return min_max(v, -1); 1031} 1032 1033static object * 1034builtin_max(self, v) 1035 object *self; 1036 object *v; 1037{ 1038 return min_max(v, 1); 1039} 1040 1041static object * 1042builtin_oct(self, args) 1043 object *self; 1044 object *args; 1045{ 1046 object *v; 1047 number_methods *nb; 1048 1049 if (!newgetargs(args, "O:oct", &v)) 1050 return NULL; 1051 if (v == NULL || (nb = v->ob_type->tp_as_number) == NULL || 1052 nb->nb_oct == NULL) { 1053 err_setstr(TypeError, 1054 "oct() argument can't be converted to oct"); 1055 return NULL; 1056 } 1057 return (*nb->nb_oct)(v); 1058} 1059 1060static object * 1061builtin_open(self, args) 1062 object *self; 1063 object *args; 1064{ 1065 char *name; 1066 char *mode = "r"; 1067 int bufsize = -1; 1068 object *f; 1069 1070 if (!newgetargs(args, "s|si:open", &name, &mode, &bufsize)) 1071 return NULL; 1072 f = newfileobject(name, mode); 1073 if (f != NULL) 1074 setfilebufsize(f, bufsize); 1075 return f; 1076} 1077 1078static object * 1079builtin_ord(self, args) 1080 object *self; 1081 object *args; 1082{ 1083 char c; 1084 1085 if (!newgetargs(args, "c:ord", &c)) 1086 return NULL; 1087 return newintobject((long)(c & 0xff)); 1088} 1089 1090static object * 1091do_pow(v, w) 1092 object *v, *w; 1093{ 1094 object *res; 1095 if (is_instanceobject(v) || is_instanceobject(w)) 1096 return instancebinop(v, w, "__pow__", "__rpow__", do_pow); 1097 if (v->ob_type->tp_as_number == NULL || 1098 w->ob_type->tp_as_number == NULL) { 1099 err_setstr(TypeError, "pow() requires numeric arguments"); 1100 return NULL; 1101 } 1102 if ( 1103#ifndef WITHOUT_COMPLEX 1104 !is_complexobject(v) && 1105#endif 1106 is_floatobject(w) && getfloatvalue(v) < 0.0) { 1107 if (!err_occurred()) 1108 err_setstr(ValueError, "negative number to float power"); 1109 return NULL; 1110 } 1111 if (coerce(&v, &w) != 0) 1112 return NULL; 1113 res = (*v->ob_type->tp_as_number->nb_power)(v, w, None); 1114 DECREF(v); 1115 DECREF(w); 1116 return res; 1117} 1118 1119static object * 1120builtin_pow(self, args) 1121 object *self; 1122 object *args; 1123{ 1124 object *v, *w, *z = None, *res; 1125 object *v1, *z1, *w2, *z2; 1126 1127 if (!newgetargs(args, "OO|O:pow", &v, &w, &z)) 1128 return NULL; 1129 if (z == None) 1130 return do_pow(v, w); 1131 /* XXX The ternary version doesn't do class instance coercions */ 1132 if (is_instanceobject(v)) 1133 return v->ob_type->tp_as_number->nb_power(v, w, z); 1134 if (v->ob_type->tp_as_number == NULL || 1135 z->ob_type->tp_as_number == NULL || 1136 w->ob_type->tp_as_number == NULL) { 1137 err_setstr(TypeError, "pow() requires numeric arguments"); 1138 return NULL; 1139 } 1140 if (coerce(&v, &w) != 0) 1141 return NULL; 1142 res = NULL; 1143 v1 = v; 1144 z1 = z; 1145 if (coerce(&v1, &z1) != 0) 1146 goto error2; 1147 w2 = w; 1148 z2 = z1; 1149 if (coerce(&w2, &z2) != 0) 1150 goto error1; 1151 res = (*v1->ob_type->tp_as_number->nb_power)(v1, w2, z2); 1152 DECREF(w2); 1153 DECREF(z2); 1154 error1: 1155 DECREF(v1); 1156 DECREF(z1); 1157 error2: 1158 DECREF(v); 1159 DECREF(w); 1160 return res; 1161} 1162 1163static object * 1164builtin_range(self, args) 1165 object *self; 1166 object *args; 1167{ 1168 long ilow = 0, ihigh = 0, istep = 1; 1169 int i, n; 1170 object *v; 1171 1172 if (gettuplesize(args) <= 1) { 1173 if (!newgetargs(args, 1174 "l;range() requires 1-3 int arguments", 1175 &ihigh)) 1176 return NULL; 1177 } 1178 else { 1179 if (!newgetargs(args, 1180 "ll|l;range() requires 1-3 int arguments", 1181 &ilow, &ihigh, &istep)) 1182 return NULL; 1183 } 1184 if (istep == 0) { 1185 err_setstr(ValueError, "zero step for range()"); 1186 return NULL; 1187 } 1188 /* XXX ought to check overflow of subtraction */ 1189 if (istep > 0) 1190 n = (ihigh - ilow + istep - 1) / istep; 1191 else 1192 n = (ihigh - ilow + istep + 1) / istep; 1193 if (n < 0) 1194 n = 0; 1195 v = newlistobject(n); 1196 if (v == NULL) 1197 return NULL; 1198 for (i = 0; i < n; i++) { 1199 object *w = newintobject(ilow); 1200 if (w == NULL) { 1201 DECREF(v); 1202 return NULL; 1203 } 1204 setlistitem(v, i, w); 1205 ilow += istep; 1206 } 1207 return v; 1208} 1209 1210static object * 1211builtin_xrange(self, args) 1212 object *self; 1213 object *args; 1214{ 1215 long ilow = 0, ihigh = 0, istep = 1; 1216 long n; 1217 1218 if (gettuplesize(args) <= 1) { 1219 if (!newgetargs(args, 1220 "l;xrange() requires 1-3 int arguments", 1221 &ihigh)) 1222 return NULL; 1223 } 1224 else { 1225 if (!newgetargs(args, 1226 "ll|l;xrange() requires 1-3 int arguments", 1227 &ilow, &ihigh, &istep)) 1228 return NULL; 1229 } 1230 if (istep == 0) { 1231 err_setstr(ValueError, "zero step for xrange()"); 1232 return NULL; 1233 } 1234 /* XXX ought to check overflow of subtraction */ 1235 if (istep > 0) 1236 n = (ihigh - ilow + istep - 1) / istep; 1237 else 1238 n = (ihigh - ilow + istep + 1) / istep; 1239 if (n < 0) 1240 n = 0; 1241 return newrangeobject(ilow, n, istep, 1); 1242} 1243 1244extern char *my_readline PROTO((char *)); 1245 1246static object * 1247builtin_raw_input(self, args) 1248 object *self; 1249 object *args; 1250{ 1251 object *v = NULL; 1252 object *f; 1253 1254 if (!newgetargs(args, "|O:[raw_]input", &v)) 1255 return NULL; 1256 if (getfilefile(sysget("stdin")) == stdin && 1257 getfilefile(sysget("stdout")) == stdout && 1258 isatty(fileno(stdin)) && isatty(fileno(stdout))) { 1259 object *po; 1260 char *prompt; 1261 char *s; 1262 object *result; 1263 if (v != NULL) { 1264 po = strobject(v); 1265 if (po == NULL) 1266 return NULL; 1267 prompt = getstringvalue(po); 1268 } 1269 else { 1270 po = NULL; 1271 prompt = ""; 1272 } 1273 s = my_readline(prompt); 1274 XDECREF(po); 1275 if (s == NULL) { 1276 err_set(KeyboardInterrupt); 1277 return NULL; 1278 } 1279 if (*s == '\0') { 1280 err_set(EOFError); 1281 result = NULL; 1282 } 1283 else { /* strip trailing '\n' */ 1284 result = newsizedstringobject(s, strlen(s)-1); 1285 } 1286 free(s); 1287 return result; 1288 } 1289 if (v != NULL) { 1290 f = sysget("stdout"); 1291 if (f == NULL) { 1292 err_setstr(RuntimeError, "lost sys.stdout"); 1293 return NULL; 1294 } 1295 flushline(); 1296 if (writeobject(v, f, PRINT_RAW) != 0) 1297 return NULL; 1298 } 1299 f = sysget("stdin"); 1300 if (f == NULL) { 1301 err_setstr(RuntimeError, "lost sys.stdin"); 1302 return NULL; 1303 } 1304 return filegetline(f, -1); 1305} 1306 1307static object * 1308builtin_reduce(self, args) 1309 object *self; 1310 object *args; 1311{ 1312 object *seq, *func, *result = NULL; 1313 sequence_methods *sqf; 1314 register int i; 1315 1316 if (!newgetargs(args, "OO|O:reduce", &func, &seq, &result)) 1317 return NULL; 1318 if (result != NULL) 1319 INCREF(result); 1320 1321 if ((sqf = seq->ob_type->tp_as_sequence) == NULL) { 1322 err_setstr(TypeError, 1323 "2nd argument to reduce() must be a sequence object"); 1324 return NULL; 1325 } 1326 1327 if ((args = newtupleobject(2)) == NULL) 1328 goto Fail; 1329 1330 for (i = 0; ; ++i) { 1331 object *op2; 1332 1333 if (args->ob_refcnt > 1) { 1334 DECREF(args); 1335 if ((args = newtupleobject(2)) == NULL) 1336 goto Fail; 1337 } 1338 1339 if ((op2 = (*sqf->sq_item)(seq, i)) == NULL) { 1340 if (err_occurred() == IndexError) { 1341 err_clear(); 1342 break; 1343 } 1344 goto Fail; 1345 } 1346 1347 if (result == NULL) 1348 result = op2; 1349 else { 1350 settupleitem(args, 0, result); 1351 settupleitem(args, 1, op2); 1352 if ((result = call_object(func, args)) == NULL) 1353 goto Fail; 1354 } 1355 } 1356 1357 DECREF(args); 1358 1359 if (result == NULL) 1360 err_setstr(TypeError, 1361 "reduce of empty sequence with no initial value"); 1362 1363 return result; 1364 1365Fail: 1366 XDECREF(args); 1367 XDECREF(result); 1368 return NULL; 1369} 1370 1371static object * 1372builtin_reload(self, args) 1373 object *self; 1374 object *args; 1375{ 1376 object *v; 1377 1378 if (!newgetargs(args, "O:reload", &v)) 1379 return NULL; 1380 return reload_module(v); 1381} 1382 1383static object * 1384builtin_repr(self, args) 1385 object *self; 1386 object *args; 1387{ 1388 object *v; 1389 1390 if (!newgetargs(args, "O:repr", &v)) 1391 return NULL; 1392 return reprobject(v); 1393} 1394 1395static object * 1396builtin_round(self, args) 1397 object *self; 1398 object *args; 1399{ 1400 double x; 1401 double f; 1402 int ndigits = 0; 1403 int i; 1404 1405 if (!newgetargs(args, "d|i:round", &x, &ndigits)) 1406 return NULL; 1407 f = 1.0; 1408 for (i = ndigits; --i >= 0; ) 1409 f = f*10.0; 1410 for (i = ndigits; ++i <= 0; ) 1411 f = f*0.1; 1412 if (x >= 0.0) 1413 return newfloatobject(floor(x*f + 0.5) / f); 1414 else 1415 return newfloatobject(ceil(x*f - 0.5) / f); 1416} 1417 1418static object * 1419builtin_str(self, args) 1420 object *self; 1421 object *args; 1422{ 1423 object *v; 1424 1425 if (!newgetargs(args, "O:str", &v)) 1426 return NULL; 1427 return strobject(v); 1428} 1429 1430static object * 1431builtin_tuple(self, args) 1432 object *self; 1433 object *args; 1434{ 1435 object *v; 1436 sequence_methods *sqf; 1437 1438 if (!newgetargs(args, "O:tuple", &v)) 1439 return NULL; 1440 if (is_tupleobject(v)) { 1441 INCREF(v); 1442 return v; 1443 } 1444 if (is_listobject(v)) 1445 return listtuple(v); 1446 if (is_stringobject(v)) { 1447 int n = getstringsize(v); 1448 object *t = newtupleobject(n); 1449 if (t != NULL) { 1450 int i; 1451 char *p = getstringvalue(v); 1452 for (i = 0; i < n; i++) { 1453 object *item = newsizedstringobject(p+i, 1); 1454 if (item == NULL) { 1455 DECREF(t); 1456 t = NULL; 1457 break; 1458 } 1459 settupleitem(t, i, item); 1460 } 1461 } 1462 return t; 1463 } 1464 /* Generic sequence object */ 1465 if ((sqf = v->ob_type->tp_as_sequence) != NULL) { 1466 int n = (*sqf->sq_length)(v); 1467 int i; 1468 object *t; 1469 if (n < 0) 1470 return NULL; 1471 t = newtupleobject(n); 1472 if (t == NULL) 1473 return NULL; 1474 for (i = 0; i < n; i++) { 1475 object *item = (*sqf->sq_item)(v, i); 1476 if (item == NULL) { 1477 DECREF(t); 1478 t = NULL; 1479 break; 1480 } 1481 settupleitem(t, i, item); 1482 } 1483 /* XXX Should support indefinite-length sequences */ 1484 return t; 1485 } 1486 /* None of the above */ 1487 err_setstr(TypeError, "tuple() argument must be a sequence"); 1488 return NULL; 1489} 1490 1491static object * 1492builtin_type(self, args) 1493 object *self; 1494 object *args; 1495{ 1496 object *v; 1497 1498 if (!newgetargs(args, "O:type", &v)) 1499 return NULL; 1500 v = (object *)v->ob_type; 1501 INCREF(v); 1502 return v; 1503} 1504 1505static object * 1506builtin_vars(self, args) 1507 object *self; 1508 object *args; 1509{ 1510 object *v = NULL; 1511 object *d; 1512 1513 if (!newgetargs(args, "|O:vars", &v)) 1514 return NULL; 1515 if (v == NULL) { 1516 d = getlocals(); 1517 if (d == NULL) { 1518 if (!err_occurred()) 1519 err_setstr(SystemError, "no locals!?"); 1520 } 1521 else 1522 INCREF(d); 1523 } 1524 else { 1525 d = getattr(v, "__dict__"); 1526 if (d == NULL) { 1527 err_setstr(TypeError, 1528 "vars() argument must have __dict__ attribute"); 1529 return NULL; 1530 } 1531 } 1532 return d; 1533} 1534 1535static struct methodlist builtin_methods[] = { 1536 {"__import__", builtin___import__, 1}, 1537 {"abs", builtin_abs, 1}, 1538 {"apply", builtin_apply, 1}, 1539 {"callable", builtin_callable, 1}, 1540 {"chr", builtin_chr, 1}, 1541 {"cmp", builtin_cmp, 1}, 1542 {"coerce", builtin_coerce, 1}, 1543 {"compile", builtin_compile, 1}, 1544#ifndef WITHOUT_COMPLEX 1545 {"complex", builtin_complex, 1}, 1546#endif 1547 {"delattr", builtin_delattr, 1}, 1548 {"dir", builtin_dir, 1}, 1549 {"divmod", builtin_divmod, 1}, 1550 {"eval", builtin_eval, 1}, 1551 {"execfile", builtin_execfile, 1}, 1552 {"filter", builtin_filter, 1}, 1553 {"float", builtin_float, 1}, 1554 {"getattr", builtin_getattr, 1}, 1555 {"globals", builtin_globals, 1}, 1556 {"hasattr", builtin_hasattr, 1}, 1557 {"hash", builtin_hash, 1}, 1558 {"hex", builtin_hex, 1}, 1559 {"id", builtin_id, 1}, 1560 {"input", builtin_input, 1}, 1561 {"int", builtin_int, 1}, 1562 {"len", builtin_len, 1}, 1563 {"list", builtin_list, 1}, 1564 {"locals", builtin_locals, 1}, 1565 {"long", builtin_long, 1}, 1566 {"map", builtin_map, 1}, 1567 {"max", builtin_max, 1}, 1568 {"min", builtin_min, 1}, 1569 {"oct", builtin_oct, 1}, 1570 {"open", builtin_open, 1}, 1571 {"ord", builtin_ord, 1}, 1572 {"pow", builtin_pow, 1}, 1573 {"range", builtin_range, 1}, 1574 {"raw_input", builtin_raw_input, 1}, 1575 {"reduce", builtin_reduce, 1}, 1576 {"reload", builtin_reload, 1}, 1577 {"repr", builtin_repr, 1}, 1578 {"round", builtin_round, 1}, 1579 {"setattr", builtin_setattr, 1}, 1580 {"slice", builtin_slice, 1}, 1581 {"str", builtin_str, 1}, 1582 {"tuple", builtin_tuple, 1}, 1583 {"type", builtin_type, 1}, 1584 {"vars", builtin_vars, 1}, 1585 {"xrange", builtin_xrange, 1}, 1586 {NULL, NULL}, 1587}; 1588 1589static object *builtin_mod; 1590static object *builtin_dict; 1591 1592object * 1593getbuiltinmod() 1594{ 1595 return builtin_mod; 1596} 1597 1598object * 1599getbuiltindict() 1600{ 1601 return builtin_dict; 1602} 1603 1604/* Predefined exceptions */ 1605 1606object *AccessError; 1607object *AttributeError; 1608object *ConflictError; 1609object *EOFError; 1610object *IOError; 1611object *ImportError; 1612object *IndexError; 1613object *KeyError; 1614object *KeyboardInterrupt; 1615object *MemoryError; 1616object *NameError; 1617object *OverflowError; 1618object *RuntimeError; 1619object *SyntaxError; 1620object *SystemError; 1621object *SystemExit; 1622object *TypeError; 1623object *ValueError; 1624object *ZeroDivisionError; 1625 1626static object * 1627newstdexception(name) 1628 char *name; 1629{ 1630 object *v = newstringobject(name); 1631 if (v == NULL || dictinsert(builtin_dict, name, v) != 0) 1632 fatal("no mem for new standard exception"); 1633 return v; 1634} 1635 1636static void 1637initerrors() 1638{ 1639 AccessError = newstdexception("AccessError"); 1640 AttributeError = newstdexception("AttributeError"); 1641 ConflictError = newstdexception("ConflictError"); 1642 EOFError = newstdexception("EOFError"); 1643 IOError = newstdexception("IOError"); 1644 ImportError = newstdexception("ImportError"); 1645 IndexError = newstdexception("IndexError"); 1646 KeyError = newstdexception("KeyError"); 1647 KeyboardInterrupt = newstdexception("KeyboardInterrupt"); 1648 MemoryError = newstdexception("MemoryError"); 1649 NameError = newstdexception("NameError"); 1650 OverflowError = newstdexception("OverflowError"); 1651 RuntimeError = newstdexception("RuntimeError"); 1652 SyntaxError = newstdexception("SyntaxError"); 1653 SystemError = newstdexception("SystemError"); 1654 SystemExit = newstdexception("SystemExit"); 1655 TypeError = newstdexception("TypeError"); 1656 ValueError = newstdexception("ValueError"); 1657 ZeroDivisionError = newstdexception("ZeroDivisionError"); 1658} 1659 1660void 1661initbuiltin() 1662{ 1663 builtin_mod = initmodule("__builtin__", builtin_methods); 1664 builtin_dict = getmoduledict(builtin_mod); 1665 INCREF(builtin_dict); 1666 initerrors(); 1667 (void) dictinsert(builtin_dict, "None", None); 1668 (void) dictinsert(builtin_dict, "Ellipsis", Py_Ellipsis); 1669} 1670 1671 1672/* Helper for filter(): filter a tuple through a function */ 1673 1674static object * 1675filtertuple(func, tuple) 1676 object *func; 1677 object *tuple; 1678{ 1679 object *result; 1680 register int i, j; 1681 int len = gettuplesize(tuple); 1682 1683 if (len == 0) { 1684 INCREF(tuple); 1685 return tuple; 1686 } 1687 1688 if ((result = newtupleobject(len)) == NULL) 1689 return NULL; 1690 1691 for (i = j = 0; i < len; ++i) { 1692 object *item, *good; 1693 int ok; 1694 1695 if ((item = gettupleitem(tuple, i)) == NULL) 1696 goto Fail_1; 1697 if (func == None) { 1698 INCREF(item); 1699 good = item; 1700 } 1701 else { 1702 object *arg = mkvalue("(O)", item); 1703 if (arg == NULL) 1704 goto Fail_1; 1705 good = call_object(func, arg); 1706 DECREF(arg); 1707 if (good == NULL) 1708 goto Fail_1; 1709 } 1710 ok = testbool(good); 1711 DECREF(good); 1712 if (ok) { 1713 INCREF(item); 1714 if (settupleitem(result, j++, item) < 0) 1715 goto Fail_1; 1716 } 1717 } 1718 1719 if (resizetuple(&result, j, 0) < 0) 1720 return NULL; 1721 1722 return result; 1723 1724Fail_1: 1725 DECREF(result); 1726 return NULL; 1727} 1728 1729 1730/* Helper for filter(): filter a string through a function */ 1731 1732static object * 1733filterstring(func, strobj) 1734 object *func; 1735 object *strobj; 1736{ 1737 object *result; 1738 register int i, j; 1739 int len = getstringsize(strobj); 1740 1741 if (func == None) { 1742 /* No character is ever false -- share input string */ 1743 INCREF(strobj); 1744 return strobj; 1745 } 1746 if ((result = newsizedstringobject(NULL, len)) == NULL) 1747 return NULL; 1748 1749 for (i = j = 0; i < len; ++i) { 1750 object *item, *arg, *good; 1751 int ok; 1752 1753 item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i); 1754 if (item == NULL) 1755 goto Fail_1; 1756 arg = mkvalue("(O)", item); 1757 DECREF(item); 1758 if (arg == NULL) 1759 goto Fail_1; 1760 good = call_object(func, arg); 1761 DECREF(arg); 1762 if (good == NULL) 1763 goto Fail_1; 1764 ok = testbool(good); 1765 DECREF(good); 1766 if (ok) 1767 GETSTRINGVALUE((stringobject *)result)[j++] = 1768 GETSTRINGVALUE((stringobject *)item)[0]; 1769 } 1770 1771 if (j < len && resizestring(&result, j) < 0) 1772 return NULL; 1773 1774 return result; 1775 1776Fail_1: 1777 DECREF(result); 1778 return NULL; 1779} 1780