/home/mdboom/Work/builds/cpython/Objects/clinic/memoryobject.c.h

Source (jump to first uncovered line)
/*[clinic input]
preserve
[clinic start generated code]*/

PyDoc_STRVAR(memoryview__doc__,
"memoryview(object)\n"
"--\n"
"\n"
"Create a new memoryview object which references the given object.");

static PyObject *
memoryview_impl(PyTypeObject *type, PyObject *object);

static PyObject *
memoryview(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
    PyObject *return_value = NULL;
    static const char * const _keywords[] = {"object", NULL};
    static _PyArg_Parser _parser = {NULL, _keywords, "memoryview", 0};
    PyObject *argsbuf[1];
    PyObject * const *fastargs;
    Py_ssize_t nargs = PyTuple_GET_SIZE(args);
    PyObject *object;

    fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 1, 0, argsbuf);
    if (!fastargs) {
        goto exit;
    }
    object = fastargs[0];
    return_value = memoryview_impl(type, object);

exit:
    return return_value;
}

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

#define MEMORYVIEW_RELEASE_METHODDEF    \
    {"release", (PyCFunction)memoryview_release, METH_NOARGS, memoryview_release__doc__},

static PyObject *
memoryview_release_impl(PyMemoryViewObject *self);

static PyObject *
memoryview_release(PyMemoryViewObject *self, PyObject *Py_UNUSED(ignored))
{
    return memoryview_release_impl(self);
}

PyDoc_STRVAR(memoryview_cast__doc__,
"cast($self, /, format, shape=<unrepresentable>)\n"
"--\n"
"\n"
"Cast a memoryview to a new format or shape.");

#define MEMORYVIEW_CAST_METHODDEF    \
    {"cast", _PyCFunction_CAST(memoryview_cast), METH_FASTCALL|METH_KEYWORDS, memoryview_cast__doc__},

static PyObject *
memoryview_cast_impl(PyMemoryViewObject *self, PyObject *format,
                     PyObject *shape);

static PyObject *
memoryview_cast(PyMemoryViewObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
    PyObject *return_value = NULL;
    static const char * const _keywords[] = {"format", "shape", NULL};
    static _PyArg_Parser _parser = {NULL, _keywords, "cast", 0};
    PyObject *argsbuf[2];
    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE11.8k(kwnames) : 024.5k) - 1;
    PyObject *format;
    PyObject *shape = NULL;

    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
    if (!args) {
        goto exit;
    }
    if (!PyUnicode_Check(args[0])) {
        _PyArg_BadArgument("cast", "argument 'format'", "str", args[0]);
        goto exit;
    }
    if (PyUnicode_READY(args[0]) == -1) {
        goto exit;
    }
    format = args[0];
    if (!noptargs) {
        goto skip_optional_pos;
    }
    shape = args[1];
skip_optional_pos:
    return_value = memoryview_cast_impl(self, format, shape);

exit:
    return return_value;
}

PyDoc_STRVAR(memoryview_toreadonly__doc__,
"toreadonly($self, /)\n"
"--\n"
"\n"
"Return a readonly version of the memoryview.");

#define MEMORYVIEW_TOREADONLY_METHODDEF    \
    {"toreadonly", (PyCFunction)memoryview_toreadonly, METH_NOARGS, memoryview_toreadonly__doc__},

static PyObject *
memoryview_toreadonly_impl(PyMemoryViewObject *self);

static PyObject *
memoryview_toreadonly(PyMemoryViewObject *self, PyObject *Py_UNUSED(ignored))
{
    return memoryview_toreadonly_impl(self);
}

PyDoc_STRVAR(memoryview_tolist__doc__,
"tolist($self, /)\n"
"--\n"
"\n"
"Return the data in the buffer as a list of elements.");

#define MEMORYVIEW_TOLIST_METHODDEF    \
    {"tolist", (PyCFunction)memoryview_tolist, METH_NOARGS, memoryview_tolist__doc__},

