1/*[clinic input]
2preserve
3[clinic start generated code]*/
4
5PyDoc_STRVAR(Struct___init____doc__,
6"Struct(format)\n"
7"--\n"
8"\n"
9"Create a compiled struct object.\n"
10"\n"
11"Return a new Struct object which writes and reads binary data according to\n"
12"the format string.\n"
13"\n"
14"See help(struct) for more on format strings.");
15
16static int
17Struct___init___impl(PyStructObject *self, PyObject *format);
18
19static int
20Struct___init__(PyObject *self, PyObject *args, PyObject *kwargs)
21{
22    int return_value = -1;
23    static const char * const _keywords[] = {"format", NULL};
24    static _PyArg_Parser _parser = {NULL, _keywords, "Struct", 0};
25    PyObject *argsbuf[1];
26    PyObject * const *fastargs;
27    Py_ssize_t nargs = PyTuple_GET_SIZE(args);
28    PyObject *format;
29
30    fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 1, 0, argsbuf);
31    if (!fastargs) {
32        goto exit;
33    }
34    format = fastargs[0];
35    return_value = Struct___init___impl((PyStructObject *)self, format);
36
37exit:
38    return return_value;
39}
40
41PyDoc_STRVAR(Struct_unpack__doc__,
42"unpack($self, buffer, /)\n"
43"--\n"
44"\n"
45"Return a tuple containing unpacked values.\n"
46"\n"
47"Unpack according to the format string Struct.format. The buffer\'s size\n"
48"in bytes must be Struct.size.\n"
49"\n"
50"See help(struct) for more on format strings.");
51
52#define STRUCT_UNPACK_METHODDEF    \
53    {"unpack", (PyCFunction)Struct_unpack, METH_O, Struct_unpack__doc__},
54
55static PyObject *
56Struct_unpack_impl(PyStructObject *self, Py_buffer *buffer);
57
58static PyObject *
59Struct_unpack(PyStructObject *self, PyObject *arg)
60{
61    PyObject *return_value = NULL;
62    Py_buffer buffer = {NULL, NULL};
63
64    if (PyObject_GetBuffer(arg, &buffer, PyBUF_SIMPLE) != 0) {
65        goto exit;
66    }
67    if (!PyBuffer_IsContiguous(&buffer, 'C')) {
68        _PyArg_BadArgument("unpack", "argument", "contiguous buffer", arg);
69        goto exit;
70    }
71    return_value = Struct_unpack_impl(self, &buffer);
72
73exit:
74    /* Cleanup for buffer */
75    if (buffer.obj) {
76       PyBuffer_Release(&buffer);
77    }
78
79    return return_value;
80}
81
82PyDoc_STRVAR(Struct_unpack_from__doc__,
83"unpack_from($self, /, buffer, offset=0)\n"
84"--\n"
85"\n"
86"Return a tuple containing unpacked values.\n"
87"\n"
88"Values are unpacked according to the format string Struct.format.\n"
89"\n"
90"The buffer\'s size in bytes, starting at position offset, must be\n"
91"at least Struct.size.\n"
92"\n"
93"See help(struct) for more on format strings.");
94
95#define STRUCT_UNPACK_FROM_METHODDEF    \
96    {"unpack_from", _PyCFunction_CAST(Struct_unpack_from), METH_FASTCALL|METH_KEYWORDS, Struct_unpack_from__doc__},
97
98static PyObject *
99Struct_unpack_from_impl(PyStructObject *self, Py_buffer *buffer,
100                        Py_ssize_t offset);
101
102static PyObject *
103Struct_unpack_from(PyStructObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
104{
105    PyObject *return_value = NULL;
106    static const char * const _keywords[] = {"buffer", "offset", NULL};
107    static _PyArg_Parser _parser = {NULL, _keywords, "unpack_from", 0};
108    PyObject *argsbuf[2];
109    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
110    Py_buffer buffer = {NULL, NULL};
111    Py_ssize_t offset = 0;
112
113    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
114    if (!args) {
115        goto exit;
116    }
117    if (PyObject_GetBuffer(args[0], &buffer, PyBUF_SIMPLE) != 0) {
118        goto exit;
119    }
120    if (!PyBuffer_IsContiguous(&buffer, 'C')) {
121        _PyArg_BadArgument("unpack_from", "argument 'buffer'", "contiguous buffer", args[0]);
122        goto exit;
123    }
124    if (!noptargs) {
125        goto skip_optional_pos;
126    }
127    {
128        Py_ssize_t ival = -1;
129        PyObject *iobj = _PyNumber_Index(args[1]);
130        if (iobj != NULL) {
131            ival = PyLong_AsSsize_t(iobj);
132            Py_DECREF(iobj);
133        }
134        if (ival == -1 && PyErr_Occurred()) {
135            goto exit;
136        }
137        offset = ival;
138    }
139skip_optional_pos:
140    return_value = Struct_unpack_from_impl(self, &buffer, offset);
141
142exit:
143    /* Cleanup for buffer */
144    if (buffer.obj) {
145       PyBuffer_Release(&buffer);
146    }
147
148    return return_value;
149}
150
151PyDoc_STRVAR(Struct_iter_unpack__doc__,
152"iter_unpack($self, buffer, /)\n"
153"--\n"
154"\n"
155"Return an iterator yielding tuples.\n"
156"\n"
157"Tuples are unpacked from the given bytes source, like a repeated\n"
158"invocation of unpack_from().\n"
159"\n"
160"Requires that the bytes length be a multiple of the struct size.");
161
162#define STRUCT_ITER_UNPACK_METHODDEF    \
163    {"iter_unpack", (PyCFunction)Struct_iter_unpack, METH_O, Struct_iter_unpack__doc__},
164
165PyDoc_STRVAR(_clearcache__doc__,
166"_clearcache($module, /)\n"
167"--\n"
168"\n"
169"Clear the internal cache.");
170
171#define _CLEARCACHE_METHODDEF    \
172    {"_clearcache", (PyCFunction)_clearcache, METH_NOARGS, _clearcache__doc__},
173
174static PyObject *
175_clearcache_impl(PyObject *module);
176
177static PyObject *
178_clearcache(PyObject *module, PyObject *Py_UNUSED(ignored))
179{
180    return _clearcache_impl(module);
181}
182
183PyDoc_STRVAR(calcsize__doc__,
184"calcsize($module, format, /)\n"
185"--\n"
186"\n"
187"Return size in bytes of the struct described by the format string.");
188
189#define CALCSIZE_METHODDEF    \
190    {"calcsize", (PyCFunction)calcsize, METH_O, calcsize__doc__},
191
192static Py_ssize_t
193calcsize_impl(PyObject *module, PyStructObject *s_object);
194
195static PyObject *
196calcsize(PyObject *module, PyObject *arg)
197{
198    PyObject *return_value = NULL;
199    PyStructObject *s_object = NULL;
200    Py_ssize_t _return_value;
201
202    if (!cache_struct_converter(module, arg, &s_object)) {
203        goto exit;
204    }
205    _return_value = calcsize_impl(module, s_object);
206    if ((_return_value == -1) && PyErr_Occurred()) {
207        goto exit;
208    }
209    return_value = PyLong_FromSsize_t(_return_value);
210
211exit:
212    /* Cleanup for s_object */
213    Py_XDECREF(s_object);
214
215    return return_value;
216}
217
218PyDoc_STRVAR(unpack__doc__,
219"unpack($module, format, buffer, /)\n"
220"--\n"
221"\n"
222"Return a tuple containing values unpacked according to the format string.\n"
223"\n"
224"The buffer\'s size in bytes must be calcsize(format).\n"
225"\n"
226"See help(struct) for more on format strings.");
227
228#define UNPACK_METHODDEF    \
229    {"unpack", _PyCFunction_CAST(unpack), METH_FASTCALL, unpack__doc__},
230
231static PyObject *
232unpack_impl(PyObject *module, PyStructObject *s_object, Py_buffer *buffer);
233
234static PyObject *
235unpack(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
236{
237    PyObject *return_value = NULL;
238    PyStructObject *s_object = NULL;
239    Py_buffer buffer = {NULL, NULL};
240
241    if (!_PyArg_CheckPositional("unpack", nargs, 2, 2)) {
242        goto exit;
243    }
244    if (!cache_struct_converter(module, args[0], &s_object)) {
245        goto exit;
246    }
247    if (PyObject_GetBuffer(args[1], &buffer, PyBUF_SIMPLE) != 0) {
248        goto exit;
249    }
250    if (!PyBuffer_IsContiguous(&buffer, 'C')) {
251        _PyArg_BadArgument("unpack", "argument 2", "contiguous buffer", args[1]);
252        goto exit;
253    }
254    return_value = unpack_impl(module, s_object, &buffer);
255
256exit:
257    /* Cleanup for s_object */
258    Py_XDECREF(s_object);
259    /* Cleanup for buffer */
260    if (buffer.obj) {
261       PyBuffer_Release(&buffer);
262    }
263
264    return return_value;
265}
266
267PyDoc_STRVAR(unpack_from__doc__,
268"unpack_from($module, format, /, buffer, offset=0)\n"
269"--\n"
270"\n"
271"Return a tuple containing values unpacked according to the format string.\n"
272"\n"
273"The buffer\'s size, minus offset, must be at least calcsize(format).\n"
274"\n"
275"See help(struct) for more on format strings.");
276
277#define UNPACK_FROM_METHODDEF    \
278    {"unpack_from", _PyCFunction_CAST(unpack_from), METH_FASTCALL|METH_KEYWORDS, unpack_from__doc__},
279
280static PyObject *
281unpack_from_impl(PyObject *module, PyStructObject *s_object,
282                 Py_buffer *buffer, Py_ssize_t offset);
283
284static PyObject *
285unpack_from(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
286{
287    PyObject *return_value = NULL;
288    static const char * const _keywords[] = {"", "buffer", "offset", NULL};
289    static _PyArg_Parser _parser = {NULL, _keywords, "unpack_from", 0};
290    PyObject *argsbuf[3];
291    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
292    PyStructObject *s_object = NULL;
293    Py_buffer buffer = {NULL, NULL};
294    Py_ssize_t offset = 0;
295
296    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 3, 0, argsbuf);
297    if (!args) {
298        goto exit;
299    }
300    if (!cache_struct_converter(module, args[0], &s_object)) {
301        goto exit;
302    }
303    if (PyObject_GetBuffer(args[1], &buffer, PyBUF_SIMPLE) != 0) {
304        goto exit;
305    }
306    if (!PyBuffer_IsContiguous(&buffer, 'C')) {
307        _PyArg_BadArgument("unpack_from", "argument 'buffer'", "contiguous buffer", args[1]);
308        goto exit;
309    }
310    if (!noptargs) {
311        goto skip_optional_pos;
312    }
313    {
314        Py_ssize_t ival = -1;
315        PyObject *iobj = _PyNumber_Index(args[2]);
316        if (iobj != NULL) {
317            ival = PyLong_AsSsize_t(iobj);
318            Py_DECREF(iobj);
319        }
320        if (ival == -1 && PyErr_Occurred()) {
321            goto exit;
322        }
323        offset = ival;
324    }
325skip_optional_pos:
326    return_value = unpack_from_impl(module, s_object, &buffer, offset);
327
328exit:
329    /* Cleanup for s_object */
330    Py_XDECREF(s_object);
331    /* Cleanup for buffer */
332    if (buffer.obj) {
333       PyBuffer_Release(&buffer);
334    }
335
336    return return_value;
337}
338
339PyDoc_STRVAR(iter_unpack__doc__,
340"iter_unpack($module, format, buffer, /)\n"
341"--\n"
342"\n"
343"Return an iterator yielding tuples unpacked from the given bytes.\n"
344"\n"
345"The bytes are unpacked according to the format string, like\n"
346"a repeated invocation of unpack_from().\n"
347"\n"
348"Requires that the bytes length be a multiple of the format struct size.");
349
350#define ITER_UNPACK_METHODDEF    \
351    {"iter_unpack", _PyCFunction_CAST(iter_unpack), METH_FASTCALL, iter_unpack__doc__},
352
353static PyObject *
354iter_unpack_impl(PyObject *module, PyStructObject *s_object,
355                 PyObject *buffer);
356
357static PyObject *
358iter_unpack(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
359{
360    PyObject *return_value = NULL;
361    PyStructObject *s_object = NULL;
362    PyObject *buffer;
363
364    if (!_PyArg_CheckPositional("iter_unpack", nargs, 2, 2)) {
365        goto exit;
366    }
367    if (!cache_struct_converter(module, args[0], &s_object)) {
368        goto exit;
369    }
370    buffer = args[1];
371    return_value = iter_unpack_impl(module, s_object, buffer);
372
373exit:
374    /* Cleanup for s_object */
375    Py_XDECREF(s_object);
376
377    return return_value;
378}
379/*[clinic end generated code: output=2065c9b007be631c input=a9049054013a1b77]*/
380