]> granicus.if.org Git - python/commitdiff
Improve extended slicing support in builtin types and classes. Specifically:
authorThomas Wouters <thomas@python.org>
Tue, 28 Aug 2007 15:28:19 +0000 (15:28 +0000)
committerThomas Wouters <thomas@python.org>
Tue, 28 Aug 2007 15:28:19 +0000 (15:28 +0000)
 - Specialcase extended slices that amount to a shallow copy the same way as
   is done for simple slices, in the tuple, string and unicode case.

 - Specialcase step-1 extended slices to optimize the common case for all
   involved types.

 - For lists, allow extended slice assignment of differing lengths as long
   as the step is 1. (Previously, 'l[:2:1] = []' failed even though
   'l[:2] = []' and 'l[:2:None] = []' do not.)

 - Implement extended slicing for buffer, array, structseq, mmap and
   UserString.UserString.

 - Implement slice-object support (but not non-step-1 slice assignment) for
   UserString.MutableString.

 - Add tests for all new functionality.

16 files changed:
Lib/UserString.py
Lib/test/list_tests.py
Lib/test/string_tests.py
Lib/test/test_array.py
Lib/test/test_buffer.py [new file with mode: 0644]
Lib/test/test_mmap.py
Lib/test/test_structseq.py
Lib/test/test_userstring.py
Modules/arraymodule.c
Modules/mmapmodule.c
Objects/bufferobject.c
Objects/listobject.c
Objects/stringobject.c
Objects/structseq.c
Objects/tupleobject.c
Objects/unicodeobject.c

index 60dc34bc4b3c2791d4d100dfc6f6f9332e09dc27..9c58a34991d50a7f660a17c6f7e65b3d9794f078 100755 (executable)
@@ -149,15 +149,41 @@ class MutableString(UserString):
     def __hash__(self):
         raise TypeError, "unhashable type (it is mutable)"
     def __setitem__(self, index, sub):
-        if index < 0:
-            index += len(self.data)
-        if index < 0 or index >= len(self.data): raise IndexError
-        self.data = self.data[:index] + sub + self.data[index+1:]
+        if isinstance(index, slice):
+            if isinstance(sub, UserString):
+                sub = sub.data
+            elif not isinstance(sub, basestring):
+                sub = str(sub)
+            start, stop, step = index.indices(len(self.data))
+            if step == -1:
+                start, stop = stop+1, start+1
+                sub = sub[::-1]
+            elif step != 1:
+                # XXX(twouters): I guess we should be reimplementing
+                # the extended slice assignment/deletion algorithm here...
+                raise TypeError, "invalid step in slicing assignment"
+            start = min(start, stop)
+            self.data = self.data[:start] + sub + self.data[stop:]
+        else:
+            if index < 0:
+                index += len(self.data)
+            if index < 0 or index >= len(self.data): raise IndexError
+            self.data = self.data[:index] + sub + self.data[index+1:]
     def __delitem__(self, index):
-        if index < 0:
-            index += len(self.data)
-        if index < 0 or index >= len(self.data): raise IndexError
-        self.data = self.data[:index] + self.data[index+1:]
+        if isinstance(index, slice):
+            start, stop, step = index.indices(len(self.data))
+            if step == -1:
+                start, stop = stop+1, start+1
+            elif step != 1:
+                # XXX(twouters): see same block in __setitem__
+                raise TypeError, "invalid step in slicing deletion"
+            start = min(start, stop)
+            self.data = self.data[:start] + self.data[stop:]
+        else:
+            if index < 0:
+                index += len(self.data)
+            if index < 0 or index >= len(self.data): raise IndexError
+            self.data = self.data[:index] + self.data[index+1:]
     def __setslice__(self, start, end, sub):
         start = max(start, 0); end = max(end, 0)
         if isinstance(sub, UserString):
index 7c6623a22f83744063c5a90f612b9e84afa3b154..1c799d760ea997f08a683c3070faa1fce338687e 100644 (file)
@@ -179,8 +179,10 @@ class CommonTest(seq_tests.CommonTest):
         self.assertEqual(a, self.type2test(range(10)))
 
         self.assertRaises(TypeError, a.__setslice__, 0, 1, 5)
+        self.assertRaises(TypeError, a.__setitem__, slice(0, 1, 5))
 
         self.assertRaises(TypeError, a.__setslice__)
+        self.assertRaises(TypeError, a.__setitem__)
 
     def test_delslice(self):
         a = self.type2test([0, 1])
index d38e4a98dd70e81e90320fbcbdab91881e173461..d0f8c03c7ef41a412da1c7098ebc5183d21421c8 100644 (file)
@@ -912,7 +912,6 @@ class MixinStrUnicodeUserStringTest:
         self.checkequal(u'abc', 'abc', '__getitem__', slice(0, 1000))
         self.checkequal(u'a', 'abc', '__getitem__', slice(0, 1))
         self.checkequal(u'', 'abc', '__getitem__', slice(0, 0))
-        # FIXME What about negative indices? This is handled differently by [] and __getitem__(slice)
 
         self.checkraises(TypeError, 'abc', '__getitem__', 'def')
 
@@ -926,10 +925,21 @@ class MixinStrUnicodeUserStringTest:
         self.checkequal('', 'abc', '__getslice__', 1000, 1000)
         self.checkequal('', 'abc', '__getslice__', 2000, 1000)
         self.checkequal('', 'abc', '__getslice__', 2, 1)
-        # FIXME What about negative indizes? This is handled differently by [] and __getslice__
 
         self.checkraises(TypeError, 'abc', '__getslice__', 'def')
 
