Python/bltinmodule.c

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