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