+    def test_extended_getslice(self):
+        # Test extended slicing by comparing with list slicing.
+        s = string.ascii_letters + string.digits
+        indices = (0, None, 1, 3, 41, -1, -2, -37)
+        for start in indices:
+            for stop in indices:
+                # Skip step 0 (invalid)
+                for step in indices[1:]:
+                    L = list(s)[start:stop:step]
+                    self.checkequal(u"".join(L), s, '__getitem__',
+                                    slice(start, stop, step))
+
     def test_mul(self):
         self.checkequal('', 'abc', '__mul__', -1)
         self.checkequal('', 'abc', '__mul__', 0)
index c10ad86eea50cfa11bf555e065b092f970e7c449..0bb7e53706546c25aefaf9d1bdea2b28b364ae14 100755 (executable)
@@ -474,6 +474,18 @@ class BaseTest(unittest.TestCase):
             array.array(self.typecode)
         )
 
+    def test_extended_getslice(self):
+        # Test extended slicing by comparing with list slicing
+        # (Assumes list conversion works correctly, too)
+        a = array.array(self.typecode, self.example)
+        indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
+        for start in indices:
+            for stop in indices:
+                # Everything except the initial 0 (invalid step)
+                for step in indices[1:]:
+                    self.assertEqual(list(a[start:stop:step]),
+                                     list(a)[start:stop:step])
+
     def test_setslice(self):
         a = array.array(self.typecode, self.example)
         a[:1] = a
@@ -557,12 +569,34 @@ class BaseTest(unittest.TestCase):
 
         a = array.array(self.typecode, self.example)
         self.assertRaises(TypeError, a.__setslice__, 0, 0, None)
+        self.assertRaises(TypeError, a.__setitem__, slice(0, 0), None)
         self.assertRaises(TypeError, a.__setitem__, slice(0, 1), None)
 
         b = array.array(self.badtypecode())
         self.assertRaises(TypeError, a.__setslice__, 0, 0, b)
+        self.assertRaises(TypeError, a.__setitem__, slice(0, 0), b)
         self.assertRaises(TypeError, a.__setitem__, slice(0, 1), b)
 
+    def test_extended_set_del_slice(self):
+        indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
+        for start in indices:
+            for stop in indices:
+                # Everything except the initial 0 (invalid step)
+                for step in indices[1:]:
+                    a = array.array(self.typecode, self.example)
+                    L = list(a)
+                    # Make sure we have a slice of exactly the right length,
+                    # but with (hopefully) different data.
+                    data = L[start:stop:step]
+                    data.reverse()
+                    L[start:stop:step] = data
+                    a[start:stop:step] = array.array(self.typecode, data)
+                    self.assertEquals(a, array.array(self.typecode, L))
+
+                    del L[start:stop:step]
+                    del a[start:stop:step]
+                    self.assertEquals(a, array.array(self.typecode, L))
+
     def test_index(self):
         example = 2*self.example
         a = array.array(self.typecode, example)
diff --git a/Lib/test/test_buffer.py b/Lib/test/test_buffer.py
new file mode 100644 (file)
index 0000000..3bede88
--- /dev/null
@@ -0,0 +1,29 @@
+"""Unit tests for buffer objects.
+
+For now, tests just new or changed functionality.
+
+"""
+
+import unittest
+from test import test_support
+
+class BufferTests(unittest.TestCase):
+
+    def test_extended_getslice(self):
+        # Test extended slicing by comparing with list slicing.
+        s = "".join(chr(c) for c in list(range(255, -1, -1)))
+        b = buffer(s)
+        indices = (0, None, 1, 3, 19, 300, -1, -2, -31, -300)
+        for start in indices:
+            for stop in indices:
+                # Skip step 0 (invalid)
+                for step in indices[1:]:
+                    self.assertEqual(b[start:stop:step],
+                                     s[start:stop:step])
+
+
+def test_main():
+    test_support.run_unittest(BufferTests)
+
+if __name__ == "__main__":
+    test_main()
index 0b5382307619efc0d288624677f5cc94ec2d7141..769eaed0b11a3be05fb0a2a03bff751137155a6a 100644 (file)
@@ -306,6 +306,40 @@ class MmapTests(unittest.TestCase):
             m[x] = ch = chr(x & 255)
             self.assertEqual(m[x], ch)
 
+    def test_extended_getslice(self):
+        # Test extended slicing by comparing with list slicing.
+        s = "".join(chr(c) for c in reversed(range(256)))
+        m = mmap.mmap(-1, len(s))
+        m[:] = s
+        self.assertEqual(m[:], s)
+        indices = (0, None, 1, 3, 19, 300, -1, -2, -31, -300)
+        for start in indices:
+            for stop in indices:
+                # Skip step 0 (invalid)
+                for step in indices[1:]:
+                    self.assertEqual(m[start:stop:step],
+                                     s[start:stop:step])
+
+    def test_extended_set_del_slice(self):
+        # Test extended slicing by comparing with list slicing.
+        s = "".join(chr(c) for c in reversed(range(256)))
+        m = mmap.mmap(-1, len(s))
+        indices = (0, None, 1, 3, 19, 300, -1, -2, -31, -300)
+        for start in indices:
+            for stop in indices:
+                # Skip invalid step 0
+                for step in indices[1:]:
+                    m[:] = s
+                    self.assertEqual(m[:], s)
+                    L = list(s)
+                    # Make sure we have a slice of exactly the right length,
+                    # but with different data.
+                    data = L[start:stop:step]
+                    data = "".join(reversed(data))
+                    L[start:stop:step] = data
+                    m[start:stop:step] = data
+                    self.assertEquals(m[:], "".join(L))
+
 def test_main():
     run_unittest(MmapTests)
 
