1 /* Implementation helper: a struct that looks like a tuple.
2 See timemodule and posixmodule for example uses.
3
4 The structseq helper is considered an internal CPython implementation
5 detail. Docs for modules using structseqs should call them
6 "named tuples" (be sure to include a space between the two
7 words and add a link back to the term in Docs/glossary.rst).
8 */
9
10 #include "Python.h"
11 #include "pycore_tupleobject.h"
12 #include "pycore_object.h"
13 #include "structmember.h"
14
15 static const char visible_length_key[] = "n_sequence_fields";
16 static const char real_length_key[] = "n_fields";
17 static const char unnamed_fields_key[] = "n_unnamed_fields";
18
19 /* Fields with this name have only a field index, not a field name.
20 They are only allowed for indices < n_visible_fields. */
21 char *PyStructSequence_UnnamedField = "unnamed field";
22 _Py_IDENTIFIER(n_sequence_fields);
23 _Py_IDENTIFIER(n_fields);
24 _Py_IDENTIFIER(n_unnamed_fields);
25
26 #define VISIBLE_SIZE(op) Py_SIZE(op)
27 #define VISIBLE_SIZE_TP(tp) PyLong_AsSsize_t( \
28 _PyDict_GetItemId((tp)->tp_dict, &PyId_n_sequence_fields))
29
30 #define REAL_SIZE_TP(tp) PyLong_AsSsize_t( \
31 _PyDict_GetItemId((tp)->tp_dict, &PyId_n_fields))
32 #define REAL_SIZE(op) REAL_SIZE_TP(Py_TYPE(op))
33
34 #define UNNAMED_FIELDS_TP(tp) PyLong_AsSsize_t( \
35 _PyDict_GetItemId((tp)->tp_dict, &PyId_n_unnamed_fields))
36 #define UNNAMED_FIELDS(op) UNNAMED_FIELDS_TP(Py_TYPE(op))
37
38
39 PyObject *
PyStructSequence_New(PyTypeObject * type)40 PyStructSequence_New(PyTypeObject *type)
41 {
42 PyStructSequence *obj;
43 Py_ssize_t size = REAL_SIZE_TP(type), i;
44
45 obj = PyObject_GC_NewVar(PyStructSequence, type, size);
46 if (obj == NULL)
47 return NULL;
48 /* Hack the size of the variable object, so invisible fields don't appear
49 to Python code. */
50 Py_SIZE(obj) = VISIBLE_SIZE_TP(type);
51 for (i = 0; i < size; i++)
52 obj->ob_item[i] = NULL;
53
54 return (PyObject*)obj;
55 }
56
57 void
PyStructSequence_SetItem(PyObject * op,Py_ssize_t i,PyObject * v)58 PyStructSequence_SetItem(PyObject* op, Py_ssize_t i, PyObject* v)
59 {
60 PyStructSequence_SET_ITEM(op, i, v);
61 }
62
63 PyObject*
PyStructSequence_GetItem(PyObject * op,Py_ssize_t i)64 PyStructSequence_GetItem(PyObject* op, Py_ssize_t i)
65 {
66 return PyStructSequence_GET_ITEM(op, i);
67 }
68
69
70 static int
structseq_traverse(PyStructSequence * obj,visitproc visit,void * arg)71 structseq_traverse(PyStructSequence *obj, visitproc visit, void *arg)
72 {
73 Py_ssize_t i, size;
74 size = REAL_SIZE(obj);
75 for (i = 0; i < size; ++i) {
76 Py_VISIT(obj->ob_item[i]);
77 }
78 return 0;
79 }
80
81 static void
structseq_dealloc(PyStructSequence * obj)82 structseq_dealloc(PyStructSequence *obj)
83 {
84 Py_ssize_t i, size;
85 PyTypeObject *tp;
86 PyObject_GC_UnTrack(obj);
87
88 tp = (PyTypeObject *) Py_TYPE(obj);
89 size = REAL_SIZE(obj);
90 for (i = 0; i < size; ++i) {
91 Py_XDECREF(obj->ob_item[i]);
92 }
93 PyObject_GC_Del(obj);
94 if (PyType_GetFlags(tp) & Py_TPFLAGS_HEAPTYPE) {
95 Py_DECREF(tp);
96 }
97 }
98
99 /*[clinic input]
100 class structseq "PyStructSequence *" "NULL"
101 [clinic start generated code]*/
102 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=9d781c6922c77752]*/
103
104 #include "clinic/structseq.c.h"
105
106 /*[clinic input]
107 @classmethod
108 structseq.__new__ as structseq_new
109 sequence as arg: object
110 dict: object(c_default="NULL") = {}
111 [clinic start generated code]*/
112
113 static PyObject *
structseq_new_impl(PyTypeObject * type,PyObject * arg,PyObject * dict)114 structseq_new_impl(PyTypeObject *type, PyObject *arg, PyObject *dict)
115 /*[clinic end generated code: output=baa082e788b171da input=90532511101aa3fb]*/
116 {
117 PyObject *ob;
118 PyStructSequence *res = NULL;
119 Py_ssize_t len, min_len, max_len, i, n_unnamed_fields;
120
121 arg = PySequence_Fast(arg, "constructor requires a sequence");
122
123 if (!arg) {
124 return NULL;
125 }
126
127 if (dict && !PyDict_Check(dict)) {
128 PyErr_Format(PyExc_TypeError,
129 "%.500s() takes a dict as second arg, if any",
130 type->tp_name);
131 Py_DECREF(arg);
132 return NULL;
133 }
134
135 len = PySequence_Fast_GET_SIZE(arg);
136 min_len = VISIBLE_SIZE_TP(type);
137 max_len = REAL_SIZE_TP(type);
138 n_unnamed_fields = UNNAMED_FIELDS_TP(type);
139
140 if (min_len != max_len) {
141 if (len < min_len) {
142 PyErr_Format(PyExc_TypeError,
143 "%.500s() takes an at least %zd-sequence (%zd-sequence given)",
144 type->tp_name, min_len, len);
145 Py_DECREF(arg);
146 return NULL;
147 }
148
149 if (len > max_len) {
150 PyErr_Format(PyExc_TypeError,
151 "%.500s() takes an at most %zd-sequence (%zd-sequence given)",
152 type->tp_name, max_len, len);
153 Py_DECREF(arg);
154 return NULL;
155 }
156 }
157 else {
158 if (len != min_len) {
159 PyErr_Format(PyExc_TypeError,
160 "%.500s() takes a %zd-sequence (%zd-sequence given)",
161 type->tp_name, min_len, len);
162 Py_DECREF(arg);
163 return NULL;
164 }
165 }
166
167 res = (PyStructSequence*) PyStructSequence_New(type);
168 if (res == NULL) {
169 Py_DECREF(arg);
170 return NULL;
171 }
172 for (i = 0; i < len; ++i) {
173 PyObject *v = PySequence_Fast_GET_ITEM(arg, i);
174 Py_INCREF(v);
175 res->ob_item[i] = v;
176 }
177 for (; i < max_len; ++i) {
178 if (dict && (ob = PyDict_GetItemString(
179 dict, type->tp_members[i-n_unnamed_fields].name))) {
180 }
181 else {
182 ob = Py_None;
183 }
184 Py_INCREF(ob);
185 res->ob_item[i] = ob;
186 }
187
188 Py_DECREF(arg);
189 _PyObject_GC_TRACK(res);
190 return (PyObject*) res;
191 }
192
193
194 static PyObject *
structseq_repr(PyStructSequence * obj)195 structseq_repr(PyStructSequence *obj)
196 {
197 PyTypeObject *typ = Py_TYPE(obj);
198 _PyUnicodeWriter writer;
199
200 /* Write "typename(" */
201 PyObject *type_name = PyUnicode_DecodeUTF8(typ->tp_name,
202 strlen(typ->tp_name),
203 NULL);
204 if (type_name == NULL) {
205 return NULL;
206 }
207
208 _PyUnicodeWriter_Init(&writer);
209 writer.overallocate = 1;
210 /* count 5 characters per item: "x=1, " */
211 writer.min_length = (PyUnicode_GET_LENGTH(type_name) + 1
212 + VISIBLE_SIZE(obj) * 5 + 1);
213
214 if (_PyUnicodeWriter_WriteStr(&writer, type_name) < 0) {
215 Py_DECREF(type_name);
216 goto error;
217 }
218 Py_DECREF(type_name);
219
220 if (_PyUnicodeWriter_WriteChar(&writer, '(') < 0) {
221 goto error;
222 }
223
224 for (Py_ssize_t i=0; i < VISIBLE_SIZE(obj); i++) {
225 if (i > 0) {
226 /* Write ", " */
227 if (_PyUnicodeWriter_WriteASCIIString(&writer, ", ", 2) < 0) {
228 goto error;
229 }
230 }
231
232 /* Write "name=repr" */
233 const char *name_utf8 = typ->tp_members[i].name;
234 if (name_utf8 == NULL) {
235 PyErr_Format(PyExc_SystemError, "In structseq_repr(), member %zd name is NULL"
236 " for type %.500s", i, typ->tp_name);
237 goto error;
238 }
239
240 PyObject *name = PyUnicode_DecodeUTF8(name_utf8, strlen(name_utf8), NULL);
241 if (name == NULL) {
242 goto error;
243 }
244 if (_PyUnicodeWriter_WriteStr(&writer, name) < 0) {
245 Py_DECREF(name);
246 goto error;
247 }
248 Py_DECREF(name);
249
250 if (_PyUnicodeWriter_WriteChar(&writer, '=') < 0) {
251 goto error;
252 }
253
254 PyObject *value = PyStructSequence_GET_ITEM(obj, i);
255 assert(value != NULL);
256 PyObject *repr = PyObject_Repr(value);
257 if (repr == NULL) {
258 goto error;
259 }
260 if (_PyUnicodeWriter_WriteStr(&writer, repr) < 0) {
261 Py_DECREF(repr);
262 goto error;
263 }
264 Py_DECREF(repr);
265 }
266
267 if (_PyUnicodeWriter_WriteChar(&writer, ')') < 0) {
268 goto error;
269 }
270
271 return _PyUnicodeWriter_Finish(&writer);
272
273 error:
274 _PyUnicodeWriter_Dealloc(&writer);
275 return NULL;
276 }
277
278
279 static PyObject *
structseq_reduce(PyStructSequence * self,PyObject * Py_UNUSED (ignored))280 structseq_reduce(PyStructSequence* self, PyObject *Py_UNUSED(ignored))
281 {
282 PyObject* tup = NULL;
283 PyObject* dict = NULL;
284 PyObject* result;
285 Py_ssize_t n_fields, n_visible_fields, n_unnamed_fields, i;
286
287 n_fields = REAL_SIZE(self);
288 n_visible_fields = VISIBLE_SIZE(self);
289 n_unnamed_fields = UNNAMED_FIELDS(self);
290 tup = _PyTuple_FromArray(self->ob_item, n_visible_fields);
291 if (!tup)
292 goto error;
293
294 dict = PyDict_New();
295 if (!dict)
296 goto error;
297
298 for (i = n_visible_fields; i < n_fields; i++) {
299 const char *n = Py_TYPE(self)->tp_members[i-n_unnamed_fields].name;
300 if (PyDict_SetItemString(dict, n, self->ob_item[i]) < 0)
301 goto error;
302 }
303
304 result = Py_BuildValue("(O(OO))", Py_TYPE(self), tup, dict);
305
306 Py_DECREF(tup);
307 Py_DECREF(dict);
308
309 return result;
310
311 error:
312 Py_XDECREF(tup);
313 Py_XDECREF(dict);
314 return NULL;
315 }
316
317 static PyMethodDef structseq_methods[] = {
318 {"__reduce__", (PyCFunction)structseq_reduce, METH_NOARGS, NULL},
319 {NULL, NULL}
320 };
321
322 static Py_ssize_t
count_members(PyStructSequence_Desc * desc,Py_ssize_t * n_unnamed_members)323 count_members(PyStructSequence_Desc *desc, Py_ssize_t *n_unnamed_members) {
324 Py_ssize_t i;
325
326 *n_unnamed_members = 0;
327 for (i = 0; desc->fields[i].name != NULL; ++i) {
328 if (desc->fields[i].name == PyStructSequence_UnnamedField) {
329 (*n_unnamed_members)++;
330 }
331 }
332 return i;
333 }
334
335 static int
initialize_structseq_dict(PyStructSequence_Desc * desc,PyObject * dict,Py_ssize_t n_members,Py_ssize_t n_unnamed_members)336 initialize_structseq_dict(PyStructSequence_Desc *desc, PyObject* dict,
337 Py_ssize_t n_members, Py_ssize_t n_unnamed_members) {
338 PyObject *v;
339
340 #define SET_DICT_FROM_SIZE(key, value) \
341 do { \
342 v = PyLong_FromSsize_t(value); \
343 if (v == NULL) { \
344 return -1; \
345 } \
346 if (PyDict_SetItemString(dict, key, v) < 0) { \
347 Py_DECREF(v); \
348 return -1; \
349 } \
350 Py_DECREF(v); \
351 } while (0)
352
353 SET_DICT_FROM_SIZE(visible_length_key, desc->n_in_sequence);
354 SET_DICT_FROM_SIZE(real_length_key, n_members);
355 SET_DICT_FROM_SIZE(unnamed_fields_key, n_unnamed_members);
356 return 0;
357 }
358
359 static void
initialize_members(PyStructSequence_Desc * desc,PyMemberDef * members,Py_ssize_t n_members)360 initialize_members(PyStructSequence_Desc *desc, PyMemberDef* members,
361 Py_ssize_t n_members) {
362 Py_ssize_t i, k;
363
364 for (i = k = 0; i < n_members; ++i) {
365 if (desc->fields[i].name == PyStructSequence_UnnamedField) {
366 continue;
367 }
368
369 /* The names and docstrings in these MemberDefs are statically */
370 /* allocated so it is expected that they'll outlive the MemberDef */
371 members[k].name = desc->fields[i].name;
372 members[k].type = T_OBJECT;
373 members[k].offset = offsetof(PyStructSequence, ob_item)
374 + i * sizeof(PyObject*);
375 members[k].flags = READONLY;
376 members[k].doc = desc->fields[i].doc;
377 k++;
378 }
379 members[k].name = NULL;
380 }
381
382 int
PyStructSequence_InitType2(PyTypeObject * type,PyStructSequence_Desc * desc)383 PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc)
384 {
385 PyMemberDef *members;
386 Py_ssize_t n_members, n_unnamed_members;
387
388 #ifdef Py_TRACE_REFS
389 /* if the type object was chained, unchain it first
390 before overwriting its storage */
391 if (type->ob_base.ob_base._ob_next) {
392 _Py_ForgetReference((PyObject *)type);
393 }
394 #endif
395
396 /* PyTypeObject has already been initialized */
397 if (Py_REFCNT(type) != 0) {
398 PyErr_BadInternalCall();
399 return -1;
400 }
401
402 type->tp_name = desc->name;
403 type->tp_basicsize = sizeof(PyStructSequence) - sizeof(PyObject *);
404 type->tp_itemsize = sizeof(PyObject *);
405 type->tp_dealloc = (destructor)structseq_dealloc;
406 type->tp_repr = (reprfunc)structseq_repr;
407 type->tp_doc = desc->doc;
408 type->tp_base = &PyTuple_Type;
409 type->tp_methods = structseq_methods;
410 type->tp_new = structseq_new;
411 type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC;
412 type->tp_traverse = (traverseproc) structseq_traverse;
413
414 n_members = count_members(desc, &n_unnamed_members);
415 members = PyMem_NEW(PyMemberDef, n_members - n_unnamed_members + 1);
416 if (members == NULL) {
417 PyErr_NoMemory();
418 return -1;
419 }
420 initialize_members(desc, members, n_members);
421 type->tp_members = members;
422
423 if (PyType_Ready(type) < 0) {
424 PyMem_FREE(members);
425 return -1;
426 }
427 Py_INCREF(type);
428
429 if (initialize_structseq_dict(
430 desc, type->tp_dict, n_members, n_unnamed_members) < 0) {
431 PyMem_FREE(members);
432 Py_DECREF(type);
433 return -1;
434 }
435
436 return 0;
437 }
438
439 void
PyStructSequence_InitType(PyTypeObject * type,PyStructSequence_Desc * desc)440 PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc)
441 {
442 (void)PyStructSequence_InitType2(type, desc);
443 }
444
445 PyTypeObject *
PyStructSequence_NewType(PyStructSequence_Desc * desc)446 PyStructSequence_NewType(PyStructSequence_Desc *desc)
447 {
448 PyMemberDef *members;
449 PyObject *bases;
450 PyTypeObject *type;
451 PyType_Slot slots[8];
452 PyType_Spec spec;
453 Py_ssize_t n_members, n_unnamed_members;
454
455 /* Initialize MemberDefs */
456 n_members = count_members(desc, &n_unnamed_members);
457 members = PyMem_NEW(PyMemberDef, n_members - n_unnamed_members + 1);
458 if (members == NULL) {
459 PyErr_NoMemory();
460 return NULL;
461 }
462 initialize_members(desc, members, n_members);
463
464 /* Initialize Slots */
465 slots[0] = (PyType_Slot){Py_tp_dealloc, (destructor)structseq_dealloc};
466 slots[1] = (PyType_Slot){Py_tp_repr, (reprfunc)structseq_repr};
467 slots[2] = (PyType_Slot){Py_tp_doc, (void *)desc->doc};
468 slots[3] = (PyType_Slot){Py_tp_methods, structseq_methods};
469 slots[4] = (PyType_Slot){Py_tp_new, structseq_new};
470 slots[5] = (PyType_Slot){Py_tp_members, members};
471 slots[6] = (PyType_Slot){Py_tp_traverse, (traverseproc)structseq_traverse};
472 slots[7] = (PyType_Slot){0, 0};
473
474 /* Initialize Spec */
475 /* The name in this PyType_Spec is statically allocated so it is */
476 /* expected that it'll outlive the PyType_Spec */
477 spec.name = desc->name;
478 spec.basicsize = sizeof(PyStructSequence) - sizeof(PyObject *);
479 spec.itemsize = sizeof(PyObject *);
480 spec.flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC;
481 spec.slots = slots;
482
483 bases = PyTuple_Pack(1, &PyTuple_Type);
484 if (bases == NULL) {
485 PyMem_FREE(members);
486 return NULL;
487 }
488 type = (PyTypeObject *)PyType_FromSpecWithBases(&spec, bases);
489 Py_DECREF(bases);
490 PyMem_FREE(members);
491 if (type == NULL) {
492 return NULL;
493 }
494
495 if (initialize_structseq_dict(
496 desc, type->tp_dict, n_members, n_unnamed_members) < 0) {
497 Py_DECREF(type);
498 return NULL;
499 }
500
501 return type;
502 }
503
_PyStructSequence_Init(void)504 int _PyStructSequence_Init(void)
505 {
506 if (_PyUnicode_FromId(&PyId_n_sequence_fields) == NULL
507 || _PyUnicode_FromId(&PyId_n_fields) == NULL
508 || _PyUnicode_FromId(&PyId_n_unnamed_fields) == NULL)
509 return -1;
510
511 return 0;
512 }
513