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 PyObject *
  16 descr_name(PyDescrObject *descr)
  17 {
  18     if (descr->d_name != NULL && PyUnicode_Check(descr->d_name))
  19         return descr->d_name;
  20     return NULL;
  21 }
  22
  23 static PyObject *
  24 descr_repr(PyDescrObject *descr, char *format)
  25 {
  26     PyObject *name = NULL;
  27     if (descr->d_name != NULL && PyUnicode_Check(descr->d_name))
  28         name = descr->d_name;
  29
  30     return PyUnicode_FromFormat(format, name, "?", descr->d_type->tp_name);
  31 }
  32
  33 static PyObject *
  34 method_repr(PyMethodDescrObject *descr)
  35 {
  36     return descr_repr((PyDescrObject *)descr,
  37                       "<method '%V' of '%s' objects>");
  38 }
  39
  40 static PyObject *
  41 member_repr(PyMemberDescrObject *descr)
  42 {
  43     return descr_repr((PyDescrObject *)descr,
  44                       "<member '%V' of '%s' objects>");
  45 }
  46
  47 static PyObject *
  48 getset_repr(PyGetSetDescrObject *descr)
  49 {
  50     return descr_repr((PyDescrObject *)descr,
  51                       "<attribute '%V' of '%s' objects>");
  52 }
  53
  54 static PyObject *
  55 wrapperdescr_repr(PyWrapperDescrObject *descr)
  56 {
  57     return descr_repr((PyDescrObject *)descr,
  58                       "<slot wrapper '%V' of '%s' objects>");
  59 }
  60
  61 static int
  62 descr_check(PyDescrObject *descr, PyObject *obj, PyObject **pres)
  63 {
  64     if (obj == NULL) {
  65         Py_INCREF(descr);
  66         *pres = (PyObject *)descr;
  67         return 1;
  68     }
  69     if (!PyObject_TypeCheck(obj, descr->d_type)) {
  70         PyErr_Format(PyExc_TypeError,
  71                      "descriptor '%V' for '%s' objects "
  72                      "doesn't apply to '%s' object",
  73                      descr_name((PyDescrObject *)descr), "?",
  74                      descr->d_type->tp_name,
  75                      obj->ob_type->tp_name);
  76         *pres = NULL;
  77         return 1;
  78     }
  79     return 0;
  80 }
  81
  82 static PyObject *
  83 classmethod_get(PyMethodDescrObject *descr, PyObject *obj, PyObject *type)
  84 {
  85     /* Ensure a valid type.  Class methods ignore obj. */
  86     if (type == NULL) {
  87         if (obj != NULL)
  88             type = (PyObject *)obj->ob_type;
  89         else {
  90             /* Wot - no type?! */
  91             PyErr_Format(PyExc_TypeError,
  92                          "descriptor '%V' for type '%s' "
  93                          "needs either an object or a type",
  94                          descr_name((PyDescrObject *)descr), "?",
  95                          descr->d_type->tp_name);
  96             return NULL;
  97         }
  98     }
  99     if (!PyType_Check(type)) {
 100         PyErr_Format(PyExc_TypeError,
 101                      "descriptor '%V' for type '%s' "
 102                      "needs a type, not a '%s' as arg 2",
 103                      descr_name((PyDescrObject *)descr), "?",
 104                      descr->d_type->tp_name,
 105                      type->ob_type->tp_name);
 106         return NULL;
 107     }
 108     if (!PyType_IsSubtype((PyTypeObject *)type, descr->d_type)) {
 109         PyErr_Format(PyExc_TypeError,
 110                      "descriptor '%V' for type '%s' "
 111                      "doesn't apply to type '%s'",
 112                      descr_name((PyDescrObject *)descr), "?",
 113                      descr->d_type->tp_name,
 114                      ((PyTypeObject *)type)->tp_name);
 115         return NULL;
 116     }
 117     return PyCFunction_New(descr->d_method, type);
 118 }
 119
 120 static PyObject *
 121 method_get(PyMethodDescrObject *descr, PyObject *obj, PyObject *type)
 122 {
 123     PyObject *res;
 124
 125     if (descr_check((PyDescrObject *)descr, obj, &res))
 126         return res;
 127     return PyCFunction_New(descr->d_method, obj);
 128 }
 129
 130 static PyObject *
 131 member_get(PyMemberDescrObject *descr, PyObject *obj, PyObject *type)
 132 {
 133     PyObject *res;
 134
 135     if (descr_check((PyDescrObject *)descr, obj, &res))
 136         return res;
 137     return PyMember_GetOne((char *)obj, descr->d_member);
 138 }
 139
 140 static PyObject *
 141 getset_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *type)
 142 {
 143     PyObject *res;
 144
 145     if (descr_check((PyDescrObject *)descr, obj, &res))
 146         return res;
 147     if (descr->d_getset->get != NULL)
 148         return descr->d_getset->get(obj, descr->d_getset->closure);
 149     PyErr_Format(PyExc_AttributeError,
 150                  "attribute '%V' of '%.100s' objects is not readable",
 151                  descr_name((PyDescrObject *)descr), "?",
 152                  descr->d_type->tp_name);
 153     return NULL;
 154 }
 155
 156 static PyObject *
 157 wrapperdescr_get(PyWrapperDescrObject *descr, PyObject *obj, PyObject *type)
 158 {
 159     PyObject *res;
 160
 161     if (descr_check((PyDescrObject *)descr, obj, &res))
 162         return res;
 163     return PyWrapper_New((PyObject *)descr, obj);
 164 }
 165
 166 static int
 167 descr_setcheck(PyDescrObject *descr, PyObject *obj, PyObject *value,
 168                int *pres)
 169 {
 170     assert(obj != NULL);
 171     if (!PyObject_TypeCheck(obj, descr->d_type)) {
 172         PyErr_Format(PyExc_TypeError,
 173                      "descriptor '%V' for '%.100s' objects "
 174                      "doesn't apply to '%.100s' object",
 175                      descr_name(descr), "?",
 176                      descr->d_type->tp_name,
 177                      obj->ob_type->tp_name);
 178         *pres = -1;
 179         return 1;
 180     }
 181     return 0;
 182 }
 183
 184 static int
 185 member_set(PyMemberDescrObject *descr, PyObject *obj, PyObject *value)
 186 {
 187     int res;
 188
 189     if (descr_setcheck((PyDescrObject *)descr, obj, value, &res))
 190         return res;
 191     return PyMember_SetOne((char *)obj, descr->d_member, value);
 192 }
 193
 194 static int
 195 getset_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value)
 196 {
 197     int res;
 198
 199     if (descr_setcheck((PyDescrObject *)descr, obj, value, &res))
 200         return res;
 201     if (descr->d_getset->set != NULL)
 202         return descr->d_getset->set(obj, value,
 203                                     descr->d_getset->closure);
 204     PyErr_Format(PyExc_AttributeError,
 205                  "attribute '%V' of '%.100s' objects is not writable",
 206                  descr_name((PyDescrObject *)descr), "?",
 207                  descr->d_type->tp_name);
 208     return -1;
 209 }
 210
 211 static PyObject *
 212 methoddescr_call(PyMethodDescrObject *descr, PyObject *args, PyObject *kwds)
 213 {
 214     Py_ssize_t argc;
 215     PyObject *self, *func, *result;
 216
 217     /* Make sure that the first argument is acceptable as 'self' */
 218     assert(PyTuple_Check(args));
 219     argc = PyTuple_GET_SIZE(args);
 220     if (argc < 1) {
 221         PyErr_Format(PyExc_TypeError,
 222                      "descriptor '%V' of '%.100s' "
 223                      "object needs an argument",
 224                      descr_name((PyDescrObject *)descr), "?",
 225                      descr->d_type->tp_name);
 226         return NULL;
 227     }
 228     self = PyTuple_GET_ITEM(args, 0);
 229     if (!PyObject_IsInstance(self, (PyObject *)(descr->d_type))) {
 230         PyErr_Format(PyExc_TypeError,
 231                      "descriptor '%V' "
 232                      "requires a '%.100s' object "
 233                      "but received a '%.100s'",
 234                      descr_name((PyDescrObject *)descr), "?",
 235                      descr->d_type->tp_name,
 236                      self->ob_type->tp_name);
 237         return NULL;
 238     }
 239
 240     func = PyCFunction_New(descr->d_method, self);
 241     if (func == NULL)
 242         return NULL;
 243     args = PyTuple_GetSlice(args, 1, argc);
 244     if (args == NULL) {
 245         Py_DECREF(func);
 246         return NULL;
 247     }
 248     result = PyEval_CallObjectWithKeywords(func, args, kwds);
 249     Py_DECREF(args);
 250     Py_DECREF(func);
 251     return result;
 252 }
 253
 254 static PyObject *
 255 classmethoddescr_call(PyMethodDescrObject *descr, PyObject *args,
 256                       PyObject *kwds)
 257 {
 258     PyObject *func, *result;
 259
 260     func = PyCFunction_New(descr->d_method, (PyObject *)descr->d_type);
 261     if (func == NULL)
 262         return NULL;
 263
 264     result = PyEval_CallObjectWithKeywords(func, args, kwds);
 265     Py_DECREF(func);
 266     return result;
 267 }
 268
 269 static PyObject *
 270 wrapperdescr_call(PyWrapperDescrObject *descr, PyObject *args, PyObject *kwds)
 271 {
 272     Py_ssize_t argc;
 273     PyObject *self, *func, *result;
 274
 275     /* Make sure that the first argument is acceptable as 'self' */
 276     assert(PyTuple_Check(args));
 277     argc = PyTuple_GET_SIZE(args);
 278     if (argc < 1) {
 279         PyErr_Format(PyExc_TypeError,
 280                      "descriptor '%V' of '%.100s' "
 281                      "object needs an argument",
 282                      descr_name((PyDescrObject *)descr), "?",
 283                      descr->d_type->tp_name);
 284         return NULL;
 285     }
 286     self = PyTuple_GET_ITEM(args, 0);
 287     if (!PyObject_IsInstance(self, (PyObject *)(descr->d_type))) {
 288         PyErr_Format(PyExc_TypeError,
 289                      "descriptor '%V' "
 290                      "requires a '%.100s' object "
 291                      "but received a '%.100s'",
 292                      descr_name((PyDescrObject *)descr), "?",
 293                      descr->d_type->tp_name,
 294                      self->ob_type->tp_name);
 295         return NULL;
 296     }
 297
 298     func = PyWrapper_New((PyObject *)descr, self);
 299     if (func == NULL)
 300         return NULL;
 301     args = PyTuple_GetSlice(args, 1, argc);
 302     if (args == NULL) {
 303         Py_DECREF(func);
 304         return NULL;
 305     }
 306     result = PyEval_CallObjectWithKeywords(func, args, kwds);
 307     Py_DECREF(args);
 308     Py_DECREF(func);
 309     return result;
 310 }
 311
 312 static PyObject *
 313 method_get_doc(PyMethodDescrObject *descr, void *closure)
 314 {
 315     if (descr->d_method->ml_doc == NULL) {
 316         Py_INCREF(Py_None);
 317         return Py_None;
 318     }
 319     return PyUnicode_FromString(descr->d_method->ml_doc);
 320 }
 321
 322 static PyMemberDef descr_members[] = {
 323     {"__objclass__", T_OBJECT, offsetof(PyDescrObject, d_type), READONLY},
 324     {"__name__", T_OBJECT, offsetof(PyDescrObject, d_name), READONLY},
 325     {0}
 326 };
 327
 328 static PyGetSetDef method_getset[] = {
 329     {"__doc__", (getter)method_get_doc},
 330     {0}
 331 };
 332
 333 static PyObject *
 334 member_get_doc(PyMemberDescrObject *descr, void *closure)
 335 {
 336     if (descr->d_member->doc == NULL) {
 337         Py_INCREF(Py_None);
 338         return Py_None;
 339     }
 340     return PyUnicode_FromString(descr->d_member->doc);
 341 }
 342
 343 static PyGetSetDef member_getset[] = {
 344     {"__doc__", (getter)member_get_doc},
 345     {0}
 346 };
 347
 348 static PyObject *
 349 getset_get_doc(PyGetSetDescrObject *descr, void *closure)
 350 {
 351     if (descr->d_getset->doc == NULL) {
 352         Py_INCREF(Py_None);
 353         return Py_None;
 354     }
 355     return PyUnicode_FromString(descr->d_getset->doc);
 356 }
 357
 358 static PyGetSetDef getset_getset[] = {
 359     {"__doc__", (getter)getset_get_doc},
 360     {0}
 361 };
 362
 363 static PyObject *
 364 wrapperdescr_get_doc(PyWrapperDescrObject *descr, void *closure)
 365 {
 366     if (descr->d_base->doc == NULL) {
 367         Py_INCREF(Py_None);
 368         return Py_None;
 369     }
 370     return PyUnicode_FromString(descr->d_base->doc);
 371 }
 372
 373 static PyGetSetDef wrapperdescr_getset[] = {
 374     {"__doc__", (getter)wrapperdescr_get_doc},
 375     {0}
 376 };
 377
 378 static int
 379 descr_traverse(PyObject *self, visitproc visit, void *arg)
 380 {
 381     PyDescrObject *descr = (PyDescrObject *)self;
 382     Py_VISIT(descr->d_type);
 383     return 0;
 384 }
 385
 386 PyTypeObject PyMethodDescr_Type = {
 387     PyVarObject_HEAD_INIT(&PyType_Type, 0)
 388     "method_descriptor",
 389     sizeof(PyMethodDescrObject),
 390     0,
 391     (destructor)descr_dealloc,                  /* tp_dealloc */
 392     0,                                          /* tp_print */
 393     0,                                          /* tp_getattr */
 394     0,                                          /* tp_setattr */
 395     0,                                          /* tp_reserved */
 396     (reprfunc)method_repr,                      /* tp_repr */
 397     0,                                          /* tp_as_number */
 398     0,                                          /* tp_as_sequence */
 399     0,                                          /* tp_as_mapping */
 400     0,                                          /* tp_hash */
 401     (ternaryfunc)methoddescr_call,              /* tp_call */
 402     0,                                          /* tp_str */
 403     PyObject_GenericGetAttr,                    /* tp_getattro */
 404     0,                                          /* tp_setattro */
 405     0,                                          /* tp_as_buffer */
 406     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
 407     0,                                          /* tp_doc */
 408     descr_traverse,                             /* tp_traverse */
 409     0,                                          /* tp_clear */
 410     0,                                          /* tp_richcompare */
 411     0,                                          /* tp_weaklistoffset */
 412     0,                                          /* tp_iter */
 413     0,                                          /* tp_iternext */
 414     0,                                          /* tp_methods */
 415     descr_members,                              /* tp_members */
 416     method_getset,                              /* tp_getset */
 417     0,                                          /* tp_base */
 418     0,                                          /* tp_dict */
 419     (descrgetfunc)method_get,                   /* tp_descr_get */
 420     0,                                          /* tp_descr_set */
 421 };
 422
 423 /* This is for METH_CLASS in C, not for "f = classmethod(f)" in Python! */
 424 PyTypeObject PyClassMethodDescr_Type = {
 425     PyVarObject_HEAD_INIT(&PyType_Type, 0)
 426     "classmethod_descriptor",
 427     sizeof(PyMethodDescrObject),
 428     0,
 429     (destructor)descr_dealloc,                  /* tp_dealloc */
 430     0,                                          /* tp_print */
 431     0,                                          /* tp_getattr */
 432     0,                                          /* tp_setattr */
 433     0,                                          /* tp_reserved */
 434     (reprfunc)method_repr,                      /* tp_repr */
 435     0,                                          /* tp_as_number */
 436     0,                                          /* tp_as_sequence */
 437     0,                                          /* tp_as_mapping */
 438     0,                                          /* tp_hash */
 439     (ternaryfunc)classmethoddescr_call,         /* tp_call */
 440     0,                                          /* tp_str */
 441     PyObject_GenericGetAttr,                    /* tp_getattro */
 442     0,                                          /* tp_setattro */
 443     0,                                          /* tp_as_buffer */
 444     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
 445     0,                                          /* tp_doc */
 446     descr_traverse,                             /* tp_traverse */
 447     0,                                          /* tp_clear */
 448     0,                                          /* tp_richcompare */
 449     0,                                          /* tp_weaklistoffset */
 450     0,                                          /* tp_iter */
 451     0,                                          /* tp_iternext */
 452     0,                                          /* tp_methods */
 453     descr_members,                              /* tp_members */
 454     method_getset,                              /* tp_getset */
 455     0,                                          /* tp_base */
 456     0,                                          /* tp_dict */
 457     (descrgetfunc)classmethod_get,              /* tp_descr_get */
 458     0,                                          /* tp_descr_set */
 459 };
 460
 461 PyTypeObject PyMemberDescr_Type = {
 462     PyVarObject_HEAD_INIT(&PyType_Type, 0)
 463     "member_descriptor",
 464     sizeof(PyMemberDescrObject),
 465     0,
 466     (destructor)descr_dealloc,                  /* tp_dealloc */
 467     0,                                          /* tp_print */
 468     0,                                          /* tp_getattr */
 469     0,                                          /* tp_setattr */
 470     0,                                          /* tp_reserved */
 471     (reprfunc)member_repr,                      /* tp_repr */
 472     0,                                          /* tp_as_number */
 473     0,                                          /* tp_as_sequence */
 474     0,                                          /* tp_as_mapping */
 475     0,                                          /* tp_hash */
 476     0,                                          /* tp_call */
 477     0,                                          /* tp_str */
 478     PyObject_GenericGetAttr,                    /* tp_getattro */
 479     0,                                          /* tp_setattro */
 480     0,                                          /* tp_as_buffer */
 481     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
 482     0,                                          /* tp_doc */
 483     descr_traverse,                             /* tp_traverse */
 484     0,                                          /* tp_clear */
 485     0,                                          /* tp_richcompare */
 486     0,                                          /* tp_weaklistoffset */
 487     0,                                          /* tp_iter */
 488     0,                                          /* tp_iternext */
 489     0,                                          /* tp_methods */
 490     descr_members,                              /* tp_members */
 491     member_getset,                              /* tp_getset */
 492     0,                                          /* tp_base */
 493     0,                                          /* tp_dict */
 494     (descrgetfunc)member_get,                   /* tp_descr_get */
 495     (descrsetfunc)member_set,                   /* tp_descr_set */
 496 };
 497
 498 PyTypeObject PyGetSetDescr_Type = {
 499     PyVarObject_HEAD_INIT(&PyType_Type, 0)
 500     "getset_descriptor",
 501     sizeof(PyGetSetDescrObject),
 502     0,
 503     (destructor)descr_dealloc,                  /* tp_dealloc */
 504     0,                                          /* tp_print */
 505     0,                                          /* tp_getattr */
 506     0,                                          /* tp_setattr */
 507     0,                                          /* tp_reserved */
 508     (reprfunc)getset_repr,                      /* tp_repr */
 509     0,                                          /* tp_as_number */
 510     0,                                          /* tp_as_sequence */
 511     0,                                          /* tp_as_mapping */
 512     0,                                          /* tp_hash */
 513     0,                                          /* tp_call */
 514     0,                                          /* tp_str */
 515     PyObject_GenericGetAttr,                    /* tp_getattro */
 516     0,                                          /* tp_setattro */
 517     0,                                          /* tp_as_buffer */
 518     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
 519     0,                                          /* tp_doc */
 520     descr_traverse,                             /* tp_traverse */
 521     0,                                          /* tp_clear */
 522     0,                                          /* tp_richcompare */
 523     0,                                          /* tp_weaklistoffset */
 524     0,                                          /* tp_iter */
 525     0,                                          /* tp_iternext */
 526     0,                                          /* tp_methods */
 527     descr_members,                              /* tp_members */
 528     getset_getset,                              /* tp_getset */
 529     0,                                          /* tp_base */
 530     0,                                          /* tp_dict */
 531     (descrgetfunc)getset_get,                   /* tp_descr_get */
 532     (descrsetfunc)getset_set,                   /* tp_descr_set */
 533 };
 534
 535 PyTypeObject PyWrapperDescr_Type = {
 536     PyVarObject_HEAD_INIT(&PyType_Type, 0)
 537     "wrapper_descriptor",
 538     sizeof(PyWrapperDescrObject),
 539     0,
 540     (destructor)descr_dealloc,                  /* tp_dealloc */
 541     0,                                          /* tp_print */
 542     0,                                          /* tp_getattr */
 543     0,                                          /* tp_setattr */
 544     0,                                          /* tp_reserved */
 545     (reprfunc)wrapperdescr_repr,                /* tp_repr */
 546     0,                                          /* tp_as_number */
 547     0,                                          /* tp_as_sequence */
 548     0,                                          /* tp_as_mapping */
 549     0,                                          /* tp_hash */
 550     (ternaryfunc)wrapperdescr_call,             /* tp_call */
 551     0,                                          /* tp_str */
 552     PyObject_GenericGetAttr,                    /* tp_getattro */
 553     0,                                          /* tp_setattro */
 554     0,                                          /* tp_as_buffer */
 555     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
 556     0,                                          /* tp_doc */
 557     descr_traverse,                             /* tp_traverse */
 558     0,                                          /* tp_clear */
 559     0,                                          /* tp_richcompare */
 560     0,                                          /* tp_weaklistoffset */
 561     0,                                          /* tp_iter */
 562     0,                                          /* tp_iternext */
 563     0,                                          /* tp_methods */
 564     descr_members,                              /* tp_members */
 565     wrapperdescr_getset,                        /* tp_getset */
 566     0,                                          /* tp_base */
 567     0,                                          /* tp_dict */
 568     (descrgetfunc)wrapperdescr_get,             /* tp_descr_get */
 569     0,                                          /* tp_descr_set */
 570 };
 571
 572 static PyDescrObject *
 573 descr_new(PyTypeObject *descrtype, PyTypeObject *type, const char *name)
 574 {
 575     PyDescrObject *descr;
 576
 577     descr = (PyDescrObject *)PyType_GenericAlloc(descrtype, 0);
 578     if (descr != NULL) {
 579         Py_XINCREF(type);
 580         descr->d_type = type;
 581         descr->d_name = PyUnicode_InternFromString(name);
 582         if (descr->d_name == NULL) {
 583             Py_DECREF(descr);
 584             descr = NULL;
 585         }
 586     }
 587     return descr;
 588 }
 589
 590 PyObject *
 591 PyDescr_NewMethod(PyTypeObject *type, PyMethodDef *method)
 592 {
 593     PyMethodDescrObject *descr;
 594
 595     descr = (PyMethodDescrObject *)descr_new(&PyMethodDescr_Type,
 596                                              type, method->ml_name);
 597     if (descr != NULL)
 598         descr->d_method = method;
 599     return (PyObject *)descr;
 600 }
 601
 602 PyObject *
 603 PyDescr_NewClassMethod(PyTypeObject *type, PyMethodDef *method)
 604 {
 605     PyMethodDescrObject *descr;
 606
 607     descr = (PyMethodDescrObject *)descr_new(&PyClassMethodDescr_Type,
 608                                              type, method->ml_name);
 609     if (descr != NULL)
 610         descr->d_method = method;
 611     return (PyObject *)descr;
 612 }
 613
 614 PyObject *
 615 PyDescr_NewMember(PyTypeObject *type, PyMemberDef *member)
 616 {
 617     PyMemberDescrObject *descr;
 618
 619     descr = (PyMemberDescrObject *)descr_new(&PyMemberDescr_Type,
 620                                              type, member->name);
 621     if (descr != NULL)
 622         descr->d_member = member;
 623     return (PyObject *)descr;
 624 }
 625
 626 PyObject *
 627 PyDescr_NewGetSet(PyTypeObject *type, PyGetSetDef *getset)
 628 {
 629     PyGetSetDescrObject *descr;
 630
 631     descr = (PyGetSetDescrObject *)descr_new(&PyGetSetDescr_Type,
 632                                              type, getset->name);
 633     if (descr != NULL)
 634         descr->d_getset = getset;
 635     return (PyObject *)descr;
 636 }
 637
 638 PyObject *
 639 PyDescr_NewWrapper(PyTypeObject *type, struct wrapperbase *base, void *wrapped)
 640 {
 641     PyWrapperDescrObject *descr;
 642
 643     descr = (PyWrapperDescrObject *)descr_new(&PyWrapperDescr_Type,
 644                                              type, base->name);
 645     if (descr != NULL) {
 646         descr->d_base = base;
 647         descr->d_wrapped = wrapped;
 648     }
 649     return (PyObject *)descr;
 650 }
 651
 652
 653 /* --- Readonly proxy for dictionaries (actually any mapping) --- */
 654
 655 /* This has no reason to be in this file except that adding new files is a
 656    bit of a pain */
 657
 658 typedef struct {
 659     PyObject_HEAD
 660     PyObject *dict;
 661 } proxyobject;
 662
 663 static Py_ssize_t
 664 proxy_len(proxyobject *pp)
 665 {
 666     return PyObject_Size(pp->dict);
 667 }
 668
 669 static PyObject *
 670 proxy_getitem(proxyobject *pp, PyObject *key)
 671 {
 672     return PyObject_GetItem(pp->dict, key);
 673 }
 674
 675 static PyMappingMethods proxy_as_mapping = {
 676     (lenfunc)proxy_len,                         /* mp_length */
 677     (binaryfunc)proxy_getitem,                  /* mp_subscript */
 678     0,                                          /* mp_ass_subscript */
 679 };
 680
 681 static int
 682 proxy_contains(proxyobject *pp, PyObject *key)
 683 {
 684     return PyDict_Contains(pp->dict, key);
 685 }
 686
 687 static PySequenceMethods proxy_as_sequence = {
 688     0,                                          /* sq_length */
 689     0,                                          /* sq_concat */
 690     0,                                          /* sq_repeat */
 691     0,                                          /* sq_item */
 692     0,                                          /* sq_slice */
 693     0,                                          /* sq_ass_item */
 694     0,                                          /* sq_ass_slice */
 695     (objobjproc)proxy_contains,                 /* sq_contains */
 696     0,                                          /* sq_inplace_concat */
 697     0,                                          /* sq_inplace_repeat */
 698 };
 699
 700 static PyObject *
 701 proxy_get(proxyobject *pp, PyObject *args)
 702 {
 703     PyObject *key, *def = Py_None;
 704
 705     if (!PyArg_UnpackTuple(args, "get", 1, 2, &key, &def))
 706         return NULL;
 707     return PyObject_CallMethod(pp->dict, "get", "(OO)", key, def);
 708 }
 709
 710 static PyObject *
 711 proxy_keys(proxyobject *pp)
 712 {
 713     return PyMapping_Keys(pp->dict);
 714 }
 715
 716 static PyObject *
 717 proxy_values(proxyobject *pp)
 718 {
 719     return PyMapping_Values(pp->dict);
 720 }
 721
 722 static PyObject *
 723 proxy_items(proxyobject *pp)
 724 {
 725     return PyMapping_Items(pp->dict);
 726 }
 727
 728 static PyObject *
 729 proxy_copy(proxyobject *pp)
 730 {
 731     return PyObject_CallMethod(pp->dict, "copy", NULL);
 732 }
 733
 734 static PyMethodDef proxy_methods[] = {
 735     {"get",       (PyCFunction)proxy_get,        METH_VARARGS,
 736      PyDoc_STR("D.get(k[,d]) -> D[k] if k in D, else d."
 737                                     "  d defaults to None.")},
 738     {"keys",      (PyCFunction)proxy_keys,       METH_NOARGS,
 739      PyDoc_STR("D.keys() -> list of D's keys")},
 740     {"values",    (PyCFunction)proxy_values,     METH_NOARGS,
 741      PyDoc_STR("D.values() -> list of D's values")},
 742     {"items",     (PyCFunction)proxy_items,      METH_NOARGS,
 743      PyDoc_STR("D.items() -> list of D's (key, value) pairs, as 2-tuples")},
 744     {"copy",      (PyCFunction)proxy_copy,       METH_NOARGS,
 745      PyDoc_STR("D.copy() -> a shallow copy of D")},
 746     {0}
 747 };
 748
 749 static void
 750 proxy_dealloc(proxyobject *pp)
 751 {
 752     _PyObject_GC_UNTRACK(pp);
 753     Py_DECREF(pp->dict);
 754     PyObject_GC_Del(pp);
 755 }
 756
 757 static PyObject *
 758 proxy_getiter(proxyobject *pp)
 759 {
 760     return PyObject_GetIter(pp->dict);
 761 }
 762
 763 static PyObject *
 764 proxy_str(proxyobject *pp)
 765 {
 766     return PyObject_Str(pp->dict);
 767 }
 768
 769 static int
 770 proxy_traverse(PyObject *self, visitproc visit, void *arg)
 771 {
 772     proxyobject *pp = (proxyobject *)self;
 773     Py_VISIT(pp->dict);
 774     return 0;
 775 }
 776
 777 static PyObject *
 778 proxy_richcompare(proxyobject *v, PyObject *w, int op)
 779 {
 780     return PyObject_RichCompare(v->dict, w, op);
 781 }
 782
 783 PyTypeObject PyDictProxy_Type = {
 784     PyVarObject_HEAD_INIT(&PyType_Type, 0)
 785     "dict_proxy",                               /* tp_name */
 786     sizeof(proxyobject),                        /* tp_basicsize */
 787     0,                                          /* tp_itemsize */
 788     /* methods */
 789     (destructor)proxy_dealloc,                  /* tp_dealloc */
 790     0,                                          /* tp_print */
 791     0,                                          /* tp_getattr */
 792     0,                                          /* tp_setattr */
 793     0,                                          /* tp_reserved */
 794     0,                                          /* tp_repr */
 795     0,                                          /* tp_as_number */
 796     &proxy_as_sequence,                         /* tp_as_sequence */
 797     &proxy_as_mapping,                          /* tp_as_mapping */
 798     0,                                          /* tp_hash */
 799     0,                                          /* tp_call */
 800     (reprfunc)proxy_str,                        /* tp_str */
 801     PyObject_GenericGetAttr,                    /* tp_getattro */
 802     0,                                          /* tp_setattro */
 803     0,                                          /* tp_as_buffer */
 804     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
 805     0,                                          /* tp_doc */
 806     proxy_traverse,                             /* tp_traverse */
 807     0,                                          /* tp_clear */
 808     (richcmpfunc)proxy_richcompare,             /* tp_richcompare */
 809     0,                                          /* tp_weaklistoffset */
 810     (getiterfunc)proxy_getiter,                 /* tp_iter */
 811     0,                                          /* tp_iternext */
 812     proxy_methods,                              /* tp_methods */
 813     0,                                          /* tp_members */
 814     0,                                          /* tp_getset */
 815     0,                                          /* tp_base */
 816     0,                                          /* tp_dict */
 817     0,                                          /* tp_descr_get */
 818     0,                                          /* tp_descr_set */
 819 };
 820
 821 PyObject *
 822 PyDictProxy_New(PyObject *dict)
 823 {
 824     proxyobject *pp;
 825
 826     pp = PyObject_GC_New(proxyobject, &PyDictProxy_Type);
 827     if (pp != NULL) {
 828         Py_INCREF(dict);
 829         pp->dict = dict;
 830         _PyObject_GC_TRACK(pp);
 831     }
 832     return (PyObject *)pp;
 833 }
 834
 835
 836 /* --- Wrapper object for "slot" methods --- */
 837
 838 /* This has no reason to be in this file except that adding new files is a
 839    bit of a pain */
 840
 841 /* forward */
 842 static PyTypeObject wrappertype;
 843
 844 typedef struct {
 845     PyObject_HEAD
 846     PyWrapperDescrObject *descr;
 847     PyObject *self;
 848 } wrapperobject;
 849
 850 #define Wrapper_Check(v) (Py_TYPE(v) == &wrappertype)
 851
 852 static void
 853 wrapper_dealloc(wrapperobject *wp)
 854 {
 855     PyObject_GC_UnTrack(wp);
 856     Py_TRASHCAN_SAFE_BEGIN(wp)
 857     Py_XDECREF(wp->descr);
 858     Py_XDECREF(wp->self);
 859     PyObject_GC_Del(wp);
 860     Py_TRASHCAN_SAFE_END(wp)
 861 }
 862
 863 #define TEST_COND(cond) ((cond) ? Py_True : Py_False)
 864
 865 static PyObject *
 866 wrapper_richcompare(PyObject *a, PyObject *b, int op)
 867 {
 868     int result;
 869     PyObject *v;
 870     PyWrapperDescrObject *a_descr, *b_descr;
 871
 872     assert(a != NULL && b != NULL);
 873
 874     /* both arguments should be wrapperobjects */
 875     if (!Wrapper_Check(a) || !Wrapper_Check(b)) {
 876         v = Py_NotImplemented;
 877         Py_INCREF(v);
 878         return v;
 879     }
 880
 881     /* compare by descriptor address; if the descriptors are the same,
 882        compare by the objects they're bound to */
 883     a_descr = ((wrapperobject *)a)->descr;
 884     b_descr = ((wrapperobject *)b)->descr;
 885     if (a_descr == b_descr) {
 886         a = ((wrapperobject *)a)->self;
 887         b = ((wrapperobject *)b)->self;
 888         return PyObject_RichCompare(a, b, op);
 889     }
 890
 891     result = a_descr - b_descr;
 892     switch (op) {
 893     case Py_EQ:
 894         v = TEST_COND(result == 0);
 895         break;
 896     case Py_NE:
 897         v = TEST_COND(result != 0);
 898         break;
 899     case Py_LE:
 900         v = TEST_COND(result <= 0);
 901         break;
 902     case Py_GE:
 903         v = TEST_COND(result >= 0);
 904         break;
 905     case Py_LT:
 906         v = TEST_COND(result < 0);
 907         break;
 908     case Py_GT:
 909         v = TEST_COND(result > 0);
 910         break;
 911     default:
 912         PyErr_BadArgument();
 913         return NULL;
 914     }
 915     Py_INCREF(v);
 916     return v;
 917 }
 918
 919 static long
 920 wrapper_hash(wrapperobject *wp)
 921 {
 922     int x, y;
 923     x = _Py_HashPointer(wp->descr);
 924     if (x == -1)
 925         return -1;
 926     y = PyObject_Hash(wp->self);
 927     if (y == -1)
 928         return -1;
 929     x = x ^ y;
 930     if (x == -1)
 931         x = -2;
 932     return x;
 933 }
 934
 935 static PyObject *
 936 wrapper_repr(wrapperobject *wp)
 937 {
 938     return PyUnicode_FromFormat("<method-wrapper '%s' of %s object at %p>",
 939                                wp->descr->d_base->name,
 940                                wp->self->ob_type->tp_name,
 941                                wp->self);
 942 }
 943
 944 static PyMemberDef wrapper_members[] = {
 945     {"__self__", T_OBJECT, offsetof(wrapperobject, self), READONLY},
 946     {0}
 947 };
 948
 949 static PyObject *
 950 wrapper_objclass(wrapperobject *wp)
 951 {
 952     PyObject *c = (PyObject *)wp->descr->d_type;
 953
 954     Py_INCREF(c);
 955     return c;
 956 }
 957
 958 static PyObject *
 959 wrapper_name(wrapperobject *wp)
 960 {
 961     const char *s = wp->descr->d_base->name;
 962
 963     return PyUnicode_FromString(s);
 964 }
 965
 966 static PyObject *
 967 wrapper_doc(wrapperobject *wp)
 968 {
 969     const char *s = wp->descr->d_base->doc;
 970
 971     if (s == NULL) {
 972         Py_INCREF(Py_None);
 973         return Py_None;
 974     }
 975     else {
 976         return PyUnicode_FromString(s);
 977     }
 978 }
 979
 980 static PyGetSetDef wrapper_getsets[] = {
 981     {"__objclass__", (getter)wrapper_objclass},
 982     {"__name__", (getter)wrapper_name},
 983     {"__doc__", (getter)wrapper_doc},
 984     {0}
 985 };
 986
 987 static PyObject *
 988 wrapper_call(wrapperobject *wp, PyObject *args, PyObject *kwds)
 989 {
 990     wrapperfunc wrapper = wp->descr->d_base->wrapper;
 991     PyObject *self = wp->self;
 992
 993     if (wp->descr->d_base->flags & PyWrapperFlag_KEYWORDS) {
 994         wrapperfunc_kwds wk = (wrapperfunc_kwds)wrapper;
 995         return (*wk)(self, args, wp->descr->d_wrapped, kwds);
 996     }
 997
 998     if (kwds != NULL && (!PyDict_Check(kwds) || PyDict_Size(kwds) != 0)) {
 999         PyErr_Format(PyExc_TypeError,
1000                      "wrapper %s doesn't take keyword arguments",
1001                      wp->descr->d_base->name);
1002         return NULL;
1003     }
1004     return (*wrapper)(self, args, wp->descr->d_wrapped);
1005 }
1006
1007 static int
1008 wrapper_traverse(PyObject *self, visitproc visit, void *arg)
1009 {
1010     wrapperobject *wp = (wrapperobject *)self;
1011     Py_VISIT(wp->descr);
1012     Py_VISIT(wp->self);
1013     return 0;
1014 }
1015
1016 static PyTypeObject wrappertype = {
1017     PyVarObject_HEAD_INIT(&PyType_Type, 0)
1018     "method-wrapper",                           /* tp_name */
1019     sizeof(wrapperobject),                      /* tp_basicsize */
1020     0,                                          /* tp_itemsize */
1021     /* methods */
1022     (destructor)wrapper_dealloc,                /* tp_dealloc */
1023     0,                                          /* tp_print */
1024     0,                                          /* tp_getattr */
1025     0,                                          /* tp_setattr */
1026     0,                                          /* tp_reserved */
1027     (reprfunc)wrapper_repr,                     /* tp_repr */
1028     0,                                          /* tp_as_number */
1029     0,                                          /* tp_as_sequence */
1030     0,                                          /* tp_as_mapping */
1031     (hashfunc)wrapper_hash,                     /* tp_hash */
1032     (ternaryfunc)wrapper_call,                  /* tp_call */
1033     0,                                          /* tp_str */
1034     PyObject_GenericGetAttr,                    /* tp_getattro */
1035     0,                                          /* tp_setattro */
1036     0,                                          /* tp_as_buffer */
1037     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
1038     0,                                          /* tp_doc */
1039     wrapper_traverse,                           /* tp_traverse */
1040     0,                                          /* tp_clear */
1041     wrapper_richcompare,                        /* tp_richcompare */
1042     0,                                          /* tp_weaklistoffset */
1043     0,                                          /* tp_iter */
1044     0,                                          /* tp_iternext */
1045     0,                                          /* tp_methods */
1046     wrapper_members,                            /* tp_members */
1047     wrapper_getsets,                            /* tp_getset */
1048     0,                                          /* tp_base */
1049     0,                                          /* tp_dict */
1050     0,                                          /* tp_descr_get */
1051     0,                                          /* tp_descr_set */
1052 };
1053
1054 PyObject *
1055 PyWrapper_New(PyObject *d, PyObject *self)
1056 {
1057     wrapperobject *wp;
1058     PyWrapperDescrObject *descr;
1059
1060     assert(PyObject_TypeCheck(d, &PyWrapperDescr_Type));
1061     descr = (PyWrapperDescrObject *)d;
1062     assert(PyObject_IsInstance(self, (PyObject *)(descr->d_type)));
1063
1064     wp = PyObject_GC_New(wrapperobject, &wrappertype);
1065     if (wp != NULL) {
1066         Py_INCREF(descr);
1067         wp->descr = descr;
1068         Py_INCREF(self);
1069         wp->self = self;
1070         _PyObject_GC_TRACK(wp);
1071     }
1072     return (PyObject *)wp;
1073 }
1074
1075
1076 /* A built-in 'property' type */
1077
1078 /*
1079     class property(object):
1080
1081     def __init__(self, fget=None, fset=None, fdel=None, doc=None):
1082         if doc is None and fget is not None and hasattr(fget, "__doc__"):
1083         doc = fget.__doc__
1084         self.__get = fget
1085         self.__set = fset
1086         self.__del = fdel
1087         self.__doc__ = doc
1088
1089     def __get__(self, inst, type=None):
1090         if inst is None:
1091         return self
1092         if self.__get is None:
1093         raise AttributeError, "unreadable attribute"
1094         return self.__get(inst)
1095
1096     def __set__(self, inst, value):
1097         if self.__set is None:
1098         raise AttributeError, "can't set attribute"
1099         return self.__set(inst, value)
1100
1101     def __delete__(self, inst):
1102         if self.__del is None:
1103         raise AttributeError, "can't delete attribute"
1104         return self.__del(inst)
1105
1106 */
1107
1108 typedef struct {
1109     PyObject_HEAD
1110     PyObject *prop_get;
1111     PyObject *prop_set;
1112     PyObject *prop_del;
1113     PyObject *prop_doc;
1114     int getter_doc;
1115 } propertyobject;
1116
1117 static PyObject * property_copy(PyObject *, PyObject *, PyObject *,
1118                                   PyObject *, PyObject *);
1119
1120 static PyMemberDef property_members[] = {
1121     {"fget", T_OBJECT, offsetof(propertyobject, prop_get), READONLY},
1122     {"fset", T_OBJECT, offsetof(propertyobject, prop_set), READONLY},
1123     {"fdel", T_OBJECT, offsetof(propertyobject, prop_del), READONLY},
1124     {"__doc__",  T_OBJECT, offsetof(propertyobject, prop_doc), READONLY},
1125     {0}
1126 };
1127
1128
1129 PyDoc_STRVAR(getter_doc,
1130              "Descriptor to change the getter on a property.");
1131
1132 static PyObject *
1133 property_getter(PyObject *self, PyObject *getter)
1134 {
1135     return property_copy(self, getter, NULL, NULL, NULL);
1136 }
1137
1138
1139 PyDoc_STRVAR(setter_doc,
1140              "Descriptor to change the setter on a property.");
1141
1142 static PyObject *
1143 property_setter(PyObject *self, PyObject *setter)
1144 {
1145     return property_copy(self, NULL, setter, NULL, NULL);
1146 }
1147
1148
1149 PyDoc_STRVAR(deleter_doc,
1150              "Descriptor to change the deleter on a property.");
1151
1152 static PyObject *
1153 property_deleter(PyObject *self, PyObject *deleter)
1154 {
1155     return property_copy(self, NULL, NULL, deleter, NULL);
1156 }
1157
1158
1159 static PyMethodDef property_methods[] = {
1160     {"getter", property_getter, METH_O, getter_doc},
1161     {"setter", property_setter, METH_O, setter_doc},
1162     {"deleter", property_deleter, METH_O, deleter_doc},
1163     {0}
1164 };
1165
1166
1167 static void
1168 property_dealloc(PyObject *self)
1169 {
1170     propertyobject *gs = (propertyobject *)self;
1171
1172     _PyObject_GC_UNTRACK(self);
1173     Py_XDECREF(gs->prop_get);
1174     Py_XDECREF(gs->prop_set);
1175     Py_XDECREF(gs->prop_del);
1176     Py_XDECREF(gs->prop_doc);
1177     self->ob_type->tp_free(self);
1178 }
1179
1180 static PyObject *
1181 property_descr_get(PyObject *self, PyObject *obj, PyObject *type)
1182 {
1183     propertyobject *gs = (propertyobject *)self;
1184
1185     if (obj == NULL || obj == Py_None) {
1186         Py_INCREF(self);
1187         return self;
1188     }
1189     if (gs->prop_get == NULL) {
1190         PyErr_SetString(PyExc_AttributeError, "unreadable attribute");
1191         return NULL;
1192     }
1193     return PyObject_CallFunction(gs->prop_get, "(O)", obj);
1194 }
1195
1196 static int
1197 property_descr_set(PyObject *self, PyObject *obj, PyObject *value)
1198 {
1199     propertyobject *gs = (propertyobject *)self;
1200     PyObject *func, *res;
1201
1202     if (value == NULL)
1203         func = gs->prop_del;
1204     else
1205         func = gs->prop_set;
1206     if (func == NULL) {
1207         PyErr_SetString(PyExc_AttributeError,
1208                         value == NULL ?
1209                         "can't delete attribute" :
1210                 "can't set attribute");
1211         return -1;
1212     }
1213     if (value == NULL)
1214         res = PyObject_CallFunction(func, "(O)", obj);
1215     else
1216         res = PyObject_CallFunction(func, "(OO)", obj, value);
1217     if (res == NULL)
1218         return -1;
1219     Py_DECREF(res);
1220     return 0;
1221 }
1222
1223 static PyObject *
1224 property_copy(PyObject *old, PyObject *get, PyObject *set, PyObject *del,
1225                 PyObject *doc)
1226 {
1227     propertyobject *pold = (propertyobject *)old;
1228     PyObject *new, *type;
1229
1230     type = PyObject_Type(old);
1231     if (type == NULL)
1232         return NULL;
1233
1234     if (get == NULL || get == Py_None) {
1235         Py_XDECREF(get);
1236         get = pold->prop_get ? pold->prop_get : Py_None;
1237     }
1238     if (set == NULL || set == Py_None) {
1239         Py_XDECREF(set);
1240         set = pold->prop_set ? pold->prop_set : Py_None;
1241     }
1242     if (del == NULL || del == Py_None) {
1243         Py_XDECREF(del);
1244         del = pold->prop_del ? pold->prop_del : Py_None;
1245     }
1246     if (doc == NULL || doc == Py_None) {
1247         Py_XDECREF(doc);
1248         if (pold->getter_doc && get != Py_None) {
1249             /* make _init use __doc__ from getter */
1250             doc = Py_None;
1251         }
1252         else {
1253             doc = pold->prop_doc ? pold->prop_doc : Py_None;
1254         }
1255     }
1256
1257     new =  PyObject_CallFunction(type, "OOOO", get, set, del, doc);
1258     Py_DECREF(type);
1259     if (new == NULL)
1260         return NULL;
1261     return new;
1262 }
1263
1264 static int
1265 property_init(PyObject *self, PyObject *args, PyObject *kwds)
1266 {
1267     PyObject *get = NULL, *set = NULL, *del = NULL, *doc = NULL;
1268     static char *kwlist[] = {"fget", "fset", "fdel", "doc", 0};
1269     propertyobject *prop = (propertyobject *)self;
1270
1271     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO:property",
1272                                      kwlist, &get, &set, &del, &doc))
1273         return -1;
1274
1275     if (get == Py_None)
1276         get = NULL;
1277     if (set == Py_None)
1278         set = NULL;
1279     if (del == Py_None)
1280         del = NULL;
1281
1282     Py_XINCREF(get);
1283     Py_XINCREF(set);
1284     Py_XINCREF(del);
1285     Py_XINCREF(doc);
1286
1287     prop->prop_get = get;
1288     prop->prop_set = set;
1289     prop->prop_del = del;
1290     prop->prop_doc = doc;
1291     prop->getter_doc = 0;
1292
1293     /* if no docstring given and the getter has one, use that one */
1294     if ((doc == NULL || doc == Py_None) && get != NULL) {
1295         PyObject *get_doc = PyObject_GetAttrString(get, "__doc__");
1296         if (get_doc) {
1297             if (Py_TYPE(self) == &PyProperty_Type) {
1298                 Py_XDECREF(prop->prop_doc);
1299                 prop->prop_doc = get_doc;
1300             }
1301             else {
1302                 /* If this is a property subclass, put __doc__
1303                 in dict of the subclass instance instead,
1304                 otherwise it gets shadowed by __doc__ in the
1305                 class's dict. */
1306                 int err = PyObject_SetAttrString(self, "__doc__", get_doc);
1307                 Py_DECREF(get_doc);
1308                 if (err < 0)
1309                     return -1;
1310             }
1311             prop->getter_doc = 1;
1312         }
1313         else if (PyErr_ExceptionMatches(PyExc_Exception)) {
1314             PyErr_Clear();
1315         }
1316         else {
1317             return -1;
1318         }
1319     }
1320
1321     return 0;
1322 }
1323
1324 PyDoc_STRVAR(property_doc,
1325 "property(fget=None, fset=None, fdel=None, doc=None) -> property attribute\n"
1326 "\n"
1327 "fget is a function to be used for getting an attribute value, and likewise\n"
1328 "fset is a function for setting, and fdel a function for del'ing, an\n"
1329 "attribute.  Typical use is to define a managed attribute x:\n"
1330 "class C(object):\n"
1331 "    def getx(self): return self._x\n"
1332 "    def setx(self, value): self._x = value\n"
1333 "    def delx(self): del self._x\n"
1334 "    x = property(getx, setx, delx, \"I'm the 'x' property.\")\n"
1335 "\n"
1336 "Decorators make defining new properties or modifying existing ones easy:\n"
1337 "class C(object):\n"
1338 "    @property\n"
1339 "    def x(self): return self._x\n"
1340 "    @x.setter\n"
1341 "    def x(self, value): self._x = value\n"
1342 "    @x.deleter\n"
1343 "    def x(self): del self._x\n"
1344 );
1345
1346 static int
1347 property_traverse(PyObject *self, visitproc visit, void *arg)
1348 {
1349     propertyobject *pp = (propertyobject *)self;
1350     Py_VISIT(pp->prop_get);
1351     Py_VISIT(pp->prop_set);
1352     Py_VISIT(pp->prop_del);
1353     Py_VISIT(pp->prop_doc);
1354     return 0;
1355 }
1356
1357 PyTypeObject PyProperty_Type = {
1358     PyVarObject_HEAD_INIT(&PyType_Type, 0)
1359     "property",                                 /* tp_name */
1360     sizeof(propertyobject),                     /* tp_basicsize */
1361     0,                                          /* tp_itemsize */
1362     /* methods */
1363     property_dealloc,                           /* tp_dealloc */
1364     0,                                          /* tp_print */
1365     0,                                          /* tp_getattr */
1366     0,                                          /* tp_setattr */
1367     0,                                          /* tp_reserved */
1368     0,                                          /* tp_repr */
1369     0,                                          /* tp_as_number */
1370     0,                                          /* tp_as_sequence */
1371     0,                                          /* tp_as_mapping */
1372     0,                                          /* tp_hash */
1373     0,                                          /* tp_call */
1374     0,                                          /* tp_str */
1375     PyObject_GenericGetAttr,                    /* tp_getattro */
1376     0,                                          /* tp_setattro */
1377     0,                                          /* tp_as_buffer */
1378     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
1379         Py_TPFLAGS_BASETYPE,                    /* tp_flags */
1380     property_doc,                               /* tp_doc */
1381     property_traverse,                          /* tp_traverse */
1382     0,                                          /* tp_clear */
1383     0,                                          /* tp_richcompare */
1384     0,                                          /* tp_weaklistoffset */
1385     0,                                          /* tp_iter */
1386     0,                                          /* tp_iternext */
1387     property_methods,                           /* tp_methods */
1388     property_members,                           /* tp_members */
1389     0,                                          /* tp_getset */
1390     0,                                          /* tp_base */
1391     0,                                          /* tp_dict */
1392     property_descr_get,                         /* tp_descr_get */
1393     property_descr_set,                         /* tp_descr_set */
1394     0,                                          /* tp_dictoffset */
1395     property_init,                              /* tp_init */
1396     PyType_GenericAlloc,                        /* tp_alloc */
1397     PyType_GenericNew,                          /* tp_new */
1398     PyObject_GC_Del,                            /* tp_free */
1399 };