Raymond Hettinger | 4210ad5 | 2019-09-12 07:56:28 -0700 | [diff] [blame] | 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 | */ |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 9 | |
| 10 | #include "Python.h" |
Victor Stinner | 384621c | 2020-06-22 17:27:35 +0200 | [diff] [blame] | 11 | #include "pycore_tuple.h" // _PyTuple_FromArray() |
| 12 | #include "pycore_object.h" // _PyObject_GC_TRACK() |
Victor Stinner | 4a21e57 | 2020-04-15 02:35:41 +0200 | [diff] [blame] | 13 | #include "structmember.h" // PyMemberDef |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 14 | |
Serhiy Storchaka | 2d06e84 | 2015-12-25 19:53:18 +0200 | [diff] [blame] | 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"; |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 18 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 19 | /* Fields with this name have only a field index, not a field name. |
Martin v. Löwis | f607bda | 2002-10-16 18:27:39 +0000 | [diff] [blame] | 20 | They are only allowed for indices < n_visible_fields. */ |
Serhiy Storchaka | bd44a7e | 2019-11-16 18:55:29 +0200 | [diff] [blame] | 21 | const char * const PyStructSequence_UnnamedField = "unnamed field"; |
Serhiy Storchaka | fb5db7e | 2020-10-26 08:43:39 +0200 | [diff] [blame] | 22 | |
Victor Stinner | 26f9199 | 2013-07-17 01:22:45 +0200 | [diff] [blame] | 23 | _Py_IDENTIFIER(n_sequence_fields); |
| 24 | _Py_IDENTIFIER(n_fields); |
| 25 | _Py_IDENTIFIER(n_unnamed_fields); |
Martin v. Löwis | f607bda | 2002-10-16 18:27:39 +0000 | [diff] [blame] | 26 | |
Serhiy Storchaka | fb5db7e | 2020-10-26 08:43:39 +0200 | [diff] [blame] | 27 | static ssize_t |
| 28 | get_type_attr_as_size(PyTypeObject *tp, _Py_Identifier *id) |
| 29 | { |
| 30 | PyObject *name = _PyUnicode_FromId(id); |
| 31 | if (name == NULL) { |
| 32 | return -1; |
| 33 | } |
| 34 | PyObject *v = PyDict_GetItemWithError(tp->tp_dict, name); |
| 35 | if (v == NULL && !PyErr_Occurred()) { |
| 36 | PyErr_Format(PyExc_TypeError, |
| 37 | "Missed attribute '%U' of type %s", |
| 38 | name, tp->tp_name); |
| 39 | } |
| 40 | return PyLong_AsSsize_t(v); |
| 41 | } |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 42 | |
Serhiy Storchaka | fb5db7e | 2020-10-26 08:43:39 +0200 | [diff] [blame] | 43 | #define VISIBLE_SIZE(op) Py_SIZE(op) |
| 44 | #define VISIBLE_SIZE_TP(tp) get_type_attr_as_size(tp, &PyId_n_sequence_fields) |
| 45 | #define REAL_SIZE_TP(tp) get_type_attr_as_size(tp, &PyId_n_fields) |
Christian Heimes | 90aa764 | 2007-12-19 02:45:37 +0000 | [diff] [blame] | 46 | #define REAL_SIZE(op) REAL_SIZE_TP(Py_TYPE(op)) |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 47 | |
Serhiy Storchaka | fb5db7e | 2020-10-26 08:43:39 +0200 | [diff] [blame] | 48 | #define UNNAMED_FIELDS_TP(tp) get_type_attr_as_size(tp, &PyId_n_unnamed_fields) |
Christian Heimes | 90aa764 | 2007-12-19 02:45:37 +0000 | [diff] [blame] | 49 | #define UNNAMED_FIELDS(op) UNNAMED_FIELDS_TP(Py_TYPE(op)) |
Martin v. Löwis | ceaa77c | 2002-10-16 19:10:03 +0000 | [diff] [blame] | 50 | |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 51 | |
| 52 | PyObject * |
| 53 | PyStructSequence_New(PyTypeObject *type) |
| 54 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 55 | PyStructSequence *obj; |
Benjamin Peterson | ccabcd4 | 2010-07-07 20:54:01 +0000 | [diff] [blame] | 56 | Py_ssize_t size = REAL_SIZE_TP(type), i; |
Serhiy Storchaka | fb5db7e | 2020-10-26 08:43:39 +0200 | [diff] [blame] | 57 | if (size < 0) { |
| 58 | return NULL; |
| 59 | } |
| 60 | Py_ssize_t vsize = VISIBLE_SIZE_TP(type); |
| 61 | if (vsize < 0) { |
| 62 | return NULL; |
| 63 | } |
Christian Heimes | d32ed6f | 2008-01-14 18:49:24 +0000 | [diff] [blame] | 64 | |
Benjamin Peterson | ccabcd4 | 2010-07-07 20:54:01 +0000 | [diff] [blame] | 65 | obj = PyObject_GC_NewVar(PyStructSequence, type, size); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 66 | if (obj == NULL) |
| 67 | return NULL; |
Benjamin Peterson | d02441e | 2010-07-08 22:33:03 +0000 | [diff] [blame] | 68 | /* Hack the size of the variable object, so invisible fields don't appear |
| 69 | to Python code. */ |
Serhiy Storchaka | fb5db7e | 2020-10-26 08:43:39 +0200 | [diff] [blame] | 70 | Py_SET_SIZE(obj, vsize); |
Benjamin Peterson | ccabcd4 | 2010-07-07 20:54:01 +0000 | [diff] [blame] | 71 | for (i = 0; i < size; i++) |
| 72 | obj->ob_item[i] = NULL; |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 73 | |
Benjamin Peterson | ccabcd4 | 2010-07-07 20:54:01 +0000 | [diff] [blame] | 74 | return (PyObject*)obj; |
Thomas Wouters | ed03b41 | 2007-08-28 21:37:11 +0000 | [diff] [blame] | 75 | } |
| 76 | |
Martin v. Löwis | 4d0d471 | 2010-12-03 20:14:31 +0000 | [diff] [blame] | 77 | void |
| 78 | PyStructSequence_SetItem(PyObject* op, Py_ssize_t i, PyObject* v) |
| 79 | { |
| 80 | PyStructSequence_SET_ITEM(op, i, v); |
| 81 | } |
| 82 | |
| 83 | PyObject* |
| 84 | PyStructSequence_GetItem(PyObject* op, Py_ssize_t i) |
| 85 | { |
| 86 | return PyStructSequence_GET_ITEM(op, i); |
| 87 | } |
| 88 | |
Pablo Galindo | 7ffcf84 | 2019-06-02 15:45:13 +0100 | [diff] [blame] | 89 | |
| 90 | static int |
| 91 | structseq_traverse(PyStructSequence *obj, visitproc visit, void *arg) |
| 92 | { |
Pablo Galindo | 1cf15af | 2020-05-27 10:03:38 +0100 | [diff] [blame] | 93 | if (Py_TYPE(obj)->tp_flags & Py_TPFLAGS_HEAPTYPE) { |
| 94 | Py_VISIT(Py_TYPE(obj)); |
| 95 | } |
Pablo Galindo | 7ffcf84 | 2019-06-02 15:45:13 +0100 | [diff] [blame] | 96 | Py_ssize_t i, size; |
| 97 | size = REAL_SIZE(obj); |
| 98 | for (i = 0; i < size; ++i) { |
| 99 | Py_VISIT(obj->ob_item[i]); |
| 100 | } |
| 101 | return 0; |
| 102 | } |
| 103 | |
Benjamin Peterson | d02441e | 2010-07-08 22:33:03 +0000 | [diff] [blame] | 104 | static void |
| 105 | structseq_dealloc(PyStructSequence *obj) |
| 106 | { |
| 107 | Py_ssize_t i, size; |
Eddie Elizondo | 364f0b0 | 2019-03-27 07:52:18 -0400 | [diff] [blame] | 108 | PyTypeObject *tp; |
Pablo Galindo | 3caf4de | 2019-06-02 21:52:49 +0100 | [diff] [blame] | 109 | PyObject_GC_UnTrack(obj); |
Victor Stinner | 26f9199 | 2013-07-17 01:22:45 +0200 | [diff] [blame] | 110 | |
Eddie Elizondo | 364f0b0 | 2019-03-27 07:52:18 -0400 | [diff] [blame] | 111 | tp = (PyTypeObject *) Py_TYPE(obj); |
Benjamin Peterson | d02441e | 2010-07-08 22:33:03 +0000 | [diff] [blame] | 112 | size = REAL_SIZE(obj); |
| 113 | for (i = 0; i < size; ++i) { |
| 114 | Py_XDECREF(obj->ob_item[i]); |
| 115 | } |
| 116 | PyObject_GC_Del(obj); |
Victor Stinner | 97d15ae | 2020-09-23 14:08:38 +0200 | [diff] [blame] | 117 | if (_PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE)) { |
Eddie Elizondo | 364f0b0 | 2019-03-27 07:52:18 -0400 | [diff] [blame] | 118 | Py_DECREF(tp); |
| 119 | } |
Benjamin Peterson | d02441e | 2010-07-08 22:33:03 +0000 | [diff] [blame] | 120 | } |
| 121 | |
Serhiy Storchaka | 18b250f | 2017-03-19 08:51:07 +0200 | [diff] [blame] | 122 | /*[clinic input] |
| 123 | class structseq "PyStructSequence *" "NULL" |
| 124 | [clinic start generated code]*/ |
| 125 | /*[clinic end generated code: output=da39a3ee5e6b4b0d input=9d781c6922c77752]*/ |
| 126 | |
| 127 | #include "clinic/structseq.c.h" |
| 128 | |
| 129 | /*[clinic input] |
| 130 | @classmethod |
| 131 | structseq.__new__ as structseq_new |
| 132 | sequence as arg: object |
Serhiy Storchaka | 279f446 | 2019-09-14 12:24:05 +0300 | [diff] [blame] | 133 | dict: object(c_default="NULL") = {} |
Serhiy Storchaka | 18b250f | 2017-03-19 08:51:07 +0200 | [diff] [blame] | 134 | [clinic start generated code]*/ |
| 135 | |
Thomas Wouters | ed03b41 | 2007-08-28 21:37:11 +0000 | [diff] [blame] | 136 | static PyObject * |
Serhiy Storchaka | 18b250f | 2017-03-19 08:51:07 +0200 | [diff] [blame] | 137 | structseq_new_impl(PyTypeObject *type, PyObject *arg, PyObject *dict) |
Serhiy Storchaka | 279f446 | 2019-09-14 12:24:05 +0300 | [diff] [blame] | 138 | /*[clinic end generated code: output=baa082e788b171da input=90532511101aa3fb]*/ |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 139 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 140 | PyObject *ob; |
| 141 | PyStructSequence *res = NULL; |
| 142 | Py_ssize_t len, min_len, max_len, i, n_unnamed_fields; |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 143 | |
Serhiy Storchaka | fb5db7e | 2020-10-26 08:43:39 +0200 | [diff] [blame] | 144 | min_len = VISIBLE_SIZE_TP(type); |
| 145 | if (min_len < 0) { |
| 146 | return NULL; |
| 147 | } |
| 148 | max_len = REAL_SIZE_TP(type); |
| 149 | if (max_len < 0) { |
| 150 | return NULL; |
| 151 | } |
| 152 | n_unnamed_fields = UNNAMED_FIELDS_TP(type); |
| 153 | if (n_unnamed_fields < 0) { |
| 154 | return NULL; |
| 155 | } |
| 156 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 157 | arg = PySequence_Fast(arg, "constructor requires a sequence"); |
Michael W. Hudson | ce358e3 | 2002-03-06 17:07:49 +0000 | [diff] [blame] | 158 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 159 | if (!arg) { |
| 160 | return NULL; |
| 161 | } |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 162 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 163 | if (dict && !PyDict_Check(dict)) { |
| 164 | PyErr_Format(PyExc_TypeError, |
| 165 | "%.500s() takes a dict as second arg, if any", |
| 166 | type->tp_name); |
| 167 | Py_DECREF(arg); |
| 168 | return NULL; |
| 169 | } |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 170 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 171 | len = PySequence_Fast_GET_SIZE(arg); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 172 | if (min_len != max_len) { |
| 173 | if (len < min_len) { |
| 174 | PyErr_Format(PyExc_TypeError, |
Antoine Pitrou | 4b3c784 | 2012-02-15 02:52:58 +0100 | [diff] [blame] | 175 | "%.500s() takes an at least %zd-sequence (%zd-sequence given)", |
| 176 | type->tp_name, min_len, len); |
| 177 | Py_DECREF(arg); |
| 178 | return NULL; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 179 | } |
Michael W. Hudson | ce358e3 | 2002-03-06 17:07:49 +0000 | [diff] [blame] | 180 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 181 | if (len > max_len) { |
| 182 | PyErr_Format(PyExc_TypeError, |
Antoine Pitrou | 4b3c784 | 2012-02-15 02:52:58 +0100 | [diff] [blame] | 183 | "%.500s() takes an at most %zd-sequence (%zd-sequence given)", |
| 184 | type->tp_name, max_len, len); |
| 185 | Py_DECREF(arg); |
| 186 | return NULL; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 187 | } |
| 188 | } |
| 189 | else { |
| 190 | if (len != min_len) { |
| 191 | PyErr_Format(PyExc_TypeError, |
Antoine Pitrou | 4b3c784 | 2012-02-15 02:52:58 +0100 | [diff] [blame] | 192 | "%.500s() takes a %zd-sequence (%zd-sequence given)", |
| 193 | type->tp_name, min_len, len); |
| 194 | Py_DECREF(arg); |
| 195 | return NULL; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 196 | } |
| 197 | } |
Michael W. Hudson | ce358e3 | 2002-03-06 17:07:49 +0000 | [diff] [blame] | 198 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 199 | res = (PyStructSequence*) PyStructSequence_New(type); |
| 200 | if (res == NULL) { |
Antoine Pitrou | 37784ba | 2012-02-15 02:51:43 +0100 | [diff] [blame] | 201 | Py_DECREF(arg); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 202 | return NULL; |
| 203 | } |
| 204 | for (i = 0; i < len; ++i) { |
| 205 | PyObject *v = PySequence_Fast_GET_ITEM(arg, i); |
| 206 | Py_INCREF(v); |
| 207 | res->ob_item[i] = v; |
| 208 | } |
Serhiy Storchaka | fb5db7e | 2020-10-26 08:43:39 +0200 | [diff] [blame] | 209 | Py_DECREF(arg); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 210 | for (; i < max_len; ++i) { |
Serhiy Storchaka | fb5db7e | 2020-10-26 08:43:39 +0200 | [diff] [blame] | 211 | if (dict == NULL) { |
| 212 | ob = Py_None; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 213 | } |
| 214 | else { |
Serhiy Storchaka | fb5db7e | 2020-10-26 08:43:39 +0200 | [diff] [blame] | 215 | ob = _PyDict_GetItemStringWithError(dict, |
| 216 | type->tp_members[i-n_unnamed_fields].name); |
| 217 | if (ob == NULL) { |
| 218 | if (PyErr_Occurred()) { |
| 219 | Py_DECREF(res); |
| 220 | return NULL; |
| 221 | } |
| 222 | ob = Py_None; |
| 223 | } |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 224 | } |
| 225 | Py_INCREF(ob); |
| 226 | res->ob_item[i] = ob; |
| 227 | } |
| 228 | |
Pablo Galindo | 7ffcf84 | 2019-06-02 15:45:13 +0100 | [diff] [blame] | 229 | _PyObject_GC_TRACK(res); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 230 | return (PyObject*) res; |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 231 | } |
| 232 | |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 233 | |
| 234 | static PyObject * |
| 235 | structseq_repr(PyStructSequence *obj) |
| 236 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 237 | PyTypeObject *typ = Py_TYPE(obj); |
Victor Stinner | c70ab02 | 2019-03-20 00:05:51 +0100 | [diff] [blame] | 238 | _PyUnicodeWriter writer; |
Christian Heimes | d32ed6f | 2008-01-14 18:49:24 +0000 | [diff] [blame] | 239 | |
Victor Stinner | c70ab02 | 2019-03-20 00:05:51 +0100 | [diff] [blame] | 240 | /* Write "typename(" */ |
| 241 | PyObject *type_name = PyUnicode_DecodeUTF8(typ->tp_name, |
| 242 | strlen(typ->tp_name), |
| 243 | NULL); |
| 244 | if (type_name == NULL) { |
Zackery Spytz | 93e8012 | 2019-03-22 01:24:34 -0600 | [diff] [blame] | 245 | return NULL; |
Victor Stinner | c70ab02 | 2019-03-20 00:05:51 +0100 | [diff] [blame] | 246 | } |
Christian Heimes | d32ed6f | 2008-01-14 18:49:24 +0000 | [diff] [blame] | 247 | |
Victor Stinner | c70ab02 | 2019-03-20 00:05:51 +0100 | [diff] [blame] | 248 | _PyUnicodeWriter_Init(&writer); |
| 249 | writer.overallocate = 1; |
| 250 | /* count 5 characters per item: "x=1, " */ |
| 251 | writer.min_length = (PyUnicode_GET_LENGTH(type_name) + 1 |
| 252 | + VISIBLE_SIZE(obj) * 5 + 1); |
Christian Heimes | d32ed6f | 2008-01-14 18:49:24 +0000 | [diff] [blame] | 253 | |
Victor Stinner | c70ab02 | 2019-03-20 00:05:51 +0100 | [diff] [blame] | 254 | if (_PyUnicodeWriter_WriteStr(&writer, type_name) < 0) { |
| 255 | Py_DECREF(type_name); |
| 256 | goto error; |
| 257 | } |
| 258 | Py_DECREF(type_name); |
Christian Heimes | d32ed6f | 2008-01-14 18:49:24 +0000 | [diff] [blame] | 259 | |
Victor Stinner | c70ab02 | 2019-03-20 00:05:51 +0100 | [diff] [blame] | 260 | if (_PyUnicodeWriter_WriteChar(&writer, '(') < 0) { |
| 261 | goto error; |
| 262 | } |
| 263 | |
| 264 | for (Py_ssize_t i=0; i < VISIBLE_SIZE(obj); i++) { |
| 265 | if (i > 0) { |
| 266 | /* Write ", " */ |
| 267 | if (_PyUnicodeWriter_WriteASCIIString(&writer, ", ", 2) < 0) { |
| 268 | goto error; |
| 269 | } |
| 270 | } |
| 271 | |
| 272 | /* Write "name=repr" */ |
| 273 | const char *name_utf8 = typ->tp_members[i].name; |
| 274 | if (name_utf8 == NULL) { |
Serhiy Storchaka | d53fe5f | 2019-03-13 22:59:55 +0200 | [diff] [blame] | 275 | PyErr_Format(PyExc_SystemError, "In structseq_repr(), member %zd name is NULL" |
Benjamin Peterson | d02441e | 2010-07-08 22:33:03 +0000 | [diff] [blame] | 276 | " for type %.500s", i, typ->tp_name); |
Victor Stinner | c70ab02 | 2019-03-20 00:05:51 +0100 | [diff] [blame] | 277 | goto error; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 278 | } |
| 279 | |
Victor Stinner | c70ab02 | 2019-03-20 00:05:51 +0100 | [diff] [blame] | 280 | PyObject *name = PyUnicode_DecodeUTF8(name_utf8, strlen(name_utf8), NULL); |
| 281 | if (name == NULL) { |
| 282 | goto error; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 283 | } |
Victor Stinner | c70ab02 | 2019-03-20 00:05:51 +0100 | [diff] [blame] | 284 | if (_PyUnicodeWriter_WriteStr(&writer, name) < 0) { |
| 285 | Py_DECREF(name); |
| 286 | goto error; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 287 | } |
Victor Stinner | c70ab02 | 2019-03-20 00:05:51 +0100 | [diff] [blame] | 288 | Py_DECREF(name); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 289 | |
Victor Stinner | c70ab02 | 2019-03-20 00:05:51 +0100 | [diff] [blame] | 290 | if (_PyUnicodeWriter_WriteChar(&writer, '=') < 0) { |
| 291 | goto error; |
| 292 | } |
| 293 | |
| 294 | PyObject *value = PyStructSequence_GET_ITEM(obj, i); |
| 295 | assert(value != NULL); |
| 296 | PyObject *repr = PyObject_Repr(value); |
| 297 | if (repr == NULL) { |
| 298 | goto error; |
| 299 | } |
| 300 | if (_PyUnicodeWriter_WriteStr(&writer, repr) < 0) { |
| 301 | Py_DECREF(repr); |
| 302 | goto error; |
| 303 | } |
| 304 | Py_DECREF(repr); |
| 305 | } |
| 306 | |
| 307 | if (_PyUnicodeWriter_WriteChar(&writer, ')') < 0) { |
| 308 | goto error; |
| 309 | } |
| 310 | |
| 311 | return _PyUnicodeWriter_Finish(&writer); |
| 312 | |
| 313 | error: |
| 314 | _PyUnicodeWriter_Dealloc(&writer); |
| 315 | return NULL; |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 316 | } |
| 317 | |
Victor Stinner | c70ab02 | 2019-03-20 00:05:51 +0100 | [diff] [blame] | 318 | |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 319 | static PyObject * |
Siddhesh Poyarekar | 55edd0c | 2018-04-30 00:29:33 +0530 | [diff] [blame] | 320 | structseq_reduce(PyStructSequence* self, PyObject *Py_UNUSED(ignored)) |
Michael W. Hudson | 7bb466a | 2002-03-05 13:27:58 +0000 | [diff] [blame] | 321 | { |
Victor Stinner | 9a146ee | 2013-07-17 13:41:39 +0200 | [diff] [blame] | 322 | PyObject* tup = NULL; |
| 323 | PyObject* dict = NULL; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 324 | PyObject* result; |
Serhiy Storchaka | 56f6e76 | 2015-09-06 21:25:30 +0300 | [diff] [blame] | 325 | Py_ssize_t n_fields, n_visible_fields, n_unnamed_fields, i; |
Michael W. Hudson | 7bb466a | 2002-03-05 13:27:58 +0000 | [diff] [blame] | 326 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 327 | n_fields = REAL_SIZE(self); |
Serhiy Storchaka | fb5db7e | 2020-10-26 08:43:39 +0200 | [diff] [blame] | 328 | if (n_fields < 0) { |
| 329 | return NULL; |
| 330 | } |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 331 | n_visible_fields = VISIBLE_SIZE(self); |
| 332 | n_unnamed_fields = UNNAMED_FIELDS(self); |
Serhiy Storchaka | fb5db7e | 2020-10-26 08:43:39 +0200 | [diff] [blame] | 333 | if (n_unnamed_fields < 0) { |
| 334 | return NULL; |
| 335 | } |
Sergey Fedoseev | 234531b | 2019-02-25 21:59:12 +0500 | [diff] [blame] | 336 | tup = _PyTuple_FromArray(self->ob_item, n_visible_fields); |
Victor Stinner | 9a146ee | 2013-07-17 13:41:39 +0200 | [diff] [blame] | 337 | if (!tup) |
| 338 | goto error; |
Michael W. Hudson | ce358e3 | 2002-03-06 17:07:49 +0000 | [diff] [blame] | 339 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 340 | dict = PyDict_New(); |
Victor Stinner | 9a146ee | 2013-07-17 13:41:39 +0200 | [diff] [blame] | 341 | if (!dict) |
| 342 | goto error; |
Michael W. Hudson | ce358e3 | 2002-03-06 17:07:49 +0000 | [diff] [blame] | 343 | |
Sergey Fedoseev | 234531b | 2019-02-25 21:59:12 +0500 | [diff] [blame] | 344 | for (i = n_visible_fields; i < n_fields; i++) { |
Serhiy Storchaka | 007d7ff | 2016-11-22 07:58:08 +0200 | [diff] [blame] | 345 | const char *n = Py_TYPE(self)->tp_members[i-n_unnamed_fields].name; |
Victor Stinner | 9a146ee | 2013-07-17 13:41:39 +0200 | [diff] [blame] | 346 | if (PyDict_SetItemString(dict, n, self->ob_item[i]) < 0) |
| 347 | goto error; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 348 | } |
Michael W. Hudson | 70ffddf | 2002-03-07 15:13:40 +0000 | [diff] [blame] | 349 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 350 | result = Py_BuildValue("(O(OO))", Py_TYPE(self), tup, dict); |
| 351 | |
| 352 | Py_DECREF(tup); |
| 353 | Py_DECREF(dict); |
| 354 | |
| 355 | return result; |
Victor Stinner | 9a146ee | 2013-07-17 13:41:39 +0200 | [diff] [blame] | 356 | |
| 357 | error: |
| 358 | Py_XDECREF(tup); |
| 359 | Py_XDECREF(dict); |
| 360 | return NULL; |
Michael W. Hudson | 7bb466a | 2002-03-05 13:27:58 +0000 | [diff] [blame] | 361 | } |
| 362 | |
Michael W. Hudson | 7bb466a | 2002-03-05 13:27:58 +0000 | [diff] [blame] | 363 | static PyMethodDef structseq_methods[] = { |
Benjamin Peterson | ccabcd4 | 2010-07-07 20:54:01 +0000 | [diff] [blame] | 364 | {"__reduce__", (PyCFunction)structseq_reduce, METH_NOARGS, NULL}, |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 365 | {NULL, NULL} |
Michael W. Hudson | 7bb466a | 2002-03-05 13:27:58 +0000 | [diff] [blame] | 366 | }; |
| 367 | |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 368 | static Py_ssize_t |
| 369 | count_members(PyStructSequence_Desc *desc, Py_ssize_t *n_unnamed_members) { |
| 370 | Py_ssize_t i; |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 371 | |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 372 | *n_unnamed_members = 0; |
| 373 | for (i = 0; desc->fields[i].name != NULL; ++i) { |
| 374 | if (desc->fields[i].name == PyStructSequence_UnnamedField) { |
| 375 | (*n_unnamed_members)++; |
| 376 | } |
| 377 | } |
| 378 | return i; |
| 379 | } |
| 380 | |
| 381 | static int |
| 382 | initialize_structseq_dict(PyStructSequence_Desc *desc, PyObject* dict, |
| 383 | Py_ssize_t n_members, Py_ssize_t n_unnamed_members) { |
Victor Stinner | 1c8f059 | 2013-07-22 22:24:54 +0200 | [diff] [blame] | 384 | PyObject *v; |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 385 | |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 386 | #define SET_DICT_FROM_SIZE(key, value) \ |
| 387 | do { \ |
| 388 | v = PyLong_FromSsize_t(value); \ |
| 389 | if (v == NULL) { \ |
| 390 | return -1; \ |
| 391 | } \ |
| 392 | if (PyDict_SetItemString(dict, key, v) < 0) { \ |
| 393 | Py_DECREF(v); \ |
| 394 | return -1; \ |
| 395 | } \ |
| 396 | Py_DECREF(v); \ |
| 397 | } while (0) |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 398 | |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 399 | SET_DICT_FROM_SIZE(visible_length_key, desc->n_in_sequence); |
| 400 | SET_DICT_FROM_SIZE(real_length_key, n_members); |
| 401 | SET_DICT_FROM_SIZE(unnamed_fields_key, n_unnamed_members); |
| 402 | return 0; |
| 403 | } |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 404 | |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 405 | static void |
| 406 | initialize_members(PyStructSequence_Desc *desc, PyMemberDef* members, |
| 407 | Py_ssize_t n_members) { |
| 408 | Py_ssize_t i, k; |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 409 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 410 | for (i = k = 0; i < n_members; ++i) { |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 411 | if (desc->fields[i].name == PyStructSequence_UnnamedField) { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 412 | continue; |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 413 | } |
| 414 | |
| 415 | /* The names and docstrings in these MemberDefs are statically */ |
| 416 | /* allocated so it is expected that they'll outlive the MemberDef */ |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 417 | members[k].name = desc->fields[i].name; |
| 418 | members[k].type = T_OBJECT; |
| 419 | members[k].offset = offsetof(PyStructSequence, ob_item) |
| 420 | + i * sizeof(PyObject*); |
| 421 | members[k].flags = READONLY; |
| 422 | members[k].doc = desc->fields[i].doc; |
| 423 | k++; |
| 424 | } |
| 425 | members[k].name = NULL; |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 426 | } |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 427 | |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 428 | int |
| 429 | PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc) |
| 430 | { |
| 431 | PyMemberDef *members; |
| 432 | Py_ssize_t n_members, n_unnamed_members; |
| 433 | |
| 434 | #ifdef Py_TRACE_REFS |
| 435 | /* if the type object was chained, unchain it first |
| 436 | before overwriting its storage */ |
| 437 | if (type->ob_base.ob_base._ob_next) { |
| 438 | _Py_ForgetReference((PyObject *)type); |
| 439 | } |
| 440 | #endif |
| 441 | |
| 442 | /* PyTypeObject has already been initialized */ |
| 443 | if (Py_REFCNT(type) != 0) { |
| 444 | PyErr_BadInternalCall(); |
| 445 | return -1; |
| 446 | } |
| 447 | |
| 448 | type->tp_name = desc->name; |
| 449 | type->tp_basicsize = sizeof(PyStructSequence) - sizeof(PyObject *); |
| 450 | type->tp_itemsize = sizeof(PyObject *); |
| 451 | type->tp_dealloc = (destructor)structseq_dealloc; |
| 452 | type->tp_repr = (reprfunc)structseq_repr; |
| 453 | type->tp_doc = desc->doc; |
| 454 | type->tp_base = &PyTuple_Type; |
| 455 | type->tp_methods = structseq_methods; |
| 456 | type->tp_new = structseq_new; |
| 457 | type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC; |
Pablo Galindo | 7ffcf84 | 2019-06-02 15:45:13 +0100 | [diff] [blame] | 458 | type->tp_traverse = (traverseproc) structseq_traverse; |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 459 | |
| 460 | n_members = count_members(desc, &n_unnamed_members); |
| 461 | members = PyMem_NEW(PyMemberDef, n_members - n_unnamed_members + 1); |
| 462 | if (members == NULL) { |
| 463 | PyErr_NoMemory(); |
| 464 | return -1; |
| 465 | } |
| 466 | initialize_members(desc, members, n_members); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 467 | type->tp_members = members; |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 468 | |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 469 | if (PyType_Ready(type) < 0) { |
Victor Stinner | 00d7abd | 2020-12-01 09:56:42 +0100 | [diff] [blame] | 470 | PyMem_Free(members); |
Victor Stinner | 1c8f059 | 2013-07-22 22:24:54 +0200 | [diff] [blame] | 471 | return -1; |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 472 | } |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 473 | Py_INCREF(type); |
Neal Norwitz | 2f99b24 | 2008-08-24 05:48:10 +0000 | [diff] [blame] | 474 | |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 475 | if (initialize_structseq_dict( |
| 476 | desc, type->tp_dict, n_members, n_unnamed_members) < 0) { |
Victor Stinner | 00d7abd | 2020-12-01 09:56:42 +0100 | [diff] [blame] | 477 | PyMem_Free(members); |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 478 | Py_DECREF(type); |
| 479 | return -1; |
| 480 | } |
Victor Stinner | 1c8f059 | 2013-07-22 22:24:54 +0200 | [diff] [blame] | 481 | |
| 482 | return 0; |
| 483 | } |
| 484 | |
| 485 | void |
| 486 | PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc) |
| 487 | { |
| 488 | (void)PyStructSequence_InitType2(type, desc); |
Guido van Rossum | e82f75a | 2001-10-18 20:47:51 +0000 | [diff] [blame] | 489 | } |
Martin v. Löwis | 4d0d471 | 2010-12-03 20:14:31 +0000 | [diff] [blame] | 490 | |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 491 | PyTypeObject * |
Martin v. Löwis | 4d0d471 | 2010-12-03 20:14:31 +0000 | [diff] [blame] | 492 | PyStructSequence_NewType(PyStructSequence_Desc *desc) |
| 493 | { |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 494 | PyMemberDef *members; |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 495 | PyTypeObject *type; |
Pablo Galindo | 7ffcf84 | 2019-06-02 15:45:13 +0100 | [diff] [blame] | 496 | PyType_Slot slots[8]; |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 497 | PyType_Spec spec; |
| 498 | Py_ssize_t n_members, n_unnamed_members; |
Victor Stinner | 26f9199 | 2013-07-17 01:22:45 +0200 | [diff] [blame] | 499 | |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 500 | /* Initialize MemberDefs */ |
| 501 | n_members = count_members(desc, &n_unnamed_members); |
| 502 | members = PyMem_NEW(PyMemberDef, n_members - n_unnamed_members + 1); |
| 503 | if (members == NULL) { |
| 504 | PyErr_NoMemory(); |
Victor Stinner | 1c8f059 | 2013-07-22 22:24:54 +0200 | [diff] [blame] | 505 | return NULL; |
Stefan Krah | 6b96286 | 2012-08-19 11:20:41 +0200 | [diff] [blame] | 506 | } |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 507 | initialize_members(desc, members, n_members); |
| 508 | |
| 509 | /* Initialize Slots */ |
| 510 | slots[0] = (PyType_Slot){Py_tp_dealloc, (destructor)structseq_dealloc}; |
| 511 | slots[1] = (PyType_Slot){Py_tp_repr, (reprfunc)structseq_repr}; |
| 512 | slots[2] = (PyType_Slot){Py_tp_doc, (void *)desc->doc}; |
| 513 | slots[3] = (PyType_Slot){Py_tp_methods, structseq_methods}; |
| 514 | slots[4] = (PyType_Slot){Py_tp_new, structseq_new}; |
| 515 | slots[5] = (PyType_Slot){Py_tp_members, members}; |
Pablo Galindo | 7ffcf84 | 2019-06-02 15:45:13 +0100 | [diff] [blame] | 516 | slots[6] = (PyType_Slot){Py_tp_traverse, (traverseproc)structseq_traverse}; |
| 517 | slots[7] = (PyType_Slot){0, 0}; |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 518 | |
| 519 | /* Initialize Spec */ |
| 520 | /* The name in this PyType_Spec is statically allocated so it is */ |
| 521 | /* expected that it'll outlive the PyType_Spec */ |
| 522 | spec.name = desc->name; |
| 523 | spec.basicsize = sizeof(PyStructSequence) - sizeof(PyObject *); |
| 524 | spec.itemsize = sizeof(PyObject *); |
| 525 | spec.flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC; |
| 526 | spec.slots = slots; |
| 527 | |
Serhiy Storchaka | 686c203 | 2020-11-22 13:25:02 +0200 | [diff] [blame] | 528 | type = (PyTypeObject *)PyType_FromSpecWithBases(&spec, (PyObject *)&PyTuple_Type); |
Victor Stinner | 00d7abd | 2020-12-01 09:56:42 +0100 | [diff] [blame] | 529 | PyMem_Free(members); |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 530 | if (type == NULL) { |
| 531 | return NULL; |
| 532 | } |
| 533 | |
| 534 | if (initialize_structseq_dict( |
| 535 | desc, type->tp_dict, n_members, n_unnamed_members) < 0) { |
Pablo Galindo | bfb855b | 2018-11-15 02:03:57 +0000 | [diff] [blame] | 536 | Py_DECREF(type); |
Eddie Elizondo | 474eedf | 2018-11-13 04:09:31 -0800 | [diff] [blame] | 537 | return NULL; |
| 538 | } |
| 539 | |
| 540 | return type; |
Martin v. Löwis | 4d0d471 | 2010-12-03 20:14:31 +0000 | [diff] [blame] | 541 | } |
Victor Stinner | 26f9199 | 2013-07-17 01:22:45 +0200 | [diff] [blame] | 542 | |
| 543 | int _PyStructSequence_Init(void) |
| 544 | { |
| 545 | if (_PyUnicode_FromId(&PyId_n_sequence_fields) == NULL |
| 546 | || _PyUnicode_FromId(&PyId_n_fields) == NULL |
| 547 | || _PyUnicode_FromId(&PyId_n_unnamed_fields) == NULL) |
| 548 | return -1; |
| 549 | |
| 550 | return 0; |
| 551 | } |