Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : PyDoc_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 : :
16 : : static int
17 : : Struct___init___impl(PyStructObject *self, PyObject *format);
18 : :
19 : : static int
20 : 245168 : Struct___init__(PyObject *self, PyObject *args, PyObject *kwargs)
21 : : {
22 : 245168 : 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 : 245168 : Py_ssize_t nargs = PyTuple_GET_SIZE(args);
28 : : PyObject *format;
29 : :
30 [ + - + - : 245168 : fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 1, 0, argsbuf);
+ - + - ]
31 [ - + ]: 245168 : if (!fastargs) {
32 : 0 : goto exit;
33 : : }
34 : 245168 : format = fastargs[0];
35 : 245168 : return_value = Struct___init___impl((PyStructObject *)self, format);
36 : :
37 : 245168 : exit:
38 : 245168 : return return_value;
39 : : }
40 : :
41 : : PyDoc_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 : :
55 : : static PyObject *
56 : : Struct_unpack_impl(PyStructObject *self, Py_buffer *buffer);
57 : :
58 : : static PyObject *
59 : 1515 : Struct_unpack(PyStructObject *self, PyObject *arg)
60 : : {
61 : 1515 : PyObject *return_value = NULL;
62 : 1515 : Py_buffer buffer = {NULL, NULL};
63 : :
64 [ - + ]: 1515 : if (PyObject_GetBuffer(arg, &buffer, PyBUF_SIMPLE) != 0) {
65 : 0 : goto exit;
66 : : }
67 [ - + ]: 1515 : if (!PyBuffer_IsContiguous(&buffer, 'C')) {
68 : 0 : _PyArg_BadArgument("unpack", "argument", "contiguous buffer", arg);
69 : 0 : goto exit;
70 : : }
71 : 1515 : return_value = Struct_unpack_impl(self, &buffer);
72 : :
73 : 1515 : exit:
74 : : /* Cleanup for buffer */
75 [ + - ]: 1515 : if (buffer.obj) {
76 : 1515 : PyBuffer_Release(&buffer);
77 : : }
78 : :
79 : 1515 : return return_value;
80 : : }
81 : :
82 : : PyDoc_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 : :
98 : : static PyObject *
99 : : Struct_unpack_from_impl(PyStructObject *self, Py_buffer *buffer,
100 : : Py_ssize_t offset);
101 : :
102 : : static PyObject *
103 : 1289232 : Struct_unpack_from(PyStructObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
104 : : {
105 : 1289232 : 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 [ + + ]: 1289232 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
110 : 1289232 : Py_buffer buffer = {NULL, NULL};
111 : 1289232 : Py_ssize_t offset = 0;
112 : :
113 [ + + + - : 1289232 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+ - - + ]
114 [ - + ]: 1289232 : if (!args) {
115 : 0 : goto exit;
116 : : }
117 [ - + ]: 1289232 : if (PyObject_GetBuffer(args[0], &buffer, PyBUF_SIMPLE) != 0) {
118 : 0 : goto exit;
119 : : }
120 [ - + ]: 1289232 : if (!PyBuffer_IsContiguous(&buffer, 'C')) {
121 : 0 : _PyArg_BadArgument("unpack_from", "argument 'buffer'", "contiguous buffer", args[0]);
122 : 0 : goto exit;
123 : : }
124 [ + + ]: 1289232 : if (!noptargs) {
125 : 1289207 : goto skip_optional_pos;
126 : : }
127 : : {
128 : 25 : Py_ssize_t ival = -1;
129 : 25 : PyObject *iobj = _PyNumber_Index(args[1]);
130 [ + - ]: 25 : if (iobj != NULL) {
131 : 25 : ival = PyLong_AsSsize_t(iobj);
132 : 25 : Py_DECREF(iobj);
133 : : }
134 [ - + - - ]: 25 : if (ival == -1 && PyErr_Occurred()) {
135 : 0 : goto exit;
136 : : }
137 : 25 : offset = ival;
138 : : }
139 : 1289232 : skip_optional_pos:
140 : 1289232 : return_value = Struct_unpack_from_impl(self, &buffer, offset);
141 : :
142 : 1289232 : exit:
143 : : /* Cleanup for buffer */
144 [ + - ]: 1289232 : if (buffer.obj) {
145 : 1289232 : PyBuffer_Release(&buffer);
146 : : }
147 : :
148 : 1289232 : return return_value;
149 : : }
150 : :
151 : : PyDoc_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 : :
165 : : PyDoc_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 : :
174 : : static PyObject *
175 : : _clearcache_impl(PyObject *module);
176 : :
177 : : static PyObject *
178 : 1 : _clearcache(PyObject *module, PyObject *Py_UNUSED(ignored))
179 : : {
180 : 1 : return _clearcache_impl(module);
181 : : }
182 : :
183 : : PyDoc_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 : :
192 : : static Py_ssize_t
193 : : calcsize_impl(PyObject *module, PyStructObject *s_object);
194 : :
195 : : static PyObject *
196 : 166906 : calcsize(PyObject *module, PyObject *arg)
197 : : {
198 : 166906 : PyObject *return_value = NULL;
199 : 166906 : PyStructObject *s_object = NULL;
200 : : Py_ssize_t _return_value;
201 : :
202 [ + + ]: 166906 : if (!cache_struct_converter(module, arg, &s_object)) {
203 : 20 : goto exit;
204 : : }
205 : 166886 : _return_value = calcsize_impl(module, s_object);
206 [ - + - - ]: 166886 : if ((_return_value == -1) && PyErr_Occurred()) {
207 : 0 : goto exit;
208 : : }
209 : 166886 : return_value = PyLong_FromSsize_t(_return_value);
210 : :
211 : 166906 : exit:
212 : : /* Cleanup for s_object */
213 : 166906 : Py_XDECREF(s_object);
214 : :
215 : 166906 : return return_value;
216 : : }
217 : :
218 : : PyDoc_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 : :
231 : : static PyObject *
232 : : unpack_impl(PyObject *module, PyStructObject *s_object, Py_buffer *buffer);
233 : :
234 : : static PyObject *
235 : 4176578 : unpack(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
236 : : {
237 : 4176578 : PyObject *return_value = NULL;
238 : 4176578 : PyStructObject *s_object = NULL;
239 : 4176578 : Py_buffer buffer = {NULL, NULL};
240 : :
241 [ + - - + : 4176578 : if (!_PyArg_CheckPositional("unpack", nargs, 2, 2)) {
- - ]
242 : 0 : goto exit;
243 : : }
244 [ + + ]: 4176578 : if (!cache_struct_converter(module, args[0], &s_object)) {
245 : 12 : goto exit;
246 : : }
247 [ + + ]: 4176566 : if (PyObject_GetBuffer(args[1], &buffer, PyBUF_SIMPLE) != 0) {
248 : 1 : goto exit;
249 : : }
250 [ - + ]: 4176565 : if (!PyBuffer_IsContiguous(&buffer, 'C')) {
251 : 0 : _PyArg_BadArgument("unpack", "argument 2", "contiguous buffer", args[1]);
252 : 0 : goto exit;
253 : : }
254 : 4176565 : return_value = unpack_impl(module, s_object, &buffer);
255 : :
256 : 4176578 : exit:
257 : : /* Cleanup for s_object */
258 : 4176578 : Py_XDECREF(s_object);
259 : : /* Cleanup for buffer */
260 [ + + ]: 4176578 : if (buffer.obj) {
261 : 4176565 : PyBuffer_Release(&buffer);
262 : : }
263 : :
264 : 4176578 : return return_value;
265 : : }
266 : :
267 : : PyDoc_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 : :
280 : : static PyObject *
281 : : unpack_from_impl(PyObject *module, PyStructObject *s_object,
282 : : Py_buffer *buffer, Py_ssize_t offset);
283 : :
284 : : static PyObject *
285 : 916976 : unpack_from(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
286 : : {
287 : 916976 : 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 [ - + ]: 916976 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
292 : 916976 : PyStructObject *s_object = NULL;
293 : 916976 : Py_buffer buffer = {NULL, NULL};
294 : 916976 : Py_ssize_t offset = 0;
295 : :
296 [ + - + - : 916976 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 3, 0, argsbuf);
+ - - + ]
297 [ - + ]: 916976 : if (!args) {
298 : 0 : goto exit;
299 : : }
300 [ + + ]: 916976 : if (!cache_struct_converter(module, args[0], &s_object)) {
301 : 3 : goto exit;
302 : : }
303 [ - + ]: 916973 : if (PyObject_GetBuffer(args[1], &buffer, PyBUF_SIMPLE) != 0) {
304 : 0 : goto exit;
305 : : }
306 [ - + ]: 916973 : if (!PyBuffer_IsContiguous(&buffer, 'C')) {
307 : 0 : _PyArg_BadArgument("unpack_from", "argument 'buffer'", "contiguous buffer", args[1]);
308 : 0 : goto exit;
309 : : }
310 [ + + ]: 916973 : if (!noptargs) {
311 : 122212 : goto skip_optional_pos;
312 : : }
313 : : {
314 : 794761 : Py_ssize_t ival = -1;
315 : 794761 : PyObject *iobj = _PyNumber_Index(args[2]);
316 [ + - ]: 794761 : if (iobj != NULL) {
317 : 794761 : ival = PyLong_AsSsize_t(iobj);
318 : 794761 : Py_DECREF(iobj);
319 : : }
320 [ - + - - ]: 794761 : if (ival == -1 && PyErr_Occurred()) {
321 : 0 : goto exit;
322 : : }
323 : 794761 : offset = ival;
324 : : }
325 : 916973 : skip_optional_pos:
326 : 916973 : return_value = unpack_from_impl(module, s_object, &buffer, offset);
327 : :
328 : 916976 : exit:
329 : : /* Cleanup for s_object */
330 : 916976 : Py_XDECREF(s_object);
331 : : /* Cleanup for buffer */
332 [ + + ]: 916976 : if (buffer.obj) {
333 : 916973 : PyBuffer_Release(&buffer);
334 : : }
335 : :
336 : 916976 : return return_value;
337 : : }
338 : :
339 : : PyDoc_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 : :
353 : : static PyObject *
354 : : iter_unpack_impl(PyObject *module, PyStructObject *s_object,
355 : : PyObject *buffer);
356 : :
357 : : static PyObject *
358 : 2 : iter_unpack(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
359 : : {
360 : 2 : PyObject *return_value = NULL;
361 : 2 : PyStructObject *s_object = NULL;
362 : : PyObject *buffer;
363 : :
364 [ + - - + : 2 : if (!_PyArg_CheckPositional("iter_unpack", nargs, 2, 2)) {
- - ]
365 : 0 : goto exit;
366 : : }
367 [ - + ]: 2 : if (!cache_struct_converter(module, args[0], &s_object)) {
368 : 0 : goto exit;
369 : : }
370 : 2 : buffer = args[1];
371 : 2 : return_value = iter_unpack_impl(module, s_object, buffer);
372 : :
373 : 2 : exit:
374 : : /* Cleanup for s_object */
375 : 2 : Py_XDECREF(s_object);
376 : :
377 : 2 : return return_value;
378 : : }
379 : : /*[clinic end generated code: output=2065c9b007be631c input=a9049054013a1b77]*/
|
