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