/home/mdboom/Work/builds/cpython/Objects/picklebufobject.c

Source (jump to first uncovered line)
/* PickleBuffer object implementation */

#define PY_SSIZE_T_CLEAN
#include "Python.h"
#include <stddef.h>

typedef struct {
    PyObject_HEAD
    /* The view exported by the original object */
    Py_buffer view;
    PyObject *weakreflist;
} PyPickleBufferObject;

/* C API */

PyObject *
PyPickleBuffer_FromObject(PyObject *base)
{
    PyTypeObject *type = &PyPickleBuffer_Type;
    PyPickleBufferObject *self;

    self = (PyPickleBufferObject *) type->tp_alloc(type, 0);
    if (self == NULL) {
        return NULL;
    }
    self->view.obj = NULL;
    self->weakreflist = NULL;
    if (PyObject_GetBuffer(base, &self->view, PyBUF_FULL_RO) < 0) {
        Py_DECREF(self);
        return NULL;
    }
    return (PyObject *) self;
}

const Py_buffer *
PyPickleBuffer_GetBuffer(PyObject *obj)
{
    PyPickleBufferObject *self = (PyPickleBufferObject *) obj;

    if (!PyPickleBuffer_Check(obj)) {
        PyErr_Format(PyExc_TypeError,
                     "expected PickleBuffer, %.200s found",
                     Py_TYPE(obj)->tp_name);
        return NULL;
    }
    if (self->view.obj == NULL) {
        PyErr_SetString(PyExc_ValueError,
                        "operation forbidden on released PickleBuffer object");
        return NULL;
    }
    return &self->view;
}

int
PyPickleBuffer_Release(PyObject *obj)
{
    PyPickleBufferObject *self = (PyPickleBufferObject *) obj;

    if (!PyPickleBuffer_Check(obj)) {
        PyErr_Format(PyExc_TypeError,
                     "expected PickleBuffer, %.200s found",
                     Py_TYPE(obj)->tp_name);
        return -1;
    }
    PyBuffer_Release(&self->view);
    return 0;
}

static PyObject *
picklebuf_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    PyPickleBufferObject *self;
    PyObject *base;
    char *keywords[] = {"", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:PickleBuffer",
                                     keywords, &base)) {
        return NULL;
    }

    self = (PyPickleBufferObject *) type->tp_alloc(type, 0);
    if (self == NULL) {
        return NULL;
    }
    self->view.obj = NULL;
    self->weakreflist = NULL;
    if (PyObject_GetBuffer(base, &self->view, PyBUF_FULL_RO) < 0) {
        Py_DECREF(self);
        return NULL;
    }
    return (PyObject *) self;
}

static int
picklebuf_traverse(PyPickleBufferObject *self, visitproc visit, void *arg)
{
    Py_VISIT(self->view.obj);
    return 0;
}

static int
picklebuf_clear(PyPickleBufferObject *self)
{
    PyBuffer_Release(&self->view);
    return 0;
}

static void
picklebuf_dealloc(PyPickleBufferObject *self)
{
    PyObject_GC_UnTrack(self);
    if (self->weakreflist != NULL)
        PyObject_ClearWeakRefs((PyObject *) self);
    PyBuffer_Release(&self->view);
    Py_TYPE(self)->tp_free((PyObject *) self);
}

/* Buffer API */

static int
picklebuf_getbuf(PyPickleBufferObject *self, Py_buffer *view, int flags)
{
    if (self->view.obj == NULL) {
        PyErr_SetString(PyExc_ValueError,
                        "operation forbidden on released PickleBuffer object");
        return -1;
    }
    return PyObject_GetBuffer(self->view.obj, view, flags);
}

static void
picklebuf_releasebuf(PyPickleBufferObject *self, Py_buffer *view)
{
    /* Since our bf_getbuffer redirects to the original object, this
     * implementation is never called.  It only exists to signal that
     * buffers exported by PickleBuffer have non-trivial releasing
     * behaviour (see check in Python/getargs.c).
     */
}

