diff options
32 files changed, 79 insertions, 811 deletions
diff --git a/Include/object.h b/Include/object.h index 9dd100f..03f4796 100644 --- a/Include/object.h +++ b/Include/object.h @@ -252,9 +252,9 @@ typedef struct { binaryfunc sq_concat; ssizeargfunc sq_repeat; ssizeargfunc sq_item; - ssizessizeargfunc sq_slice; + void *was_sq_slice; ssizeobjargproc sq_ass_item; - ssizessizeobjargproc sq_ass_slice; + void *was_sq_ass_slice; objobjproc sq_contains; binaryfunc sq_inplace_concat; diff --git a/Include/opcode.h b/Include/opcode.h index 1c6683d..f2abab3 100644 --- a/Include/opcode.h +++ b/Include/opcode.h @@ -36,15 +36,6 @@ extern "C" { #define INPLACE_FLOOR_DIVIDE 28 #define INPLACE_TRUE_DIVIDE 29 -#define SLICE 30 -/* Also uses 31-33 */ - -#define STORE_SLICE 40 -/* Also uses 41-43 */ - -#define DELETE_SLICE 50 -/* Also uses 51-53 */ - #define INPLACE_ADD 55 #define INPLACE_SUBTRACT 56 #define INPLACE_MULTIPLY 57 diff --git a/Lib/UserList.py b/Lib/UserList.py index 072f6a7..116122f 100644 --- a/Lib/UserList.py +++ b/Lib/UserList.py @@ -28,20 +28,6 @@ class UserList: def __getitem__(self, i): return self.data[i] def __setitem__(self, i, item): self.data[i] = item def __delitem__(self, i): del self.data[i] - def __getslice__(self, i, j): - i = max(i, 0); j = max(j, 0) - return self.__class__(self.data[i:j]) - def __setslice__(self, i, j, other): - i = max(i, 0); j = max(j, 0) - if isinstance(other, UserList): - self.data[i:j] = other.data - elif isinstance(other, type(self.data)): - self.data[i:j] = other - else: - self.data[i:j] = list(other) - def __delslice__(self, i, j): - i = max(i, 0); j = max(j, 0) - del self.data[i:j] def __add__(self, other): if isinstance(other, UserList): return self.__class__(self.data + other.data) diff --git a/Lib/UserString.py b/Lib/UserString.py index de50396..8417be7 100755 --- a/Lib/UserString.py +++ b/Lib/UserString.py @@ -63,10 +63,6 @@ class UserString: def __len__(self): return len(self.data) def __getitem__(self, index): return self.__class__(self.data[index]) - def __getslice__(self, start, end): - start = max(start, 0); end = max(end, 0) - return self.__class__(self.data[start:end]) - def __add__(self, other): if isinstance(other, UserString): return self.__class__(self.data + other.data) @@ -220,17 +216,6 @@ class MutableString(UserString): 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): - self.data = self.data[:start]+sub.data+self.data[end:] - elif isinstance(sub, basestring): - self.data = self.data[:start]+sub+self.data[end:] - else: - self.data = self.data[:start]+str(sub)+self.data[end:] - def __delslice__(self, start, end): - start = max(start, 0); end = max(end, 0) - self.data = self.data[:start] + self.data[end:] def immutable(self): return UserString(self.data) def __iadd__(self, other): diff --git a/Lib/opcode.py b/Lib/opcode.py index 4125a79..ac26583 100644 --- a/Lib/opcode.py +++ b/Lib/opcode.py @@ -70,20 +70,6 @@ def_op('BINARY_FLOOR_DIVIDE', 26) def_op('BINARY_TRUE_DIVIDE', 27) def_op('INPLACE_FLOOR_DIVIDE', 28) def_op('INPLACE_TRUE_DIVIDE', 29) -def_op('SLICE+0', 30) -def_op('SLICE+1', 31) -def_op('SLICE+2', 32) -def_op('SLICE+3', 33) - -def_op('STORE_SLICE+0', 40) -def_op('STORE_SLICE+1', 41) -def_op('STORE_SLICE+2', 42) -def_op('STORE_SLICE+3', 43) - -def_op('DELETE_SLICE+0', 50) -def_op('DELETE_SLICE+1', 51) -def_op('DELETE_SLICE+2', 52) -def_op('DELETE_SLICE+3', 53) def_op('INPLACE_ADD', 55) def_op('INPLACE_SUBTRACT', 56) diff --git a/Lib/sre_parse.py b/Lib/sre_parse.py index 7d5c0d6..22e762b 100644 --- a/Lib/sre_parse.py +++ b/Lib/sre_parse.py @@ -139,8 +139,6 @@ class SubPattern: return self.data[index] def __setitem__(self, index, code): self.data[index] = code - def __getslice__(self, start, stop): - return SubPattern(self.pattern, self.data[start:stop]) def insert(self, index, code): self.data.insert(index, code) def append(self, code): diff --git a/Lib/test/list_tests.py b/Lib/test/list_tests.py index a8a7e76..9d53077 100644 --- a/Lib/test/list_tests.py +++ b/Lib/test/list_tests.py @@ -178,10 +178,8 @@ class CommonTest(seq_tests.CommonTest): a[:] = tuple(range(10)) 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): diff --git a/Lib/test/seq_tests.py b/Lib/test/seq_tests.py index 6ec03e8..eb6d141 100644 --- a/Lib/test/seq_tests.py +++ b/Lib/test/seq_tests.py @@ -196,8 +196,6 @@ class CommonTest(unittest.TestCase): self.assertEqual(a[ -pow(2,128): 3 ], self.type2test([0,1,2])) self.assertEqual(a[ 3: pow(2,145) ], self.type2test([3,4])) - self.assertRaises(TypeError, u.__getslice__) - def test_contains(self): u = self.type2test([0, 1, 2]) for i in u: diff --git a/Lib/test/string_tests.py b/Lib/test/string_tests.py index 916a98f..9e178ca 100644 --- a/Lib/test/string_tests.py +++ b/Lib/test/string_tests.py @@ -939,17 +939,17 @@ class MixinStrUnicodeUserStringTest: self.checkraises(TypeError, 'abc', '__getitem__', 'def') def test_slice(self): - self.checkequal('abc', 'abc', '__getslice__', 0, 1000) - self.checkequal('abc', 'abc', '__getslice__', 0, 3) - self.checkequal('ab', 'abc', '__getslice__', 0, 2) - self.checkequal('bc', 'abc', '__getslice__', 1, 3) - self.checkequal('b', 'abc', '__getslice__', 1, 2) - self.checkequal('', 'abc', '__getslice__', 2, 2) - self.checkequal('', 'abc', '__getslice__', 1000, 1000) - self.checkequal('', 'abc', '__getslice__', 2000, 1000) - self.checkequal('', 'abc', '__getslice__', 2, 1) - - self.checkraises(TypeError, 'abc', '__getslice__', 'def') + self.checkequal('abc', 'abc', '__getitem__', slice(0, 1000)) + self.checkequal('abc', 'abc', '__getitem__', slice(0, 3)) + self.checkequal('ab', 'abc', '__getitem__', slice(0, 2)) + self.checkequal('bc', 'abc', '__getitem__', slice(1, 3)) + self.checkequal('b', 'abc', '__getitem__', slice(1, 2)) + self.checkequal('', 'abc', '__getitem__', slice(2, 2)) + self.checkequal('', 'abc', '__getitem__', slice(1000, 1000)) + self.checkequal('', 'abc', '__getitem__', slice(2000, 1000)) + self.checkequal('', 'abc', '__getitem__', slice(2, 1)) + + self.checkraises(TypeError, 'abc', '__getitem__', 'def') def test_extended_getslice(self): # Test extended slicing by comparing with list slicing. diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py index bae496e..db029f3 100755 --- a/Lib/test/test_array.py +++ b/Lib/test/test_array.py @@ -562,12 +562,10 @@ 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) diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py index bde63a8..76b30a3 100644 --- a/Lib/test/test_class.py +++ b/Lib/test/test_class.py @@ -36,11 +36,8 @@ testmeths = [ # List/dict operations "contains", "getitem", - "getslice", "setitem", - "setslice", "delitem", - "delslice", # Unary operations "neg", @@ -288,15 +285,16 @@ class ClassTests(unittest.TestCase): callLst[:] = [] testme[:42] - self.assertCallStack([('__getslice__', (testme, 0, 42))]) + self.assertCallStack([('__getitem__', (testme, slice(None, 42)))]) callLst[:] = [] testme[:42] = "The Answer" - self.assertCallStack([('__setslice__', (testme, 0, 42, "The Answer"))]) + self.assertCallStack([('__setitem__', (testme, slice(None, 42), + "The Answer"))]) callLst[:] = [] del testme[:42] - self.assertCallStack([('__delslice__', (testme, 0, 42))]) + self.assertCallStack([('__delitem__', (testme, slice(None, 42)))]) callLst[:] = [] testme[2:1024:10] @@ -329,37 +327,6 @@ class ClassTests(unittest.TestCase): slice(None, 24, None), 24, 100)))]) - # Now remove the slice hooks to see if converting normal slices to - # slice object works. - - getslice = AllTests.__getslice__ - del AllTests.__getslice__ - setslice = AllTests.__setslice__ - del AllTests.__setslice__ - delslice = AllTests.__delslice__ - del AllTests.__delslice__ - - # XXX when using new-style classes the slice testme[:42] produces - # slice(None, 42, None) instead of slice(0, 42, None). py3k will have - # to change this test. - callLst[:] = [] - testme[0:42] - self.assertCallStack([('__getitem__', (testme, slice(0, 42, None)))]) - - callLst[:] = [] - testme[:42] = "The Answer" - self.assertCallStack([('__setitem__', (testme, slice(None, 42, None), - "The Answer"))]) - callLst[:] = [] - del testme[0:42] - self.assertCallStack([('__delitem__', (testme, slice(0, 42, None)))]) - - # Restore the slice methods, or the tests will fail with regrtest -R. - AllTests.__getslice__ = getslice - AllTests.__setslice__ = setslice - AllTests.__delslice__ = delslice - - def testUnaryOps(self): testme = AllTests() diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py index 69400ee..47b647c 100644 --- a/Lib/test/test_descr.py +++ b/Lib/test/test_descr.py @@ -41,7 +41,7 @@ def testbinop(a, b, res, expr="a+b", meth="__add__"): bm = getattr(a, meth) vereq(bm(b), res) -def testternop(a, b, c, res, expr="a[b:c]", meth="__getslice__"): +def testsliceop(a, b, c, res, expr="a[b:c]", meth="__getitem__"): if verbose: print("checking", expr) dict = {'a': a, 'b': b, 'c': c} vereq(eval(expr, dict), res) @@ -50,9 +50,9 @@ def testternop(a, b, c, res, expr="a[b:c]", meth="__getslice__"): while meth not in t.__dict__: t = t.__bases__[0] vereq(m, t.__dict__[meth]) - vereq(m(a, b, c), res) + vereq(m(a, slice(b, c)), res) bm = getattr(a, meth) - vereq(bm(b, c), res) + vereq(bm(slice(b, c)), res) def testsetop(a, b, res, stmt="a+=b", meth="__iadd__"): if verbose: print("checking", stmt) @@ -90,7 +90,7 @@ def testset2op(a, b, c, res, stmt="a[b]=c", meth="__setitem__"): bm(b, c) vereq(dict['a'], res) -def testset3op(a, b, c, d, res, stmt="a[b:c]=d", meth="__setslice__"): +def testsetsliceop(a, b, c, d, res, stmt="a[b:c]=d", meth="__setitem__"): if verbose: print("checking", stmt) dict = {'a': deepcopy(a), 'b': b, 'c': c, 'd': d} exec(stmt, dict) @@ -101,11 +101,11 @@ def testset3op(a, b, c, d, res, stmt="a[b:c]=d", meth="__setslice__"): m = getattr(t, meth) vereq(m, t.__dict__[meth]) dict['a'] = deepcopy(a) - m(dict['a'], b, c, d) + m(dict['a'], slice(b, c), d) vereq(dict['a'], res) dict['a'] = deepcopy(a) bm = getattr(dict['a'], meth) - bm(b, c, d) + bm(slice(b, c), d) vereq(dict['a'], res) def class_docstrings(): @@ -142,14 +142,15 @@ def lists(): testbinop([1,2,3], 2, 1, "b in a", "__contains__") testbinop([1,2,3], 4, 0, "b in a", "__contains__") testbinop([1,2,3], 1, 2, "a[b]", "__getitem__") - testternop([1,2,3], 0, 2, [1,2], "a[b:c]", "__getslice__") + testsliceop([1,2,3], 0, 2, [1,2], "a[b:c]", "__getitem__") testsetop([1], [2], [1,2], "a+=b", "__iadd__") testsetop([1,2], 3, [1,2,1,2,1,2], "a*=b", "__imul__") testunop([1,2,3], 3, "len(a)", "__len__") testbinop([1,2], 3, [1,2,1,2,1,2], "a*b", "__mul__") testbinop([1,2], 3, [1,2,1,2,1,2], "b*a", "__rmul__") testset2op([1,2], 1, 3, [1,3], "a[b]=c", "__setitem__") - testset3op([1,2,3,4], 1, 3, [5,6], [1,5,6,4], "a[b:c]=d", "__setslice__") + testsetsliceop([1,2,3,4], 1, 3, [5,6], [1,5,6,4], "a[b:c]=d", + "__setitem__") def dicts(): if verbose: print("Testing dict operations...") @@ -485,8 +486,8 @@ def spamlists(): testbinop(spamlist([1,2,3]), 2, 1, "b in a", "__contains__") testbinop(spamlist([1,2,3]), 4, 0, "b in a", "__contains__") testbinop(spamlist([1,2,3]), 1, 2, "a[b]", "__getitem__") - testternop(spamlist([1,2,3]), 0, 2, spamlist([1,2]), - "a[b:c]", "__getslice__") + testsliceop(spamlist([1,2,3]), 0, 2, spamlist([1,2]), + "a[b:c]", "__getitem__") testsetop(spamlist([1]), spamlist([2]), spamlist([1,2]), "a+=b", "__iadd__") testsetop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*=b", "__imul__") @@ -494,8 +495,8 @@ def spamlists(): testbinop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*b", "__mul__") testbinop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "b*a", "__rmul__") testset2op(spamlist([1,2]), 1, 3, spamlist([1,3]), "a[b]=c", "__setitem__") - testset3op(spamlist([1,2,3,4]), 1, 3, spamlist([5,6]), - spamlist([1,5,6,4]), "a[b:c]=d", "__setslice__") + testsetsliceop(spamlist([1,2,3,4]), 1, 3, spamlist([5,6]), + spamlist([1,5,6,4]), "a[b:c]=d", "__setitem__") # Test subclassing class C(spam.spamlist): def foo(self): return 1 @@ -609,9 +610,9 @@ def pylists(): if verbose: print("Testing Python subclass of list...") class C(list): def __getitem__(self, i): + if isinstance(i, slice): + return (i.start, i.stop) return list.__getitem__(self, i) + 100 - def __getslice__(self, i, j): - return (i, j) a = C() a.extend([0,1,2]) vereq(a[0], 100) @@ -1651,13 +1652,6 @@ def overloading(): def __delitem__(self, key): self.delitem = key - def __getslice__(self, i, j): - return ("getslice", i, j) - def __setslice__(self, i, j, value): - self.setslice = (i, j, value) - def __delslice__(self, i, j): - self.delslice = (i, j) - a = C() vereq(a.foo, ("getattr", "foo")) a.foo = 12 @@ -1671,11 +1665,11 @@ def overloading(): del a[12] vereq(a.delitem, 12) - vereq(a[0:10], ("getslice", 0, 10)) + vereq(a[0:10], ("getitem", slice(0, 10))) a[0:10] = "foo" - vereq(a.setslice, (0, 10, "foo")) + vereq(a.setitem, (slice(0, 10), "foo")) del a[0:10] - vereq(a.delslice, (0, 10)) + vereq(a.delitem, slice(0, 10)) def methods(): if verbose: print("Testing methods...") @@ -4116,7 +4110,7 @@ def test_assign_slice(): # tp->tp_as_sequence->sq_ass_slice class C(object): - def __setslice__(self, start, stop, value): + def __setitem__(self, idx, value): self.value = value c = C() diff --git a/Lib/test/test_descrtut.py b/Lib/test/test_descrtut.py index 8080e41..ea75366 100644 --- a/Lib/test/test_descrtut.py +++ b/Lib/test/test_descrtut.py @@ -170,14 +170,12 @@ You can get the information from the list type: '__contains__', '__delattr__', '__delitem__', - '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', - '__getslice__', '__gt__', '__hash__', '__iadd__', @@ -197,7 +195,6 @@ You can get the information from the list type: '__rmul__', '__setattr__', '__setitem__', - '__setslice__', '__str__', 'append', 'count', diff --git a/Lib/test/test_index.py b/Lib/test/test_index.py index 653665e..6275e12 100644 --- a/Lib/test/test_index.py +++ b/Lib/test/test_index.py @@ -177,26 +177,17 @@ class OverflowTestCase(unittest.TestCase): self.assertEqual(self.pos.__index__(), self.pos) self.assertEqual(self.neg.__index__(), self.neg) - def _getitem_helper(self, base): - class GetItem(base): + def test_getitem(self): + class GetItem(object): def __len__(self): return maxint #cannot return long here def __getitem__(self, key): return key - def __getslice__(self, i, j): - return i, j x = GetItem() self.assertEqual(x[self.pos], self.pos) self.assertEqual(x[self.neg], self.neg) - self.assertEqual(x[self.neg:self.pos], (maxint+minsize, maxsize)) - self.assertEqual(x[self.neg:self.pos:1].indices(maxsize), (0, maxsize, 1)) - - def test_getitem(self): - self._getitem_helper(object) - - def test_getitem_classic(self): - class Empty: pass - self._getitem_helper(Empty) + self.assertEqual(x[self.neg:self.pos].indices(maxsize), + (0, maxsize, 1)) def test_sequence_repeat(self): self.failUnlessRaises(OverflowError, lambda: "a" * self.pos) diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py index 4ba825a..bdda5d8 100644 --- a/Lib/test/test_long.py +++ b/Lib/test/test_long.py @@ -283,17 +283,6 @@ class LongTest(unittest.TestCase): self.assert_(type(y) is int, "overflowing int conversion must return long not long subtype") - # long -> Py_ssize_t conversion - class X(object): - def __getslice__(self, i, j): - return i, j - - self.assertEqual(X()[-5:7], (-5, 7)) - # use the clamping effect to test the smallest and largest longs - # that fit a Py_ssize_t - slicemin, slicemax = X()[-2**100:2**100] - self.assertEqual(X()[slicemin:slicemax], (slicemin, slicemax)) - # ----------------------------------- tests of auto int->long conversion def test_auto_overflow(self): diff --git a/Lib/test/test_slice.py b/Lib/test/test_slice.py index 97b3084..cb9d8b2 100644 --- a/Lib/test/test_slice.py +++ b/Lib/test/test_slice.py @@ -99,12 +99,12 @@ class SliceTest(unittest.TestCase): def test_setslice_without_getslice(self): tmp = [] class X(object): - def __setslice__(self, i, j, k): - tmp.append((i, j, k)) + def __setitem__(self, i, k): + tmp.append((i, k)) x = X() x[1:2] = 42 - self.assertEquals(tmp, [(1, 2, 42)]) + self.assertEquals(tmp, [(slice(1, 2), 42)]) def test_pickle(self): s = slice(10, 20, 3) diff --git a/Lib/test/test_support.py b/Lib/test/test_support.py index 637043d..5b2176e 100644 --- a/Lib/test/test_support.py +++ b/Lib/test/test_support.py @@ -423,11 +423,7 @@ _1M = 1024*1024 _1G = 1024 * _1M _2G = 2 * _1G -# Hack to get at the maximum value an internal index can take. -class _Dummy: - def __getslice__(self, i, j): - return j -MAX_Py_ssize_t = _Dummy()[:] +MAX_Py_ssize_t = sys.maxsize def set_memlimit(limit): import re diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c index ced02c9..75792ad 100644 --- a/Modules/_ctypes/_ctypes.c +++ b/Modules/_ctypes/_ctypes.c @@ -3702,52 +3702,6 @@ Array_item(PyObject *_self, Py_ssize_t index) } static PyObject * -Array_slice(PyObject *_self, Py_ssize_t ilow, Py_ssize_t ihigh) -{ - CDataObject *self = (CDataObject *)_self; - StgDictObject *stgdict, *itemdict; - PyObject *proto; - PyListObject *np; - Py_ssize_t i, len; - - if (ilow < 0) - ilow = 0; - else if (ilow > self->b_length) - ilow = self->b_length; - if (ihigh < ilow) - ihigh = ilow; - else if (ihigh > self->b_length) - ihigh = self->b_length; - len = ihigh - ilow; - - stgdict = PyObject_stgdict((PyObject *)self); - assert(stgdict); /* Cannot be NULL for array object instances */ - proto = stgdict->proto; - itemdict = PyType_stgdict(proto); - assert(itemdict); /* proto is the item type of the array, a ctypes - type, so this cannot be NULL */ - if (itemdict->getfunc == getentry("c")->getfunc) { - char *ptr = (char *)self->b_ptr; - return PyString_FromStringAndSize(ptr + ilow, len); -#ifdef CTYPES_UNICODE - } else if (itemdict->getfunc == getentry("u")->getfunc) { - wchar_t *ptr = (wchar_t *)self->b_ptr; - return PyUnicode_FromWideChar(ptr + ilow, len); -#endif - } - - np = (PyListObject *) PyList_New(len); - if (np == NULL) - return NULL; - - for (i = 0; i < len; i++) { - PyObject *v = Array_item(_self, i+ilow); - PyList_SET_ITEM(np, i, v); - } - return (PyObject *)np; -} - -static PyObject * Array_subscript(PyObject *_self, PyObject *item) { CDataObject *self = (CDataObject *)_self; @@ -3989,9 +3943,9 @@ static PySequenceMethods Array_as_sequence = { 0, /* sq_concat; */ 0, /* sq_repeat; */ Array_item, /* sq_item; */ - Array_slice, /* sq_slice; */ + 0, /* sq_slice; */ Array_ass_item, /* sq_ass_item; */ - Array_ass_slice, /* sq_ass_slice; */ + 0, /* sq_ass_slice; */ 0, /* sq_contains; */ 0, /* sq_inplace_concat; */ @@ -4427,48 +4381,6 @@ Pointer_new(PyTypeObject *type, PyObject *args, PyObject *kw) } static PyObject * -Pointer_slice(PyObject *_self, Py_ssize_t ilow, Py_ssize_t ihigh) -{ - CDataObject *self = (CDataObject *)_self; - PyListObject *np; - StgDictObject *stgdict, *itemdict; - PyObject *proto; - Py_ssize_t i, len; - - if (ilow < 0) - ilow = 0; - if (ihigh < ilow) - ihigh = ilow; - len = ihigh - ilow; - - stgdict = PyObject_stgdict((PyObject *)self); - assert(stgdict); /* Cannot be NULL fr pointer instances */ - proto = stgdict->proto; - assert(proto); - itemdict = PyType_stgdict(proto); - assert(itemdict); - if (itemdict->getfunc == getentry("c")->getfunc) { - char *ptr = *(char **)self->b_ptr; - return PyString_FromStringAndSize(ptr + ilow, len); -#ifdef CTYPES_UNICODE - } else if (itemdict->getfunc == getentry("u")->getfunc) { - wchar_t *ptr = *(wchar_t **)self->b_ptr; - return PyUnicode_FromWideChar(ptr + ilow, len); -#endif - } - - np = (PyListObject *) PyList_New(len); - if (np == NULL) - return NULL; - - for (i = 0; i < len; i++) { - PyObject *v = Pointer_item(_self, i+ilow); - PyList_SET_ITEM(np, i, v); - } - return (PyObject *)np; -} - -static PyObject * Pointer_subscript(PyObject *_self, PyObject *item) { CDataObject *self = (CDataObject *)_self; @@ -4606,7 +4518,7 @@ static PySequenceMethods Pointer_as_sequence = { 0, /* binaryfunc sq_concat; */ 0, /* intargfunc sq_repeat; */ Pointer_item, /* intargfunc sq_item; */ - Pointer_slice, /* intintargfunc sq_slice; */ + 0, /* intintargfunc sq_slice; */ Pointer_ass_item, /* intobjargproc sq_ass_item; */ 0, /* intintobjargproc sq_ass_slice; */ 0, /* objobjproc sq_contains; */ diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c index e79847f..afe4587 100644 --- a/Modules/arraymodule.c +++ b/Modules/arraymodule.c @@ -1835,9 +1835,9 @@ static PySequenceMethods array_as_sequence = { (binaryfunc)array_concat, /*sq_concat*/ (ssizeargfunc)array_repeat, /*sq_repeat*/ (ssizeargfunc)array_item, /*sq_item*/ - (ssizessizeargfunc)array_slice, /*sq_slice*/ + 0, /*sq_slice*/ (ssizeobjargproc)array_ass_item, /*sq_ass_item*/ - (ssizessizeobjargproc)array_ass_slice, /*sq_ass_slice*/ + 0, /*sq_ass_slice*/ (objobjproc)array_contains, /*sq_contains*/ (binaryfunc)array_inplace_concat, /*sq_inplace_concat*/ (ssizeargfunc)array_inplace_repeat /*sq_inplace_repeat*/ diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c index f3727e3..77f64bc 100644 --- a/Modules/mmapmodule.c +++ b/Modules/mmapmodule.c @@ -642,24 +642,6 @@ mmap_item(mmap_object *self, Py_ssize_t i) } static PyObject * -mmap_slice(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh) -{ - CHECK_VALID(NULL); - if (ilow < 0) - ilow = 0; - else if ((size_t)ilow > self->size) - ilow = self->size; - if (ihigh < 0) - ihigh = 0; - if (ihigh < ilow) - ihigh = ilow; - else if ((size_t)ihigh > self->size) - ihigh = self->size; - - return PyBytes_FromStringAndSize(self->data + ilow, ihigh-ilow); -} - -static PyObject * mmap_subscript(mmap_object *self, PyObject *item) { CHECK_VALID(NULL); @@ -732,45 +714,6 @@ mmap_repeat(mmap_object *self, Py_ssize_t n) } static int -mmap_ass_slice(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v) -{ - const char *buf; - - CHECK_VALID(-1); - if (ilow < 0) - ilow = 0; - else if ((size_t)ilow > self->size) - ilow = self->size; - if (ihigh < 0) - ihigh = 0; - if (ihigh < ilow) - ihigh = ilow; - else if ((size_t)ihigh > self->size) - ihigh = self->size; - - if (v == NULL) { - PyErr_SetString(PyExc_TypeError, - "mmap object doesn't support slice deletion"); - return -1; - } - if (! (PyBytes_Check(v)) ) { - PyErr_SetString(PyExc_IndexError, - "mmap slice assignment must be bytes"); - return -1; - } - if (PyBytes_Size(v) != (ihigh - ilow)) { - PyErr_SetString(PyExc_IndexError, - "mmap slice assignment is wrong size"); - return -1; - } - if (!is_writeable(self)) - return -1; - buf = PyBytes_AsString(v); - memcpy(self->data + ilow, buf, ihigh-ilow); - return 0; -} - -static int mmap_ass_item(mmap_object *self, Py_ssize_t i, PyObject *v) { const char *buf; @@ -892,9 +835,9 @@ static PySequenceMethods mmap_as_sequence = { (binaryfunc)mmap_concat, /*sq_concat*/ (ssizeargfunc)mmap_repeat, /*sq_repeat*/ (ssizeargfunc)mmap_item, /*sq_item*/ - (ssizessizeargfunc)mmap_slice, /*sq_slice*/ + 0, /*sq_slice*/ (ssizeobjargproc)mmap_ass_item, /*sq_ass_item*/ - (ssizessizeobjargproc)mmap_ass_slice, /*sq_ass_slice*/ + 0, /*sq_ass_slice*/ }; static PyMappingMethods mmap_as_mapping = { diff --git a/Objects/abstract.c b/Objects/abstract.c index e303caf..8eb0fea 100644 --- a/Objects/abstract.c +++ b/Objects/abstract.c @@ -1505,26 +1505,12 @@ PySequence_GetItem(PyObject *s, Py_ssize_t i) PyObject * PySequence_GetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2) { - PySequenceMethods *m; PyMappingMethods *mp; if (!s) return null_error(); - m = s->ob_type->tp_as_sequence; - if (m && m->sq_slice) { - if (i1 < 0 || i2 < 0) { - if (m->sq_length) { - Py_ssize_t l = (*m->sq_length)(s); - if (l < 0) - return NULL; - if (i1 < 0) - i1 += l; - if (i2 < 0) - i2 += l; - } - } - return m->sq_slice(s, i1, i2); - } else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_subscript) { + mp = s->ob_type->tp_as_mapping; + if (mp->mp_subscript) { PyObject *res; PyObject *slice = _PySlice_FromIndices(i1, i2); if (!slice) @@ -1594,7 +1580,6 @@ PySequence_DelItem(PyObject *s, Py_ssize_t i) int PySequence_SetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2, PyObject *o) { - PySequenceMethods *m; PyMappingMethods *mp; if (s == NULL) { @@ -1602,21 +1587,8 @@ PySequence_SetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2, PyObject *o) return -1; } - m = s->ob_type->tp_as_sequence; - if (m && m->sq_ass_slice) { - if (i1 < 0 || i2 < 0) { - if (m->sq_length) { - Py_ssize_t l = (*m->sq_length)(s); - if (l < 0) - return -1; - if (i1 < 0) - i1 += l; - if (i2 < 0) - i2 += l; - } - } - return m->sq_ass_slice(s, i1, i2, o); - } else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_ass_subscript) { + mp = s->ob_type->tp_as_mapping; + if (mp->mp_ass_subscript) { int res; PyObject *slice = _PySlice_FromIndices(i1, i2); if (!slice) @@ -1633,27 +1605,22 @@ PySequence_SetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2, PyObject *o) int PySequence_DelSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2) { - PySequenceMethods *m; + PyMappingMethods *mp; if (s == NULL) { null_error(); return -1; } - m = s->ob_type->tp_as_sequence; - if (m && m->sq_ass_slice) { - if (i1 < 0 || i2 < 0) { - if (m->sq_length) { - Py_ssize_t l = (*m->sq_length)(s); - if (l < 0) - return -1; - if (i1 < 0) - i1 += l; - if (i2 < 0) - i2 += l; - } - } - return m->sq_ass_slice(s, i1, i2, (PyObject *)NULL); + mp = s->ob_type->tp_as_mapping; + if (mp->mp_ass_subscript) { + int res; + PyObject *slice = _PySlice_FromIndices(i1, i2); + if (!slice) + return -1; + res = mp->mp_ass_subscript(s, slice, NULL); + Py_DECREF(slice); + return res; } type_error("'%.200s' object doesn't support slice deletion", s); return -1; @@ -1925,9 +1892,7 @@ int PyMapping_Check(PyObject *o) { return o && o->ob_type->tp_as_mapping && - o->ob_type->tp_as_mapping->mp_subscript && - !(o->ob_type->tp_as_sequence && - o->ob_type->tp_as_sequence->sq_slice); + o->ob_type->tp_as_mapping->mp_subscript; } Py_ssize_t diff --git a/Objects/bufferobject.c b/Objects/bufferobject.c index d3464c1..d697d26 100644 --- a/Objects/bufferobject.c +++ b/Objects/bufferobject.c @@ -465,28 +465,6 @@ buffer_item(PyBufferObject *self, Py_ssize_t idx) } static PyObject * -buffer_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right) -{ - PyObject *ob; - PyBuffer view; - if (!get_buf(self, &view, PyBUF_SIMPLE)) - return NULL; - if (left < 0) - left = 0; - if (right < 0) - right = 0; - if (right > view.len) - right = view.len; - if (right < left) - right = left; - /* XXX(nnorwitz): is it possible to access unitialized memory? */ - ob = PyBytes_FromStringAndSize((char *)view.buf + left, - right - left); - PyObject_ReleaseBuffer((PyObject *)self, &view); - return ob; -} - -static PyObject * buffer_subscript(PyBufferObject *self, PyObject *item) { PyBuffer view; @@ -605,62 +583,6 @@ buffer_ass_item(PyBufferObject *self, Py_ssize_t idx, PyObject *other) } static int -buffer_ass_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right, - PyObject *other) -{ - PyBufferProcs *pb; - PyBuffer v1, v2; - Py_ssize_t slice_len; - - pb = other ? other->ob_type->tp_as_buffer : NULL; - if (pb == NULL || - pb->bf_getbuffer == NULL) { - PyErr_BadArgument(); - return -1; - } - if (!get_buf(self, &v1, PyBUF_SIMPLE)) - return -1; - - if (self->b_readonly || v1.readonly) { - PyErr_SetString(PyExc_TypeError, - "buffer is read-only"); - PyObject_ReleaseBuffer((PyObject *)self, &v1); - return -1; - } - - if ((*pb->bf_getbuffer)(other, &v2, PyBUF_SIMPLE) < 0) { - PyObject_ReleaseBuffer((PyObject *)self, &v1); - return -1; - } - - if (left < 0) - left = 0; - else if (left > v1.len) - left = v1.len; - if (right < left) - right = left; - else if (right > v1.len) - right = v1.len; - slice_len = right - left; - - if (v2.len != slice_len) { - PyErr_SetString( - PyExc_TypeError, - "right operand length must match slice length"); - PyObject_ReleaseBuffer((PyObject *)self, &v1); - PyObject_ReleaseBuffer(other, &v2); - return -1; - } - - if (slice_len) - memcpy((char *)v1.buf + left, v2.buf, slice_len); - - PyObject_ReleaseBuffer((PyObject *)self, &v1); - PyObject_ReleaseBuffer(other, &v2); - return 0; -} - -static int buffer_ass_subscript(PyBufferObject *self, PyObject *item, PyObject *value) { PyBuffer v1; @@ -743,9 +665,9 @@ static PySequenceMethods buffer_as_sequence = { (binaryfunc)buffer_concat, /*sq_concat*/ (ssizeargfunc)buffer_repeat, /*sq_repeat*/ (ssizeargfunc)buffer_item, /*sq_item*/ - (ssizessizeargfunc)buffer_slice, /*sq_slice*/ + 0, /*sq_slice*/ (ssizeobjargproc)buffer_ass_item, /*sq_ass_item*/ - (ssizessizeobjargproc)buffer_ass_slice, /*sq_ass_slice*/ + 0, /*sq_ass_slice*/ }; static PyMappingMethods buffer_as_mapping = { diff --git a/Objects/listobject.c b/Objects/listobject.c index c5a4287..f0e6408 100644 --- a/Objects/listobject.c +++ b/Objects/listobject.c @@ -2423,9 +2423,9 @@ static PySequenceMethods list_as_sequence = { (binaryfunc)list_concat, /* sq_concat */ (ssizeargfunc)list_repeat, /* sq_repeat */ (ssizeargfunc)list_item, /* sq_item */ - (ssizessizeargfunc)list_slice, /* sq_slice */ + 0, /* sq_slice */ (ssizeobjargproc)list_ass_item, /* sq_ass_item */ - (ssizessizeobjargproc)list_ass_slice, /* sq_ass_slice */ + 0, /* sq_ass_slice */ (objobjproc)list_contains, /* sq_contains */ (binaryfunc)list_inplace_concat, /* sq_inplace_concat */ (ssizeargfunc)list_inplace_repeat, /* sq_inplace_repeat */ diff --git a/Objects/stringobject.c b/Objects/stringobject.c index 8d0f4b8..d263812 100644 --- a/Objects/stringobject.c +++ b/Objects/stringobject.c @@ -965,29 +965,6 @@ string_repeat(register PyStringObject *a, register Py_ssize_t n) return (PyObject *) op; } -/* String slice a[i:j] consists of characters a[i] ... a[j-1] */ - -static PyObject * -string_slice(register PyStringObject *a, register Py_ssize_t i, - register Py_ssize_t j) - /* j -- may be negative! */ -{ - if (i < 0) - i = 0; - if (j < 0) - j = 0; /* Avoid signed/unsigned bug in next line */ - if (j > Py_Size(a)) - j = Py_Size(a); - if (i == 0 && j == Py_Size(a) && PyString_CheckExact(a)) { - /* It's the same as a */ - Py_INCREF(a); - return (PyObject *)a; - } - if (j < i) - j = i; - return PyString_FromStringAndSize(a->ob_sval + i, j-i); -} - static int string_contains(PyObject *str_obj, PyObject *sub_obj) { @@ -1193,7 +1170,7 @@ static PySequenceMethods string_as_sequence = { (binaryfunc)string_concat, /*sq_concat*/ (ssizeargfunc)string_repeat, /*sq_repeat*/ (ssizeargfunc)string_item, /*sq_item*/ - (ssizessizeargfunc)string_slice, /*sq_slice*/ + 0, /*sq_slice*/ 0, /*sq_ass_item*/ 0, /*sq_ass_slice*/ (objobjproc)string_contains /*sq_contains*/ diff --git a/Objects/structseq.c b/Objects/structseq.c index a3ff045..1b6aafd 100644 --- a/Objects/structseq.c +++ b/Objects/structseq.c @@ -340,7 +340,7 @@ static PySequenceMethods structseq_as_sequence = { (binaryfunc)structseq_concat, /* sq_concat */ (ssizeargfunc)structseq_repeat, /* sq_repeat */ (ssizeargfunc)structseq_item, /* sq_item */ - (ssizessizeargfunc)structseq_slice, /* sq_slice */ + 0, /* sq_slice */ 0, /* sq_ass_item */ 0, /* sq_ass_slice */ (objobjproc)structseq_contains, /* sq_contains */ diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c index 37b5a1f..222f362 100644 --- a/Objects/tupleobject.c +++ b/Objects/tupleobject.c @@ -554,7 +554,7 @@ static PySequenceMethods tuple_as_sequence = { (binaryfunc)tupleconcat, /* sq_concat */ (ssizeargfunc)tuplerepeat, /* sq_repeat */ (ssizeargfunc)tupleitem, /* sq_item */ - (ssizessizeargfunc)tupleslice, /* sq_slice */ + 0, /* sq_slice */ 0, /* sq_ass_item */ 0, /* sq_ass_slice */ (objobjproc)tuplecontains, /* sq_contains */ diff --git a/Objects/typeobject.c b/Objects/typeobject.c index 0cc63fc..ae48e75 100644 --- a/Objects/typeobject.c +++ b/Objects/typeobject.c @@ -3260,9 +3260,7 @@ inherit_slots(PyTypeObject *type, PyTypeObject *base) COPYSEQ(sq_concat); COPYSEQ(sq_repeat); COPYSEQ(sq_item); - COPYSEQ(sq_slice); COPYSEQ(sq_ass_item); - COPYSEQ(sq_ass_slice); COPYSEQ(sq_contains); COPYSEQ(sq_inplace_concat); COPYSEQ(sq_inplace_repeat); @@ -3766,17 +3764,6 @@ wrap_sq_item(PyObject *self, PyObject *args, void *wrapped) } static PyObject * -wrap_ssizessizeargfunc(PyObject *self, PyObject *args, void *wrapped) -{ - ssizessizeargfunc func = (ssizessizeargfunc)wrapped; - Py_ssize_t i, j; - - if (!PyArg_ParseTuple(args, "nn", &i, &j)) - return NULL; - return (*func)(self, i, j); -} - -static PyObject * wrap_sq_setitem(PyObject *self, PyObject *args, void *wrapped) { ssizeobjargproc func = (ssizeobjargproc)wrapped; @@ -3817,39 +3804,6 @@ wrap_sq_delitem(PyObject *self, PyObject *args, void *wrapped) return Py_None; } -static PyObject * -wrap_ssizessizeobjargproc(PyObject *self, PyObject *args, void *wrapped) -{ - ssizessizeobjargproc func = (ssizessizeobjargproc)wrapped; - Py_ssize_t i, j; - int res; - PyObject *value; - - if (!PyArg_ParseTuple(args, "nnO", &i, &j, &value)) - return NULL; - res = (*func)(self, i, j, value); - if (res == -1 && PyErr_Occurred()) - return NULL; - Py_INCREF(Py_None); - return Py_None; -} - -static PyObject * -wrap_delslice(PyObject *self, PyObject *args, void *wrapped) -{ - ssizessizeobjargproc func = (ssizessizeobjargproc)wrapped; - Py_ssize_t i, j; - int res; - - if (!PyArg_ParseTuple(args, "nn", &i, &j)) - return NULL; - res = (*func)(self, i, j, NULL); - if (res == -1 && PyErr_Occurred()) - return NULL; - Py_INCREF(Py_None); - return Py_None; -} - /* XXX objobjproc is a misnomer; should be objargpred */ static PyObject * wrap_objobjproc(PyObject *self, PyObject *args, void *wrapped) @@ -4363,8 +4317,6 @@ slot_sq_item(PyObject *self, Py_ssize_t i) return NULL; } -SLOT2(slot_sq_slice, "__getslice__", Py_ssize_t, Py_ssize_t, "nn") - static int slot_sq_ass_item(PyObject *self, Py_ssize_t index, PyObject *value) { @@ -4384,24 +4336,6 @@ slot_sq_ass_item(PyObject *self, Py_ssize_t index, PyObject *value) } static int -slot_sq_ass_slice(PyObject *self, Py_ssize_t i, Py_ssize_t j, PyObject *value) -{ - PyObject *res; - static PyObject *delslice_str, *setslice_str; - - if (value == NULL) - res = call_method(self, "__delslice__", &delslice_str, - "(nn)", i, j); - else - res = call_method(self, "__setslice__", &setslice_str, - "(nnO)", i, j, value); - if (res == NULL) - return -1; - Py_DECREF(res); - return 0; -} - -static int slot_sq_contains(PyObject *self, PyObject *value) { PyObject *func, *res, *args; @@ -5123,23 +5057,10 @@ static slotdef slotdefs[] = { "x.__rmul__(n) <==> n*x"), SQSLOT("__getitem__", sq_item, slot_sq_item, wrap_sq_item, "x.__getitem__(y) <==> x[y]"), - SQSLOT("__getslice__", sq_slice, slot_sq_slice, wrap_ssizessizeargfunc, - "x.__getslice__(i, j) <==> x[i:j]\n\ - \n\ - Use of negative indices is not supported."), SQSLOT("__setitem__", sq_ass_item, slot_sq_ass_item, wrap_sq_setitem, "x.__setitem__(i, y) <==> x[i]=y"), SQSLOT("__delitem__", sq_ass_item, slot_sq_ass_item, wrap_sq_delitem, "x.__delitem__(y) <==> del x[y]"), - SQSLOT("__setslice__", sq_ass_slice, slot_sq_ass_slice, - wrap_ssizessizeobjargproc, - "x.__setslice__(i, j, y) <==> x[i:j]=y\n\ - \n\ - Use of negative indices is not supported."), - SQSLOT("__delslice__", sq_ass_slice, slot_sq_ass_slice, wrap_delslice, - "x.__delslice__(i, j) <==> del x[i:j]\n\ - \n\ - Use of negative indices is not supported."), SQSLOT("__contains__", sq_contains, slot_sq_contains, wrap_objobjproc, "x.__contains__(y) <==> y in x"), SQSLOT("__iadd__", sq_inplace_concat, NULL, diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c index 208bc88..f9d3068 100644 --- a/Objects/unicodeobject.c +++ b/Objects/unicodeobject.c @@ -7502,28 +7502,6 @@ unicode_rjust(PyUnicodeObject *self, PyObject *args) return (PyObject*) pad(self, width - self->length, 0, fillchar); } -static PyObject* -unicode_slice(PyUnicodeObject *self, Py_ssize_t start, Py_ssize_t end) -{ - /* standard clamping */ - if (start < 0) - start = 0; - if (end < 0) - end = 0; - if (end > self->length) - end = self->length; - if (start == 0 && end == self->length && PyUnicode_CheckExact(self)) { - /* full slice, return original string */ - Py_INCREF(self); - return (PyObject*) self; - } - if (start > end) - start = end; - /* copy slice */ - return (PyObject*) PyUnicode_FromUnicode(self->str + start, - end - start); -} - PyObject *PyUnicode_Split(PyObject *s, PyObject *sep, Py_ssize_t maxsplit) @@ -8039,7 +8017,7 @@ static PySequenceMethods unicode_as_sequence = { PyUnicode_Concat, /* sq_concat */ (ssizeargfunc) unicode_repeat, /* sq_repeat */ (ssizeargfunc) unicode_getitem, /* sq_item */ - (ssizessizeargfunc) unicode_slice, /* sq_slice */ + 0, /* sq_slice */ 0, /* sq_ass_item */ 0, /* sq_ass_slice */ PyUnicode_Contains, /* sq_contains */ diff --git a/Objects/weakrefobject.c b/Objects/weakrefobject.c index 8c324f3..c3d3ff0 100644 --- a/Objects/weakrefobject.c +++ b/Objects/weakrefobject.c @@ -520,22 +520,6 @@ proxy_dealloc(PyWeakReference *self) /* sequence slots */ -static PyObject * -proxy_slice(PyWeakReference *proxy, Py_ssize_t i, Py_ssize_t j) -{ - if (!proxy_checkref(proxy)) - return NULL; - return PySequence_GetSlice(PyWeakref_GET_OBJECT(proxy), i, j); -} - -static int -proxy_ass_slice(PyWeakReference *proxy, Py_ssize_t i, Py_ssize_t j, PyObject *value) -{ - if (!proxy_checkref(proxy)) - return -1; - return PySequence_SetSlice(PyWeakref_GET_OBJECT(proxy), i, j, value); -} - static int proxy_contains(PyWeakReference *proxy, PyObject *value) { @@ -628,9 +612,9 @@ static PySequenceMethods proxy_as_sequence = { 0, /*sq_concat*/ 0, /*sq_repeat*/ 0, /*sq_item*/ - (ssizessizeargfunc)proxy_slice, /*sq_slice*/ + 0, /*sq_slice*/ 0, /*sq_ass_item*/ - (ssizessizeobjargproc)proxy_ass_slice, /*sq_ass_slice*/ + 0, /*sq_ass_slice*/ (objobjproc)proxy_contains, /* sq_contains */ }; diff --git a/Python/ceval.c b/Python/ceval.c index eea87a8..be804ad 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -111,9 +111,6 @@ static void call_exc_trace(Py_tracefunc, PyObject *, PyFrameObject *); static int maybe_call_line_trace(Py_tracefunc, PyObject *, PyFrameObject *, int *, int *, int *); -static PyObject * apply_slice(PyObject *, PyObject *, PyObject *); -static int assign_slice(PyObject *, PyObject *, - PyObject *, PyObject *); static PyObject * cmp_outcome(int, PyObject *, PyObject *); static PyObject * import_from(PyObject *, PyObject *); static int import_all_from(PyObject *, PyObject *); @@ -1416,70 +1413,6 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) if (x != NULL) continue; break; - case SLICE+0: - case SLICE+1: - case SLICE+2: - case SLICE+3: - if ((opcode-SLICE) & 2) - w = POP(); - else - w = NULL; - if ((opcode-SLICE) & 1) - v = POP(); - else - v = NULL; - u = TOP(); - x = apply_slice(u, v, w); - Py_DECREF(u); - Py_XDECREF(v); - Py_XDECREF(w); - SET_TOP(x); - if (x != NULL) continue; - break; - - case STORE_SLICE+0: - case STORE_SLICE+1: - case STORE_SLICE+2: - case STORE_SLICE+3: - if ((opcode-STORE_SLICE) & 2) - w = POP(); - else - w = NULL; - if ((opcode-STORE_SLICE) & 1) - v = POP(); - else - v = NULL; - u = POP(); - t = POP(); - err = assign_slice(u, v, w, t); /* u[v:w] = t */ - Py_DECREF(t); - Py_DECREF(u); - Py_XDECREF(v); - Py_XDECREF(w); - if (err == 0) continue; - break; - - case DELETE_SLICE+0: - case DELETE_SLICE+1: - case DELETE_SLICE+2: - case DELETE_SLICE+3: - if ((opcode-DELETE_SLICE) & 2) - w = POP(); - else - w = NULL; - if ((opcode-DELETE_SLICE) & 1) - v = POP(); - else - v = NULL; - u = POP(); - err = assign_slice(u, v, w, (PyObject *)NULL); - /* del u[v:w] */ - Py_DECREF(u); - Py_XDECREF(v); - Py_XDECREF(w); - if (err == 0) continue; - break; - case STORE_SUBSCR: w = TOP(); v = SECOND(); @@ -3895,70 +3828,6 @@ _PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi) return 1; } -#undef ISINDEX -#define ISINDEX(x) ((x) == NULL || \ - PyInt_Check(x) || PyLong_Check(x) || PyIndex_Check(x)) - -static PyObject * -apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */ -{ - PyTypeObject *tp = u->ob_type; - PySequenceMethods *sq = tp->tp_as_sequence; - - if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) { - Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX; - if (!_PyEval_SliceIndex(v, &ilow)) - return NULL; - if (!_PyEval_SliceIndex(w, &ihigh)) - return NULL; - return PySequence_GetSlice(u, ilow, ihigh); - } - else { - PyObject *slice = PySlice_New(v, w, NULL); - if (slice != NULL) { - PyObject *res = PyObject_GetItem(u, slice); - Py_DECREF(slice); - return res; - } - else - return NULL; - } -} - -static int -assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x) - /* u[v:w] = x */ -{ - PyTypeObject *tp = u->ob_type; - PySequenceMethods *sq = tp->tp_as_sequence; - - if (sq && sq->sq_ass_slice && ISINDEX(v) && ISINDEX(w)) { - Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX; - if (!_PyEval_SliceIndex(v, &ilow)) - return -1; - if (!_PyEval_SliceIndex(w, &ihigh)) - return -1; - if (x == NULL) - return PySequence_DelSlice(u, ilow, ihigh); - else - return PySequence_SetSlice(u, ilow, ihigh, x); - } - else { - PyObject *slice = PySlice_New(v, w, NULL); - if (slice != NULL) { - int res; - if (x != NULL) - res = PyObject_SetItem(u, slice, x); - else - res = PyObject_DelItem(u, slice); - Py_DECREF(slice); - return res; - } - else - return -1; - } -} - #define CANNOT_CATCH_MSG "catching classes that do not inherit from "\ "BaseException is not allowed" diff --git a/Python/compile.c b/Python/compile.c index d2bfe86..3a21127 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -707,33 +707,6 @@ opcode_stack_effect(int opcode, int oparg) case INPLACE_TRUE_DIVIDE: return -1; - case SLICE+0: - return 1; - case SLICE+1: - return 0; - case SLICE+2: - return 0; - case SLICE+3: - return -1; - - case STORE_SLICE+0: - return -2; - case STORE_SLICE+1: - return -3; - case STORE_SLICE+2: - return -3; - case STORE_SLICE+3: - return -4; - - case DELETE_SLICE+0: - return -1; - case DELETE_SLICE+1: - return -2; - case DELETE_SLICE+2: - return -2; - case DELETE_SLICE+3: - return -3; - case INPLACE_ADD: case INPLACE_SUBTRACT: case INPLACE_MULTIPLY: @@ -3508,57 +3481,6 @@ compiler_slice(struct compiler *c, slice_ty s, expr_context_ty ctx) } static int -compiler_simple_slice(struct compiler *c, slice_ty s, expr_context_ty ctx) -{ - int op = 0, slice_offset = 0, stack_count = 0; - - assert(s->v.Slice.step == NULL); - if (s->v.Slice.lower) { - slice_offset++; - stack_count++; - if (ctx != AugStore) - VISIT(c, expr, s->v.Slice.lower); - } - if (s->v.Slice.upper) { - slice_offset += 2; - stack_count++; - if (ctx != AugStore) - VISIT(c, expr, s->v.Slice.upper); - } - - if (ctx == AugLoad) { - switch (stack_count) { - case 0: ADDOP(c, DUP_TOP); break; - case 1: ADDOP_I(c, DUP_TOPX, 2); break; - case 2: ADDOP_I(c, DUP_TOPX, 3); break; - } - } - else if (ctx == AugStore) { - switch (stack_count) { - case 0: ADDOP(c, ROT_TWO); break; - case 1: ADDOP(c, ROT_THREE); break; - case 2: ADDOP(c, ROT_FOUR); break; - } - } - - switch (ctx) { - case AugLoad: /* fall through to Load */ - case Load: op = SLICE; break; - case AugStore:/* fall through to Store */ - case Store: op = STORE_SLICE; break; - case Del: op = DELETE_SLICE; break; - case Param: - default: - PyErr_SetString(PyExc_SystemError, - "param invalid in simple slice"); - return 0; - } - - ADDOP(c, op + slice_offset); - return 1; -} - -static int compiler_visit_nested_slice(struct compiler *c, slice_ty s, expr_context_ty ctx) { @@ -3590,8 +3512,6 @@ compiler_visit_slice(struct compiler *c, slice_ty s, expr_context_ty ctx) break; case Slice_kind: kindname = "slice"; - if (!s->v.Slice.step) - return compiler_simple_slice(c, s, ctx); if (ctx != AugStore) { if (!compiler_slice(c, s, ctx)) return 0; diff --git a/Python/sysmodule.c b/Python/sysmodule.c index 6ccd3e9..c3eb68e 100644 --- a/Python/sysmodule.c +++ b/Python/sysmodule.c @@ -875,6 +875,7 @@ PyDoc_STR( Static objects:\n\ \n\ maxint -- the largest supported integer (the smallest is -maxint-1)\n\ +maxsize -- the largest supported length of containers.\n\ maxunicode -- the largest supported character\n\ builtin_module_names -- tuple of module names built into this interpreter\n\ version -- the version of this interpreter as a string\n\ @@ -1087,6 +1088,8 @@ _PySys_Init(void) PyUnicode_FromString(Py_GetExecPrefix())); SET_SYS_FROM_STRING("maxint", PyInt_FromLong(PyInt_GetMax())); + SET_SYS_FROM_STRING("maxsize", + PyInt_FromLong(PY_SSIZE_T_MAX)); SET_SYS_FROM_STRING("maxunicode", PyInt_FromLong(PyUnicode_GetMax())); SET_SYS_FROM_STRING("builtin_module_names", |