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 #include "structseq.h" 7 8 static char visible_length_key[] = "n_sequence_fields"; 9 static char real_length_key[] = "n_fields"; 10 static char unnamed_fields_key[] = "n_unnamed_fields"; 11 12 /* Fields with this name have only a field index, not a field name. 13 They are only allowed for indices < n_visible_fields. */ 14 char *PyStructSequence_UnnamedField = "unnamed field"; 15 16 #define VISIBLE_SIZE(op) Py_SIZE(op) 17 #define VISIBLE_SIZE_TP(tp) PyInt_AsLong( \ 18 PyDict_GetItemString((tp)->tp_dict, visible_length_key)) 19 20 #define REAL_SIZE_TP(tp) PyInt_AsLong( \ 21 PyDict_GetItemString((tp)->tp_dict, real_length_key)) 22 #define REAL_SIZE(op) REAL_SIZE_TP(Py_TYPE(op)) 23 24 #define UNNAMED_FIELDS_TP(tp) PyInt_AsLong( \ 25 PyDict_GetItemString((tp)->tp_dict, unnamed_fields_key)) 26 #define UNNAMED_FIELDS(op) UNNAMED_FIELDS_TP(Py_TYPE(op)) 27 28 29 PyObject * 30 PyStructSequence_New(PyTypeObject *type) 31 { 32 PyStructSequence *obj; 33 34 obj = PyObject_New(PyStructSequence, type); 35 if (obj == NULL) 36 return NULL; 37 Py_SIZE(obj) = VISIBLE_SIZE_TP(type); 38 39 return (PyObject*) obj; 40 } 41 42 static void 43 structseq_dealloc(PyStructSequence *obj) 44 { 45 Py_ssize_t i, size; 46 47 size = REAL_SIZE(obj); 48 for (i = 0; i < size; ++i) { 49 Py_XDECREF(obj->ob_item[i]); 50 } 51 PyObject_Del(obj); 52 } 53 54 static Py_ssize_t 55 structseq_length(PyStructSequence *obj) 56 { 57 return VISIBLE_SIZE(obj); 58 } 59 60 static PyObject* 61 structseq_item(PyStructSequence *obj, Py_ssize_t i) 62 { 63 if (i < 0 || i >= VISIBLE_SIZE(obj)) { 64 PyErr_SetString(PyExc_IndexError, "tuple index out of range"); 65 return NULL; 66 } 67 Py_INCREF(obj->ob_item[i]); 68 return obj->ob_item[i]; 69 } 70 71 static PyObject* 72 structseq_slice(PyStructSequence *obj, Py_ssize_t low, Py_ssize_t high) 73 { 74 PyTupleObject *np; 75 Py_ssize_t i; 76 77 if (low < 0) 78 low = 0; 79 if (high > VISIBLE_SIZE(obj)) 80 high = VISIBLE_SIZE(obj); 81 if (high < low) 82 high = low; 83 np = (PyTupleObject *)PyTuple_New(high-low); 84 if (np == NULL) 85 return NULL; 86 for(i = low; i < high; ++i) { 87 PyObject *v = obj->ob_item[i]; 88 Py_INCREF(v); 89 PyTuple_SET_ITEM(np, i-low, v); 90 } 91 return (PyObject *) np; 92 } 93 94 static PyObject * 95 structseq_subscript(PyStructSequence *self, PyObject *item) 96 { 97 if (PyIndex_Check(item)) { 98 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); 99 if (i == -1 && PyErr_Occurred()) 100 return NULL; 101 102 if (i < 0) 103 i += VISIBLE_SIZE(self); 104 105 if (i < 0 || i >= VISIBLE_SIZE(self)) { 106 PyErr_SetString(PyExc_IndexError, 107 "tuple index out of range"); 108 return NULL; 109 } 110 Py_INCREF(self->ob_item[i]); 111 return self->ob_item[i]; 112 } 113 else if (PySlice_Check(item)) { 114 Py_ssize_t start, stop, step, slicelen, cur, i; 115 PyObject *result; 116 117 if (PySlice_GetIndicesEx((PySliceObject *)item, 118 VISIBLE_SIZE(self), &start, &stop, 119 &step, &slicelen) < 0) { 120 return NULL; 121 } 122 if (slicelen <= 0) 123 return PyTuple_New(0); 124 result = PyTuple_New(slicelen); 125 if (result == NULL) 126 return NULL; 127 for (cur = start, i = 0; i < slicelen; 128 cur += step, i++) { 129 PyObject *v = self->ob_item[cur]; 130 Py_INCREF(v); 131 PyTuple_SET_ITEM(result, i, v); 132 } 133 return result; 134 } 135 else { 136 PyErr_SetString(PyExc_TypeError, 137 "structseq index must be integer"); 138 return NULL; 139 } 140 } 141 142 static PyObject * 143 structseq_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 144 { 145 PyObject *arg = NULL; 146 PyObject *dict = NULL; 147 PyObject *ob; 148 PyStructSequence *res = NULL; 149 Py_ssize_t len, min_len, max_len, i, n_unnamed_fields; 150 static char *kwlist[] = {"sequence", "dict", 0}; 151 152 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:structseq", 153 kwlist, &arg, &dict)) 154 return NULL; 155 156 arg = PySequence_Fast(arg, "constructor requires a sequence"); 157 158 if (!arg) { 159 return NULL; 160 } 161 162 if (dict && !PyDict_Check(dict)) { 163 PyErr_Format(PyExc_TypeError, 164 "%.500s() takes a dict as second arg, if any", 165 type->tp_name); 166 Py_DECREF(arg); 167 return NULL; 168 } 169 170 len = PySequence_Fast_GET_SIZE(arg); 171 min_len = VISIBLE_SIZE_TP(type); 172 max_len = REAL_SIZE_TP(type); 173 n_unnamed_fields = UNNAMED_FIELDS_TP(type); 174 175 if (min_len != max_len) { 176 if (len < min_len) { 177 PyErr_Format(PyExc_TypeError, 178 "%.500s() takes an at least %zd-sequence (%zd-sequence given)", 179 type->tp_name, min_len, len); 180 Py_DECREF(arg); 181 return NULL; 182 } 183 184 if (len > max_len) { 185 PyErr_Format(PyExc_TypeError, 186 "%.500s() takes an at most %zd-sequence (%zd-sequence given)", 187 type->tp_name, max_len, len); 188 Py_DECREF(arg); 189 return NULL; 190 } 191 } 192 else { 193 if (len != min_len) { 194 PyErr_Format(PyExc_TypeError, 195 "%.500s() takes a %zd-sequence (%zd-sequence given)", 196 type->tp_name, min_len, len); 197 Py_DECREF(arg); 198 return NULL; 199 } 200 } 201 202 res = (PyStructSequence*) PyStructSequence_New(type); 203 if (res == NULL) { 204 return NULL; 205 } 206 for (i = 0; i < len; ++i) { 207 PyObject *v = PySequence_Fast_GET_ITEM(arg, i); 208 Py_INCREF(v); 209 res->ob_item[i] = v; 210 } 211 for (; i < max_len; ++i) { 212 if (dict && (ob = PyDict_GetItemString( 213 dict, type->tp_members[i-n_unnamed_fields].name))) { 214 } 215 else { 216 ob = Py_None; 217 } 218 Py_INCREF(ob); 219 res->ob_item[i] = ob; 220 } 221 222 Py_DECREF(arg); 223 return (PyObject*) res; 224 } 225 226 static PyObject * 227 make_tuple(PyStructSequence *obj) 228 { 229 return structseq_slice(obj, 0, VISIBLE_SIZE(obj)); 230 } 231 232 static PyObject * 233 structseq_repr(PyStructSequence *obj) 234 { 235 /* buffer and type size were chosen well considered. */ 236 #define REPR_BUFFER_SIZE 512 237 #define TYPE_MAXSIZE 100 238 239 PyObject *tup; 240 PyTypeObject *typ = Py_TYPE(obj); 241 int i, removelast = 0; 242 Py_ssize_t len; 243 char buf[REPR_BUFFER_SIZE]; 244 char *endofbuf, *pbuf = buf; 245 246 /* pointer to end of writeable buffer; safes space for "...)\0" */ 247 endofbuf= &buf[REPR_BUFFER_SIZE-5]; 248 249 if ((tup = make_tuple(obj)) == NULL) { 250 return NULL; 251 } 252 253 /* "typename(", limited to TYPE_MAXSIZE */ 254 len = strlen(typ->tp_name) > TYPE_MAXSIZE ? TYPE_MAXSIZE : 255 strlen(typ->tp_name); 256 strncpy(pbuf, typ->tp_name, len); 257 pbuf += len; 258 *pbuf++ = '('; 259 260 for (i=0; i < VISIBLE_SIZE(obj); i++) { 261 PyObject *val, *repr; 262 char *cname, *crepr; 263 264 cname = typ->tp_members[i].name; 265 266 val = PyTuple_GetItem(tup, i); 267 if (cname == NULL || val == NULL) { 268 return NULL; 269 } 270 repr = PyObject_Repr(val); 271 if (repr == NULL) { 272 Py_DECREF(tup); 273 return NULL; 274 } 275 crepr = PyString_AsString(repr); 276 if (crepr == NULL) { 277 Py_DECREF(tup); 278 Py_DECREF(repr); 279 return NULL; 280 } 281 282 /* + 3: keep space for "=" and ", " */ 283 len = strlen(cname) + strlen(crepr) + 3; 284 if ((pbuf+len) <= endofbuf) { 285 strcpy(pbuf, cname); 286 pbuf += strlen(cname); 287 *pbuf++ = '='; 288 strcpy(pbuf, crepr); 289 pbuf += strlen(crepr); 290 *pbuf++ = ','; 291 *pbuf++ = ' '; 292 removelast = 1; 293 Py_DECREF(repr); 294 } 295 else { 296 strcpy(pbuf, "..."); 297 pbuf += 3; 298 removelast = 0; 299 Py_DECREF(repr); 300 break; 301 } 302 } 303 Py_DECREF(tup); 304 if (removelast) { 305 /* overwrite last ", " */ 306 pbuf-=2; 307 } 308 *pbuf++ = ')'; 309 *pbuf = '\0'; 310 311 return PyString_FromString(buf); 312 } 313 314 static PyObject * 315 structseq_concat(PyStructSequence *obj, PyObject *b) 316 { 317 PyObject *tup, *result; 318 tup = make_tuple(obj); 319 result = PySequence_Concat(tup, b); 320 Py_DECREF(tup); 321 return result; 322 } 323 324 static PyObject * 325 structseq_repeat(PyStructSequence *obj, Py_ssize_t n) 326 { 327 PyObject *tup, *result; 328 tup = make_tuple(obj); 329 result = PySequence_Repeat(tup, n); 330 Py_DECREF(tup); 331 return result; 332 } 333 334 static int 335 structseq_contains(PyStructSequence *obj, PyObject *o) 336 { 337 PyObject *tup; 338 int result; 339 tup = make_tuple(obj); 340 if (!tup) 341 return -1; 342 result = PySequence_Contains(tup, o); 343 Py_DECREF(tup); 344 return result; 345 } 346 347 static long 348 structseq_hash(PyObject *obj) 349 { 350 PyObject *tup; 351 long result; 352 tup = make_tuple((PyStructSequence*) obj); 353 if (!tup) 354 return -1; 355 result = PyObject_Hash(tup); 356 Py_DECREF(tup); 357 return result; 358 } 359 360 static PyObject * 361 structseq_richcompare(PyObject *obj, PyObject *o2, int op) 362 { 363 PyObject *tup, *result; 364 tup = make_tuple((PyStructSequence*) obj); 365 result = PyObject_RichCompare(tup, o2, op); 366 Py_DECREF(tup); 367 return result; 368 } 369 370 static PyObject * 371 structseq_reduce(PyStructSequence* self) 372 { 373 PyObject* tup; 374 PyObject* dict; 375 PyObject* result; 376 Py_ssize_t n_fields, n_visible_fields, n_unnamed_fields; 377 int i; 378 379 n_fields = REAL_SIZE(self); 380 n_visible_fields = VISIBLE_SIZE(self); 381 n_unnamed_fields = UNNAMED_FIELDS(self); 382 tup = PyTuple_New(n_visible_fields); 383 if (!tup) { 384 return NULL; 385 } 386 387 dict = PyDict_New(); 388 if (!dict) { 389 Py_DECREF(tup); 390 return NULL; 391 } 392 393 for (i = 0; i < n_visible_fields; i++) { 394 Py_INCREF(self->ob_item[i]); 395 PyTuple_SET_ITEM(tup, i, self->ob_item[i]); 396 } 397 398 for (; i < n_fields; i++) { 399 char *n = Py_TYPE(self)->tp_members[i-n_unnamed_fields].name; 400 PyDict_SetItemString(dict, n, 401 self->ob_item[i]); 402 } 403 404 result = Py_BuildValue("(O(OO))", Py_TYPE(self), tup, dict); 405 406 Py_DECREF(tup); 407 Py_DECREF(dict); 408 409 return result; 410 } 411 412 static PySequenceMethods structseq_as_sequence = { 413 (lenfunc)structseq_length, 414 (binaryfunc)structseq_concat, /* sq_concat */ 415 (ssizeargfunc)structseq_repeat, /* sq_repeat */ 416 (ssizeargfunc)structseq_item, /* sq_item */ 417 (ssizessizeargfunc)structseq_slice, /* sq_slice */ 418 0, /* sq_ass_item */ 419 0, /* sq_ass_slice */ 420 (objobjproc)structseq_contains, /* sq_contains */ 421 }; 422 423 static PyMappingMethods structseq_as_mapping = { 424 (lenfunc)structseq_length, 425 (binaryfunc)structseq_subscript, 426 }; 427 428 static PyMethodDef structseq_methods[] = { 429 {"__reduce__", (PyCFunction)structseq_reduce, 430 METH_NOARGS, NULL}, 431 {NULL, NULL} 432 }; 433 434 static PyTypeObject _struct_sequence_template = { 435 PyVarObject_HEAD_INIT(&PyType_Type, 0) 436 NULL, /* tp_name */ 437 0, /* tp_basicsize */ 438 0, /* tp_itemsize */ 439 (destructor)structseq_dealloc, /* tp_dealloc */ 440 0, /* tp_print */ 441 0, /* tp_getattr */ 442 0, /* tp_setattr */ 443 0, /* tp_compare */ 444 (reprfunc)structseq_repr, /* tp_repr */ 445 0, /* tp_as_number */ 446 &structseq_as_sequence, /* tp_as_sequence */ 447 &structseq_as_mapping, /* tp_as_mapping */ 448 structseq_hash, /* tp_hash */ 449 0, /* tp_call */ 450 0, /* tp_str */ 451 0, /* tp_getattro */ 452 0, /* tp_setattro */ 453 0, /* tp_as_buffer */ 454 Py_TPFLAGS_DEFAULT, /* tp_flags */ 455 NULL, /* tp_doc */ 456 0, /* tp_traverse */ 457 0, /* tp_clear */ 458 structseq_richcompare, /* tp_richcompare */ 459 0, /* tp_weaklistoffset */ 460 0, /* tp_iter */ 461 0, /* tp_iternext */ 462 structseq_methods, /* tp_methods */ 463 NULL, /* tp_members */ 464 0, /* tp_getset */ 465 0, /* tp_base */ 466 0, /* tp_dict */ 467 0, /* tp_descr_get */ 468 0, /* tp_descr_set */ 469 0, /* tp_dictoffset */ 470 0, /* tp_init */ 471 0, /* tp_alloc */ 472 structseq_new, /* tp_new */ 473 }; 474 475 void 476 PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc) 477 { 478 PyObject *dict; 479 PyMemberDef* members; 480 int n_members, n_unnamed_members, i, k; 481 482 #ifdef Py_TRACE_REFS 483 /* if the type object was chained, unchain it first 484 before overwriting its storage */ 485 if (type->_ob_next) { 486 _Py_ForgetReference((PyObject*)type); 487 } 488 #endif 489 490 n_unnamed_members = 0; 491 for (i = 0; desc->fields[i].name != NULL; ++i) 492 if (desc->fields[i].name == PyStructSequence_UnnamedField) 493 n_unnamed_members++; 494 n_members = i; 495 496 memcpy(type, &_struct_sequence_template, sizeof(PyTypeObject)); 497 type->tp_name = desc->name; 498 type->tp_doc = desc->doc; 499 type->tp_basicsize = sizeof(PyStructSequence)+ 500 sizeof(PyObject*)*(n_members-1); 501 type->tp_itemsize = 0; 502 503 members = PyMem_NEW(PyMemberDef, n_members-n_unnamed_members+1); 504 if (members == NULL) 505 return; 506 507 for (i = k = 0; i < n_members; ++i) { 508 if (desc->fields[i].name == PyStructSequence_UnnamedField) 509 continue; 510 members[k].name = desc->fields[i].name; 511 members[k].type = T_OBJECT; 512 members[k].offset = offsetof(PyStructSequence, ob_item) 513 + i * sizeof(PyObject*); 514 members[k].flags = READONLY; 515 members[k].doc = desc->fields[i].doc; 516 k++; 517 } 518 members[k].name = NULL; 519 520 type->tp_members = members; 521 522 if (PyType_Ready(type) < 0) 523 return; 524 Py_INCREF(type); 525 526 dict = type->tp_dict; 527 #define SET_DICT_FROM_INT(key, value) \ 528 do { \ 529 PyObject *v = PyInt_FromLong((long) value); \ 530 if (v != NULL) { \ 531 PyDict_SetItemString(dict, key, v); \ 532 Py_DECREF(v); \ 533 } \ 534 } while (0) 535 536 SET_DICT_FROM_INT(visible_length_key, desc->n_in_sequence); 537 SET_DICT_FROM_INT(real_length_key, n_members); 538 SET_DICT_FROM_INT(unnamed_fields_key, n_unnamed_members); 539 } 540