static PyBufferProcs picklebuf_as_buffer = {
    .bf_getbuffer = (getbufferproc) picklebuf_getbuf,
    .bf_releasebuffer = (releasebufferproc) picklebuf_releasebuf,
};

/* Methods */

static PyObject *
picklebuf_raw(PyPickleBufferObject *self, PyObject *Py_UNUSED(ignored))
{
    if (self->view.obj == NULL) {
        PyErr_SetString(PyExc_ValueError,
                        "operation forbidden on released PickleBuffer object");
        return NULL;
    }
    if (self->view.suboffsets != NULL
        || !PyBuffer_IsContiguous(&self->view, 'A')) {
        PyErr_SetString(PyExc_BufferError,
                        "cannot extract raw buffer from non-contiguous buffer");
        return NULL;
    }
    PyObject *m = PyMemoryView_FromObject((PyObject *) self);
    if (m == NULL) {
        return NULL;
    }
    PyMemoryViewObject *mv = (PyMemoryViewObject *) m;
    assert(mv->view.suboffsets == NULL);
    /* Mutate memoryview instance to make it a "raw" memoryview */
    mv->view.format = "B";
    mv->view.ndim = 1;
    mv->view.itemsize = 1;
    /* shape = (length,) */
    mv->view.shape = &mv->view.len;
    /* strides = (1,) */
    mv->view.strides = &mv->view.itemsize;
    /* Fix memoryview state flags */
    /* XXX Expose memoryobject.c's init_flags() instead? */
    mv->flags = _Py_MEMORYVIEW_C | _Py_MEMORYVIEW_FORTRAN;
    return m;
}

PyDoc_STRVAR(picklebuf_raw_doc,
"raw($self, /)\n--\n\
\n\
Return a memoryview of the raw memory underlying this buffer.\n\
Will raise BufferError is the buffer isn't contiguous.");

static PyObject *
picklebuf_release(PyPickleBufferObject *self, PyObject *Py_UNUSED(ignored))
{
    PyBuffer_Release(&self->view);
    Py_RETURN_NONE;
}

PyDoc_STRVAR(picklebuf_release_doc,
"release($self, /)\n--\n\
\n\
Release the underlying buffer exposed by the PickleBuffer object.");

static PyMethodDef picklebuf_methods[] = {
    {"raw",     (PyCFunction) picklebuf_raw,     METH_NOARGS, picklebuf_raw_doc},
    {"release", (PyCFunction) picklebuf_release, METH_NOARGS, picklebuf_release_doc},
    {NULL,      NULL}
};

PyTypeObject PyPickleBuffer_Type = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name = "pickle.PickleBuffer",
    .tp_doc = PyDoc_STR("Wrapper for potentially out-of-band buffers"),
    .tp_basicsize = sizeof(PyPickleBufferObject),
    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
    .tp_new = picklebuf_new,
    .tp_dealloc = (destructor) picklebuf_dealloc,
    .tp_traverse = (traverseproc) picklebuf_traverse,
    .tp_clear = (inquiry) picklebuf_clear,
    .tp_weaklistoffset = offsetof(PyPickleBufferObject, weakreflist),
    .tp_as_buffer = &picklebuf_as_buffer,
    .tp_methods = picklebuf_methods,
};

Coverage Report

Created: 2022-07-08 09:39

