Objects/structseq.c

   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) ((op)->ob_size)
  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((op)->ob_type)
  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((op)->ob_type)
  27
  28
  29 PyObject *
  30 PyStructSequence_New(PyTypeObject *type)
  31 {
  32         PyStructSequence *obj;
  33
  34         obj = PyObject_New(PyStructSequence, type);
  35         obj->ob_size = VISIBLE_SIZE_TP(type);
  36
  37         return (PyObject*) obj;
  38 }
  39
  40 static void
  41 structseq_dealloc(PyStructSequence *obj)
  42 {
  43         Py_ssize_t i, size;
  44
  45         size = REAL_SIZE(obj);
  46         for (i = 0; i < size; ++i) {
  47                 Py_XDECREF(obj->ob_item[i]);
  48         }
  49         PyObject_Del(obj);
  50 }
  51
  52 static Py_ssize_t
  53 structseq_length(PyStructSequence *obj)
  54 {
  55         return VISIBLE_SIZE(obj);
  56 }
  57
  58 static PyObject*
  59 structseq_item(PyStructSequence *obj, Py_ssize_t i)
  60 {
  61         if (i < 0 || i >= VISIBLE_SIZE(obj)) {
  62                 PyErr_SetString(PyExc_IndexError, "tuple index out of range");
  63                 return NULL;
  64         }
  65         Py_INCREF(obj->ob_item[i]);
  66         return obj->ob_item[i];
  67 }
  68
  69 static PyObject*
  70 structseq_slice(PyStructSequence *obj, Py_ssize_t low, Py_ssize_t high)
  71 {
  72         PyTupleObject *np;
  73         Py_ssize_t i;
  74
  75         if (low < 0)
  76                 low = 0;
  77         if (high > VISIBLE_SIZE(obj))
  78                 high = VISIBLE_SIZE(obj);
  79         if (high < low)
  80                 high = low;
  81         np = (PyTupleObject *)PyTuple_New(high-low);
  82         if (np == NULL)
  83                 return NULL;
  84         for(i = low; i < high; ++i) {
  85                 PyObject *v = obj->ob_item[i];
  86                 Py_INCREF(v);
  87                 PyTuple_SET_ITEM(np, i-low, v);
  88         }
  89         return (PyObject *) np;
  90 }
  91
  92 static PyObject *
  93 structseq_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
  94 {
  95         PyObject *arg = NULL;
  96         PyObject *dict = NULL;
  97         PyObject *ob;
  98         PyStructSequence *res = NULL;
  99         Py_ssize_t len, min_len, max_len, i, n_unnamed_fields;
 100         static char *kwlist[] = {"sequence", "dict", 0};
 101
 102         if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:structseq",
 103                                          kwlist, &arg, &dict))
 104                 return NULL;
 105
 106         arg = PySequence_Fast(arg, "constructor requires a sequence");
 107
 108         if (!arg) {
 109                 return NULL;
 110         }
 111
 112         if (dict && !PyDict_Check(dict)) {
 113                 PyErr_Format(PyExc_TypeError,
 114                              "%.500s() takes a dict as second arg, if any",
 115                              type->tp_name);
 116                 Py_DECREF(arg);
 117                 return NULL;
 118         }
 119
 120         len = PySequence_Fast_GET_SIZE(arg);
 121         min_len = VISIBLE_SIZE_TP(type);
 122         max_len = REAL_SIZE_TP(type);
 123         n_unnamed_fields = UNNAMED_FIELDS_TP(type);
 124
 125         if (min_len != max_len) {
 126                 if (len < min_len) {
 127                         PyErr_Format(PyExc_TypeError,
 128                "%.500s() takes an at least %zd-sequence (%zd-sequence given)",
 129                                      type->tp_name, min_len, len);
 130                         Py_DECREF(arg);
 131                         return NULL;
 132                 }
 133
 134                 if (len > max_len) {
 135                         PyErr_Format(PyExc_TypeError,
 136                "%.500s() takes an at most %zd-sequence (%zd-sequence given)",
 137                                      type->tp_name, max_len, len);
 138                         Py_DECREF(arg);
 139                         return NULL;
 140                 }
 141         }
 142         else {
 143                 if (len != min_len) {
 144                         PyErr_Format(PyExc_TypeError,
 145                "%.500s() takes a %zd-sequence (%zd-sequence given)",
 146                                      type->tp_name, min_len, len);
 147                         Py_DECREF(arg);
 148                         return NULL;
 149                 }
 150         }
 151
 152         res = (PyStructSequence*) PyStructSequence_New(type);
 153         if (res == NULL) {
 154                 return NULL;
 155         }
 156         for (i = 0; i < len; ++i) {
 157                 PyObject *v = PySequence_Fast_GET_ITEM(arg, i);
 158                 Py_INCREF(v);
 159                 res->ob_item[i] = v;
 160         }
 161         for (; i < max_len; ++i) {
 162                 if (dict && (ob = PyDict_GetItemString(
 163                         dict, type->tp_members[i-n_unnamed_fields].name))) {
 164                 }
 165                 else {
 166                         ob = Py_None;
 167                 }
 168                 Py_INCREF(ob);
 169                 res->ob_item[i] = ob;
 170         }
 171
 172         Py_DECREF(arg);
 173         return (PyObject*) res;
 174 }
 175
 176 static PyObject *
 177 make_tuple(PyStructSequence *obj)
 178 {
 179         return structseq_slice(obj, 0, VISIBLE_SIZE(obj));
 180 }
 181
 182 static PyObject *
 183 structseq_repr(PyStructSequence *obj)
 184 {
 185         PyObject *tup, *str;
 186         tup = make_tuple(obj);
 187         str = PyObject_Repr(tup);
 188         Py_DECREF(tup);
 189         return str;
 190 }
 191
 192 static PyObject *
 193 structseq_concat(PyStructSequence *obj, PyObject *b)
 194 {
 195         PyObject *tup, *result;
 196         tup = make_tuple(obj);
 197         result = PySequence_Concat(tup, b);
 198         Py_DECREF(tup);
 199         return result;
 200 }
 201
 202 static PyObject *
 203 structseq_repeat(PyStructSequence *obj, Py_ssize_t n)
 204 {
 205         PyObject *tup, *result;
 206         tup = make_tuple(obj);
 207         result = PySequence_Repeat(tup, n);
 208         Py_DECREF(tup);
 209         return result;
 210 }
 211
 212 static int
 213 structseq_contains(PyStructSequence *obj, PyObject *o)
 214 {
 215         PyObject *tup;
 216         int result;
 217         tup = make_tuple(obj);
 218         result = PySequence_Contains(tup, o);
 219         Py_DECREF(tup);
 220         return result;
 221 }
 222
 223 static long
 224 structseq_hash(PyObject *obj)
 225 {
 226         PyObject *tup;
 227         long result;
 228         tup = make_tuple((PyStructSequence*) obj);
 229         result = PyObject_Hash(tup);
 230         Py_DECREF(tup);
 231         return result;
 232 }
 233
 234 static PyObject *
 235 structseq_richcompare(PyObject *obj, PyObject *o2, int op)
 236 {
 237         PyObject *tup, *result;
 238         tup = make_tuple((PyStructSequence*) obj);
 239         result = PyObject_RichCompare(tup, o2, op);
 240         Py_DECREF(tup);
 241         return result;
 242 }
 243
 244 static PyObject *
 245 structseq_reduce(PyStructSequence* self)
 246 {
 247         PyObject* tup;
 248         PyObject* dict;
 249         PyObject* result;
 250         Py_ssize_t n_fields, n_visible_fields, n_unnamed_fields;
 251         int i;
 252
 253         n_fields = REAL_SIZE(self);
 254         n_visible_fields = VISIBLE_SIZE(self);
 255         n_unnamed_fields = UNNAMED_FIELDS(self);
 256         tup = PyTuple_New(n_visible_fields);
 257         if (!tup) {
 258                 return NULL;
 259         }
 260
 261         dict = PyDict_New();
 262         if (!dict) {
 263                 Py_DECREF(tup);
 264                 return NULL;
 265         }
 266
 267         for (i = 0; i < n_visible_fields; i++) {
 268                 Py_INCREF(self->ob_item[i]);
 269                 PyTuple_SET_ITEM(tup, i, self->ob_item[i]);
 270         }
 271
 272         for (; i < n_fields; i++) {
 273                 char *n = self->ob_type->tp_members[i-n_unnamed_fields].name;
 274                 PyDict_SetItemString(dict, n,
 275                                      self->ob_item[i]);
 276         }
 277
 278         result = Py_BuildValue("(O(OO))", self->ob_type, tup, dict);
 279
 280         Py_DECREF(tup);
 281         Py_DECREF(dict);
 282
 283         return result;
 284 }
 285
 286 static PySequenceMethods structseq_as_sequence = {
 287         (lenfunc)structseq_length,
 288         (binaryfunc)structseq_concat,           /* sq_concat */
 289         (ssizeargfunc)structseq_repeat,         /* sq_repeat */
 290         (ssizeargfunc)structseq_item,           /* sq_item */
 291         (ssizessizeargfunc)structseq_slice,     /* sq_slice */
 292         0,                                      /* sq_ass_item */
 293         0,                                      /* sq_ass_slice */
 294         (objobjproc)structseq_contains,         /* sq_contains */
 295 };
 296
 297 static PyMethodDef structseq_methods[] = {
 298         {"__reduce__", (PyCFunction)structseq_reduce,
 299          METH_NOARGS, NULL},
 300         {NULL, NULL}
 301 };
 302
 303 static PyTypeObject _struct_sequence_template = {
 304         PyObject_HEAD_INIT(&PyType_Type)
 305         0,                                      /* ob_size */
 306         NULL,                                   /* tp_name */
 307         0,                                      /* tp_basicsize */
 308         0,                                      /* tp_itemsize */
 309         (destructor)structseq_dealloc,          /* tp_dealloc */
 310         0,                                      /* tp_print */
 311         0,                                      /* tp_getattr */
 312         0,                                      /* tp_setattr */
 313         0,                                      /* tp_compare */
 314         (reprfunc)structseq_repr,               /* tp_repr */
 315         0,                                      /* tp_as_number */
 316         &structseq_as_sequence,                 /* tp_as_sequence */
 317         0,                                      /* tp_as_mapping */
 318         structseq_hash,                         /* tp_hash */
 319         0,                                      /* tp_call */
 320         0,                                      /* tp_str */
 321         0,                                      /* tp_getattro */
 322         0,                                      /* tp_setattro */
 323         0,                                      /* tp_as_buffer */
 324         Py_TPFLAGS_DEFAULT,                     /* tp_flags */
 325         NULL,                                   /* tp_doc */
 326         0,                                      /* tp_traverse */
 327         0,                                      /* tp_clear */
 328         structseq_richcompare,                  /* tp_richcompare */
 329         0,                                      /* tp_weaklistoffset */
 330         0,                                      /* tp_iter */
 331         0,                                      /* tp_iternext */
 332         structseq_methods,                      /* tp_methods */
 333         NULL,                                   /* tp_members */
 334         0,                                      /* tp_getset */
 335         0,                                      /* tp_base */
 336         0,                                      /* tp_dict */
 337         0,                                      /* tp_descr_get */
 338         0,                                      /* tp_descr_set */
 339         0,                                      /* tp_dictoffset */
 340         0,                                      /* tp_init */
 341         0,                                      /* tp_alloc */
 342         structseq_new,                          /* tp_new */
 343 };
 344
 345 void
 346 PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc)
 347 {
 348         PyObject *dict;
 349         PyMemberDef* members;
 350         int n_members, n_unnamed_members, i, k;
 351
 352 #ifdef Py_TRACE_REFS
 353         /* if the type object was chained, unchain it first
 354            before overwriting its storage */
 355         if (type->_ob_next) {
 356                 _Py_ForgetReference((PyObject*)type);
 357         }
 358 #endif
 359
 360         n_unnamed_members = 0;
 361         for (i = 0; desc->fields[i].name != NULL; ++i)
 362                 if (desc->fields[i].name == PyStructSequence_UnnamedField)
 363                         n_unnamed_members++;
 364         n_members = i;
 365
 366         memcpy(type, &_struct_sequence_template, sizeof(PyTypeObject));
 367         type->tp_name = desc->name;
 368         type->tp_doc = desc->doc;
 369         type->tp_basicsize = sizeof(PyStructSequence)+
 370                 sizeof(PyObject*)*(n_members-1);
 371         type->tp_itemsize = 0;
 372
 373         members = PyMem_NEW(PyMemberDef, n_members-n_unnamed_members+1);
 374         if (members == NULL)
 375                 return;
 376
 377         for (i = k = 0; i < n_members; ++i) {
 378                 if (desc->fields[i].name == PyStructSequence_UnnamedField)
 379                         continue;
 380                 members[k].name = desc->fields[i].name;
 381                 members[k].type = T_OBJECT;
 382                 members[k].offset = offsetof(PyStructSequence, ob_item)
 383                   + i * sizeof(PyObject*);
 384                 members[k].flags = READONLY;
 385                 members[k].doc = desc->fields[i].doc;
 386                 k++;
 387         }
 388         members[k].name = NULL;
 389
 390         type->tp_members = members;
 391
 392         if (PyType_Ready(type) < 0)
 393                 return;
 394         Py_INCREF(type);
 395
 396         dict = type->tp_dict;
 397         PyDict_SetItemString(dict, visible_length_key,
 398                        PyInt_FromLong((long) desc->n_in_sequence));
 399         PyDict_SetItemString(dict, real_length_key,
 400                        PyInt_FromLong((long) n_members));
 401         PyDict_SetItemString(dict, unnamed_fields_key,
 402                        PyInt_FromLong((long) n_unnamed_members));
 403 }