|
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 } |