Line	Count	Source (jump to first uncovered line)
1	/* PickleBuffer object implementation */
2
3	#define PY_SSIZE_T_CLEAN
4	#include "Python.h"
5	#include <stddef.h>
6
7	typedef struct {
8	PyObject_HEAD
9	/* The view exported by the original object */
10	Py_buffer view;
11	PyObject *weakreflist;
12	} PyPickleBufferObject;
13
14	/* C API */
15
16	PyObject *
17	PyPickleBuffer_FromObject(PyObject *base)
18	{
19	PyTypeObject *type = &PyPickleBuffer_Type;
20	PyPickleBufferObject *self;
21
22	self = (PyPickleBufferObject *) type->tp_alloc(type, 0);
23	if (self == NULL) { Branch (23:9): [True: 0, False: 0]
24	return NULL;
25	}
26	self->view.obj = NULL;
27	self->weakreflist = NULL;
28	if (PyObject_GetBuffer(base, &self->view, PyBUF_FULL_RO) < 0) { Branch (28:9): [True: 0, False: 0]
29	Py_DECREF(self);
30	return NULL;
31	}
32	return (PyObject *) self;
33	}
34
35	const Py_buffer *
36	PyPickleBuffer_GetBuffer(PyObject *obj)
37	{
38	PyPickleBufferObject self = (PyPickleBufferObject ) obj;
39
40	if (!PyPickleBuffer_Check(obj)) { Branch (40:9): [True: 0, False: 110]
41	PyErr_Format(PyExc_TypeError,
42	"expected PickleBuffer, %.200s found",
43	Py_TYPE(obj)->tp_name);
44	return NULL;
45	}
46	if (self->view.obj == NULL) { Branch (46:9): [True: 0, False: 110]
47	PyErr_SetString(PyExc_ValueError,
48	"operation forbidden on released PickleBuffer object");
49	return NULL;
50	}
51	return &self->view;
52	}
53
54	int
55	PyPickleBuffer_Release(PyObject *obj)
56	{
57	PyPickleBufferObject self = (PyPickleBufferObject ) obj;
58
59	if (!PyPickleBuffer_Check(obj)) { Branch (59:9): [True: 0, False: 0]
60	PyErr_Format(PyExc_TypeError,
61	"expected PickleBuffer, %.200s found",
62	Py_TYPE(obj)->tp_name);
63	return -1;
64	}
65	PyBuffer_Release(&self->view);
66	return 0;
67	}
68
69	static PyObject *
70	picklebuf_new(PyTypeObject type, PyObject args, PyObject *kwds)
71	{
72	PyPickleBufferObject *self;
73	PyObject *base;
74	char *keywords[] = {"", NULL};
75
76	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:PickleBuffer", Branch (76:9): [True: 1, False: 370]
77	keywords, &base)) {
78	return NULL;
79	}
80
81	self = (PyPickleBufferObject *) type->tp_alloc(type, 0);
82	if (self == NULL) { Branch (82:9): [True: 0, False: 370]
83	return NULL;
84	}
85	self->view.obj = NULL;
86	self->weakreflist = NULL;
87	if (PyObject_GetBuffer(base, &self->view, PyBUF_FULL_RO) < 0) { Branch (87:9): [True: 2, False: 368]
88	Py_DECREF(self);
89	return NULL;
90	}
91	return (PyObject *) self;
92	}
93
94	static int
95	picklebuf_traverse(PyPickleBufferObject self, visitproc visit, void arg)
96	{
97	Py_VISIT(self->view.obj);
98	return 0;
99	}
100
101	static int
102	picklebuf_clear(PyPickleBufferObject *self)
103	{
104	PyBuffer_Release(&self->view);
105	return 0;
106	}
107
108	static void
109	picklebuf_dealloc(PyPickleBufferObject *self)
110	{
111	PyObject_GC_UnTrack(self);
112	if (self->weakreflist != NULL) Branch (112:9): [True: 0, False: 370]
113	PyObject_ClearWeakRefs((PyObject *) self);
114	PyBuffer_Release(&self->view);
115	Py_TYPE(self)->tp_free((PyObject *) self);
116	}
117
118	/* Buffer API */
119
120	static int
121	picklebuf_getbuf(PyPickleBufferObject self, Py_buffer view, int flags)
122	{
123	if (self->view.obj == NULL) { Branch (123:9): [True: 1, False: 316]
124	PyErr_SetString(PyExc_ValueError,
125	"operation forbidden on released PickleBuffer object");
126	return -1;
127	}
128	return PyObject_GetBuffer(self->view.obj, view, flags);
129	}
130
131	static void
132	picklebuf_releasebuf(PyPickleBufferObject self, Py_buffer view)
133	{
134	/* Since our bf_getbuffer redirects to the original object, this
135	* implementation is never called. It only exists to signal that
136	* buffers exported by PickleBuffer have non-trivial releasing
137	* behaviour (see check in Python/getargs.c).
138	*/
139	}
140
141	static PyBufferProcs picklebuf_as_buffer = {
142	.bf_getbuffer = (getbufferproc) picklebuf_getbuf,
143	.bf_releasebuffer = (releasebufferproc) picklebuf_releasebuf,
144	};
145
146	/* Methods */
147
148	static PyObject *
149	picklebuf_raw(PyPickleBufferObject self, PyObject Py_UNUSED(ignored))
150	{
151	if (self->view.obj == NULL) { Branch (151:9): [True: 1, False: 292]
152	PyErr_SetString(PyExc_ValueError,
153	"operation forbidden on released PickleBuffer object");
154	return NULL;
155	}
156	if (self->view.suboffsets != NULL Branch (156:9): [True: 0, False: 292]
157	\|\| !PyBuffer_IsContiguous(&self->view, 'A')) { Branch (157:12): [True: 2, False: 290]
158	PyErr_SetString(PyExc_BufferError,
159	"cannot extract raw buffer from non-contiguous buffer");
160	return NULL;
161	}
162	PyObject m = PyMemoryView_FromObject((PyObject ) self);
163	if (m == NULL) { Branch (163:9): [True: 0, False: 290]
164	return NULL;
165	}
166	PyMemoryViewObject mv = (PyMemoryViewObject ) m;
167	assert(mv->view.suboffsets == NULL);
168	/* Mutate memoryview instance to make it a "raw" memoryview */
169	mv->view.format = "B";
170	mv->view.ndim = 1;
171	mv->view.itemsize = 1;
172	/* shape = (length,) */
173	mv->view.shape = &mv->view.len;
174	/* strides = (1,) */
175	mv->view.strides = &mv->view.itemsize;
176	/* Fix memoryview state flags */
177	/* XXX Expose memoryobject.c's init_flags() instead? */
178	mv->flags = _Py_MEMORYVIEW_C \| _Py_MEMORYVIEW_FORTRAN;
179	return m;
180	}
181
182	PyDoc_STRVAR(picklebuf_raw_doc,
183	"raw($self, /)\n--\n\
184	\n\
185	Return a memoryview of the raw memory underlying this buffer.\n\
186	Will raise BufferError is the buffer isn't contiguous.");
187
188	static PyObject *
189	picklebuf_release(PyPickleBufferObject self, PyObject Py_UNUSED(ignored))
190	{
191	PyBuffer_Release(&self->view);
192	Py_RETURN_NONE;
193	}
194
195	PyDoc_STRVAR(picklebuf_release_doc,
196	"release($self, /)\n--\n\
197	\n\
198	Release the underlying buffer exposed by the PickleBuffer object.");
199
200	static PyMethodDef picklebuf_methods[] = {
201	{"raw", (PyCFunction) picklebuf_raw, METH_NOARGS, picklebuf_raw_doc},
202	{"release", (PyCFunction) picklebuf_release, METH_NOARGS, picklebuf_release_doc},
203	{NULL, NULL}
204	};
205
206	PyTypeObject PyPickleBuffer_Type = {
207	PyVarObject_HEAD_INIT(NULL, 0)
208	.tp_name = "pickle.PickleBuffer",
209	.tp_doc = PyDoc_STR("Wrapper for potentially out-of-band buffers"),
210	.tp_basicsize = sizeof(PyPickleBufferObject),
211	.tp_flags = Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_HAVE_GC,
212	.tp_new = picklebuf_new,
213	.tp_dealloc = (destructor) picklebuf_dealloc,
214	.tp_traverse = (traverseproc) picklebuf_traverse,
215	.tp_clear = (inquiry) picklebuf_clear,
216	.tp_weaklistoffset = offsetof(PyPickleBufferObject, weakreflist),
217	.tp_as_buffer = &picklebuf_as_buffer,
218	.tp_methods = picklebuf_methods,
219	};