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, *alist = NULL, *kwdict = NULL;
  84
  85         if (!newgetargs(args, "O|OO:apply", &func, &alist, &kwdict))
  86                 return NULL;
  87         if (alist != NULL && !is_tupleobject(alist)) {
  88                 err_setstr(TypeError, "apply() 2nd argument must be tuple");
  89                 return NULL;
  90         }
  91         if (kwdict != NULL && !is_dictobject(kwdict)) {
  92                 err_setstr(TypeError,
  93                            "apply() 3rd argument must be dictionary");
  94                 return NULL;
  95         }
  96         return PyEval_CallObjectWithKeywords(func, alist, kwdict);
  97 }
  98
  99 static object *
 100 builtin_callable(self, args)
 101         object *self;
 102         object *args;
 103 {
 104         object *v;
 105
 106         if (!newgetargs(args, "O:callable", &v))
 107                 return NULL;
 108         return newintobject((long)callable(v));
 109 }
 110
 111 static object *
 112 builtin_filter(self, args)
 113         object *self;
 114         object *args;
 115 {
 116         object *func, *seq, *result;
 117         sequence_methods *sqf;
 118         int len;
 119         register int i, j;
 120
 121         if (!newgetargs(args, "OO:filter", &func, &seq))
 122                 return NULL;
 123
 124         if (is_stringobject(seq)) {
 125                 object *r = filterstring(func, seq);
 126                 return r;
 127         }
 128
 129         if (is_tupleobject(seq)) {
 130                 object *r = filtertuple(func, seq);
 131                 return r;
 132         }
 133
 134         if ((sqf = seq->ob_type->tp_as_sequence) == NULL) {
 135                 err_setstr(TypeError,
 136                            "argument 2 to filter() must be a sequence type");
 137                 goto Fail_2;
 138         }
 139
 140         if ((len = (*sqf->sq_length)(seq)) < 0)
 141                 goto Fail_2;
 142
 143         if (is_listobject(seq) && seq->ob_refcnt == 1) {
 144                 INCREF(seq);
 145                 result = seq;
 146         }
 147         else {
 148                 if ((result = newlistobject(len)) == NULL)
 149                         goto Fail_2;
 150         }
 151
 152         for (i = j = 0; ; ++i) {
 153                 object *item, *good;
 154                 int ok;
 155
 156                 if ((item = (*sqf->sq_item)(seq, i)) == NULL) {
 157                         if (i < len)
 158                                 goto Fail_1;
 159                         if (err_occurred() == IndexError) {
 160                                 err_clear();
 161                                 break;
 162                         }
 163                         goto Fail_1;
 164                 }
 165
 166                 if (func == None) {
 167                         good = item;
 168                         INCREF(good);
 169                 }
 170                 else {
 171                         object *arg = mkvalue("(O)", item);
 172                         if (arg == NULL)
 173                                 goto Fail_1;
 174                         good = call_object(func, arg);
 175                         DECREF(arg);
 176                         if (good == NULL) {
 177                                 DECREF(item);
 178                                 goto Fail_1;
 179                         }
 180                 }
 181                 ok = testbool(good);
 182                 DECREF(good);
 183                 if (ok) {
 184                         if (j < len) {
 185                                 if (setlistitem(result, j++, item) < 0)
 186                                         goto Fail_1;
 187                         }
 188                         else {
 189                                 j++;
 190                                 if (addlistitem(result, item) < 0)
 191                                         goto Fail_1;
 192                         }
 193                 } else {
 194                         DECREF(item);
 195                 }
 196         }
 197
 198
 199         if (j < len && setlistslice(result, j, len, NULL) < 0)
 200                 goto Fail_1;
 201
 202         return result;
 203
 204 Fail_1:
 205         DECREF(result);
 206 Fail_2:
 207         return NULL;
 208 }
 209
 210 static object *
 211 builtin_chr(self, args)
 212         object *self;
 213         object *args;
 214 {
 215         long x;
 216         char s[1];
 217
 218         if (!newgetargs(args, "l:chr", &x))
 219                 return NULL;
 220         if (x < 0 || x >= 256) {
 221                 err_setstr(ValueError, "chr() arg not in range(256)");
 222                 return NULL;
 223         }
 224         s[0] = x;
 225         return newsizedstringobject(s, 1);
 226 }
 227
 228 static object *
 229 builtin_cmp(self, args)
 230         object *self;
 231         object *args;
 232 {
 233         object *a, *b;
 234
 235         if (!newgetargs(args, "OO:cmp", &a, &b))
 236                 return NULL;
 237         return newintobject((long)cmpobject(a, b));
 238 }
 239
 240 static object *
 241 builtin_coerce(self, args)
 242         object *self;
 243         object *args;
 244 {
 245         object *v, *w;
 246         object *res;
 247
 248         if (!newgetargs(args, "OO:coerce", &v, &w))
 249                 return NULL;
 250         if (coerce(&v, &w) < 0)
 251                 return NULL;
 252         res = mkvalue("(OO)", v, w);
 253         DECREF(v);
 254         DECREF(w);
 255         return res;
 256 }
 257
 258 static object *
 259 builtin_compile(self, args)
 260         object *self;
 261         object *args;
 262 {
 263         char *str;
 264         char *filename;
 265         char *startstr;
 266         int start;
 267
 268         if (!newgetargs(args, "sss:compile", &str, &filename, &startstr))
 269                 return NULL;
 270         if (strcmp(startstr, "exec") == 0)
 271                 start = file_input;
 272         else if (strcmp(startstr, "eval") == 0)
 273                 start = eval_input;
 274         else if (strcmp(startstr, "single") == 0)
 275                 start = single_input;
 276         else {
 277                 err_setstr(ValueError,
 278                    "compile() mode must be 'exec' or 'eval' or 'single'");
 279                 return NULL;
 280         }
 281         return compile_string(str, filename, start);
 282 }
 283
 284 #ifndef WITHOUT_COMPLEX
 285
 286 static object *
 287 builtin_complex(self, args)
 288         object *self;
 289         object *args;
 290 {
 291         object *r, *i;
 292         number_methods *nbr, *nbi;
 293         complex cr, ci;
 294
 295         i = NULL;
 296         if (!newgetargs(args, "O|O:complex", &r, &i))
 297                 return NULL;
 298         if ((nbr = r->ob_type->tp_as_number) == NULL ||
 299              nbr->nb_float == NULL || (i != NULL &&
 300            ((nbi = i->ob_type->tp_as_number) == NULL ||
 301              nbi->nb_float == NULL))) {
 302                 err_setstr(TypeError,
 303                            "complex() argument can't be converted to complex");
 304                 return NULL;
 305         }
 306         if (is_complexobject(r))
 307                 cr = ((complexobject*)r)->cval;
 308         else {
 309                 cr.real = getfloatvalue((*nbr->nb_float)(r));
 310                 cr.imag = 0.;
 311         }
 312         if (i == NULL) {
 313                 ci.real = 0.;
 314                 ci.imag = 0.;
 315         }
 316         else if (is_complexobject(i))
 317                 ci = ((complexobject*)i)->cval;
 318         else {
 319                 ci.real = getfloatvalue((*nbi->nb_float)(i));
 320                 ci.imag = 0.;
 321         }
 322         cr.real -= ci.imag;
 323         cr.imag += ci.real;
 324         return newcomplexobject(cr);
 325 }
 326
 327 #endif
 328
 329 static object *
 330 builtin_dir(self, args)
 331         object *self;
 332         object *args;
 333 {
 334         object *v = NULL;
 335         object *d;
 336
 337         if (!newgetargs(args, "|O:dir", &v))
 338                 return NULL;
 339         if (v == NULL) {
 340                 d = getlocals();
 341                 INCREF(d);
 342         }
 343         else {
 344                 d = getattr(v, "__dict__");
 345                 if (d == NULL) {
 346                         err_setstr(TypeError,
 347                                 "dir() argument must have __dict__ attribute");
 348                         return NULL;
 349                 }
 350         }
 351         if (is_dictobject(d)) {
 352                 v = getdictkeys(d);
 353                 if (sortlist(v) != 0) {
 354                         DECREF(v);
 355                         v = NULL;
 356                 }
 357         }
 358         else {
 359                 v = newlistobject(0);
 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_locals(self, args)
 849         object *self;
 850         object *args;
 851 {
 852         object *d;
 853
 854         if (!newgetargs(args, ""))
 855                 return NULL;
 856         d = getlocals();
 857         INCREF(d);
 858         return d;
 859 }
 860
 861 static object *
 862 builtin_long(self, args)
 863         object *self;
 864         object *args;
 865 {
 866         object *v;
 867         number_methods *nb;
 868
 869         if (!newgetargs(args, "O:long", &v))
 870                 return NULL;
 871         if ((nb = v->ob_type->tp_as_number) == NULL ||
 872             nb->nb_long == NULL) {
 873                 err_setstr(TypeError,
 874                            "long() argument can't be converted to long");
 875                 return NULL;
 876         }
 877         return (*nb->nb_long)(v);
 878 }
 879
 880 static object *
 881 min_max(args, sign)
 882         object *args;
 883         int sign;
 884 {
 885         int i;
 886         object *v, *w, *x;
 887         sequence_methods *sq;
 888
 889         if (gettuplesize(args) > 1)
 890                 v = args;
 891         else if (!newgetargs(args, "O:min/max", &v))
 892                 return NULL;
 893         sq = v->ob_type->tp_as_sequence;
 894         if (sq == NULL) {
 895                 err_setstr(TypeError, "min() or max() of non-sequence");
 896                 return NULL;
 897         }
 898         w = NULL;
 899         for (i = 0; ; i++) {
 900                 x = (*sq->sq_item)(v, i); /* Implies INCREF */
 901                 if (x == NULL) {
 902                         if (err_occurred() == IndexError) {
 903                                 err_clear();
 904                                 break;
 905                         }
 906                         XDECREF(w);
 907                         return NULL;
 908                 }
 909                 if (w == NULL)
 910                         w = x;
 911                 else {
 912                         if (cmpobject(x, w) * sign > 0) {
 913                                 DECREF(w);
 914                                 w = x;
 915                         }
 916                         else
 917                                 DECREF(x);
 918                 }
 919         }
 920         if (w == NULL)
 921                 err_setstr(ValueError, "min() or max() of empty sequence");
 922         return w;
 923 }
 924
 925 static object *
 926 builtin_min(self, v)
 927         object *self;
 928         object *v;
 929 {
 930         return min_max(v, -1);
 931 }
 932
 933 static object *
 934 builtin_max(self, v)
 935         object *self;
 936         object *v;
 937 {
 938         return min_max(v, 1);
 939 }
 940
 941 static object *
 942 builtin_oct(self, args)
 943         object *self;
 944         object *args;
 945 {
 946         object *v;
 947         number_methods *nb;
 948
 949         if (!newgetargs(args, "O:oct", &v))
 950                 return NULL;
 951         if (v == NULL || (nb = v->ob_type->tp_as_number) == NULL ||
 952             nb->nb_oct == NULL) {
 953                 err_setstr(TypeError,
 954                            "oct() argument can't be converted to oct");
 955                 return NULL;
 956         }
 957         return (*nb->nb_oct)(v);
 958 }
 959
 960 static object *
 961 builtin_open(self, args)
 962         object *self;
 963         object *args;
 964 {
 965         char *name;
 966         char *mode = "r";
 967         int bufsize = -1;
 968         object *f;
 969
 970         if (!newgetargs(args, "s|si:open", &name, &mode, &bufsize))
 971                 return NULL;
 972         f = newfileobject(name, mode);
 973         if (f != NULL)
 974                 setfilebufsize(f, bufsize);
 975         return f;
 976 }
 977
 978 static object *
 979 builtin_ord(self, args)
 980         object *self;
 981         object *args;
 982 {
 983         char c;
 984
 985         if (!newgetargs(args, "c:ord", &c))
 986                 return NULL;
 987         return newintobject((long)(c & 0xff));
 988 }
 989
 990 static object *
 991 do_pow(v, w)
 992         object *v, *w;
 993 {
 994         object *res;
 995         if (is_instanceobject(v) || is_instanceobject(w))
 996                 return instancebinop(v, w, "__pow__", "__rpow__", do_pow);
 997         if (v->ob_type->tp_as_number == NULL ||
 998             w->ob_type->tp_as_number == NULL) {
 999                 err_setstr(TypeError, "pow() requires numeric arguments");
1000                 return NULL;
1001         }
1002         if (
1003 #ifndef WITHOUT_COMPLEX
1004             !is_complexobject(v) &&
1005 #endif
1006             is_floatobject(w) && getfloatvalue(v) < 0.0) {
1007                 if (!err_occurred())
1008                     err_setstr(ValueError, "negative number to float power");
1009                 return NULL;
1010         }
1011         if (coerce(&v, &w) != 0)
1012                 return NULL;
1013         res = (*v->ob_type->tp_as_number->nb_power)(v, w, None);
1014         DECREF(v);
1015         DECREF(w);
1016         return res;
1017 }
1018
1019 static object *
1020 builtin_pow(self, args)
1021         object *self;
1022         object *args;
1023 {
1024         object *v, *w, *z = None, *res;
1025         object *v1, *z1, *w2, *z2;
1026
1027         if (!newgetargs(args, "OO|O:pow", &v, &w, &z))
1028                 return NULL;
1029         if (z == None)
1030                 return do_pow(v, w);
1031         /* XXX The ternary version doesn't do class instance coercions */
1032         if (is_instanceobject(v))
1033                 return v->ob_type->tp_as_number->nb_power(v, w, z);
1034         if (v->ob_type->tp_as_number == NULL ||
1035             z->ob_type->tp_as_number == NULL ||
1036             w->ob_type->tp_as_number == NULL) {
1037                 err_setstr(TypeError, "pow() requires numeric arguments");
1038                 return NULL;
1039         }
1040         if (coerce(&v, &w) != 0)
1041                 return NULL;
1042         res = NULL;
1043         v1 = v;
1044         z1 = z;
1045         if (coerce(&v1, &z1) != 0)
1046                 goto error2;
1047         w2 = w;
1048         z2 = z1;
1049         if (coerce(&w2, &z2) != 0)
1050                 goto error1;
1051         res = (*v1->ob_type->tp_as_number->nb_power)(v1, w2, z2);
1052         DECREF(w2);
1053         DECREF(z2);
1054  error1:
1055         DECREF(v1);
1056         DECREF(z1);
1057  error2:
1058         DECREF(v);
1059         DECREF(w);
1060         return res;
1061 }
1062
1063 static object *
1064 builtin_range(self, args)
1065         object *self;
1066         object *args;
1067 {
1068         long ilow = 0, ihigh = 0, istep = 1;
1069         int i, n;
1070         object *v;
1071
1072         if (gettuplesize(args) <= 1) {
1073                 if (!newgetargs(args,
1074                                 "l;range() requires 1-3 int arguments",
1075                                 &ihigh))
1076                         return NULL;
1077         }
1078         else {
1079                 if (!newgetargs(args,
1080                                 "ll|l;range() requires 1-3 int arguments",
1081                                 &ilow, &ihigh, &istep))
1082                         return NULL;
1083         }
1084         if (istep == 0) {
1085                 err_setstr(ValueError, "zero step for range()");
1086                 return NULL;
1087         }
1088         /* XXX ought to check overflow of subtraction */
1089         if (istep > 0)
1090                 n = (ihigh - ilow + istep - 1) / istep;
1091         else
1092                 n = (ihigh - ilow + istep + 1) / istep;
1093         if (n < 0)
1094                 n = 0;
1095         v = newlistobject(n);
1096         if (v == NULL)
1097                 return NULL;
1098         for (i = 0; i < n; i++) {
1099                 object *w = newintobject(ilow);
1100                 if (w == NULL) {
1101                         DECREF(v);
1102                         return NULL;
1103                 }
1104                 setlistitem(v, i, w);
1105                 ilow += istep;
1106         }
1107         return v;
1108 }
1109
1110 static object *
1111 builtin_xrange(self, args)
1112         object *self;
1113         object *args;
1114 {
1115         long ilow = 0, ihigh = 0, istep = 1;
1116         long n;
1117
1118         if (gettuplesize(args) <= 1) {
1119                 if (!newgetargs(args,
1120                                 "l;xrange() requires 1-3 int arguments",
1121                                 &ihigh))
1122                         return NULL;
1123         }
1124         else {
1125                 if (!newgetargs(args,
1126                                 "ll|l;xrange() requires 1-3 int arguments",
1127                                 &ilow, &ihigh, &istep))
1128                         return NULL;
1129         }
1130         if (istep == 0) {
1131                 err_setstr(ValueError, "zero step for xrange()");
1132                 return NULL;
1133         }
1134         /* XXX ought to check overflow of subtraction */
1135         if (istep > 0)
1136                 n = (ihigh - ilow + istep - 1) / istep;
1137         else
1138                 n = (ihigh - ilow + istep + 1) / istep;
1139         if (n < 0)
1140                 n = 0;
1141         return newrangeobject(ilow, n, istep, 1);
1142 }
1143
1144 extern char *my_readline PROTO((char *));
1145
1146 static object *
1147 builtin_raw_input(self, args)
1148         object *self;
1149         object *args;
1150 {
1151         object *v = NULL;
1152         object *f;
1153
1154         if (!newgetargs(args, "|O:[raw_]input", &v))
1155                 return NULL;
1156         if (getfilefile(sysget("stdin")) == stdin &&
1157             getfilefile(sysget("stdout")) == stdout &&
1158             isatty(fileno(stdin)) && isatty(fileno(stdout))) {
1159                 object *po;
1160                 char *prompt;
1161                 char *s;
1162                 object *result;
1163                 if (v != NULL) {
1164                         po = strobject(v);
1165                         if (po == NULL)
1166                                 return NULL;
1167                         prompt = getstringvalue(po);
1168                 }
1169                 else {
1170                         po = NULL;
1171                         prompt = "";
1172                 }
1173                 s = my_readline(prompt);
1174                 XDECREF(po);
1175                 if (s == NULL) {
1176                         err_set(KeyboardInterrupt);
1177                         return NULL;
1178                 }
1179                 if (*s == '\0') {
1180                         err_set(EOFError);
1181                         result = NULL;
1182                 }
1183                 else { /* strip trailing '\n' */
1184                         result = newsizedstringobject(s, strlen(s)-1);
1185                 }
1186                 free(s);
1187                 return result;
1188         }
1189         if (v != NULL) {
1190                 f = sysget("stdout");
1191                 if (f == NULL) {
1192                         err_setstr(RuntimeError, "lost sys.stdout");
1193                         return NULL;
1194                 }
1195                 flushline();
1196                 if (writeobject(v, f, PRINT_RAW) != 0)
1197                         return NULL;
1198         }
1199         f = sysget("stdin");
1200         if (f == NULL) {
1201                 err_setstr(RuntimeError, "lost sys.stdin");
1202                 return NULL;
1203         }
1204         return filegetline(f, -1);
1205 }
1206
1207 static object *
1208 builtin_reduce(self, args)
1209         object *self;
1210         object *args;
1211 {
1212         object *seq, *func, *result = NULL;
1213         sequence_methods *sqf;
1214         register int i;
1215
1216         if (!newgetargs(args, "OO|O:reduce", &func, &seq, &result))
1217                 return NULL;
1218         if (result != NULL)
1219                 INCREF(result);
1220
1221         if ((sqf = seq->ob_type->tp_as_sequence) == NULL) {
1222                 err_setstr(TypeError,
1223                     "2nd argument to reduce() must be a sequence object");
1224                 return NULL;
1225         }
1226
1227         if ((args = newtupleobject(2)) == NULL)
1228                 goto Fail;
1229
1230         for (i = 0; ; ++i) {
1231                 object *op2;
1232
1233                 if (args->ob_refcnt > 1) {
1234                         DECREF(args);
1235                         if ((args = newtupleobject(2)) == NULL)
1236                                 goto Fail;
1237                 }
1238
1239                 if ((op2 = (*sqf->sq_item)(seq, i)) == NULL) {
1240                         if (err_occurred() == IndexError) {
1241                                 err_clear();
1242                                 break;
1243                         }
1244                         goto Fail;
1245                 }
1246
1247                 if (result == NULL)
1248                         result = op2;
1249                 else {
1250                         settupleitem(args, 0, result);
1251                         settupleitem(args, 1, op2);
1252                         if ((result = call_object(func, args)) == NULL)
1253                                 goto Fail;
1254                 }
1255         }
1256
1257         DECREF(args);
1258
1259         if (result == NULL)
1260                 err_setstr(TypeError,
1261                            "reduce of empty sequence with no initial value");
1262
1263         return result;
1264
1265 Fail:
1266         XDECREF(args);
1267         XDECREF(result);
1268         return NULL;
1269 }
1270
1271 static object *
1272 builtin_reload(self, args)
1273         object *self;
1274         object *args;
1275 {
1276         object *v;
1277
1278         if (!newgetargs(args, "O:reload", &v))
1279                 return NULL;
1280         return reload_module(v);
1281 }
1282
1283 static object *
1284 builtin_repr(self, args)
1285         object *self;
1286         object *args;
1287 {
1288         object *v;
1289
1290         if (!newgetargs(args, "O:repr", &v))
1291                 return NULL;
1292         return reprobject(v);
1293 }
1294
1295 static object *
1296 builtin_round(self, args)
1297         object *self;
1298         object *args;
1299 {
1300         extern double floor PROTO((double));
1301         extern double ceil PROTO((double));
1302         double x;
1303         double f;
1304         int ndigits = 0;
1305         int i;
1306
1307         if (!newgetargs(args, "d|i:round", &x, &ndigits))
1308                         return NULL;
1309         f = 1.0;
1310         for (i = ndigits; --i >= 0; )
1311                 f = f*10.0;
1312         for (i = ndigits; ++i <= 0; )
1313                 f = f*0.1;
1314         if (x >= 0.0)
1315                 return newfloatobject(floor(x*f + 0.5) / f);
1316         else
1317                 return newfloatobject(ceil(x*f - 0.5) / f);
1318 }
1319
1320 static object *
1321 builtin_str(self, args)
1322         object *self;
1323         object *args;
1324 {
1325         object *v;
1326
1327         if (!newgetargs(args, "O:str", &v))
1328                 return NULL;
1329         return strobject(v);
1330 }
1331
1332 static object *
1333 builtin_tuple(self, args)
1334         object *self;
1335         object *args;
1336 {
1337         object *v;
1338         sequence_methods *sqf;
1339
1340         if (!newgetargs(args, "O:tuple", &v))
1341                 return NULL;
1342         if (is_tupleobject(v)) {
1343                 INCREF(v);
1344                 return v;
1345         }
1346         if (is_listobject(v))
1347                 return listtuple(v);
1348         if (is_stringobject(v)) {
1349                 int n = getstringsize(v);
1350                 object *t = newtupleobject(n);
1351                 if (t != NULL) {
1352                         int i;
1353                         char *p = getstringvalue(v);
1354                         for (i = 0; i < n; i++) {
1355                                 object *item = newsizedstringobject(p+i, 1);
1356                                 if (item == NULL) {
1357                                         DECREF(t);
1358                                         t = NULL;
1359                                         break;
1360                                 }
1361                                 settupleitem(t, i, item);
1362                         }
1363                 }
1364                 return t;
1365         }
1366         /* Generic sequence object */
1367         if ((sqf = v->ob_type->tp_as_sequence) != NULL) {
1368                 int n = (*sqf->sq_length)(v);
1369                 int i;
1370                 object *t;
1371                 if (n < 0)
1372                         return NULL;
1373                 t = newtupleobject(n);
1374                 if (t == NULL)
1375                         return NULL;
1376                 for (i = 0; i < n; i++) {
1377                         object *item = (*sqf->sq_item)(v, i);
1378                         if (item == NULL) {
1379                                 DECREF(t);
1380                                 t = NULL;
1381                                 break;
1382                         }
1383                         settupleitem(t, i, item);
1384                 }
1385                 /* XXX Should support indefinite-length sequences */
1386                 return t;
1387         }
1388         /* None of the above */
1389         err_setstr(TypeError, "tuple() argument must be a sequence");
1390         return NULL;
1391 }
1392
1393 static object *
1394 builtin_type(self, args)
1395         object *self;
1396         object *args;
1397 {
1398         object *v;
1399
1400         if (!newgetargs(args, "O:type", &v))
1401                 return NULL;
1402         v = (object *)v->ob_type;
1403         INCREF(v);
1404         return v;
1405 }
1406
1407 static object *
1408 builtin_vars(self, args)
1409         object *self;
1410         object *args;
1411 {
1412         object *v = NULL;
1413         object *d;
1414
1415         if (!newgetargs(args, "|O:vars", &v))
1416                 return NULL;
1417         if (v == NULL) {
1418                 d = getlocals();
1419                 if (d == NULL) {
1420                         if (!err_occurred())
1421                                 err_setstr(SystemError, "no locals!?");
1422                 }
1423                 else
1424                         INCREF(d);
1425         }
1426         else {
1427                 d = getattr(v, "__dict__");
1428                 if (d == NULL) {
1429                         err_setstr(TypeError,
1430                             "vars() argument must have __dict__ attribute");
1431                         return NULL;
1432                 }
1433         }
1434         return d;
1435 }
1436
1437 static struct methodlist builtin_methods[] = {
1438         {"__import__",  builtin___import__, 1},
1439         {"abs",         builtin_abs, 1},
1440         {"apply",       builtin_apply, 1},
1441         {"callable",    builtin_callable, 1},
1442         {"chr",         builtin_chr, 1},
1443         {"cmp",         builtin_cmp, 1},
1444         {"coerce",      builtin_coerce, 1},
1445         {"compile",     builtin_compile, 1},
1446 #ifndef WITHOUT_COMPLEX
1447         {"complex",     builtin_complex, 1},
1448 #endif
1449         {"delattr",     builtin_delattr, 1},
1450         {"dir",         builtin_dir, 1},
1451         {"divmod",      builtin_divmod, 1},
1452         {"eval",        builtin_eval, 1},
1453         {"execfile",    builtin_execfile, 1},
1454         {"filter",      builtin_filter, 1},
1455         {"float",       builtin_float, 1},
1456         {"getattr",     builtin_getattr, 1},
1457         {"globals",     builtin_globals, 1},
1458         {"hasattr",     builtin_hasattr, 1},
1459         {"hash",        builtin_hash, 1},
1460         {"hex",         builtin_hex, 1},
1461         {"id",          builtin_id, 1},
1462         {"input",       builtin_input, 1},
1463         {"int",         builtin_int, 1},
1464         {"len",         builtin_len, 1},
1465         {"locals",      builtin_locals, 1},
1466         {"long",        builtin_long, 1},
1467         {"map",         builtin_map, 1},
1468         {"max",         builtin_max, 1},
1469         {"min",         builtin_min, 1},
1470         {"oct",         builtin_oct, 1},
1471         {"open",        builtin_open, 1},
1472         {"ord",         builtin_ord, 1},
1473         {"pow",         builtin_pow, 1},
1474         {"range",       builtin_range, 1},
1475         {"raw_input",   builtin_raw_input, 1},
1476         {"reduce",      builtin_reduce, 1},
1477         {"reload",      builtin_reload, 1},
1478         {"repr",        builtin_repr, 1},
1479         {"round",       builtin_round, 1},
1480         {"setattr",     builtin_setattr, 1},
1481         {"str",         builtin_str, 1},
1482         {"tuple",       builtin_tuple, 1},
1483         {"type",        builtin_type, 1},
1484         {"vars",        builtin_vars, 1},
1485         {"xrange",      builtin_xrange, 1},
1486         {NULL,          NULL},
1487 };
1488
1489 static object *builtin_mod;
1490 static object *builtin_dict;
1491
1492 object *
1493 getbuiltinmod()
1494 {
1495         return builtin_mod;
1496 }
1497
1498 object *
1499 getbuiltindict()
1500 {
1501         return builtin_dict;
1502 }
1503
1504 /* Predefined exceptions */
1505
1506 object *AccessError;
1507 object *AttributeError;
1508 object *ConflictError;
1509 object *EOFError;
1510 object *IOError;
1511 object *ImportError;
1512 object *IndexError;
1513 object *KeyError;
1514 object *KeyboardInterrupt;
1515 object *MemoryError;
1516 object *NameError;
1517 object *OverflowError;
1518 object *RuntimeError;
1519 object *SyntaxError;
1520 object *SystemError;
1521 object *SystemExit;
1522 object *TypeError;
1523 object *ValueError;
1524 object *ZeroDivisionError;
1525
1526 static object *
1527 newstdexception(name)
1528         char *name;
1529 {
1530         object *v = newstringobject(name);
1531         if (v == NULL || dictinsert(builtin_dict, name, v) != 0)
1532                 fatal("no mem for new standard exception");
1533         return v;
1534 }
1535
1536 static void
1537 initerrors()
1538 {
1539         AccessError = newstdexception("AccessError");
1540         AttributeError = newstdexception("AttributeError");
1541         ConflictError = newstdexception("ConflictError");
1542         EOFError = newstdexception("EOFError");
1543         IOError = newstdexception("IOError");
1544         ImportError = newstdexception("ImportError");
1545         IndexError = newstdexception("IndexError");
1546         KeyError = newstdexception("KeyError");
1547         KeyboardInterrupt = newstdexception("KeyboardInterrupt");
1548         MemoryError = newstdexception("MemoryError");
1549         NameError = newstdexception("NameError");
1550         OverflowError = newstdexception("OverflowError");
1551         RuntimeError = newstdexception("RuntimeError");
1552         SyntaxError = newstdexception("SyntaxError");
1553         SystemError = newstdexception("SystemError");
1554         SystemExit = newstdexception("SystemExit");
1555         TypeError = newstdexception("TypeError");
1556         ValueError = newstdexception("ValueError");
1557         ZeroDivisionError = newstdexception("ZeroDivisionError");
1558 }
1559
1560 void
1561 initbuiltin()
1562 {
1563         builtin_mod = initmodule("__builtin__", builtin_methods);
1564         builtin_dict = getmoduledict(builtin_mod);
1565         INCREF(builtin_dict);
1566         initerrors();
1567         (void) dictinsert(builtin_dict, "None", None);
1568 }
1569
1570
1571 /* Helper for filter(): filter a tuple through a function */
1572
1573 static object *
1574 filtertuple(func, tuple)
1575         object *func;
1576         object *tuple;
1577 {
1578         object *result;
1579         register int i, j;
1580         int len = gettuplesize(tuple);
1581
1582         if (len == 0) {
1583                 INCREF(tuple);
1584                 return tuple;
1585         }
1586
1587         if ((result = newtupleobject(len)) == NULL)
1588                 return NULL;
1589
1590         for (i = j = 0; i < len; ++i) {
1591                 object *item, *good;
1592                 int ok;
1593
1594                 if ((item = gettupleitem(tuple, i)) == NULL)
1595                         goto Fail_1;
1596                 if (func == None) {
1597                         INCREF(item);
1598                         good = item;
1599                 }
1600                 else {
1601                         object *arg = mkvalue("(O)", item);
1602                         if (arg == NULL)
1603                                 goto Fail_1;
1604                         good = call_object(func, arg);
1605                         DECREF(arg);
1606                         if (good == NULL)
1607                                 goto Fail_1;
1608                 }
1609                 ok = testbool(good);
1610                 DECREF(good);
1611                 if (ok) {
1612                         INCREF(item);
1613                         if (settupleitem(result, j++, item) < 0)
1614                                 goto Fail_1;
1615                 }
1616         }
1617
1618         if (resizetuple(&result, j, 0) < 0)
1619                 return NULL;
1620
1621         return result;
1622
1623 Fail_1:
1624         DECREF(result);
1625         return NULL;
1626 }
1627
1628
1629 /* Helper for filter(): filter a string through a function */
1630
1631 static object *
1632 filterstring(func, strobj)
1633         object *func;
1634         object *strobj;
1635 {
1636         object *result;
1637         register int i, j;
1638         int len = getstringsize(strobj);
1639
1640         if (func == None) {
1641                 /* No character is ever false -- share input string */
1642                 INCREF(strobj);
1643                 return strobj;
1644         }
1645         if ((result = newsizedstringobject(NULL, len)) == NULL)
1646                 return NULL;
1647
1648         for (i = j = 0; i < len; ++i) {
1649                 object *item, *arg, *good;
1650                 int ok;
1651
1652                 item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
1653                 if (item == NULL)
1654                         goto Fail_1;
1655                 arg = mkvalue("(O)", item);
1656                 DECREF(item);
1657                 if (arg == NULL)
1658                         goto Fail_1;
1659                 good = call_object(func, arg);
1660                 DECREF(arg);
1661                 if (good == NULL)
1662                         goto Fail_1;
1663                 ok = testbool(good);
1664                 DECREF(good);
1665                 if (ok)
1666                         GETSTRINGVALUE((stringobject *)result)[j++] =
1667                                 GETSTRINGVALUE((stringobject *)item)[0];
1668         }
1669
1670         if (resizestring(&result, j) < 0)
1671                 return NULL;
1672
1673         return result;
1674
1675 Fail_1:
1676         DECREF(result);
1677         return NULL;
1678 }