* compile.[ch]: support for lambda()
* PROTO.h, mymalloc.h: added #ifdefs for TURBOC and GNUC.
* allobjects.h: added #include "rangeobject.h"
* Grammar: added lambda_input; relaxed syntax for exec.
* bltinmodule.c: added bagof, map, reduce, lambda, xrange.
* tupleobject.[ch]: added resizetuple().
* rangeobject.[ch]: new object type to speed up range operations (not
convinced this is needed!!!)
diff --git a/Objects/rangeobject.c b/Objects/rangeobject.c
new file mode 100644
index 0000000..a68d317
--- /dev/null
+++ b/Objects/rangeobject.c
@@ -0,0 +1,205 @@
+/***********************************************************
+Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
+Amsterdam, The Netherlands.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/* Range object implementation */
+
+#include "allobjects.h"
+
+typedef struct {
+ OB_HEAD
+ long start;
+ long step;
+ long len;
+ int reps;
+} rangeobject;
+
+
+object *
+newrangeobject(start, len, step, reps)
+ long start, len, step;
+ int reps;
+{
+ rangeobject *obj = (rangeobject *) newobject(&Rangetype);
+
+ obj->start = start;
+ obj->len = len;
+ obj->step = step;
+ obj->reps = reps;
+
+ return (object *) obj;
+}
+
+static void
+range_dealloc(r)
+ rangeobject *r;
+{
+ DEL(r);
+}
+
+static object *
+range_item(r, i)
+ rangeobject *r;
+ int i;
+{
+ if (i < 0 || i >= r->len * r->reps) {
+ err_setstr(IndexError, "range object index out of range");
+ return NULL;
+ }
+
+ return newintobject(r->start + (i % r->len) * r->step);
+}
+
+static int
+range_length(r)
+ rangeobject *r;
+{
+ return r->len * r->reps;
+}
+
+static object *
+range_repr(r)
+ rangeobject *r;
+{
+ char buf[80];
+ if (r->reps != 1)
+ sprintf(buf, "(xrange(%ld, %ld, %ld) * %d)",
+ r->start,
+ r->start + r->len * r->step,
+ r->step,
+ r->reps);
+ else
+ sprintf(buf, "xrange(%ld, %ld, %ld)",
+ r->start,
+ r->start + r->len * r->step,
+ r->step);
+ return newstringobject(buf);
+}
+
+object *
+range_concat(r, obj)
+ rangeobject *r;
+ object *obj;
+{
+ if (is_rangeobject(obj)) {
+ rangeobject *s = (rangeobject *)obj;
+ if (r->start == s->start && r->len == s->len &&
+ r->step == s->step)
+ return newrangeobject(r->start, r->len, r->step,
+ r->reps + s->reps);
+ }
+ err_setstr(TypeError, "cannot concatenate different range objects");
+ return NULL;
+}
+
+object *
+range_repeat(r, n)
+ rangeobject *r;
+ int n;
+{
+ if (n < 0)
+ return (object *) newrangeobject(0, 0, 1, 1);
+
+ else if (n == 1) {
+ INCREF(r);
+ return (object *) r;
+ }
+
+ else
+ return (object *) newrangeobject(
+ r->start,
+ r->len,
+ r->step,
+ r->reps * n);
+}
+
+static int
+range_compare(r1, r2)
+ rangeobject *r1, *r2;
+{
+ if (r1->start != r2->start)
+ return r1->start - r2->start;
+
+ else if (r1->step != r2->step)
+ return r1->step - r2->step;
+
+ else if (r1->len != r2->len)
+ return r1->len - r2->len;
+
+ else
+ return r1->reps - r2->reps;
+}
+
+static object *
+range_slice(r, low, high)
+ rangeobject *r;
+ int low, high;
+{
+ if (r->reps != 1) {
+ err_setstr(TypeError, "cannot slice a replicated range");
+ return NULL;
+ }
+ if (low < 0)
+ low = 0;
+ else if (low > r->len)
+ low = r->len;
+ if (high < 0)
+ high = 0;
+ if (high < low)
+ high = low;
+ else if (high > r->len)
+ high = r->len;
+
+ return (object *) newrangeobject(
+ low * r->step + r->start,
+ high - low,
+ r->step,
+ 1);
+}
+
+static sequence_methods range_as_sequence = {
+ range_length, /*sq_length*/
+ range_concat, /*sq_concat*/
+ range_repeat, /*sq_repeat*/
+ range_item, /*sq_item*/
+ range_slice, /*sq_slice*/
+ 0, /*sq_ass_item*/
+ 0, /*sq_ass_slice*/
+};
+
+typeobject Rangetype = {
+ OB_HEAD_INIT(&Typetype)
+ 0, /* Number of items for varobject */
+ "range", /* Name of this type */
+ sizeof(rangeobject), /* Basic object size */
+ 0, /* Item size for varobject */
+ range_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ range_compare, /*tp_compare*/
+ range_repr, /*tp_repr*/
+ 0, /*tp_as_number*/
+ &range_as_sequence, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+};
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index bc68744..0047a09 100644
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -123,21 +123,18 @@
{
register object *olditem;
if (!is_tupleobject(op)) {
- if (newitem != NULL)
- DECREF(newitem);
+ XDECREF(newitem);
err_badcall();
return -1;
}
if (i < 0 || i >= ((tupleobject *)op) -> ob_size) {
- if (newitem != NULL)
- DECREF(newitem);
+ XDECREF(newitem);
err_setstr(IndexError, "tuple assignment index out of range");
return -1;
}
olditem = ((tupleobject *)op) -> ob_item[i];
((tupleobject *)op) -> ob_item[i] = newitem;
- if (olditem != NULL)
- DECREF(olditem);
+ XDECREF(olditem);
return 0;
}
@@ -148,10 +145,8 @@
register tupleobject *op;
{
register int i;
- for (i = 0; i < op->ob_size; i++) {
- if (op->ob_item[i] != NULL)
- DECREF(op->ob_item[i]);
- }
+ for (i = 0; i < op->ob_size; i++)
+ XDECREF(op->ob_item[i]);
#if MAXSAVESIZE > 0
if (0 < op->ob_size && op->ob_size < MAXSAVESIZE) {
op->ob_item[0] = (object *) free_list[op->ob_size];
@@ -194,8 +189,7 @@
joinstring(&s, comma);
t = reprobject(v->ob_item[i]);
joinstring(&s, t);
- if (t != NULL)
- DECREF(t);
+ XDECREF(t);
}
DECREF(comma);
if (v->ob_size == 1) {
@@ -397,3 +391,42 @@
0, /*tp_as_mapping*/
tuplehash, /*tp_hash*/
};
+
+/* The following function breaks the notion that tuples are immutable:
+ it changes the size of a tuple. We get away with this only if there
+ is only one module referencing the object. You can also think of it
+ as creating a new tuple object and destroying the old one, only
+ more efficiently. In any case, don't use this if the tuple may
+ already be known to some other part of the code... */
+
+int
+resizetuple(pv, newsize)
+ object **pv;
+ int newsize;
+{
+ register object *v;
+ register tupleobject *sv;
+ v = *pv;
+ if (!is_tupleobject(v) || v->ob_refcnt != 1) {
+ *pv = 0;
+ DECREF(v);
+ err_badcall();
+ return -1;
+ }
+ /* XXX UNREF/NEWREF interface should be more symmetrical */
+#ifdef REF_DEBUG
+ --ref_total;
+#endif
+ UNREF(v);
+ *pv = (object *)
+ realloc((char *)v,
+ sizeof(tupleobject) + newsize * sizeof(object *));
+ if (*pv == NULL) {
+ DEL(v);
+ err_nomem();
+ return -1;
+ }
+ NEWREF(*pv);
+ ((tupleobject *) *pv)->ob_size = newsize;
+ return 0;
+}