Objects/descrobject.c

   1 /* Descriptors -- a new, flexible way to describe attributes */
   2
   3 #include "Python.h"
   4 #include "structmember.h" /* Why is this not included in Python.h? */
   5
   6 static void
   7 descr_dealloc(PyDescrObject *descr)
   8 {
   9         _PyObject_GC_UNTRACK(descr);
  10         Py_XDECREF(descr->d_type);
  11         Py_XDECREF(descr->d_name);
  12         PyObject_GC_Del(descr);
  13 }
  14
  15 static char *
  16 descr_name(PyDescrObject *descr)
  17 {
  18         if (descr->d_name != NULL && PyString_Check(descr->d_name))
  19                 return PyString_AS_STRING(descr->d_name);
  20         else
  21                 return "?";
  22 }
  23
  24 static PyObject *
  25 descr_repr(PyDescrObject *descr, char *format)
  26 {
  27         return PyString_FromFormat(format, descr_name(descr),
  28                                    descr->d_type->tp_name);
  29 }
  30
  31 static PyObject *
  32 method_repr(PyMethodDescrObject *descr)
  33 {
  34         return descr_repr((PyDescrObject *)descr,
  35                           "<method '%s' of '%s' objects>");
  36 }
  37
  38 static PyObject *
  39 member_repr(PyMemberDescrObject *descr)
  40 {
  41         return descr_repr((PyDescrObject *)descr,
  42                           "<member '%s' of '%s' objects>");
  43 }
  44
  45 static PyObject *
  46 getset_repr(PyGetSetDescrObject *descr)
  47 {
  48         return descr_repr((PyDescrObject *)descr,
  49                           "<attribute '%s' of '%s' objects>");
  50 }
  51
  52 static PyObject *
  53 wrapper_repr(PyWrapperDescrObject *descr)
  54 {
  55         return descr_repr((PyDescrObject *)descr,
  56                           "<slot wrapper '%s' of '%s' objects>");
  57 }
  58
  59 static int
  60 descr_check(PyDescrObject *descr, PyObject *obj, PyTypeObject *type,
  61             PyObject **pres)
  62 {
  63         if (obj == NULL || (obj == Py_None && type != Py_None->ob_type)) {
  64                 Py_INCREF(descr);
  65                 *pres = (PyObject *)descr;
  66                 return 1;
  67         }
  68         if (!PyObject_IsInstance(obj, (PyObject *)(descr->d_type))) {
  69                 PyErr_Format(PyExc_TypeError,
  70                              "descriptor '%s' for '%s' objects "
  71                              "doesn't apply to '%s' object",
  72                              descr_name((PyDescrObject *)descr),
  73                              descr->d_type->tp_name,
  74                              obj->ob_type->tp_name);
  75                 *pres = NULL;
  76                 return 1;
  77         }
  78         return 0;
  79 }
  80
  81 static PyObject *
  82 method_get(PyMethodDescrObject *descr, PyObject *obj, PyTypeObject *type)
  83 {
  84         PyObject *res;
  85
  86         if (descr_check((PyDescrObject *)descr, obj, type, &res))
  87                 return res;
  88         return PyCFunction_New(descr->d_method, obj);
  89 }
  90
  91 static PyObject *
  92 member_get(PyMemberDescrObject *descr, PyObject *obj, PyTypeObject *type)
  93 {
  94         PyObject *res;
  95
  96         if (descr_check((PyDescrObject *)descr, obj, type, &res))
  97                 return res;
  98         return PyMember_GetOne((char *)obj, descr->d_member);
  99 }
 100
 101 static PyObject *
 102 getset_get(PyGetSetDescrObject *descr, PyObject *obj, PyTypeObject *type)
 103 {
 104         PyObject *res;
 105
 106         if (descr_check((PyDescrObject *)descr, obj, type, &res))
 107                 return res;
 108         if (descr->d_getset->get != NULL)
 109                 return descr->d_getset->get(obj, descr->d_getset->closure);
 110         PyErr_Format(PyExc_TypeError,
 111                      "attribute '%.300s' of '%.100s' objects is not readable",
 112                      descr_name((PyDescrObject *)descr),
 113                      descr->d_type->tp_name);
 114         return NULL;
 115 }
 116
 117 static PyObject *
 118 wrapper_get(PyWrapperDescrObject *descr, PyObject *obj, PyTypeObject *type)
 119 {
 120         PyObject *res;
 121
 122         if (descr_check((PyDescrObject *)descr, obj, type, &res))
 123                 return res;
 124         return PyWrapper_New((PyObject *)descr, obj);
 125 }
 126
 127 static int
 128 descr_setcheck(PyDescrObject *descr, PyObject *obj, PyObject *value,
 129                int *pres)
 130 {
 131         assert(obj != NULL);
 132         if (!PyObject_IsInstance(obj, (PyObject *)(descr->d_type))) {
 133                 PyErr_Format(PyExc_TypeError,
 134                              "descriptor '%.200s' for '%.100s' objects "
 135                              "doesn't apply to '%.100s' object",
 136                              descr_name(descr),
 137                              descr->d_type->tp_name,
 138                              obj->ob_type->tp_name);
 139                 *pres = -1;
 140                 return 1;
 141         }
 142         return 0;
 143 }
 144
 145 static int
 146 member_set(PyMemberDescrObject *descr, PyObject *obj, PyObject *value)
 147 {
 148         int res;
 149
 150         if (descr_setcheck((PyDescrObject *)descr, obj, value, &res))
 151                 return res;
 152         return PyMember_SetOne((char *)obj, descr->d_member, value);
 153 }
 154
 155 static int
 156 getset_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value)
 157 {
 158         int res;
 159
 160         if (descr_setcheck((PyDescrObject *)descr, obj, value, &res))
 161                 return res;
 162         if (descr->d_getset->set != NULL)
 163                 return descr->d_getset->set(obj, value,
 164                                             descr->d_getset->closure);
 165         PyErr_Format(PyExc_TypeError,
 166                      "attribute '%.300s' of '%.100s' objects is not writable",
 167                      descr_name((PyDescrObject *)descr),
 168                      descr->d_type->tp_name);
 169         return -1;
 170 }
 171
 172 static PyObject *
 173 methoddescr_call(PyMethodDescrObject *descr, PyObject *args, PyObject *kwds)
 174 {
 175         int argc;
 176         PyObject *self, *func, *result;
 177
 178         /* Make sure that the first argument is acceptable as 'self' */
 179         assert(PyTuple_Check(args));
 180         argc = PyTuple_GET_SIZE(args);
 181         if (argc < 1) {
 182                 PyErr_Format(PyExc_TypeError,
 183                              "descriptor '%.300s' of '%.100s' "
 184                              "object needs an argument",
 185                              descr_name((PyDescrObject *)descr),
 186                              descr->d_type->tp_name);
 187                 return NULL;
 188         }
 189         self = PyTuple_GET_ITEM(args, 0);
 190         if (!PyObject_IsInstance(self, (PyObject *)(descr->d_type))) {
 191                 PyErr_Format(PyExc_TypeError,
 192                              "descriptor '%.200s' "
 193                              "requires a '%.100s' object "
 194                              "but received a '%.100s'",
 195                              descr_name((PyDescrObject *)descr),
 196                              descr->d_type->tp_name,
 197                              self->ob_type->tp_name);
 198                 return NULL;
 199         }
 200
 201         func = PyCFunction_New(descr->d_method, self);
 202         if (func == NULL)
 203                 return NULL;
 204         args = PyTuple_GetSlice(args, 1, argc);
 205         if (args == NULL) {
 206                 Py_DECREF(func);
 207                 return NULL;
 208         }
 209         result = PyEval_CallObjectWithKeywords(func, args, kwds);
 210         Py_DECREF(args);
 211         Py_DECREF(func);
 212         return result;
 213 }
 214
 215 static PyObject *
 216 wrapperdescr_call(PyWrapperDescrObject *descr, PyObject *args, PyObject *kwds)
 217 {
 218         int argc;
 219         PyObject *self, *func, *result;
 220
 221         /* Make sure that the first argument is acceptable as 'self' */
 222         assert(PyTuple_Check(args));
 223         argc = PyTuple_GET_SIZE(args);
 224         if (argc < 1) {
 225                 PyErr_Format(PyExc_TypeError,
 226                              "descriptor '%.300s' of '%.100s' "
 227                              "object needs an argument",
 228                              descr_name((PyDescrObject *)descr),
 229                              descr->d_type->tp_name);
 230                 return NULL;
 231         }
 232         self = PyTuple_GET_ITEM(args, 0);
 233         if (!PyObject_IsInstance(self, (PyObject *)(descr->d_type))) {
 234                 PyErr_Format(PyExc_TypeError,
 235                              "descriptor '%.200s' "
 236                              "requires a '%.100s' object "
 237                              "but received a '%.100s'",
 238                              descr_name((PyDescrObject *)descr),
 239                              descr->d_type->tp_name,
 240                              self->ob_type->tp_name);
 241                 return NULL;
 242         }
 243
 244         func = PyWrapper_New((PyObject *)descr, self);
 245         if (func == NULL)
 246                 return NULL;
 247         args = PyTuple_GetSlice(args, 1, argc);
 248         if (args == NULL) {
 249                 Py_DECREF(func);
 250                 return NULL;
 251         }
 252         result = PyEval_CallObjectWithKeywords(func, args, kwds);
 253         Py_DECREF(args);
 254         Py_DECREF(func);
 255         return result;
 256 }
 257
 258 static PyObject *
 259 method_get_doc(PyMethodDescrObject *descr, void *closure)
 260 {
 261         if (descr->d_method->ml_doc == NULL) {
 262                 Py_INCREF(Py_None);
 263                 return Py_None;
 264         }
 265         return PyString_FromString(descr->d_method->ml_doc);
 266 }
 267
 268 static PyMemberDef descr_members[] = {
 269         {"__objclass__", T_OBJECT, offsetof(PyDescrObject, d_type), READONLY},
 270         {"__name__", T_OBJECT, offsetof(PyDescrObject, d_name), READONLY},
 271         {0}
 272 };
 273
 274 static PyGetSetDef method_getset[] = {
 275         {"__doc__", (getter)method_get_doc},
 276         {0}
 277 };
 278
 279 static PyObject *
 280 member_get_doc(PyMemberDescrObject *descr, void *closure)
 281 {
 282         if (descr->d_member->doc == NULL) {
 283                 Py_INCREF(Py_None);
 284                 return Py_None;
 285         }
 286         return PyString_FromString(descr->d_member->doc);
 287 }
 288
 289 static PyGetSetDef member_getset[] = {
 290         {"__doc__", (getter)member_get_doc},
 291         {0}
 292 };
 293
 294 static PyObject *
 295 getset_get_doc(PyGetSetDescrObject *descr, void *closure)
 296 {
 297         if (descr->d_getset->doc == NULL) {
 298                 Py_INCREF(Py_None);
 299                 return Py_None;
 300         }
 301         return PyString_FromString(descr->d_getset->doc);
 302 }
 303
 304 static PyGetSetDef getset_getset[] = {
 305         {"__doc__", (getter)getset_get_doc},
 306         {0}
 307 };
 308
 309 static PyObject *
 310 wrapper_get_doc(PyWrapperDescrObject *descr, void *closure)
 311 {
 312         if (descr->d_base->doc == NULL) {
 313                 Py_INCREF(Py_None);
 314                 return Py_None;
 315         }
 316         return PyString_FromString(descr->d_base->doc);
 317 }
 318
 319 static PyGetSetDef wrapper_getset[] = {
 320         {"__doc__", (getter)wrapper_get_doc},
 321         {0}
 322 };
 323
 324 static int
 325 descr_traverse(PyObject *self, visitproc visit, void *arg)
 326 {
 327         PyDescrObject *descr = (PyDescrObject *)self;
 328         int err;
 329
 330         if (descr->d_type) {
 331                 err = visit((PyObject *)(descr->d_type), arg);
 332                 if (err)
 333                         return err;
 334         }
 335         return 0;
 336 }
 337
 338 static PyTypeObject PyMethodDescr_Type = {
 339         PyObject_HEAD_INIT(&PyType_Type)
 340         0,
 341         "method_descriptor",
 342         sizeof(PyMethodDescrObject),
 343         0,
 344         (destructor)descr_dealloc,              /* tp_dealloc */
 345         0,                                      /* tp_print */
 346         0,                                      /* tp_getattr */
 347         0,                                      /* tp_setattr */
 348         0,                                      /* tp_compare */
 349         (reprfunc)method_repr,                  /* tp_repr */
 350         0,                                      /* tp_as_number */
 351         0,                                      /* tp_as_sequence */
 352         0,                                      /* tp_as_mapping */
 353         0,                                      /* tp_hash */
 354         (ternaryfunc)methoddescr_call,          /* tp_call */
 355         0,                                      /* tp_str */
 356         PyObject_GenericGetAttr,                /* tp_getattro */
 357         0,                                      /* tp_setattro */
 358         0,                                      /* tp_as_buffer */
 359         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
 360         0,                                      /* tp_doc */
 361         descr_traverse,                         /* tp_traverse */
 362         0,                                      /* tp_clear */
 363         0,                                      /* tp_richcompare */
 364         0,                                      /* tp_weaklistoffset */
 365         0,                                      /* tp_iter */
 366         0,                                      /* tp_iternext */
 367         0,                                      /* tp_methods */
 368         descr_members,                          /* tp_members */
 369         method_getset,                          /* tp_getset */
 370         0,                                      /* tp_base */
 371         0,                                      /* tp_dict */
 372         (descrgetfunc)method_get,               /* tp_descr_get */
 373         0,                                      /* tp_descr_set */
 374 };
 375
 376 static PyTypeObject PyMemberDescr_Type = {
 377         PyObject_HEAD_INIT(&PyType_Type)
 378         0,
 379         "member_descriptor",
 380         sizeof(PyMemberDescrObject),
 381         0,
 382         (destructor)descr_dealloc,              /* tp_dealloc */
 383         0,                                      /* tp_print */
 384         0,                                      /* tp_getattr */
 385         0,                                      /* tp_setattr */
 386         0,                                      /* tp_compare */
 387         (reprfunc)member_repr,                  /* tp_repr */
 388         0,                                      /* tp_as_number */
 389         0,                                      /* tp_as_sequence */
 390         0,                                      /* tp_as_mapping */
 391         0,                                      /* tp_hash */
 392         (ternaryfunc)0,                         /* tp_call */
 393         0,                                      /* tp_str */
 394         PyObject_GenericGetAttr,                /* tp_getattro */
 395         0,                                      /* tp_setattro */
 396         0,                                      /* tp_as_buffer */
 397         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
 398         0,                                      /* tp_doc */
 399         descr_traverse,                         /* tp_traverse */
 400         0,                                      /* tp_clear */
 401         0,                                      /* tp_richcompare */
 402         0,                                      /* tp_weaklistoffset */
 403         0,                                      /* tp_iter */
 404         0,                                      /* tp_iternext */
 405         0,                                      /* tp_methods */
 406         descr_members,                          /* tp_members */
 407         member_getset,                          /* tp_getset */
 408         0,                                      /* tp_base */
 409         0,                                      /* tp_dict */
 410         (descrgetfunc)member_get,               /* tp_descr_get */
 411         (descrsetfunc)member_set,               /* tp_descr_set */
 412 };
 413
 414 static PyTypeObject PyGetSetDescr_Type = {
 415         PyObject_HEAD_INIT(&PyType_Type)
 416         0,
 417         "getset_descriptor",
 418         sizeof(PyGetSetDescrObject),
 419         0,
 420         (destructor)descr_dealloc,              /* tp_dealloc */
 421         0,                                      /* tp_print */
 422         0,                                      /* tp_getattr */
 423         0,                                      /* tp_setattr */
 424         0,                                      /* tp_compare */
 425         (reprfunc)getset_repr,                  /* tp_repr */
 426         0,                                      /* tp_as_number */
 427         0,                                      /* tp_as_sequence */
 428         0,                                      /* tp_as_mapping */
 429         0,                                      /* tp_hash */
 430         (ternaryfunc)0,                         /* tp_call */
 431         0,                                      /* tp_str */
 432         PyObject_GenericGetAttr,                /* tp_getattro */
 433         0,                                      /* tp_setattro */
 434         0,                                      /* tp_as_buffer */
 435         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
 436         0,                                      /* tp_doc */
 437         descr_traverse,                         /* tp_traverse */
 438         0,                                      /* tp_clear */
 439         0,                                      /* tp_richcompare */
 440         0,                                      /* tp_weaklistoffset */
 441         0,                                      /* tp_iter */
 442         0,                                      /* tp_iternext */
 443         0,                                      /* tp_methods */
 444         descr_members,                          /* tp_members */
 445         getset_getset,                          /* tp_getset */
 446         0,                                      /* tp_base */
 447         0,                                      /* tp_dict */
 448         (descrgetfunc)getset_get,               /* tp_descr_get */
 449         (descrsetfunc)getset_set,               /* tp_descr_set */
 450 };
 451
 452 PyTypeObject PyWrapperDescr_Type = {
 453         PyObject_HEAD_INIT(&PyType_Type)
 454         0,
 455         "wrapper_descriptor",
 456         sizeof(PyWrapperDescrObject),
 457         0,
 458         (destructor)descr_dealloc,              /* tp_dealloc */
 459         0,                                      /* tp_print */
 460         0,                                      /* tp_getattr */
 461         0,                                      /* tp_setattr */
 462         0,                                      /* tp_compare */
 463         (reprfunc)wrapper_repr,                 /* tp_repr */
 464         0,                                      /* tp_as_number */
 465         0,                                      /* tp_as_sequence */
 466         0,                                      /* tp_as_mapping */
 467         0,                                      /* tp_hash */
 468         (ternaryfunc)wrapperdescr_call,         /* tp_call */
 469         0,                                      /* tp_str */
 470         PyObject_GenericGetAttr,                /* tp_getattro */
 471         0,                                      /* tp_setattro */
 472         0,                                      /* tp_as_buffer */
 473         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
 474         0,                                      /* tp_doc */
 475         descr_traverse,                         /* tp_traverse */
 476         0,                                      /* tp_clear */
 477         0,                                      /* tp_richcompare */
 478         0,                                      /* tp_weaklistoffset */
 479         0,                                      /* tp_iter */
 480         0,                                      /* tp_iternext */
 481         0,                                      /* tp_methods */
 482         descr_members,                          /* tp_members */
 483         wrapper_getset,                         /* tp_getset */
 484         0,                                      /* tp_base */
 485         0,                                      /* tp_dict */
 486         (descrgetfunc)wrapper_get,              /* tp_descr_get */
 487         0,                                      /* tp_descr_set */
 488 };
 489
 490 static PyDescrObject *
 491 descr_new(PyTypeObject *descrtype, PyTypeObject *type, char *name)
 492 {
 493         PyDescrObject *descr;
 494
 495         descr = (PyDescrObject *)PyType_GenericAlloc(descrtype, 0);
 496         if (descr != NULL) {
 497                 Py_XINCREF(type);
 498                 descr->d_type = type;
 499                 descr->d_name = PyString_InternFromString(name);
 500                 if (descr->d_name == NULL) {
 501                         Py_DECREF(descr);
 502                         descr = NULL;
 503                 }
 504         }
 505         return descr;
 506 }
 507
 508 PyObject *
 509 PyDescr_NewMethod(PyTypeObject *type, PyMethodDef *method)
 510 {
 511         PyMethodDescrObject *descr;
 512
 513         descr = (PyMethodDescrObject *)descr_new(&PyMethodDescr_Type,
 514                                                  type, method->ml_name);
 515         if (descr != NULL)
 516                 descr->d_method = method;
 517         return (PyObject *)descr;
 518 }
 519
 520 PyObject *
 521 PyDescr_NewMember(PyTypeObject *type, PyMemberDef *member)
 522 {
 523         PyMemberDescrObject *descr;
 524
 525         descr = (PyMemberDescrObject *)descr_new(&PyMemberDescr_Type,
 526                                                  type, member->name);
 527         if (descr != NULL)
 528                 descr->d_member = member;
 529         return (PyObject *)descr;
 530 }
 531
 532 PyObject *
 533 PyDescr_NewGetSet(PyTypeObject *type, PyGetSetDef *getset)
 534 {
 535         PyGetSetDescrObject *descr;
 536
 537         descr = (PyGetSetDescrObject *)descr_new(&PyGetSetDescr_Type,
 538                                                  type, getset->name);
 539         if (descr != NULL)
 540                 descr->d_getset = getset;
 541         return (PyObject *)descr;
 542 }
 543
 544 PyObject *
 545 PyDescr_NewWrapper(PyTypeObject *type, struct wrapperbase *base, void *wrapped)
 546 {
 547         PyWrapperDescrObject *descr;
 548
 549         descr = (PyWrapperDescrObject *)descr_new(&PyWrapperDescr_Type,
 550                                                  type, base->name);
 551         if (descr != NULL) {
 552                 descr->d_base = base;
 553                 descr->d_wrapped = wrapped;
 554         }
 555         return (PyObject *)descr;
 556 }
 557
 558 int
 559 PyDescr_IsData(PyObject *d)
 560 {
 561         return d->ob_type->tp_descr_set != NULL;
 562 }
 563
 564
 565 /* --- Readonly proxy for dictionaries (actually any mapping) --- */
 566
 567 /* This has no reason to be in this file except that adding new files is a
 568    bit of a pain */
 569
 570 typedef struct {
 571         PyObject_HEAD
 572         PyObject *dict;
 573 } proxyobject;
 574
 575 static int
 576 proxy_len(proxyobject *pp)
 577 {
 578         return PyObject_Size(pp->dict);
 579 }
 580
 581 static PyObject *
 582 proxy_getitem(proxyobject *pp, PyObject *key)
 583 {
 584         return PyObject_GetItem(pp->dict, key);
 585 }
 586
 587 static PyMappingMethods proxy_as_mapping = {
 588         (inquiry)proxy_len,                     /* mp_length */
 589         (binaryfunc)proxy_getitem,              /* mp_subscript */
 590         0,                                      /* mp_ass_subscript */
 591 };
 592
 593 static int
 594 proxy_contains(proxyobject *pp, PyObject *key)
 595 {
 596         return PySequence_Contains(pp->dict, key);
 597 }
 598
 599 static PySequenceMethods proxy_as_sequence = {
 600         0,                                      /* sq_length */
 601         0,                                      /* sq_concat */
 602         0,                                      /* sq_repeat */
 603         0,                                      /* sq_item */
 604         0,                                      /* sq_slice */
 605         0,                                      /* sq_ass_item */
 606         0,                                      /* sq_ass_slice */
 607         (objobjproc)proxy_contains,             /* sq_contains */
 608         0,                                      /* sq_inplace_concat */
 609         0,                                      /* sq_inplace_repeat */
 610 };
 611
 612 static PyObject *
 613 proxy_has_key(proxyobject *pp, PyObject *key)
 614 {
 615         return PyInt_FromLong(PySequence_Contains(pp->dict, key));
 616 }
 617
 618 static PyObject *
 619 proxy_get(proxyobject *pp, PyObject *args)
 620 {
 621         PyObject *key, *def = Py_None;
 622
 623         if (!PyArg_ParseTuple(args, "O|O:get", &key, &def))
 624                 return NULL;
 625         return PyObject_CallMethod(pp->dict, "get", "(OO)", key, def);
 626 }
 627
 628 static PyObject *
 629 proxy_keys(proxyobject *pp)
 630 {
 631         return PyMapping_Keys(pp->dict);
 632 }
 633
 634 static PyObject *
 635 proxy_values(proxyobject *pp)
 636 {
 637         return PyMapping_Values(pp->dict);
 638 }
 639
 640 static PyObject *
 641 proxy_items(proxyobject *pp)
 642 {
 643         return PyMapping_Items(pp->dict);
 644 }
 645
 646 static PyObject *
 647 proxy_copy(proxyobject *pp)
 648 {
 649         return PyObject_CallMethod(pp->dict, "copy", NULL);
 650 }
 651
 652 static PyMethodDef proxy_methods[] = {
 653         {"has_key", (PyCFunction)proxy_has_key, METH_O, "XXX"},
 654         {"get",     (PyCFunction)proxy_get,     METH_VARARGS, "XXX"},
 655         {"keys",    (PyCFunction)proxy_keys,    METH_NOARGS, "XXX"},
 656         {"values",  (PyCFunction)proxy_values,  METH_NOARGS, "XXX"},
 657         {"items",   (PyCFunction)proxy_items,   METH_NOARGS, "XXX"},
 658         {"copy",    (PyCFunction)proxy_copy,    METH_NOARGS, "XXX"},
 659         {0}
 660 };
 661
 662 static void
 663 proxy_dealloc(proxyobject *pp)
 664 {
 665         _PyObject_GC_UNTRACK(pp);
 666         Py_DECREF(pp->dict);
 667         PyObject_GC_Del(pp);
 668 }
 669
 670 static PyObject *
 671 proxy_getiter(proxyobject *pp)
 672 {
 673         return PyObject_GetIter(pp->dict);
 674 }
 675
 676 static PyObject *
 677 proxy_str(proxyobject *pp)
 678 {
 679         return PyObject_Str(pp->dict);
 680 }
 681
 682 static int
 683 proxy_traverse(PyObject *self, visitproc visit, void *arg)
 684 {
 685         proxyobject *pp = (proxyobject *)self;
 686         int err;
 687
 688         if (pp->dict) {
 689                 err = visit(pp->dict, arg);
 690                 if (err)
 691                         return err;
 692         }
 693         return 0;
 694 }
 695
 696 static PyTypeObject proxytype = {
 697         PyObject_HEAD_INIT(&PyType_Type)
 698         0,                                      /* ob_size */
 699         "dict-proxy",                           /* tp_name */
 700         sizeof(proxyobject),                    /* tp_basicsize */
 701         0,                                      /* tp_itemsize */
 702         /* methods */
 703         (destructor)proxy_dealloc,              /* tp_dealloc */
 704         0,                                      /* tp_print */
 705         0,                                      /* tp_getattr */
 706         0,                                      /* tp_setattr */
 707         0,                                      /* tp_compare */
 708         0,                                      /* tp_repr */
 709         0,                                      /* tp_as_number */
 710         &proxy_as_sequence,                     /* tp_as_sequence */
 711         &proxy_as_mapping,                      /* tp_as_mapping */
 712         0,                                      /* tp_hash */
 713         0,                                      /* tp_call */
 714         (reprfunc)proxy_str,                    /* tp_str */
 715         PyObject_GenericGetAttr,                /* tp_getattro */
 716         0,                                      /* tp_setattro */
 717         0,                                      /* tp_as_buffer */
 718         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
 719         0,                                      /* tp_doc */
 720         proxy_traverse,                         /* tp_traverse */
 721         0,                                      /* tp_clear */
 722         0,                                      /* tp_richcompare */
 723         0,                                      /* tp_weaklistoffset */
 724         (getiterfunc)proxy_getiter,             /* tp_iter */
 725         0,                                      /* tp_iternext */
 726         proxy_methods,                          /* tp_methods */
 727         0,                                      /* tp_members */
 728         0,                                      /* tp_getset */
 729         0,                                      /* tp_base */
 730         0,                                      /* tp_dict */
 731         0,                                      /* tp_descr_get */
 732         0,                                      /* tp_descr_set */
 733 };
 734
 735 PyObject *
 736 PyDictProxy_New(PyObject *dict)
 737 {
 738         proxyobject *pp;
 739
 740         pp = PyObject_GC_New(proxyobject, &proxytype);
 741         if (pp != NULL) {
 742                 Py_INCREF(dict);
 743                 pp->dict = dict;
 744                 _PyObject_GC_TRACK(pp);
 745         }
 746         return (PyObject *)pp;
 747 }
 748
 749
 750 /* --- Wrapper object for "slot" methods --- */
 751
 752 /* This has no reason to be in this file except that adding new files is a
 753    bit of a pain */
 754
 755 typedef struct {
 756         PyObject_HEAD
 757         PyWrapperDescrObject *descr;
 758         PyObject *self;
 759 } wrapperobject;
 760
 761 static void
 762 wrapper_dealloc(wrapperobject *wp)
 763 {
 764         _PyObject_GC_UNTRACK(wp);
 765         Py_XDECREF(wp->descr);
 766         Py_XDECREF(wp->self);
 767         PyObject_GC_Del(wp);
 768 }
 769
 770 static PyMethodDef wrapper_methods[] = {
 771         {0}
 772 };
 773
 774 static PyObject *
 775 wrapper_name(wrapperobject *wp)
 776 {
 777         char *s = wp->descr->d_base->name;
 778
 779         return PyString_FromString(s);
 780 }
 781
 782 static PyObject *
 783 wrapper_doc(wrapperobject *wp)
 784 {
 785         char *s = wp->descr->d_base->doc;
 786
 787         if (s == NULL) {
 788                 Py_INCREF(Py_None);
 789                 return Py_None;
 790         }
 791         else {
 792                 return PyString_FromString(s);
 793         }
 794 }
 795
 796 static PyGetSetDef wrapper_getsets[] = {
 797         {"__name__", (getter)wrapper_name},
 798         {"__doc__", (getter)wrapper_doc},
 799         {0}
 800 };
 801
 802 static PyObject *
 803 wrapper_call(wrapperobject *wp, PyObject *args, PyObject *kwds)
 804 {
 805         wrapperfunc wrapper = wp->descr->d_base->wrapper;
 806         PyObject *self = wp->self;
 807
 808         if (wp->descr->d_base->flags & PyWrapperFlag_KEYWORDS) {
 809                 wrapperfunc_kwds wk = (wrapperfunc_kwds)wrapper;
 810                 return (*wk)(self, args, wp->descr->d_wrapped, kwds);
 811         }
 812
 813         if (kwds != NULL && (!PyDict_Check(kwds) || PyDict_Size(kwds) != 0)) {
 814                 PyErr_Format(PyExc_TypeError,
 815                              "wrapper %s doesn't take keyword arguments",
 816                              wp->descr->d_base->name);
 817                 return NULL;
 818         }
 819         return (*wrapper)(self, args, wp->descr->d_wrapped);
 820 }
 821
 822 static int
 823 wrapper_traverse(PyObject *self, visitproc visit, void *arg)
 824 {
 825         wrapperobject *wp = (wrapperobject *)self;
 826         int err;
 827
 828         if (wp->descr) {
 829                 err = visit((PyObject *)(wp->descr), arg);
 830                 if (err)
 831                         return err;
 832         }
 833         if (wp->self) {
 834                 err = visit(wp->self, arg);
 835                 if (err)
 836                         return err;
 837         }
 838         return 0;
 839 }
 840
 841 static PyTypeObject wrappertype = {
 842         PyObject_HEAD_INIT(&PyType_Type)
 843         0,                                      /* ob_size */
 844         "method-wrapper",                       /* tp_name */
 845         sizeof(wrapperobject),                  /* tp_basicsize */
 846         0,                                      /* tp_itemsize */
 847         /* methods */
 848         (destructor)wrapper_dealloc,            /* tp_dealloc */
 849         0,                                      /* tp_print */
 850         0,                                      /* tp_getattr */
 851         0,                                      /* tp_setattr */
 852         0,                                      /* tp_compare */
 853         0,                                      /* tp_repr */
 854         0,                                      /* tp_as_number */
 855         0,                                      /* tp_as_sequence */
 856         0,                                      /* tp_as_mapping */
 857         0,                                      /* tp_hash */
 858         (ternaryfunc)wrapper_call,              /* tp_call */
 859         0,                                      /* tp_str */
 860         PyObject_GenericGetAttr,                /* tp_getattro */
 861         0,                                      /* tp_setattro */
 862         0,                                      /* tp_as_buffer */
 863         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
 864         0,                                      /* tp_doc */
 865         wrapper_traverse,                       /* tp_traverse */
 866         0,                                      /* tp_clear */
 867         0,                                      /* tp_richcompare */
 868         0,                                      /* tp_weaklistoffset */
 869         0,                                      /* tp_iter */
 870         0,                                      /* tp_iternext */
 871         wrapper_methods,                        /* tp_methods */
 872         0,                                      /* tp_members */
 873         wrapper_getsets,                        /* tp_getset */
 874         0,                                      /* tp_base */
 875         0,                                      /* tp_dict */
 876         0,                                      /* tp_descr_get */
 877         0,                                      /* tp_descr_set */
 878 };
 879
 880 PyObject *
 881 PyWrapper_New(PyObject *d, PyObject *self)
 882 {
 883         wrapperobject *wp;
 884         PyWrapperDescrObject *descr;
 885
 886         assert(PyObject_TypeCheck(d, &PyWrapperDescr_Type));
 887         descr = (PyWrapperDescrObject *)d;
 888         assert(PyObject_IsInstance(self, (PyObject *)(descr->d_type)));
 889
 890         wp = PyObject_GC_New(wrapperobject, &wrappertype);
 891         if (wp != NULL) {
 892                 Py_INCREF(descr);
 893                 wp->descr = descr;
 894                 Py_INCREF(self);
 895                 wp->self = self;
 896                 _PyObject_GC_TRACK(wp);
 897         }
 898         return (PyObject *)wp;
 899 }
 900
 901
 902 /* A built-in 'property' type */
 903
 904 /*
 905     class property(object):
 906
 907         def __init__(self, fget=None, fset=None, fdel=None, doc=None):
 908             self.__get = fget
 909             self.__set = fset
 910             self.__del = fdel
 911             self.__doc__ = doc
 912
 913         def __get__(self, inst, type=None):
 914             if inst is None:
 915                 return self
 916             if self.__get is None:
 917                 raise AttributeError, "unreadable attribute"
 918             return self.__get(inst)
 919
 920         def __set__(self, inst, value):
 921             if self.__set is None:
 922                 raise AttributeError, "can't set attribute"
 923             return self.__set(inst, value)
 924
 925         def __delete__(self, inst):
 926             if self.__del is None:
 927                 raise AttributeError, "can't delete attribute"
 928             return self.__del(inst)
 929
 930 */
 931
 932 typedef struct {
 933         PyObject_HEAD
 934         PyObject *prop_get;
 935         PyObject *prop_set;
 936         PyObject *prop_del;
 937         PyObject *prop_doc;
 938 } propertyobject;
 939
 940 static PyMemberDef property_members[] = {
 941         {"fget", T_OBJECT, offsetof(propertyobject, prop_get), READONLY},
 942         {"fset", T_OBJECT, offsetof(propertyobject, prop_set), READONLY},
 943         {"fdel", T_OBJECT, offsetof(propertyobject, prop_del), READONLY},
 944         {"__doc__",  T_OBJECT, offsetof(propertyobject, prop_doc), READONLY},
 945         {0}
 946 };
 947
 948
 949 static void
 950 property_dealloc(PyObject *self)
 951 {
 952         propertyobject *gs = (propertyobject *)self;
 953
 954         _PyObject_GC_UNTRACK(self);
 955         Py_XDECREF(gs->prop_get);
 956         Py_XDECREF(gs->prop_set);
 957         Py_XDECREF(gs->prop_del);
 958         Py_XDECREF(gs->prop_doc);
 959         self->ob_type->tp_free(self);
 960 }
 961
 962 static PyObject *
 963 property_descr_get(PyObject *self, PyObject *obj, PyObject *type)
 964 {
 965         propertyobject *gs = (propertyobject *)self;
 966
 967         if (obj == NULL || obj == Py_None) {
 968                 Py_INCREF(self);
 969                 return self;
 970         }
 971         if (gs->prop_get == NULL) {
 972                 PyErr_SetString(PyExc_AttributeError, "unreadable attribute");
 973                 return NULL;
 974         }
 975         return PyObject_CallFunction(gs->prop_get, "(O)", obj);
 976 }
 977
 978 static int
 979 property_descr_set(PyObject *self, PyObject *obj, PyObject *value)
 980 {
 981         propertyobject *gs = (propertyobject *)self;
 982         PyObject *func, *res;
 983
 984         if (value == NULL)
 985                 func = gs->prop_del;
 986         else
 987                 func = gs->prop_set;
 988         if (func == NULL) {
 989                 PyErr_SetString(PyExc_AttributeError,
 990                                 value == NULL ?
 991                                 "can't delete attribute" :
 992                                 "can't set attribute");
 993                 return -1;
 994         }
 995         if (value == NULL)
 996                 res = PyObject_CallFunction(func, "(O)", obj);
 997         else
 998                 res = PyObject_CallFunction(func, "(OO)", obj, value);
 999         if (res == NULL)
1000                 return -1;
1001         Py_DECREF(res);
1002         return 0;
1003 }
1004
1005 static int
1006 property_init(PyObject *self, PyObject *args, PyObject *kwds)
1007 {
1008         PyObject *get = NULL, *set = NULL, *del = NULL, *doc = NULL;
1009         static char *kwlist[] = {"fget", "fset", "fdel", "doc", 0};
1010         propertyobject *gs = (propertyobject *)self;
1011
1012         if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO:property",
1013                                          kwlist, &get, &set, &del, &doc))
1014                 return -1;
1015
1016         if (get == Py_None)
1017                 get = NULL;
1018         if (set == Py_None)
1019                 set = NULL;
1020         if (del == Py_None)
1021                 del = NULL;
1022
1023         Py_XINCREF(get);
1024         Py_XINCREF(set);
1025         Py_XINCREF(del);
1026         Py_XINCREF(doc);
1027
1028         gs->prop_get = get;
1029         gs->prop_set = set;
1030         gs->prop_del = del;
1031         gs->prop_doc = doc;
1032
1033         return 0;
1034 }
1035
1036 static char property_doc[] =
1037 "property(fget=None, fset=None, fdel=None, doc=None) -> property attribute\n"
1038 "\n"
1039 "fget is a function to be used for getting an attribute value, and likewise\n"
1040 "fset is a function for setting, and fdel a function for del'ing, an\n"
1041 "attribute.  Typical use is to define a managed attribute x:\n"
1042 "class C(object):\n"
1043 "    def getx(self): return self.__x\n"
1044 "    def setx(self, value): self.__x = value\n"
1045 "    def delx(self): del self.__x\n"
1046 "    x = property(getx, setx, delx, \"I'm the 'x' property.\")";
1047
1048 static int
1049 property_traverse(PyObject *self, visitproc visit, void *arg)
1050 {
1051         propertyobject *pp = (propertyobject *)self;
1052         int err;
1053
1054 #define VISIT(SLOT) \
1055         if (pp->SLOT) { \
1056                 err = visit((PyObject *)(pp->SLOT), arg); \
1057                 if (err) \
1058                         return err; \
1059         }
1060
1061         VISIT(prop_get);
1062         VISIT(prop_set);
1063         VISIT(prop_del);
1064
1065         return 0;
1066 }
1067
1068 PyTypeObject PyProperty_Type = {
1069         PyObject_HEAD_INIT(&PyType_Type)
1070         0,                                      /* ob_size */
1071         "property",                             /* tp_name */
1072         sizeof(propertyobject),                 /* tp_basicsize */
1073         0,                                      /* tp_itemsize */
1074         /* methods */
1075         property_dealloc,                       /* tp_dealloc */
1076         0,                                      /* tp_print */
1077         0,                                      /* tp_getattr */
1078         0,                                      /* tp_setattr */
1079         0,                                      /* tp_compare */
1080         0,                                      /* tp_repr */
1081         0,                                      /* tp_as_number */
1082         0,                                      /* tp_as_sequence */
1083         0,                                      /* tp_as_mapping */
1084         0,                                      /* tp_hash */
1085         0,                                      /* tp_call */
1086         0,                                      /* tp_str */
1087         PyObject_GenericGetAttr,                /* tp_getattro */
1088         0,                                      /* tp_setattro */
1089         0,                                      /* tp_as_buffer */
1090         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
1091                 Py_TPFLAGS_BASETYPE,            /* tp_flags */
1092         property_doc,                           /* tp_doc */
1093         property_traverse,                      /* tp_traverse */
1094         0,                                      /* tp_clear */
1095         0,                                      /* tp_richcompare */
1096         0,                                      /* tp_weaklistoffset */
1097         0,                                      /* tp_iter */
1098         0,                                      /* tp_iternext */
1099         0,                                      /* tp_methods */
1100         property_members,                       /* tp_members */
1101         0,                                      /* tp_getset */
1102         0,                                      /* tp_base */
1103         0,                                      /* tp_dict */
1104         property_descr_get,                     /* tp_descr_get */
1105         property_descr_set,                     /* tp_descr_set */
1106         0,                                      /* tp_dictoffset */
1107         property_init,                          /* tp_init */
1108         PyType_GenericAlloc,                    /* tp_alloc */
1109         PyType_GenericNew,                      /* tp_new */
1110         _PyObject_GC_Del,                       /* tp_free */
1111 };