1 /* Implementation helper: a struct that looks like a tuple. See timemodule 2 and posixmodule for example uses. */ 3 4 #include "Python.h" 5 #include "structmember.h" 6 7 static const char visible_length_key[] = "n_sequence_fields"; 8 static const char real_length_key[] = "n_fields"; 9 static const char unnamed_fields_key[] = "n_unnamed_fields"; 10 11 /* Fields with this name have only a field index, not a field name. 12 They are only allowed for indices < n_visible_fields. */ 13 char *PyStructSequence_UnnamedField = "unnamed field"; 14 _Py_IDENTIFIER(n_sequence_fields); 15 _Py_IDENTIFIER(n_fields); 16 _Py_IDENTIFIER(n_unnamed_fields); 17 18 #define VISIBLE_SIZE(op) Py_SIZE(op) 19 #define VISIBLE_SIZE_TP(tp) PyLong_AsSsize_t( \ 20 _PyDict_GetItemId((tp)->tp_dict, &PyId_n_sequence_fields)) 21 22 #define REAL_SIZE_TP(tp) PyLong_AsSsize_t( \ 23 _PyDict_GetItemId((tp)->tp_dict, &PyId_n_fields)) 24 #define REAL_SIZE(op) REAL_SIZE_TP(Py_TYPE(op)) 25 26 #define UNNAMED_FIELDS_TP(tp) PyLong_AsSsize_t( \ 27 _PyDict_GetItemId((tp)->tp_dict, &PyId_n_unnamed_fields)) 28 #define UNNAMED_FIELDS(op) UNNAMED_FIELDS_TP(Py_TYPE(op)) 29 30 31 PyObject * PyStructSequence_New(PyTypeObject * type)32 PyStructSequence_New(PyTypeObject *type) 33 { 34 PyStructSequence *obj; 35 Py_ssize_t size = REAL_SIZE_TP(type), i; 36 37 obj = PyObject_GC_NewVar(PyStructSequence, type, size); 38 if (obj == NULL) 39 return NULL; 40 /* Hack the size of the variable object, so invisible fields don't appear 41 to Python code. */ 42 Py_SIZE(obj) = VISIBLE_SIZE_TP(type); 43 for (i = 0; i < size; i++) 44 obj->ob_item[i] = NULL; 45 46 return (PyObject*)obj; 47 } 48 49 void PyStructSequence_SetItem(PyObject * op,Py_ssize_t i,PyObject * v)50 PyStructSequence_SetItem(PyObject* op, Py_ssize_t i, PyObject* v) 51 { 52 PyStructSequence_SET_ITEM(op, i, v); 53 } 54 55 PyObject* PyStructSequence_GetItem(PyObject * op,Py_ssize_t i)56 PyStructSequence_GetItem(PyObject* op, Py_ssize_t i) 57 { 58 return PyStructSequence_GET_ITEM(op, i); 59 } 60 61 static void structseq_dealloc(PyStructSequence * obj)62 structseq_dealloc(PyStructSequence *obj) 63 { 64 Py_ssize_t i, size; 65 66 size = REAL_SIZE(obj); 67 for (i = 0; i < size; ++i) { 68 Py_XDECREF(obj->ob_item[i]); 69 } 70 PyObject_GC_Del(obj); 71 } 72 73 static PyObject * structseq_new(PyTypeObject * type,PyObject * args,PyObject * kwds)74 structseq_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 75 { 76 PyObject *arg = NULL; 77 PyObject *dict = NULL; 78 PyObject *ob; 79 PyStructSequence *res = NULL; 80 Py_ssize_t len, min_len, max_len, i, n_unnamed_fields; 81 static char *kwlist[] = {"sequence", "dict", 0}; 82 83 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:structseq", 84 kwlist, &arg, &dict)) 85 return NULL; 86 87 arg = PySequence_Fast(arg, "constructor requires a sequence"); 88 89 if (!arg) { 90 return NULL; 91 } 92 93 if (dict && !PyDict_Check(dict)) { 94 PyErr_Format(PyExc_TypeError, 95 "%.500s() takes a dict as second arg, if any", 96 type->tp_name); 97 Py_DECREF(arg); 98 return NULL; 99 } 100 101 len = PySequence_Fast_GET_SIZE(arg); 102 min_len = VISIBLE_SIZE_TP(type); 103 max_len = REAL_SIZE_TP(type); 104 n_unnamed_fields = UNNAMED_FIELDS_TP(type); 105 106 if (min_len != max_len) { 107 if (len < min_len) { 108 PyErr_Format(PyExc_TypeError, 109 "%.500s() takes an at least %zd-sequence (%zd-sequence given)", 110 type->tp_name, min_len, len); 111 Py_DECREF(arg); 112 return NULL; 113 } 114 115 if (len > max_len) { 116 PyErr_Format(PyExc_TypeError, 117 "%.500s() takes an at most %zd-sequence (%zd-sequence given)", 118 type->tp_name, max_len, len); 119 Py_DECREF(arg); 120 return NULL; 121 } 122 } 123 else { 124 if (len != min_len) { 125 PyErr_Format(PyExc_TypeError, 126 "%.500s() takes a %zd-sequence (%zd-sequence given)", 127 type->tp_name, min_len, len); 128 Py_DECREF(arg); 129 return NULL; 130 } 131 } 132 133 res = (PyStructSequence*) PyStructSequence_New(type); 134 if (res == NULL) { 135 Py_DECREF(arg); 136 return NULL; 137 } 138 for (i = 0; i < len; ++i) { 139 PyObject *v = PySequence_Fast_GET_ITEM(arg, i); 140 Py_INCREF(v); 141 res->ob_item[i] = v; 142 } 143 for (; i < max_len; ++i) { 144 if (dict && (ob = PyDict_GetItemString( 145 dict, type->tp_members[i-n_unnamed_fields].name))) { 146 } 147 else { 148 ob = Py_None; 149 } 150 Py_INCREF(ob); 151 res->ob_item[i] = ob; 152 } 153 154 Py_DECREF(arg); 155 return (PyObject*) res; 156 } 157 158 159 static PyObject * structseq_repr(PyStructSequence * obj)160 structseq_repr(PyStructSequence *obj) 161 { 162 /* buffer and type size were chosen well considered. */ 163 #define REPR_BUFFER_SIZE 512 164 #define TYPE_MAXSIZE 100 165 166 PyTypeObject *typ = Py_TYPE(obj); 167 Py_ssize_t i; 168 int removelast = 0; 169 Py_ssize_t len; 170 char buf[REPR_BUFFER_SIZE]; 171 char *endofbuf, *pbuf = buf; 172 173 /* pointer to end of writeable buffer; safes space for "...)\0" */ 174 endofbuf= &buf[REPR_BUFFER_SIZE-5]; 175 176 /* "typename(", limited to TYPE_MAXSIZE */ 177 len = strlen(typ->tp_name) > TYPE_MAXSIZE ? TYPE_MAXSIZE : 178 strlen(typ->tp_name); 179 strncpy(pbuf, typ->tp_name, len); 180 pbuf += len; 181 *pbuf++ = '('; 182 183 for (i=0; i < VISIBLE_SIZE(obj); i++) { 184 PyObject *val, *repr; 185 char *cname, *crepr; 186 187 cname = typ->tp_members[i].name; 188 if (cname == NULL) { 189 PyErr_Format(PyExc_SystemError, "In structseq_repr(), member %d name is NULL" 190 " for type %.500s", i, typ->tp_name); 191 return NULL; 192 } 193 val = PyStructSequence_GET_ITEM(obj, i); 194 repr = PyObject_Repr(val); 195 if (repr == NULL) 196 return NULL; 197 crepr = PyUnicode_AsUTF8(repr); 198 if (crepr == NULL) { 199 Py_DECREF(repr); 200 return NULL; 201 } 202 203 /* + 3: keep space for "=" and ", " */ 204 len = strlen(cname) + strlen(crepr) + 3; 205 if ((pbuf+len) <= endofbuf) { 206 strcpy(pbuf, cname); 207 pbuf += strlen(cname); 208 *pbuf++ = '='; 209 strcpy(pbuf, crepr); 210 pbuf += strlen(crepr); 211 *pbuf++ = ','; 212 *pbuf++ = ' '; 213 removelast = 1; 214 Py_DECREF(repr); 215 } 216 else { 217 strcpy(pbuf, "..."); 218 pbuf += 3; 219 removelast = 0; 220 Py_DECREF(repr); 221 break; 222 } 223 } 224 if (removelast) { 225 /* overwrite last ", " */ 226 pbuf-=2; 227 } 228 *pbuf++ = ')'; 229 *pbuf = '\0'; 230 231 return PyUnicode_FromString(buf); 232 } 233 234 static PyObject * structseq_reduce(PyStructSequence * self)235 structseq_reduce(PyStructSequence* self) 236 { 237 PyObject* tup = NULL; 238 PyObject* dict = NULL; 239 PyObject* result; 240 Py_ssize_t n_fields, n_visible_fields, n_unnamed_fields, i; 241 242 n_fields = REAL_SIZE(self); 243 n_visible_fields = VISIBLE_SIZE(self); 244 n_unnamed_fields = UNNAMED_FIELDS(self); 245 tup = PyTuple_New(n_visible_fields); 246 if (!tup) 247 goto error; 248 249 dict = PyDict_New(); 250 if (!dict) 251 goto error; 252 253 for (i = 0; i < n_visible_fields; i++) { 254 Py_INCREF(self->ob_item[i]); 255 PyTuple_SET_ITEM(tup, i, self->ob_item[i]); 256 } 257 258 for (; i < n_fields; i++) { 259 char *n = Py_TYPE(self)->tp_members[i-n_unnamed_fields].name; 260 if (PyDict_SetItemString(dict, n, self->ob_item[i]) < 0) 261 goto error; 262 } 263 264 result = Py_BuildValue("(O(OO))", Py_TYPE(self), tup, dict); 265 266 Py_DECREF(tup); 267 Py_DECREF(dict); 268 269 return result; 270 271 error: 272 Py_XDECREF(tup); 273 Py_XDECREF(dict); 274 return NULL; 275 } 276 277 static PyMethodDef structseq_methods[] = { 278 {"__reduce__", (PyCFunction)structseq_reduce, METH_NOARGS, NULL}, 279 {NULL, NULL} 280 }; 281 282 static PyTypeObject _struct_sequence_template = { 283 PyVarObject_HEAD_INIT(&PyType_Type, 0) 284 NULL, /* tp_name */ 285 sizeof(PyStructSequence) - sizeof(PyObject *), /* tp_basicsize */ 286 sizeof(PyObject *), /* tp_itemsize */ 287 (destructor)structseq_dealloc, /* tp_dealloc */ 288 0, /* tp_print */ 289 0, /* tp_getattr */ 290 0, /* tp_setattr */ 291 0, /* tp_reserved */ 292 (reprfunc)structseq_repr, /* tp_repr */ 293 0, /* tp_as_number */ 294 0, /* tp_as_sequence */ 295 0, /* tp_as_mapping */ 296 0, /* tp_hash */ 297 0, /* tp_call */ 298 0, /* tp_str */ 299 0, /* tp_getattro */ 300 0, /* tp_setattro */ 301 0, /* tp_as_buffer */ 302 Py_TPFLAGS_DEFAULT, /* tp_flags */ 303 NULL, /* tp_doc */ 304 0, /* tp_traverse */ 305 0, /* tp_clear */ 306 0, /* tp_richcompare */ 307 0, /* tp_weaklistoffset */ 308 0, /* tp_iter */ 309 0, /* tp_iternext */ 310 structseq_methods, /* tp_methods */ 311 NULL, /* tp_members */ 312 0, /* tp_getset */ 313 0, /* tp_base */ 314 0, /* tp_dict */ 315 0, /* tp_descr_get */ 316 0, /* tp_descr_set */ 317 0, /* tp_dictoffset */ 318 0, /* tp_init */ 319 0, /* tp_alloc */ 320 structseq_new, /* tp_new */ 321 }; 322 323 int PyStructSequence_InitType2(PyTypeObject * type,PyStructSequence_Desc * desc)324 PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc) 325 { 326 PyObject *dict; 327 PyMemberDef* members; 328 Py_ssize_t n_members, n_unnamed_members, i, k; 329 PyObject *v; 330 331 #ifdef Py_TRACE_REFS 332 /* if the type object was chained, unchain it first 333 before overwriting its storage */ 334 if (type->ob_base.ob_base._ob_next) { 335 _Py_ForgetReference((PyObject*)type); 336 } 337 #endif 338 339 n_unnamed_members = 0; 340 for (i = 0; desc->fields[i].name != NULL; ++i) 341 if (desc->fields[i].name == PyStructSequence_UnnamedField) 342 n_unnamed_members++; 343 n_members = i; 344 345 memcpy(type, &_struct_sequence_template, sizeof(PyTypeObject)); 346 type->tp_base = &PyTuple_Type; 347 type->tp_name = desc->name; 348 type->tp_doc = desc->doc; 349 350 members = PyMem_NEW(PyMemberDef, n_members-n_unnamed_members+1); 351 if (members == NULL) { 352 PyErr_NoMemory(); 353 return -1; 354 } 355 356 for (i = k = 0; i < n_members; ++i) { 357 if (desc->fields[i].name == PyStructSequence_UnnamedField) 358 continue; 359 members[k].name = desc->fields[i].name; 360 members[k].type = T_OBJECT; 361 members[k].offset = offsetof(PyStructSequence, ob_item) 362 + i * sizeof(PyObject*); 363 members[k].flags = READONLY; 364 members[k].doc = desc->fields[i].doc; 365 k++; 366 } 367 members[k].name = NULL; 368 369 type->tp_members = members; 370 371 if (PyType_Ready(type) < 0) 372 return -1; 373 Py_INCREF(type); 374 375 dict = type->tp_dict; 376 #define SET_DICT_FROM_SIZE(key, value) \ 377 do { \ 378 v = PyLong_FromSsize_t(value); \ 379 if (v == NULL) \ 380 return -1; \ 381 if (PyDict_SetItemString(dict, key, v) < 0) { \ 382 Py_DECREF(v); \ 383 return -1; \ 384 } \ 385 Py_DECREF(v); \ 386 } while (0) 387 388 SET_DICT_FROM_SIZE(visible_length_key, desc->n_in_sequence); 389 SET_DICT_FROM_SIZE(real_length_key, n_members); 390 SET_DICT_FROM_SIZE(unnamed_fields_key, n_unnamed_members); 391 392 return 0; 393 } 394 395 void PyStructSequence_InitType(PyTypeObject * type,PyStructSequence_Desc * desc)396 PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc) 397 { 398 (void)PyStructSequence_InitType2(type, desc); 399 } 400 401 PyTypeObject* PyStructSequence_NewType(PyStructSequence_Desc * desc)402 PyStructSequence_NewType(PyStructSequence_Desc *desc) 403 { 404 PyTypeObject *result; 405 406 result = (PyTypeObject*)PyType_GenericAlloc(&PyType_Type, 0); 407 if (result == NULL) 408 return NULL; 409 if (PyStructSequence_InitType2(result, desc) < 0) { 410 Py_DECREF(result); 411 return NULL; 412 } 413 return result; 414 } 415 _PyStructSequence_Init(void)416 int _PyStructSequence_Init(void) 417 { 418 if (_PyUnicode_FromId(&PyId_n_sequence_fields) == NULL 419 || _PyUnicode_FromId(&PyId_n_fields) == NULL 420 || _PyUnicode_FromId(&PyId_n_unnamed_fields) == NULL) 421 return -1; 422 423 return 0; 424 } 425