index eb6d58104fcc3c61b64bcfb10f54d07ad0f75f45..1af0583804d79a80aa4a573b954f5168faec4514 100644 (file)
@@ -97,6 +97,18 @@ class StructSeqTest(unittest.TestCase):
         t = time.gmtime()
         x = t.__reduce__()
 
+    def test_extended_getslice(self):
+        # Test extended slicing by comparing with list slicing.
+        t = time.gmtime()
+        L = list(t)
+        indices = (0, None, 1, 3, 19, 300, -1, -2, -31, -300)
+        for start in indices:
+            for stop in indices:
+                # Skip step 0 (invalid)
+                for step in indices[1:]:
+                    self.assertEqual(list(t[start:stop:step]),
+                                     L[start:stop:step])
+
 def test_main():
     test_support.run_unittest(StructSeqTest)
 
index 53114db28513ae1a53c7bb3491577dcf748372a2..b66dffe3f6e0a35b0c69da53ae94519f9e4bed8f 100755 (executable)
@@ -3,6 +3,7 @@
 # UserString instances should behave similar to builtin string objects.
 
 import unittest
+import string
 from test import test_support, string_tests
 
 from UserString import UserString, MutableString
@@ -88,6 +89,28 @@ class MutableStringTest(UserStringTest):
         del s[-1:10]
         self.assertEqual(s, "fo")
 
+    def test_extended_set_del_slice(self):
+        indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
+        orig = string.ascii_letters + string.digits
+        for start in indices:
+            for stop in indices:
+                # Use indices[1:] when MutableString can handle real
+                # extended slices
+                for step in (None, 1, -1):
+                    s = self.type2test(orig)
+                    L = list(orig)
+                    # Make sure we have a slice of exactly the right length,
+                    # but with (hopefully) different data.
+                    data = L[start:stop:step]
+                    data.reverse()
+                    L[start:stop:step] = data
+                    s[start:stop:step] = "".join(data)
+                    self.assertEquals(s, "".join(L))
+
+                    del L[start:stop:step]
+                    del s[start:stop:step]
+                    self.assertEquals(s, "".join(L))
+
     def test_immutable(self):
         s = self.type2test("foobar")
         s2 = s.immutable()
index 21a5e5b705dadde7abefcaf177998c6e0c728499..b2ee5b016db43ddba92af1bc6a784d7a62a38bc7 100644 (file)
@@ -1605,6 +1605,16 @@ array_subscr(arrayobject* self, PyObject* item)
                if (slicelength <= 0) {
                        return newarrayobject(&Arraytype, 0, self->ob_descr);
                }
+               else if (step == 1) {
+                       PyObject *result = newarrayobject(&Arraytype,
+                                               slicelength, self->ob_descr);
+                       if (result == NULL)
+                               return NULL;
+                       memcpy(((arrayobject *)result)->ob_item,
+                              self->ob_item + start * itemsize,
+                              slicelength * itemsize);
+                       return result;
+               }
                else {
                        result = newarrayobject(&Arraytype, slicelength, self->ob_descr);
                        if (!result) return NULL;
@@ -1623,7 +1633,7 @@ array_subscr(arrayobject* self, PyObject* item)
        }
        else {
                PyErr_SetString(PyExc_TypeError, 
-                               "list indices must be integers");
+                               "array indices must be integers");
                return NULL;
        }
 }
