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