static PyObject *
memoryview_tolist_impl(PyMemoryViewObject *self);

static PyObject *
memoryview_tolist(PyMemoryViewObject *self, PyObject *Py_UNUSED(ignored))
{
    return memoryview_tolist_impl(self);
}

PyDoc_STRVAR(memoryview_tobytes__doc__,
"tobytes($self, /, order=\'C\')\n"
"--\n"
"\n"
"Return the data in the buffer as a byte string.\n"
"\n"
"Order can be {\'C\', \'F\', \'A\'}. When order is \'C\' or \'F\', the data of the\n"
"original array is converted to C or Fortran order. For contiguous views,\n"
"\'A\' returns an exact copy of the physical memory. In particular, in-memory\n"
"Fortran order is preserved. For non-contiguous views, the data is converted\n"
"to C first. order=None is the same as order=\'C\'.");

#define MEMORYVIEW_TOBYTES_METHODDEF    \
    {"tobytes", _PyCFunction_CAST(memoryview_tobytes), METH_FASTCALL|METH_KEYWORDS, memoryview_tobytes__doc__},

static PyObject *
memoryview_tobytes_impl(PyMemoryViewObject *self, const char *order);

static PyObject *
memoryview_tobytes(PyMemoryViewObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
    PyObject *return_value = NULL;
    static const char * const _keywords[] = {"order", NULL};
    static _PyArg_Parser _parser = {NULL, _keywords, "tobytes", 0};
    PyObject *argsbuf[1];
    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE125k(kwnames) : 095.4k) - 0;
    const char *order = NULL;

    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
    if (!args) {
        goto exit;
    }
    if (!noptargs) {
        goto skip_optional_pos;
    }
    if (args[0] == Py_None) {
        order = NULL;
    }
    else if (PyUnicode_Check(args[0])) {
        Py_ssize_t order_length;
        order = PyUnicode_AsUTF8AndSize(args[0], &order_length);
        if (order == NULL) {
            goto exit;
        }
        if (strlen(order) != (size_t)order_length) {
            PyErr_SetString(PyExc_ValueError, "embedded null character");
            goto exit;
        }
    }
    else {
        _PyArg_BadArgument("tobytes", "argument 'order'", "str or None", args[0]);
        goto exit;
    }
skip_optional_pos:
    return_value = memoryview_tobytes_impl(self, order);

exit:
    return return_value;
}

PyDoc_STRVAR(memoryview_hex__doc__,
"hex($self, /, sep=<unrepresentable>, bytes_per_sep=1)\n"
"--\n"
"\n"
"Return the data in the buffer as a str of hexadecimal numbers.\n"
"\n"
"  sep\n"
"    An optional single character or byte to separate hex bytes.\n"
"  bytes_per_sep\n"
"    How many bytes between separators.  Positive values count from the\n"
"    right, negative values count from the left.\n"
"\n"
"Example:\n"
">>> value = memoryview(b\'\\xb9\\x01\\xef\')\n"
">>> value.hex()\n"
"\'b901ef\'\n"
">>> value.hex(\':\')\n"
"\'b9:01:ef\'\n"
">>> value.hex(\':\', 2)\n"
"\'b9:01ef\'\n"
">>> value.hex(\':\', -2)\n"
"\'b901:ef\'");

#define MEMORYVIEW_HEX_METHODDEF    \
    {"hex", _PyCFunction_CAST(memoryview_hex), METH_FASTCALL|METH_KEYWORDS, memoryview_hex__doc__},

static PyObject *
memoryview_hex_impl(PyMemoryViewObject *self, PyObject *sep,
                    int bytes_per_sep);