@@ -1631,112 +1641,146 @@ array_subscr(arrayobject* self, PyObject* item)
 static int
 array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
 {
+       Py_ssize_t start, stop, step, slicelength, needed;
+       arrayobject* other;
+       int itemsize;
+
        if (PyIndex_Check(item)) {
                Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
-               if (i==-1 && PyErr_Occurred()) 
+               
+               if (i == -1 && PyErr_Occurred())
                        return -1;
                if (i < 0)
                        i += Py_Size(self);
-               return array_ass_item(self, i, value);
-       }
-       else if (PySlice_Check(item)) {
-               Py_ssize_t start, stop, step, slicelength;
-               int itemsize = self->ob_descr->itemsize;
-
-               if (PySlice_GetIndicesEx((PySliceObject*)item, Py_Size(self),
-                                &start, &stop, &step, &slicelength) < 0) {
+               if (i < 0 || i >= Py_Size(self)) {
+                       PyErr_SetString(PyExc_IndexError,
+                               "array assignment index out of range");
                        return -1;
                }
-
-               /* treat A[slice(a,b)] = v _exactly_ like A[a:b] = v */
-               if (step == 1 && ((PySliceObject*)item)->step == Py_None)
-                       return array_ass_slice(self, start, stop, value);
-
                if (value == NULL) {
-                       /* delete slice */
-                       Py_ssize_t cur, i, extra;
-                       
-                       if (slicelength <= 0)
-                               return 0;
-
-                       if (step < 0) {
-                               stop = start + 1;
-                               start = stop + step*(slicelength - 1) - 1;
-                               step = -step;
-                       }
-
-                       for (cur = start, i = 0; i < slicelength - 1;
-                            cur += step, i++) {
-                               memmove(self->ob_item + (cur - i)*itemsize,
-                                       self->ob_item + (cur + 1)*itemsize,
-                                       (step - 1) * itemsize);
-                       }
-                       extra = Py_Size(self) - (cur + 1);
-                       if (extra > 0) {
-                               memmove(self->ob_item + (cur - i)*itemsize,
-                                       self->ob_item + (cur + 1)*itemsize,
-                                       extra*itemsize);
-                       }
-
-                       Py_Size(self) -= slicelength;
-                       self->ob_item = (char *)PyMem_REALLOC(self->ob_item,
-                                                             itemsize*Py_Size(self));
-                       self->allocated = Py_Size(self);
-
-                       return 0;
+                       /* Fall through to slice assignment */
+                       start = i;
+                       stop = i + 1;
+                       step = 1;
+                       slicelength = 1;
                }
-               else {
-                       /* assign slice */
-                       Py_ssize_t cur, i;
-                       arrayobject* av;
-
-                       if (!array_Check(value)) {
-                               PyErr_Format(PyExc_TypeError,
-                            "must assign array (not \"%.200s\") to slice",
-                                            Py_Type(value)->tp_name);
-                               return -1;
-                       }
-
-                       av = (arrayobject*)value;
-
-                       if (Py_Size(av) != slicelength) {
-                               PyErr_Format(PyExc_ValueError,
-            "attempt to assign array of size %ld to extended slice of size %ld",
-                                            /*XXX*/(long)Py_Size(av), /*XXX*/(long)slicelength);
+               else
+                       return (*self->ob_descr->setitem)(self, i, value);
+       }
+       else if (PySlice_Check(item)) {
+               if (PySlice_GetIndicesEx((PySliceObject *)item,
+                                        Py_Size(self), &start, &stop,
+                                        &step, &slicelength) < 0) {
+                       return -1;
+               }
+       }
+       else {
+               PyErr_SetString(PyExc_TypeError,
+                               "array indices must be integer");
+               return -1;
+       }
+       if (value == NULL) {
+               other = NULL;
+               needed = 0;
+       }
+       else if (array_Check(value)) {
+               other = (arrayobject *)value;
+               needed = Py_Size(other);
+               if (self == other) {
+                       /* Special case "self[i:j] = self" -- copy self first */
+                       int ret;
+                       value = array_slice(other, 0, needed);
+                       if (value == NULL)
                                return -1;
-                       }
-
-                       if (!slicelength)
-                               return 0;
-
-                       /* protect against a[::-1] = a */
-                       if (self == av) { 
-                               value = array_slice(av, 0, Py_Size(av));
-                               av = (arrayobject*)value;
-                               if (!av)
-                                       return -1;
-                       } 
-                       else {
-                               Py_INCREF(value);
-                       }
-
-                       for (cur = start, i = 0; i < slicelength; 
-                            cur += step, i++) {
-                               memcpy(self->ob_item + cur*itemsize,
-                                      av->ob_item + i*itemsize,
-                                      itemsize);
-                       }
-
+                       ret = array_ass_subscr(self, item, value);
                        Py_DECREF(value);
-                       
-                       return 0;
+                       return ret;
+               }
+               if (other->ob_descr != self->ob_descr) {
+                       PyErr_BadArgument();
+                       return -1;
                }
-       } 
+       }
        else {
-               PyErr_SetString(PyExc_TypeError, 
-                               "list indices must be integers");
+               PyErr_Format(PyExc_TypeError,
+            "can only assign array (not \"%.200s\") to array slice",
+                            Py_Type(value)->tp_name);
                return -1;
        }
+       itemsize = self->ob_descr->itemsize;
+       /* for 'a[2:1] = ...', the insertion point is 'start', not 'stop' */
+       if ((step > 0 && stop < start) ||
+           (step < 0 && stop > start))
+               stop = start;
+       if (step == 1) {
+               if (slicelength > needed) {
+                       memmove(self->ob_item + (start + needed) * itemsize,
+                               self->ob_item + stop * itemsize,
+                               (Py_Size(self) - stop) * itemsize);
+                       if (array_resize(self, Py_Size(self) +
+                                        needed - slicelength) < 0)
+                               return -1;
+               }
+               else if (slicelength < needed) {
+                       if (array_resize(self, Py_Size(self) +
+                                        needed - slicelength) < 0)
+                               return -1;
+                       memmove(self->ob_item + (start + needed) * itemsize,
+                               self->ob_item + stop * itemsize,
+                               (Py_Size(self) - start - needed) * itemsize);
+               }
+               if (needed > 0)
+                       memcpy(self->ob_item + start * itemsize,
+                              other->ob_item, needed * itemsize);
+               return 0;
+       }
+       else if (needed == 0) {
+               /* Delete slice */
+               Py_ssize_t cur, i;
+               
+               if (step < 0) {
+                       stop = start + 1;
+                       start = stop + step * (slicelength - 1) - 1;
+                       step = -step;
+               }
+               for (cur = start, i = 0; i < slicelength;
+                    cur += step, i++) {
+                       Py_ssize_t lim = step - 1;
+
+                       if (cur + step >= Py_Size(self))
+                               lim = Py_Size(self) - cur - 1;
+                       memmove(self->ob_item + (cur - i) * itemsize,
+                               self->ob_item + (cur + 1) * itemsize,
+                               lim * itemsize);
+               }
+               cur = start + slicelength * step;
+               if (cur < Py_Size(self)) {
+                       memmove(self->ob_item + (cur-slicelength) * itemsize,
+                               self->ob_item + cur * itemsize,
+                               (Py_Size(self) - cur) * itemsize);
+               }
+               if (array_resize(self, Py_Size(self) - slicelength) < 0)
+                       return -1;
+               return 0;
+       }
+       else {
+               Py_ssize_t cur, i;
+
+               if (needed != slicelength) {
+                       PyErr_Format(PyExc_ValueError,
+                               "attempt to assign array of size %zd "
+                               "to extended slice of size %zd",
+                               needed, slicelength);
+                       return -1;
+               }
+               for (cur = start, i = 0; i < slicelength;
+                    cur += step, i++) {
+                       memcpy(self->ob_item + cur * itemsize,
+                              other->ob_item + i * itemsize,
+                              itemsize);
+               }
+               return 0;
+       }
 }
 
 static PyMappingMethods array_as_mapping = {
index a92954bccdcfb09f154474c6954170d209f76e85..61144428b263ed19ae1937185e9631c832ef7b53 100644 (file)
@@ -680,6 +680,60 @@ mmap_slice(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh)
        return PyString_FromStringAndSize(self->data + ilow, ihigh-ilow);
 }
 
+static PyObject *
+mmap_subscript(mmap_object *self, PyObject *item)
+{
+       CHECK_VALID(NULL);
+       if (PyIndex_Check(item)) {
+               Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
+               if (i == -1 && PyErr_Occurred())
+                       return NULL;
+               if (i < 0)
+                       i += self->size;
+               if (i < 0 || i > self->size) {
+                       PyErr_SetString(PyExc_IndexError,
+                               "mmap index out of range");
+                       return NULL;
+               }
+               return PyString_FromStringAndSize(self->data + i, 1);
+       }
+       else if (PySlice_Check(item)) {
+               Py_ssize_t start, stop, step, slicelen;
+
+               if (PySlice_GetIndicesEx((PySliceObject *)item, self->size,
+                                &start, &stop, &step, &slicelen) < 0) {
+                       return NULL;
+               }
+               
+               if (slicelen <= 0)
+                       return PyString_FromStringAndSize("", 0);
+               else if (step == 1)
+                       return PyString_FromStringAndSize(self->data + start,
+                                                         slicelen);
+               else {
+                       char *result_buf = (char *)PyMem_Malloc(slicelen);
+                       Py_ssize_t cur, i;
+                       PyObject *result;
+
+                       if (result_buf == NULL)
+                               return PyErr_NoMemory();
+                       for (cur = start, i = 0; i < slicelen;
+                            cur += step, i++) {
+                               result_buf[i] = self->data[cur];
+                       }
+                       result = PyString_FromStringAndSize(result_buf,
+                                                           slicelen);
+                       PyMem_Free(result_buf);
+                       return result;
+               }
+       }
+       else {
+               PyErr_SetString(PyExc_TypeError,
+                               "mmap indices must be integers");
+               return NULL;
+       }
+}
+
 static PyObject *
 mmap_concat(mmap_object *self, PyObject *bb)
 {
@@ -764,6 +818,96 @@ mmap_ass_item(mmap_object *self, Py_ssize_t i, PyObject *v)
        return 0;
 }
 
+static int
+mmap_ass_subscript(mmap_object *self, PyObject *item, PyObject *value)
+{
+       CHECK_VALID(-1);
+
+       if (PyIndex_Check(item)) {
+               Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
+               const char *buf;
+
+               if (i == -1 && PyErr_Occurred())
+                       return -1;
+               if (i < 0)
+                       i += self->size;
+               if (i < 0 || i > self->size) {
+                       PyErr_SetString(PyExc_IndexError,
+                               "mmap index out of range");
+                       return -1;
+               }
+               if (value == NULL) {
+                       PyErr_SetString(PyExc_TypeError,
+                               "mmap object doesn't support item deletion");
+                       return -1;
+               }
+               if (!PyString_Check(value) || PyString_Size(value) != 1) {
+                       PyErr_SetString(PyExc_IndexError,
+                         "mmap assignment must be single-character string");
+                       return -1;
+               }
+               if (!is_writeable(self))
+                       return -1;
+               buf = PyString_AsString(value);
+               self->data[i] = buf[0];
+               return 0;
+       }
+       else if (PySlice_Check(item)) {
+               Py_ssize_t start, stop, step, slicelen;
+               
+               if (PySlice_GetIndicesEx((PySliceObject *)item,
+                                        self->size, &start, &stop,
+                                        &step, &slicelen) < 0) {
+                       return -1;
+               }
+               if (value == NULL) {
+                       PyErr_SetString(PyExc_TypeError,
+                               "mmap object doesn't support slice deletion");
+                       return -1;
+               }
+               if (!PyString_Check(value)) {
+                       PyErr_SetString(PyExc_IndexError,
+                               "mmap slice assignment must be a string");
+                       return -1;
+               }
+               if (PyString_Size(value) != slicelen) {
+                       PyErr_SetString(PyExc_IndexError,
+                               "mmap slice assignment is wrong size");
+                       return -1;
+               }
+               if (!is_writeable(self))
+                       return -1;
+
+               if (slicelen == 0)
+                       return 0;
+               else if (step == 1) {
+                       const char *buf = PyString_AsString(value);
+
+                       if (buf == NULL)
+                               return -1;
+                       memcpy(self->data + start, buf, slicelen);
+                       return 0;
+               }
+               else {
+                       Py_ssize_t cur, i;
+                       const char *buf = PyString_AsString(value);
+                       
+                       if (buf == NULL)
+                               return -1;
+                       for (cur = start, i = 0; i < slicelen;
+                            cur += step, i++) {
+                               self->data[cur] = buf[i];
+                       }
+                       return 0;
+               }
+       }
+       else {
+               PyErr_SetString(PyExc_TypeError,
+                               "mmap indices must be integer");
+               return -1;
+       }
+}
+
 static PySequenceMethods mmap_as_sequence = {
        (lenfunc)mmap_length,                  /*sq_length*/
        (binaryfunc)mmap_concat,               /*sq_concat*/
@@ -774,6 +918,12 @@ static PySequenceMethods mmap_as_sequence = {
        (ssizessizeobjargproc)mmap_ass_slice,      /*sq_ass_slice*/
 };
 
+static PyMappingMethods mmap_as_mapping = {
+       (lenfunc)mmap_length,
+       (binaryfunc)mmap_subscript,
+       (objobjargproc)mmap_ass_subscript,
+};
+
 static PyBufferProcs mmap_as_buffer = {
        (readbufferproc)mmap_buffer_getreadbuf,
        (writebufferproc)mmap_buffer_getwritebuf,
@@ -795,7 +945,7 @@ static PyTypeObject mmap_object_type = {
        0,                                      /* tp_repr */
        0,                                      /* tp_as_number */
        &mmap_as_sequence,                      /*tp_as_sequence*/
-       0,                                      /*tp_as_mapping*/
+       &mmap_as_mapping,                       /*tp_as_mapping*/
        0,                                      /*tp_hash*/
        0,                                      /*tp_call*/
        0,                                      /*tp_str*/
index 98be77141d3732aa1963b3aa04dc933a36ae7e10..13442c9c4164cc1549c976cc5af6885c798316aa 100644 (file)
@@ -472,6 +472,61 @@ buffer_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right)
                                          right - left);
 }
 
+static PyObject *
+buffer_subscript(PyBufferObject *self, PyObject *item)
+{
+       void *p;
+       Py_ssize_t size;
+       
+       if (!get_buf(self, &p, &size, ANY_BUFFER))
+               return NULL;
+       if (PyIndex_Check(item)) {
+               Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
+               if (i == -1 && PyErr_Occurred())
+                       return NULL;
+               if (i < 0)
+                       i += size;
+               return buffer_item(self, i);
+       }
+       else if (PySlice_Check(item)) {
+               Py_ssize_t start, stop, step, slicelength, cur, i;
+
+               if (PySlice_GetIndicesEx((PySliceObject*)item, size,
+                                &start, &stop, &step, &slicelength) < 0) {
+                       return NULL;
+               }
+
+               if (slicelength <= 0)
+                       return PyString_FromStringAndSize("", 0);
+               else if (step == 1)
+                       return PyString_FromStringAndSize((char *)p + start,
+                                                         stop - start);
+               else {
+                       PyObject *result;
+                       char *source_buf = (char *)p;
+                       char *result_buf = (char *)PyMem_Malloc(slicelength);
+
+                       if (result_buf == NULL)
+                               return PyErr_NoMemory();
+
+                       for (cur = start, i = 0; i < slicelength;
+                            cur += step, i++) {
+                               result_buf[i] = source_buf[cur];
+                       }
+
+                       result = PyString_FromStringAndSize(result_buf,
+                                                           slicelength);
+                       PyMem_Free(result_buf);
+                       return result;
+               }
+       }
+       else {
+               PyErr_SetString(PyExc_TypeError,
+                               "sequence index must be integer");
+               return NULL;
+       }
+}
+
 static int
 buffer_ass_item(PyBufferObject *self, Py_ssize_t idx, PyObject *other)
 {
@@ -581,6 +636,98 @@ buffer_ass_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right, PyObje
        return 0;
 }
 
+static int
+buffer_ass_subscript(PyBufferObject *self, PyObject *item, PyObject *value)
+{
+       PyBufferProcs *pb;
+       void *ptr1, *ptr2;
+       Py_ssize_t selfsize;
+       Py_ssize_t othersize;
+
+       if ( self->b_readonly ) {
+               PyErr_SetString(PyExc_TypeError,
+                               "buffer is read-only");
+               return -1;
+       }
+
+       pb = value ? value->ob_type->tp_as_buffer : NULL;
+       if ( pb == NULL ||
+            pb->bf_getreadbuffer == NULL ||
+            pb->bf_getsegcount == NULL )
+       {
+               PyErr_BadArgument();
+               return -1;
+       }
+       if ( (*pb->bf_getsegcount)(value, NULL) != 1 )
+       {
+               /* ### use a different exception type/message? */
+               PyErr_SetString(PyExc_TypeError,
+                               "single-segment buffer object expected");
+               return -1;
+       }
+       if (!get_buf(self, &ptr1, &selfsize, ANY_BUFFER))
+               return -1;
+       if (PyIndex_Check(item)) {
+               Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
+               if (i == -1 && PyErr_Occurred())
+                       return -1;
+               if (i < 0)
+                       i += selfsize;
+               return buffer_ass_item(self, i, value);
+       }
+       else if (PySlice_Check(item)) {
+               Py_ssize_t start, stop, step, slicelength;
+               
+               if (PySlice_GetIndicesEx((PySliceObject *)item, selfsize,
+                               &start, &stop, &step, &slicelength) < 0)
+                       return -1;
+
+               pb = value ? value->ob_type->tp_as_buffer : NULL;
+               if (pb == NULL ||
+                   pb->bf_getreadbuffer == NULL ||
+                   pb->bf_getsegcount == NULL) {
+                       PyErr_BadArgument();
+                       return -1;
+               }
+               if ((*pb->bf_getsegcount)(value, NULL) != 1) {
+                       /* ### use a different exception type/message? */
+                       PyErr_SetString(PyExc_TypeError,
+                                       "single-segment buffer object expected");
+                       return -1;
+               }
+               if ((othersize = (*pb->bf_getreadbuffer)(value, 0, &ptr2)) < 0)
+                       return -1;
+
+               if (othersize != slicelength) {
+                       PyErr_SetString(
+                               PyExc_TypeError,
+                               "right operand length must match slice length");
+                       return -1;
+               }
+
+               if (slicelength == 0)
+                       return 0;
+               else if (step == 1) {
+                       memcpy((char *)ptr1 + start, ptr2, slicelength);
+                       return 0;
+               }
+               else {
+                       Py_ssize_t cur, i;
+                       
+                       for (cur = start, i = 0; i < slicelength;
+                            cur += step, i++) {
+                               ((char *)ptr1)[cur] = ((char *)ptr2)[i];
+                       }
+
+                       return 0;
+               }
+       } else {
+               PyErr_SetString(PyExc_TypeError,
+                               "buffer indices must be integers");
+               return -1;
+       }
+}
+
 /* Buffer methods */
 
 static Py_ssize_t
@@ -656,6 +803,12 @@ static PySequenceMethods buffer_as_sequence = {
        (ssizessizeobjargproc)buffer_ass_slice, /*sq_ass_slice*/
 };
 
+static PyMappingMethods buffer_as_mapping = {
+       (lenfunc)buffer_length,
+       (binaryfunc)buffer_subscript,
+       (objobjargproc)buffer_ass_subscript,
+};
+
 static PyBufferProcs buffer_as_buffer = {
        (readbufferproc)buffer_getreadbuf,
        (writebufferproc)buffer_getwritebuf,
@@ -676,7 +829,7 @@ PyTypeObject PyBuffer_Type = {
        (reprfunc)buffer_repr,                  /* tp_repr */
        0,                                      /* tp_as_number */
        &buffer_as_sequence,                    /* tp_as_sequence */
-       0,                                      /* tp_as_mapping */
+       &buffer_as_mapping,                     /* tp_as_mapping */
        (hashfunc)buffer_hash,                  /* tp_hash */
        0,                                      /* tp_call */
        (reprfunc)buffer_str,                   /* tp_str */
index ac0d0183a0493c22dd294bd8f7cd81792ff7518a..c0621dce914a0458d91c5b212fee26cdce55a5ea 100644 (file)
@@ -2473,6 +2473,9 @@ list_subscript(PyListObject* self, PyObject* item)
                if (slicelength <= 0) {
                        return PyList_New(0);
                }
+               else if (step == 1) {
+                       return list_slice(self, start, stop);
+               }
                else {
                        result = PyList_New(slicelength);
                        if (!result) return NULL;
@@ -2516,10 +2519,15 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
                        return -1;
                }
 
-               /* treat L[slice(a,b)] = v _exactly_ like L[a:b] = v */
-               if (step == 1 && ((PySliceObject*)item)->step == Py_None)
+               if (step == 1)
                        return list_ass_slice(self, start, stop, value);
 
+               /* Make sure s[5:2] = [..] inserts at the right place:
+                  before 5, not before 2. */
+               if ((step < 0 && start < stop) ||
+                   (step > 0 && start > stop))
+                       stop = start;
+
                if (value == NULL) {
                        /* delete slice */
                        PyObject **garbage;
@@ -2541,12 +2549,16 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
                                return -1;
                        }
 
-                       /* drawing pictures might help
-                          understand these for loops */
+                       /* drawing pictures might help understand these for
+                          loops. Basically, we memmove the parts of the
+                          list that are *not* part of the slice: step-1
+                          items for each item that is part of the slice,
+                          and then tail end of the list that was not
+                          covered by the slice */
                        for (cur = start, i = 0;
                             cur < stop;
                             cur += step, i++) {
-                               Py_ssize_t lim = step;
+                               Py_ssize_t lim = step - 1;
 
                                garbage[i] = PyList_GET_ITEM(self, cur);
 
@@ -2558,11 +2570,12 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
                                        self->ob_item + cur + 1,
                                        lim * sizeof(PyObject *));
                        }
-
-                       for (cur = start + slicelength*step + 1;
-                            cur < Py_Size(self); cur++) {
-                               PyList_SET_ITEM(self, cur - slicelength,
-                                               PyList_GET_ITEM(self, cur));
+                       cur = start + slicelength*step;
+                       if (cur < Py_Size(self)) {
+                               memmove(self->ob_item + cur - slicelength,
+                                       self->ob_item + cur,
+                                       (Py_Size(self) - cur) * 
+                                        sizeof(PyObject *));
                        }
 
                        Py_Size(self) -= slicelength;
@@ -2577,7 +2590,8 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
                }
                else {
                        /* assign slice */
-                       PyObject **garbage, *ins, *seq, **seqitems, **selfitems;
+                       PyObject *ins, *seq;
+                       PyObject **garbage, **seqitems, **selfitems;
                        Py_ssize_t cur, i;
 
                        /* protect against a[::-1] = a */
@@ -2587,14 +2601,17 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
                        }
                        else {
                                seq = PySequence_Fast(value,
-                                       "must assign iterable to extended slice");
+                                                     "must assign iterable "
+                                                     "to extended slice");
                        }
                        if (!seq)
                                return -1;
 
                        if (PySequence_Fast_GET_SIZE(seq) != slicelength) {
                                PyErr_Format(PyExc_ValueError,
-            "attempt to assign sequence of size %zd to extended slice of size %zd",
+                                       "attempt to assign sequence of "
+                                       "size %zd to extended slice of "
+                                       "size %zd",
                                             PySequence_Fast_GET_SIZE(seq),
                                             slicelength);
                                Py_DECREF(seq);
index 4dd64f8429aec3fc95ab618b16a30d9abbbe1e6c..fb7548d33f73bb54aa9b140a0e991d6f7305e360 100644 (file)
@@ -1222,6 +1222,17 @@ string_subscript(PyStringObject* self, PyObject* item)
                if (slicelength <= 0) {
                        return PyString_FromStringAndSize("", 0);
                }
+               else if (start == 0 && step == 1 &&
+                        slicelength == PyString_GET_SIZE(self) &&
+                        PyString_CheckExact(self)) {
+                       Py_INCREF(self);
+                       return (PyObject *)self;
+               }
+               else if (step == 1) {
+                       return PyString_FromStringAndSize(
+                               PyString_AS_STRING(self) + start,
+                               slicelength);
+               }
                else {
                        source_buf = PyString_AsString((PyObject*)self);
                        result_buf = (char *)PyMem_Malloc(slicelength);
index 1d5ce870e047109f11f71116bf0fb06312da6379..fb6b96d167391f0aa9d06173f1b3fd2524aafce4 100644 (file)
@@ -89,6 +89,54 @@ structseq_slice(PyStructSequence *obj, Py_ssize_t low, Py_ssize_t high)
        return (PyObject *) np;
 }
 
+static PyObject *
+structseq_subscript(PyStructSequence *self, PyObject *item)
+{
+       if (PyIndex_Check(item)) {
+               Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
+               if (i == -1 && PyErr_Occurred())
+                       return NULL;
+
+               if (i < 0)
+                       i += VISIBLE_SIZE(self);
+
+               if (i < 0 || i >= VISIBLE_SIZE(self)) {
+                       PyErr_SetString(PyExc_IndexError,
+                               "tuple index out of range");
+                       return NULL;
+               }
+               Py_INCREF(self->ob_item[i]);
+               return self->ob_item[i];
+       }
+       else if (PySlice_Check(item)) {
+               Py_ssize_t start, stop, step, slicelen, cur, i;
+               PyObject *result;
+               
+               if (PySlice_GetIndicesEx((PySliceObject *)item,
+                                        VISIBLE_SIZE(self), &start, &stop,
+                                        &step, &slicelen) < 0) {
+                       return NULL;
+               }
+               if (slicelen <= 0)
+                       return PyTuple_New(0);
+               result = PyTuple_New(slicelen);
+               if (result == NULL)
+                       return NULL;
+               for (cur = start, i = 0; i < slicelen;
+                    cur += step, i++) {
+                       PyObject *v = self->ob_item[cur];
+                       Py_INCREF(v);
+                       PyTuple_SET_ITEM(result, i, v);
+               }
+               return result;
+       }
+       else {
+               PyErr_SetString(PyExc_TypeError,
+                               "structseq index must be integer");
+               return NULL;
+       }
+}
+
 static PyObject *
 structseq_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
@@ -298,6 +346,11 @@ static PySequenceMethods structseq_as_sequence = {
        (objobjproc)structseq_contains,         /* sq_contains */
 };
 
+static PyMappingMethods structseq_as_mapping = {
+       (lenfunc)structseq_length,
+       (binaryfunc)structseq_subscript,
+};
+
 static PyMethodDef structseq_methods[] = {
        {"__reduce__", (PyCFunction)structseq_reduce, 
         METH_NOARGS, NULL},
@@ -317,7 +370,7 @@ static PyTypeObject _struct_sequence_template = {
        (reprfunc)structseq_repr,               /* tp_repr */
        0,                                      /* tp_as_number */
        &structseq_as_sequence,                 /* tp_as_sequence */
-       0,                                      /* tp_as_mapping */
+       &structseq_as_mapping,                  /* tp_as_mapping */
        structseq_hash,                         /* tp_hash */
        0,                                      /* tp_call */
        0,                                      /* tp_str */
index 4d4a9ad8120879e5fcc232335e5c2e0a1e7727fb..f1e3aeeee761fea8d02cb3c2c5d1b6d8eabacb5d 100644 (file)
@@ -603,6 +603,12 @@ tuplesubscript(PyTupleObject* self, PyObject* item)
                if (slicelength <= 0) {
                        return PyTuple_New(0);
                }
+               else if (start == 0 && step == 1 &&
+                        slicelength == PyTuple_GET_SIZE(self) &&
+                        PyTuple_CheckExact(self)) {
+                       Py_INCREF(self);
+                       return (PyObject *)self;
+               }
                else {
                        result = PyTuple_New(slicelength);
                        if (!result) return NULL;
index e3c5d042a78fd8a2e7c6a652ce6a0984865fb74f..db1e43d17f060bd33f174ed6ee7014cd050940d2 100644 (file)
@@ -7385,6 +7385,12 @@ unicode_subscript(PyUnicodeObject* self, PyObject* item)
 
         if (slicelength <= 0) {
             return PyUnicode_FromUnicode(NULL, 0);
+        } else if (start == 0 && step == 1 && slicelength == self->length &&
+                   PyUnicode_CheckExact(self)) {
+            Py_INCREF(self);
+            return (PyObject *)self;
+        } else if (step == 1) {
+            return PyUnicode_FromUnicode(self->str + start, slicelength);
         } else {
             source_buf = PyUnicode_AS_UNICODE((PyObject*)self);
             result_buf = (Py_UNICODE *)PyMem_MALLOC(slicelength*