summaryrefslogtreecommitdiffstats
path: root/Objects
diff options
context:
space:
mode:
Diffstat (limited to 'Objects')
-rw-r--r--Objects/bufferobject.c153
-rw-r--r--Objects/listobject.c43
-rw-r--r--Objects/stringobject.c11
-rw-r--r--Objects/structseq.c55
-rw-r--r--Objects/tupleobject.c6
-rw-r--r--Objects/unicodeobject.c6
6 files changed, 259 insertions, 15 deletions
diff --git a/Objects/bufferobject.c b/Objects/bufferobject.c
index c415013..e307aab 100644
--- a/Objects/bufferobject.c
+++ b/Objects/bufferobject.c
@@ -482,6 +482,75 @@ buffer_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right)
return ob;
}
+static PyObject *
+buffer_subscript(PyBufferObject *self, PyObject *item)
+{
+ PyBuffer view;
+ PyObject *ob;
+
+ if (!get_buf(self, &view, PyBUF_SIMPLE))
+ return NULL;
+ if (PyIndex_Check(item)) {
+ Py_ssize_t idx = PyNumber_AsSsize_t(item, PyExc_IndexError);
+
+ if (idx == -1 && PyErr_Occurred())
+ return NULL;
+ if (idx < 0)
+ idx += view.len;
+ if ( idx < 0 || idx >= view.len ) {
+ PyErr_SetString(PyExc_IndexError,
+ "buffer index out of range");
+ return NULL;
+ }
+ ob = PyBytes_FromStringAndSize((char *)view.buf + idx, 1);
+ PyObject_ReleaseBuffer((PyObject *)self, &view);
+ return ob;
+ }
+ else if (PySlice_Check(item)) {
+ Py_ssize_t start, stop, step, slicelength, cur, i;
+
+ if (PySlice_GetIndicesEx((PySliceObject*)item, view.len,
+ &start, &stop, &step, &slicelength) < 0) {
+ PyObject_ReleaseBuffer((PyObject *)self, &view);
+ return NULL;
+ }
+
+ if (slicelength <= 0) {
+ PyObject_ReleaseBuffer((PyObject *)self, &view);
+ return PyBytes_FromStringAndSize("", 0);
+ }
+ else if (step == 1) {
+ ob = PyBytes_FromStringAndSize((char *)view.buf +
+ start, stop - start);
+ PyObject_ReleaseBuffer((PyObject *)self, &view);
+ return ob;
+ }
+ else {
+ char *source_buf = (char *)view.buf;
+ 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];
+ }
+
+ ob = PyBytes_FromStringAndSize(result_buf,
+ slicelength);
+ PyMem_Free(result_buf);
+ PyObject_ReleaseBuffer((PyObject *)self, &view);
+ return ob;
+ }
+ }
+ 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)
{
@@ -587,6 +656,82 @@ 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)
+{
+ PyBuffer v1;
+
+ 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 (PyIndex_Check(item)) {
+ Py_ssize_t idx = PyNumber_AsSsize_t(item, PyExc_IndexError);
+ if (idx == -1 && PyErr_Occurred())
+ return -1;
+ if (idx < 0)
+ idx += v1.len;
+ PyObject_ReleaseBuffer((PyObject *)self, &v1);
+ return buffer_ass_item(self, idx, value);
+ }
+ else if (PySlice_Check(item)) {
+ Py_ssize_t start, stop, step, slicelength;
+ PyBuffer v2;
+ PyBufferProcs *pb;
+
+ if (PySlice_GetIndicesEx((PySliceObject *)item, v1.len,
+ &start, &stop, &step, &slicelength) < 0) {
+ PyObject_ReleaseBuffer((PyObject *)self, &v1);
+ return -1;
+ }
+
+ pb = value ? value->ob_type->tp_as_buffer : NULL;
+ if (pb == NULL ||
+ pb->bf_getbuffer == NULL) {
+ PyObject_ReleaseBuffer((PyObject *)self, &v1);
+ PyErr_BadArgument();
+ return -1;
+ }
+ if ((*pb->bf_getbuffer)(value, &v2, PyBUF_SIMPLE) < 0) {
+ PyObject_ReleaseBuffer((PyObject *)self, &v1);
+ return -1;
+ }
+
+ if (v2.len != slicelength) {
+ PyObject_ReleaseBuffer((PyObject *)self, &v1);
+ PyObject_ReleaseBuffer(value, &v2);
+ PyErr_SetString(PyExc_TypeError, "right operand"
+ " length must match slice length");
+ return -1;
+ }
+
+ if (slicelength == 0)
+ /* nothing to do */;
+ else if (step == 1)
+ memcpy((char *)v1.buf + start, v2.buf, slicelength);
+ else {
+ Py_ssize_t cur, i;
+
+ for (cur = start, i = 0; i < slicelength;
+ cur += step, i++) {
+ ((char *)v1.buf)[cur] = ((char *)v2.buf)[i];
+ }
+ }
+ PyObject_ReleaseBuffer((PyObject *)self, &v1);
+ PyObject_ReleaseBuffer(value, &v2);
+ return 0;
+ } else {
+ PyErr_SetString(PyExc_TypeError,
+ "buffer indices must be integers");
+ PyObject_ReleaseBuffer((PyObject *)self, &v1);
+ return -1;
+ }
+}
+
/* Buffer methods */
static PySequenceMethods buffer_as_sequence = {
@@ -599,6 +744,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 = {
(getbufferproc)buffer_getbuf,
(releasebufferproc)buffer_releasebuf,
@@ -617,7 +768,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 */
diff --git a/Objects/listobject.c b/Objects/listobject.c
index 3de07c9..c5a4287 100644
--- a/Objects/listobject.c
+++ b/Objects/listobject.c
@@ -2461,6 +2461,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;
@@ -2504,10 +2507,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;
@@ -2529,12 +2537,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);
@@ -2546,11 +2558,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;
@@ -2565,7 +2578,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 */
@@ -2575,14 +2589,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);
diff --git a/Objects/stringobject.c b/Objects/stringobject.c
index fff4b45..8d0f4b8 100644
--- a/Objects/stringobject.c
+++ b/Objects/stringobject.c
@@ -1146,6 +1146,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);
diff --git a/Objects/structseq.c b/Objects/structseq.c
index 5e57f1f..a3ff045 100644
--- a/Objects/structseq.c
+++ b/Objects/structseq.c
@@ -90,6 +90,54 @@ structseq_slice(PyStructSequence *obj, Py_ssize_t low, Py_ssize_t high)
}
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)
{
PyObject *arg = NULL;
@@ -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 */
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index 3c5dfb5..37b5a1f 100644
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -586,6 +586,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;
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index ebf8c42..1e8f63f 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -8096,6 +8096,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*
generated by cgit v0.12 at 2025-06-02 20:52:38 (GMT)