static PyObject *
memoryview_hex(PyMemoryViewObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
    PyObject *return_value = NULL;
    static const char * const _keywords[] = {"sep", "bytes_per_sep", NULL};
    static _PyArg_Parser _parser = {NULL, _keywords, "hex", 0};
    PyObject *argsbuf[2];
    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE0(kwnames) : 0) - 0;
    PyObject *sep = NULL;
    int bytes_per_sep = 1;

    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
    if (!args) {
        goto exit;
    }
    if (!noptargs) {
        goto skip_optional_pos;
    }
    if (args[0]) {
        sep = args[0];
        if (!--noptargs) {
            goto skip_optional_pos;
        }
    }
    bytes_per_sep = _PyLong_AsInt(args[1]);
    if (bytes_per_sep == -1 && PyErr_Occurred()0) {
        goto exit;
    }
skip_optional_pos:
    return_value = memoryview_hex_impl(self, sep, bytes_per_sep);

exit:
    return return_value;
}
/*[clinic end generated code: output=48be570b5e6038e3 input=a9049054013a1b77]*/

Coverage Report

Created: 2022-07-08 09:39

Line	Count	Source (jump to first uncovered line)
1	/*[clinic input]
2	preserve
3	[clinic start generated code]*/
4
5	PyDoc_STRVAR(memoryview__doc__,
6	"memoryview(object)\n"
7	"--\n"
8	"\n"
9	"Create a new memoryview object which references the given object.");
10
11	static PyObject *
12	memoryview_impl(PyTypeObject type, PyObject object);
13
14	static PyObject *
15	memoryview(PyTypeObject type, PyObject args, PyObject *kwargs)
16	{
17	PyObject *return_value = NULL;
18	static const char * const _keywords[] = {"object", NULL};
19	static _PyArg_Parser _parser = {NULL, _keywords, "memoryview", 0};
20	PyObject *argsbuf[1];
21	PyObject * const *fastargs;
22	Py_ssize_t nargs = PyTuple_GET_SIZE(args);
23	PyObject *object;
24
25	fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 1, 0, argsbuf);
26	if (!fastargs) { Branch (26:9): [True: 9, False: 437k]
27	goto exit;
28	}
29	object = fastargs[0];
30	return_value = memoryview_impl(type, object);
31
32	exit:
33	return return_value;
34	}
35
36	PyDoc_STRVAR(memoryview_release__doc__,
37	"release($self, /)\n"
38	"--\n"
39	"\n"
40	"Release the underlying buffer exposed by the memoryview object.");
41
42	#define MEMORYVIEW_RELEASE_METHODDEF \
43	{"release", (PyCFunction)memoryview_release, METH_NOARGS, memoryview_release__doc__},
44
45	static PyObject *
46	memoryview_release_impl(PyMemoryViewObject *self);
47
48	static PyObject *
49	memoryview_release(PyMemoryViewObject self, PyObject Py_UNUSED(ignored))
50	{
51	return memoryview_release_impl(self);
52	}
53
54	PyDoc_STRVAR(memoryview_cast__doc__,
55	"cast($self, /, format, shape=<unrepresentable>)\n"
56	"--\n"
57	"\n"
58	"Cast a memoryview to a new format or shape.");
59
60	#define MEMORYVIEW_CAST_METHODDEF \
61	{"cast", _PyCFunction_CAST(memoryview_cast), METH_FASTCALL\|METH_KEYWORDS, memoryview_cast__doc__},
62
63	static PyObject *
64	memoryview_cast_impl(PyMemoryViewObject self, PyObject format,
65	PyObject *shape);
66
67	static PyObject *
68	memoryview_cast(PyMemoryViewObject self, PyObject const args, Py_ssize_t nargs, PyObject kwnames)
69	{
70	PyObject *return_value = NULL;
71	static const char * const _keywords[] = {"format", "shape", NULL};
72	static _PyArg_Parser _parser = {NULL, _keywords, "cast", 0};
73	PyObject *argsbuf[2];
74	Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE11.8k (kwnames) : 024.5k ) - 1; Branch (74:36): [True: 11.8k, False: 24.5k]
75	PyObject *format;
76	PyObject *shape = NULL;
77
78	args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
79	if (!args) { Branch (79:9): [True: 2, False: 36.4k]
80	goto exit;
81	}
82	if (!PyUnicode_Check(args[0])) { Branch (82:9): [True: 1, False: 36.4k]
83	_PyArg_BadArgument("cast", "argument 'format'", "str", args[0]);
84	goto exit;
85	}
86	if (PyUnicode_READY(args[0]) == -1) { Branch (86:9): [True: 0, False: 36.4k]
87	goto exit;
88	}
89	format = args[0];
90	if (!noptargs) { Branch (90:9): [True: 16.1k, False: 20.2k]
91	goto skip_optional_pos;
92	}
93	shape = args[1];
94	skip_optional_pos:
95	return_value = memoryview_cast_impl(self, format, shape);
96
97	exit:
98	return return_value;
99	}
100
101	PyDoc_STRVAR(memoryview_toreadonly__doc__,
102	"toreadonly($self, /)\n"
103	"--\n"
104	"\n"
105	"Return a readonly version of the memoryview.");
106
107	#define MEMORYVIEW_TOREADONLY_METHODDEF \
108	{"toreadonly", (PyCFunction)memoryview_toreadonly, METH_NOARGS, memoryview_toreadonly__doc__},
109
110	static PyObject *
111	memoryview_toreadonly_impl(PyMemoryViewObject *self);
112
113	static PyObject *
114	memoryview_toreadonly(PyMemoryViewObject self, PyObject Py_UNUSED(ignored))
115	{
116	return memoryview_toreadonly_impl(self);
117	}
118
119	PyDoc_STRVAR(memoryview_tolist__doc__,
120	"tolist($self, /)\n"
121	"--\n"
122	"\n"
123	"Return the data in the buffer as a list of elements.");
124
125	#define MEMORYVIEW_TOLIST_METHODDEF \
126	{"tolist", (PyCFunction)memoryview_tolist, METH_NOARGS, memoryview_tolist__doc__},
127
128	static PyObject *
129	memoryview_tolist_impl(PyMemoryViewObject *self);
130
131	static PyObject *
132	memoryview_tolist(PyMemoryViewObject self, PyObject Py_UNUSED(ignored))
133	{
134	return memoryview_tolist_impl(self);
135	}
136
137	PyDoc_STRVAR(memoryview_tobytes__doc__,
138	"tobytes($self, /, order=\'C\')\n"
139	"--\n"
140	"\n"
141	"Return the data in the buffer as a byte string.\n"
142	"\n"
143	"Order can be {\'C\', \'F\', \'A\'}. When order is \'C\' or \'F\', the data of the\n"
144	"original array is converted to C or Fortran order. For contiguous views,\n"
145	"\'A\' returns an exact copy of the physical memory. In particular, in-memory\n"
146	"Fortran order is preserved. For non-contiguous views, the data is converted\n"
147	"to C first. order=None is the same as order=\'C\'.");
148
149	#define MEMORYVIEW_TOBYTES_METHODDEF \
150	{"tobytes", _PyCFunction_CAST(memoryview_tobytes), METH_FASTCALL\|METH_KEYWORDS, memoryview_tobytes__doc__},
151
152	static PyObject *
153	memoryview_tobytes_impl(PyMemoryViewObject self, const char order);
154
155	static PyObject *
156	memoryview_tobytes(PyMemoryViewObject self, PyObject const args, Py_ssize_t nargs, PyObject kwnames)
157	{
158	PyObject *return_value = NULL;
159	static const char * const _keywords[] = {"order", NULL};
160	static _PyArg_Parser _parser = {NULL, _keywords, "tobytes", 0};
161	PyObject *argsbuf[1];
162	Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE125k (kwnames) : 095.4k ) - 0; Branch (162:36): [True: 125k, False: 95.4k]
163	const char *order = NULL;
164
165	args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
166	if (!args) { Branch (166:9): [True: 0, False: 220k]
167	goto exit;
168	}
169	if (!noptargs) { Branch (169:9): [True: 95.4k, False: 125k]
170	goto skip_optional_pos;
171	}
172	if (args[0] == Py_None) { Branch (172:9): [True: 31.3k, False: 94.1k]
173	order = NULL;
174	}
175	else if (PyUnicode_Check(args[0])) {
176	Py_ssize_t order_length;
177	order = PyUnicode_AsUTF8AndSize(args[0], &order_length);
178	if (order == NULL) { Branch (178:13): [True: 0, False: 94.1k]
179	goto exit;
180	}
181	if (strlen(order) != (size_t)order_length) { Branch (181:13): [True: 0, False: 94.1k]
182	PyErr_SetString(PyExc_ValueError, "embedded null character");
183	goto exit;
184	}
185	}
186	else {
187	_PyArg_BadArgument("tobytes", "argument 'order'", "str or None", args[0]);
188	goto exit;
189	}
190	skip_optional_pos:
191	return_value = memoryview_tobytes_impl(self, order);
192
193	exit:
194	return return_value;
195	}
196
197	PyDoc_STRVAR(memoryview_hex__doc__,
198	"hex($self, /, sep=<unrepresentable>, bytes_per_sep=1)\n"
199	"--\n"
200	"\n"
201	"Return the data in the buffer as a str of hexadecimal numbers.\n"
202	"\n"
203	" sep\n"
204	" An optional single character or byte to separate hex bytes.\n"
205	" bytes_per_sep\n"
206	" How many bytes between separators. Positive values count from the\n"
207	" right, negative values count from the left.\n"
208	"\n"
209	"Example:\n"
210	">>> value = memoryview(b\'\\xb9\\x01\\xef\')\n"
211	">>> value.hex()\n"
212	"\'b901ef\'\n"
213	">>> value.hex(\':\')\n"
214	"\'b9:01:ef\'\n"
215	">>> value.hex(\':\', 2)\n"
216	"\'b9:01ef\'\n"
217	">>> value.hex(\':\', -2)\n"
218	"\'b901:ef\'");
219
220	#define MEMORYVIEW_HEX_METHODDEF \
221	{"hex", _PyCFunction_CAST(memoryview_hex), METH_FASTCALL\|METH_KEYWORDS, memoryview_hex__doc__},
222
223	static PyObject *
224	memoryview_hex_impl(PyMemoryViewObject self, PyObject sep,
225	int bytes_per_sep);
226
227	static PyObject *
228	memoryview_hex(PyMemoryViewObject self, PyObject const args, Py_ssize_t nargs, PyObject kwnames)
229	{
230	PyObject *return_value = NULL;
231	static const char * const _keywords[] = {"sep", "bytes_per_sep", NULL};
232	static _PyArg_Parser _parser = {NULL, _keywords, "hex", 0};
233	PyObject *argsbuf[2];
234	Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE0 (kwnames) : 0) - 0; Branch (234:36): [True: 0, False: 11.3k]
235	PyObject *sep = NULL;
236	int bytes_per_sep = 1;
237
238	args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
239	if (!args) { Branch (239:9): [True: 0, False: 11.3k]
240	goto exit;
241	}
242	if (!noptargs) { Branch (242:9): [True: 11.3k, False: 3]
243	goto skip_optional_pos;
244	}
245	if (args[0]) { Branch (245:9): [True: 3, False: 0]
246	sep = args[0];
247	if (!--noptargs) { Branch (247:13): [True: 1, False: 2]
248	goto skip_optional_pos;
249	}
250	}
251	bytes_per_sep = _PyLong_AsInt(args[1]);
252	if (bytes_per_sep == -1 && PyErr_Occurred()0 ) { Branch (252:9): [True: 0, False: 2] Branch (252:32): [True: 0, False: 0]
253	goto exit;
254	}
255	skip_optional_pos:
256	return_value = memoryview_hex_impl(self, sep, bytes_per_sep);
257
258	exit:
259	return return_value;
260	}
261	/[clinic end generated code: output=48be570b5e6038e3 input=a9049054013a1b77]/