AppPkg/Applications/Python/Python-2.7.2/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 wrapperdescr_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, PyObject **pres)
  61 {
  62     if (obj == NULL) {
  63         Py_INCREF(descr);
  64         *pres = (PyObject *)descr;
  65         return 1;
  66     }
  67     if (!PyObject_TypeCheck(obj, descr->d_type)) {
  68         PyErr_Format(PyExc_TypeError,
  69                      "descriptor '%s' for '%s' objects "
  70                      "doesn't apply to '%s' object",
  71                      descr_name((PyDescrObject *)descr),
  72                      descr->d_type->tp_name,
  73                      obj->ob_type->tp_name);
  74         *pres = NULL;
  75         return 1;
  76     }
  77     return 0;
  78 }
  79
  80 static PyObject *
  81 classmethod_get(PyMethodDescrObject *descr, PyObject *obj, PyObject *type)
  82 {
  83     /* Ensure a valid type.  Class methods ignore obj. */
  84     if (type == NULL) {
  85         if (obj != NULL)
  86             type = (PyObject *)obj->ob_type;
  87         else {
  88             /* Wot - no type?! */
  89             PyErr_Format(PyExc_TypeError,
  90                          "descriptor '%s' for type '%s' "
  91                          "needs either an object or a type",
  92                          descr_name((PyDescrObject *)descr),
  93                          descr->d_type->tp_name);
  94             return NULL;
  95         }
  96     }
  97     if (!PyType_Check(type)) {
  98         PyErr_Format(PyExc_TypeError,
  99                      "descriptor '%s' for type '%s' "
 100                      "needs a type, not a '%s' as arg 2",
 101                      descr_name((PyDescrObject *)descr),
 102                      descr->d_type->tp_name,
 103                      type->ob_type->tp_name);
 104         return NULL;
 105     }
 106     if (!PyType_IsSubtype((PyTypeObject *)type, descr->d_type)) {
 107         PyErr_Format(PyExc_TypeError,
 108                      "descriptor '%s' for type '%s' "
 109                      "doesn't apply to type '%s'",
 110                      descr_name((PyDescrObject *)descr),
 111                      descr->d_type->tp_name,
 112                      ((PyTypeObject *)type)->tp_name);
 113         return NULL;
 114     }
 115     return PyCFunction_New(descr->d_method, type);
 116 }
 117
 118 static PyObject *
 119 method_get(PyMethodDescrObject *descr, PyObject *obj, PyObject *type)
 120 {
 121     PyObject *res;
 122
 123     if (descr_check((PyDescrObject *)descr, obj, &res))
 124         return res;
 125     return PyCFunction_New(descr->d_method, obj);
 126 }
 127
 128 static PyObject *
 129 member_get(PyMemberDescrObject *descr, PyObject *obj, PyObject *type)
 130 {
 131     PyObject *res;
 132
 133     if (descr_check((PyDescrObject *)descr, obj, &res))
 134         return res;
 135     return PyMember_GetOne((char *)obj, descr->d_member);
 136 }
 137
 138 static PyObject *
 139 getset_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *type)
 140 {
 141     PyObject *res;
 142
 143     if (descr_check((PyDescrObject *)descr, obj, &res))
 144         return res;
 145     if (descr->d_getset->get != NULL)
 146         return descr->d_getset->get(obj, descr->d_getset->closure);
 147     PyErr_Format(PyExc_AttributeError,
 148                  "attribute '%.300s' of '%.100s' objects is not readable",
 149                  descr_name((PyDescrObject *)descr),
 150                  descr->d_type->tp_name);
 151     return NULL;
 152 }
 153
 154 static PyObject *
 155 wrapperdescr_get(PyWrapperDescrObject *descr, PyObject *obj, PyObject *type)
 156 {
 157     PyObject *res;
 158
 159     if (descr_check((PyDescrObject *)descr, obj, &res))
 160         return res;
 161     return PyWrapper_New((PyObject *)descr, obj);
 162 }
 163
 164 static int
 165 descr_setcheck(PyDescrObject *descr, PyObject *obj, PyObject *value,
 166                int *pres)
 167 {
 168     assert(obj != NULL);
 169     if (!PyObject_TypeCheck(obj, descr->d_type)) {
 170         PyErr_Format(PyExc_TypeError,
 171                      "descriptor '%.200s' for '%.100s' objects "
 172                      "doesn't apply to '%.100s' object",
 173                      descr_name(descr),
 174                      descr->d_type->tp_name,
 175                      obj->ob_type->tp_name);
 176         *pres = -1;
 177         return 1;
 178     }
 179     return 0;
 180 }
 181
 182 static int
 183 member_set(PyMemberDescrObject *descr, PyObject *obj, PyObject *value)
 184 {
 185     int res;
 186
 187     if (descr_setcheck((PyDescrObject *)descr, obj, value, &res))
 188         return res;
 189     return PyMember_SetOne((char *)obj, descr->d_member, value);
 190 }
 191
 192 static int
 193 getset_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value)
 194 {
 195     int res;
 196
 197     if (descr_setcheck((PyDescrObject *)descr, obj, value, &res))
 198         return res;
 199     if (descr->d_getset->set != NULL)
 200         return descr->d_getset->set(obj, value,
 201                                     descr->d_getset->closure);
 202     PyErr_Format(PyExc_AttributeError,
 203                  "attribute '%.300s' of '%.100s' objects is not writable",
 204                  descr_name((PyDescrObject *)descr),
 205                  descr->d_type->tp_name);
 206     return -1;
 207 }
 208
 209 static PyObject *
 210 methoddescr_call(PyMethodDescrObject *descr, PyObject *args, PyObject *kwds)
 211 {
 212     Py_ssize_t argc;
 213     PyObject *self, *func, *result;
 214
 215     /* Make sure that the first argument is acceptable as 'self' */
 216     assert(PyTuple_Check(args));
 217     argc = PyTuple_GET_SIZE(args);
 218     if (argc < 1) {
 219         PyErr_Format(PyExc_TypeError,
 220                      "descriptor '%.300s' of '%.100s' "
 221                      "object needs an argument",
 222                      descr_name((PyDescrObject *)descr),
 223                      descr->d_type->tp_name);
 224         return NULL;
 225     }
 226     self = PyTuple_GET_ITEM(args, 0);
 227     if (!_PyObject_RealIsSubclass((PyObject *)Py_TYPE(self),
 228                                   (PyObject *)(descr->d_type))) {
 229         PyErr_Format(PyExc_TypeError,
 230                      "descriptor '%.200s' "
 231                      "requires a '%.100s' object "
 232                      "but received a '%.100s'",
 233                      descr_name((PyDescrObject *)descr),
 234                      descr->d_type->tp_name,
 235                      self->ob_type->tp_name);
 236         return NULL;
 237     }
 238
 239     func = PyCFunction_New(descr->d_method, self);
 240     if (func == NULL)
 241         return NULL;
 242     args = PyTuple_GetSlice(args, 1, argc);
 243     if (args == NULL) {
 244         Py_DECREF(func);
 245         return NULL;
 246     }
 247     result = PyEval_CallObjectWithKeywords(func, args, kwds);
 248     Py_DECREF(args);
 249     Py_DECREF(func);
 250     return result;
 251 }
 252
 253 static PyObject *
 254 classmethoddescr_call(PyMethodDescrObject *descr, PyObject *args,
 255                       PyObject *kwds)
 256 {
 257     PyObject *func, *result;
 258
 259     func = PyCFunction_New(descr->d_method, (PyObject *)descr->d_type);
 260     if (func == NULL)
 261         return NULL;
 262
 263     result = PyEval_CallObjectWithKeywords(func, args, kwds);
 264     Py_DECREF(func);
 265     return result;
 266 }
 267
 268 static PyObject *
 269 wrapperdescr_call(PyWrapperDescrObject *descr, PyObject *args, PyObject *kwds)
 270 {
 271     Py_ssize_t argc;
 272     PyObject *self, *func, *result;
 273
 274     /* Make sure that the first argument is acceptable as 'self' */
 275     assert(PyTuple_Check(args));
 276     argc = PyTuple_GET_SIZE(args);
 277     if (argc < 1) {
 278         PyErr_Format(PyExc_TypeError,
 279                      "descriptor '%.300s' of '%.100s' "
 280                      "object needs an argument",
 281                      descr_name((PyDescrObject *)descr),
 282                      descr->d_type->tp_name);
 283         return NULL;
 284     }
 285     self = PyTuple_GET_ITEM(args, 0);
 286     if (!_PyObject_RealIsSubclass((PyObject *)Py_TYPE(self),
 287                                   (PyObject *)(descr->d_type))) {
 288         PyErr_Format(PyExc_TypeError,
 289                      "descriptor '%.200s' "
 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 PyString_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 PyString_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 PyString_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 PyString_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 static 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_compare */
 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 static 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_compare */
 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_compare */
 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_compare */
 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_compare */
 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 = PyString_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_has_key(proxyobject *pp, PyObject *key)
 702 {
 703     int res = PyDict_Contains(pp->dict, key);
 704     if (res < 0)
 705         return NULL;
 706     return PyBool_FromLong(res);
 707 }
 708
 709 static PyObject *
 710 proxy_get(proxyobject *pp, PyObject *args)
 711 {
 712     PyObject *key, *def = Py_None;
 713
 714     if (!PyArg_UnpackTuple(args, "get", 1, 2, &key, &def))
 715         return NULL;
 716     return PyObject_CallMethod(pp->dict, "get", "(OO)", key, def);
 717 }
 718
 719 static PyObject *
 720 proxy_keys(proxyobject *pp)
 721 {
 722     return PyMapping_Keys(pp->dict);
 723 }
 724
 725 static PyObject *
 726 proxy_values(proxyobject *pp)
 727 {
 728     return PyMapping_Values(pp->dict);
 729 }
 730
 731 static PyObject *
 732 proxy_items(proxyobject *pp)
 733 {
 734     return PyMapping_Items(pp->dict);
 735 }
 736
 737 static PyObject *
 738 proxy_iterkeys(proxyobject *pp)
 739 {
 740     return PyObject_CallMethod(pp->dict, "iterkeys", NULL);
 741 }
 742
 743 static PyObject *
 744 proxy_itervalues(proxyobject *pp)
 745 {
 746     return PyObject_CallMethod(pp->dict, "itervalues", NULL);
 747 }
 748
 749 static PyObject *
 750 proxy_iteritems(proxyobject *pp)
 751 {
 752     return PyObject_CallMethod(pp->dict, "iteritems", NULL);
 753 }
 754 static PyObject *
 755 proxy_copy(proxyobject *pp)
 756 {
 757     return PyObject_CallMethod(pp->dict, "copy", NULL);
 758 }
 759
 760 static PyMethodDef proxy_methods[] = {
 761     {"has_key",   (PyCFunction)proxy_has_key,    METH_O,
 762      PyDoc_STR("D.has_key(k) -> True if D has a key k, else False")},
 763     {"get",       (PyCFunction)proxy_get,        METH_VARARGS,
 764      PyDoc_STR("D.get(k[,d]) -> D[k] if D.has_key(k), else d."
 765                                     "  d defaults to None.")},
 766     {"keys",      (PyCFunction)proxy_keys,       METH_NOARGS,
 767      PyDoc_STR("D.keys() -> list of D's keys")},
 768     {"values",    (PyCFunction)proxy_values,     METH_NOARGS,
 769      PyDoc_STR("D.values() -> list of D's values")},
 770     {"items",     (PyCFunction)proxy_items,      METH_NOARGS,
 771      PyDoc_STR("D.items() -> list of D's (key, value) pairs, as 2-tuples")},
 772     {"iterkeys",  (PyCFunction)proxy_iterkeys,   METH_NOARGS,
 773      PyDoc_STR("D.iterkeys() -> an iterator over the keys of D")},
 774     {"itervalues",(PyCFunction)proxy_itervalues, METH_NOARGS,
 775      PyDoc_STR("D.itervalues() -> an iterator over the values of D")},
 776     {"iteritems", (PyCFunction)proxy_iteritems,  METH_NOARGS,
 777      PyDoc_STR("D.iteritems() ->"
 778                " an iterator over the (key, value) items of D")},
 779     {"copy",      (PyCFunction)proxy_copy,       METH_NOARGS,
 780      PyDoc_STR("D.copy() -> a shallow copy of D")},
 781     {0}
 782 };
 783
 784 static void
 785 proxy_dealloc(proxyobject *pp)
 786 {
 787     _PyObject_GC_UNTRACK(pp);
 788     Py_DECREF(pp->dict);
 789     PyObject_GC_Del(pp);
 790 }
 791
 792 static PyObject *
 793 proxy_getiter(proxyobject *pp)
 794 {
 795     return PyObject_GetIter(pp->dict);
 796 }
 797
 798 static PyObject *
 799 proxy_str(proxyobject *pp)
 800 {
 801     return PyObject_Str(pp->dict);
 802 }
 803
 804 static int
 805 proxy_traverse(PyObject *self, visitproc visit, void *arg)
 806 {
 807     proxyobject *pp = (proxyobject *)self;
 808     Py_VISIT(pp->dict);
 809     return 0;
 810 }
 811
 812 static int
 813 proxy_compare(proxyobject *v, PyObject *w)
 814 {
 815     return PyObject_Compare(v->dict, w);
 816 }
 817
 818 static PyObject *
 819 proxy_richcompare(proxyobject *v, PyObject *w, int op)
 820 {
 821     return PyObject_RichCompare(v->dict, w, op);
 822 }
 823
 824 PyTypeObject PyDictProxy_Type = {
 825     PyVarObject_HEAD_INIT(&PyType_Type, 0)
 826     "dictproxy",                                /* tp_name */
 827     sizeof(proxyobject),                        /* tp_basicsize */
 828     0,                                          /* tp_itemsize */
 829     /* methods */
 830     (destructor)proxy_dealloc,                  /* tp_dealloc */
 831     0,                                          /* tp_print */
 832     0,                                          /* tp_getattr */
 833     0,                                          /* tp_setattr */
 834     (cmpfunc)proxy_compare,                     /* tp_compare */
 835     0,                                          /* tp_repr */
 836     0,                                          /* tp_as_number */
 837     &proxy_as_sequence,                         /* tp_as_sequence */
 838     &proxy_as_mapping,                          /* tp_as_mapping */
 839     0,                                          /* tp_hash */
 840     0,                                          /* tp_call */
 841     (reprfunc)proxy_str,                        /* tp_str */
 842     PyObject_GenericGetAttr,                    /* tp_getattro */
 843     0,                                          /* tp_setattro */
 844     0,                                          /* tp_as_buffer */
 845     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
 846     0,                                          /* tp_doc */
 847     proxy_traverse,                             /* tp_traverse */
 848     0,                                          /* tp_clear */
 849     (richcmpfunc)proxy_richcompare,             /* tp_richcompare */
 850     0,                                          /* tp_weaklistoffset */
 851     (getiterfunc)proxy_getiter,                 /* tp_iter */
 852     0,                                          /* tp_iternext */
 853     proxy_methods,                              /* tp_methods */
 854     0,                                          /* tp_members */
 855     0,                                          /* tp_getset */
 856     0,                                          /* tp_base */
 857     0,                                          /* tp_dict */
 858     0,                                          /* tp_descr_get */
 859     0,                                          /* tp_descr_set */
 860 };
 861
 862 PyObject *
 863 PyDictProxy_New(PyObject *dict)
 864 {
 865     proxyobject *pp;
 866
 867     pp = PyObject_GC_New(proxyobject, &PyDictProxy_Type);
 868     if (pp != NULL) {
 869         Py_INCREF(dict);
 870         pp->dict = dict;
 871         _PyObject_GC_TRACK(pp);
 872     }
 873     return (PyObject *)pp;
 874 }
 875
 876
 877 /* --- Wrapper object for "slot" methods --- */
 878
 879 /* This has no reason to be in this file except that adding new files is a
 880    bit of a pain */
 881
 882 typedef struct {
 883     PyObject_HEAD
 884     PyWrapperDescrObject *descr;
 885     PyObject *self;
 886 } wrapperobject;
 887
 888 static void
 889 wrapper_dealloc(wrapperobject *wp)
 890 {
 891     PyObject_GC_UnTrack(wp);
 892     Py_TRASHCAN_SAFE_BEGIN(wp)
 893     Py_XDECREF(wp->descr);
 894     Py_XDECREF(wp->self);
 895     PyObject_GC_Del(wp);
 896     Py_TRASHCAN_SAFE_END(wp)
 897 }
 898
 899 static int
 900 wrapper_compare(wrapperobject *a, wrapperobject *b)
 901 {
 902     if (a->descr == b->descr)
 903         return PyObject_Compare(a->self, b->self);
 904     else
 905         return (a->descr < b->descr) ? -1 : 1;
 906 }
 907
 908 static long
 909 wrapper_hash(wrapperobject *wp)
 910 {
 911     int x, y;
 912     x = _Py_HashPointer(wp->descr);
 913     if (x == -1)
 914         return -1;
 915     y = PyObject_Hash(wp->self);
 916     if (y == -1)
 917         return -1;
 918     x = x ^ y;
 919     if (x == -1)
 920         x = -2;
 921     return x;
 922 }
 923
 924 static PyObject *
 925 wrapper_repr(wrapperobject *wp)
 926 {
 927     return PyString_FromFormat("<method-wrapper '%s' of %s object at %p>",
 928                                wp->descr->d_base->name,
 929                                wp->self->ob_type->tp_name,
 930                                wp->self);
 931 }
 932
 933 static PyMemberDef wrapper_members[] = {
 934     {"__self__", T_OBJECT, offsetof(wrapperobject, self), READONLY},
 935     {0}
 936 };
 937
 938 static PyObject *
 939 wrapper_objclass(wrapperobject *wp)
 940 {
 941     PyObject *c = (PyObject *)wp->descr->d_type;
 942
 943     Py_INCREF(c);
 944     return c;
 945 }
 946
 947 static PyObject *
 948 wrapper_name(wrapperobject *wp)
 949 {
 950     char *s = wp->descr->d_base->name;
 951
 952     return PyString_FromString(s);
 953 }
 954
 955 static PyObject *
 956 wrapper_doc(wrapperobject *wp)
 957 {
 958     char *s = wp->descr->d_base->doc;
 959
 960     if (s == NULL) {
 961         Py_INCREF(Py_None);
 962         return Py_None;
 963     }
 964     else {
 965         return PyString_FromString(s);
 966     }
 967 }
 968
 969 static PyGetSetDef wrapper_getsets[] = {
 970     {"__objclass__", (getter)wrapper_objclass},
 971     {"__name__", (getter)wrapper_name},
 972     {"__doc__", (getter)wrapper_doc},
 973     {0}
 974 };
 975
 976 static PyObject *
 977 wrapper_call(wrapperobject *wp, PyObject *args, PyObject *kwds)
 978 {
 979     wrapperfunc wrapper = wp->descr->d_base->wrapper;
 980     PyObject *self = wp->self;
 981
 982     if (wp->descr->d_base->flags & PyWrapperFlag_KEYWORDS) {
 983         wrapperfunc_kwds wk = (wrapperfunc_kwds)wrapper;
 984         return (*wk)(self, args, wp->descr->d_wrapped, kwds);
 985     }
 986
 987     if (kwds != NULL && (!PyDict_Check(kwds) || PyDict_Size(kwds) != 0)) {
 988         PyErr_Format(PyExc_TypeError,
 989                      "wrapper %s doesn't take keyword arguments",
 990                      wp->descr->d_base->name);
 991         return NULL;
 992     }
 993     return (*wrapper)(self, args, wp->descr->d_wrapped);
 994 }
 995
 996 static int
 997 wrapper_traverse(PyObject *self, visitproc visit, void *arg)
 998 {
 999     wrapperobject *wp = (wrapperobject *)self;
1000     Py_VISIT(wp->descr);
1001     Py_VISIT(wp->self);
1002     return 0;
1003 }
1004
1005 static PyTypeObject wrappertype = {
1006     PyVarObject_HEAD_INIT(&PyType_Type, 0)
1007     "method-wrapper",                           /* tp_name */
1008     sizeof(wrapperobject),                      /* tp_basicsize */
1009     0,                                          /* tp_itemsize */
1010     /* methods */
1011     (destructor)wrapper_dealloc,                /* tp_dealloc */
1012     0,                                          /* tp_print */
1013     0,                                          /* tp_getattr */
1014     0,                                          /* tp_setattr */
1015     (cmpfunc)wrapper_compare,                   /* tp_compare */
1016     (reprfunc)wrapper_repr,                     /* tp_repr */
1017     0,                                          /* tp_as_number */
1018     0,                                          /* tp_as_sequence */
1019     0,                                          /* tp_as_mapping */
1020     (hashfunc)wrapper_hash,                     /* tp_hash */
1021     (ternaryfunc)wrapper_call,                  /* tp_call */
1022     0,                                          /* tp_str */
1023     PyObject_GenericGetAttr,                    /* tp_getattro */
1024     0,                                          /* tp_setattro */
1025     0,                                          /* tp_as_buffer */
1026     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
1027     0,                                          /* tp_doc */
1028     wrapper_traverse,                           /* tp_traverse */
1029     0,                                          /* tp_clear */
1030     0,                                          /* tp_richcompare */
1031     0,                                          /* tp_weaklistoffset */
1032     0,                                          /* tp_iter */
1033     0,                                          /* tp_iternext */
1034     0,                                          /* tp_methods */
1035     wrapper_members,                            /* tp_members */
1036     wrapper_getsets,                            /* tp_getset */
1037     0,                                          /* tp_base */
1038     0,                                          /* tp_dict */
1039     0,                                          /* tp_descr_get */
1040     0,                                          /* tp_descr_set */
1041 };
1042
1043 PyObject *
1044 PyWrapper_New(PyObject *d, PyObject *self)
1045 {
1046     wrapperobject *wp;
1047     PyWrapperDescrObject *descr;
1048
1049     assert(PyObject_TypeCheck(d, &PyWrapperDescr_Type));
1050     descr = (PyWrapperDescrObject *)d;
1051     assert(_PyObject_RealIsSubclass((PyObject *)Py_TYPE(self),
1052                                     (PyObject *)(descr->d_type)));
1053
1054     wp = PyObject_GC_New(wrapperobject, &wrappertype);
1055     if (wp != NULL) {
1056         Py_INCREF(descr);
1057         wp->descr = descr;
1058         Py_INCREF(self);
1059         wp->self = self;
1060         _PyObject_GC_TRACK(wp);
1061     }
1062     return (PyObject *)wp;
1063 }
1064
1065
1066 /* A built-in 'property' type */
1067
1068 /*
1069     class property(object):
1070
1071     def __init__(self, fget=None, fset=None, fdel=None, doc=None):
1072         if doc is None and fget is not None and hasattr(fget, "__doc__"):
1073         doc = fget.__doc__
1074         self.__get = fget
1075         self.__set = fset
1076         self.__del = fdel
1077         self.__doc__ = doc
1078
1079     def __get__(self, inst, type=None):
1080         if inst is None:
1081         return self
1082         if self.__get is None:
1083         raise AttributeError, "unreadable attribute"
1084         return self.__get(inst)
1085
1086     def __set__(self, inst, value):
1087         if self.__set is None:
1088         raise AttributeError, "can't set attribute"
1089         return self.__set(inst, value)
1090
1091     def __delete__(self, inst):
1092         if self.__del is None:
1093         raise AttributeError, "can't delete attribute"
1094         return self.__del(inst)
1095
1096 */
1097
1098 typedef struct {
1099     PyObject_HEAD
1100     PyObject *prop_get;
1101     PyObject *prop_set;
1102     PyObject *prop_del;
1103     PyObject *prop_doc;
1104     int getter_doc;
1105 } propertyobject;
1106
1107 static PyObject * property_copy(PyObject *, PyObject *, PyObject *,
1108                                   PyObject *);
1109
1110 static PyMemberDef property_members[] = {
1111     {"fget", T_OBJECT, offsetof(propertyobject, prop_get), READONLY},
1112     {"fset", T_OBJECT, offsetof(propertyobject, prop_set), READONLY},
1113     {"fdel", T_OBJECT, offsetof(propertyobject, prop_del), READONLY},
1114     {"__doc__",  T_OBJECT, offsetof(propertyobject, prop_doc), READONLY},
1115     {0}
1116 };
1117
1118
1119 PyDoc_STRVAR(getter_doc,
1120              "Descriptor to change the getter on a property.");
1121
1122 static PyObject *
1123 property_getter(PyObject *self, PyObject *getter)
1124 {
1125     return property_copy(self, getter, NULL, NULL);
1126 }
1127
1128
1129 PyDoc_STRVAR(setter_doc,
1130              "Descriptor to change the setter on a property.");
1131
1132 static PyObject *
1133 property_setter(PyObject *self, PyObject *setter)
1134 {
1135     return property_copy(self, NULL, setter, NULL);
1136 }
1137
1138
1139 PyDoc_STRVAR(deleter_doc,
1140              "Descriptor to change the deleter on a property.");
1141
1142 static PyObject *
1143 property_deleter(PyObject *self, PyObject *deleter)
1144 {
1145     return property_copy(self, NULL, NULL, deleter);
1146 }
1147
1148
1149 static PyMethodDef property_methods[] = {
1150     {"getter", property_getter, METH_O, getter_doc},
1151     {"setter", property_setter, METH_O, setter_doc},
1152     {"deleter", property_deleter, METH_O, deleter_doc},
1153     {0}
1154 };
1155
1156
1157 static void
1158 property_dealloc(PyObject *self)
1159 {
1160     propertyobject *gs = (propertyobject *)self;
1161
1162     _PyObject_GC_UNTRACK(self);
1163     Py_XDECREF(gs->prop_get);
1164     Py_XDECREF(gs->prop_set);
1165     Py_XDECREF(gs->prop_del);
1166     Py_XDECREF(gs->prop_doc);
1167     self->ob_type->tp_free(self);
1168 }
1169
1170 static PyObject *
1171 property_descr_get(PyObject *self, PyObject *obj, PyObject *type)
1172 {
1173     propertyobject *gs = (propertyobject *)self;
1174
1175     if (obj == NULL || obj == Py_None) {
1176         Py_INCREF(self);
1177         return self;
1178     }
1179     if (gs->prop_get == NULL) {
1180         PyErr_SetString(PyExc_AttributeError, "unreadable attribute");
1181         return NULL;
1182     }
1183     return PyObject_CallFunction(gs->prop_get, "(O)", obj);
1184 }
1185
1186 static int
1187 property_descr_set(PyObject *self, PyObject *obj, PyObject *value)
1188 {
1189     propertyobject *gs = (propertyobject *)self;
1190     PyObject *func, *res;
1191
1192     if (value == NULL)
1193         func = gs->prop_del;
1194     else
1195         func = gs->prop_set;
1196     if (func == NULL) {
1197         PyErr_SetString(PyExc_AttributeError,
1198                         value == NULL ?
1199                         "can't delete attribute" :
1200                 "can't set attribute");
1201         return -1;
1202     }
1203     if (value == NULL)
1204         res = PyObject_CallFunction(func, "(O)", obj);
1205     else
1206         res = PyObject_CallFunction(func, "(OO)", obj, value);
1207     if (res == NULL)
1208         return -1;
1209     Py_DECREF(res);
1210     return 0;
1211 }
1212
1213 static PyObject *
1214 property_copy(PyObject *old, PyObject *get, PyObject *set, PyObject *del)
1215 {
1216     propertyobject *pold = (propertyobject *)old;
1217     PyObject *new, *type, *doc;
1218
1219     type = PyObject_Type(old);
1220     if (type == NULL)
1221         return NULL;
1222
1223     if (get == NULL || get == Py_None) {
1224         Py_XDECREF(get);
1225         get = pold->prop_get ? pold->prop_get : Py_None;
1226     }
1227     if (set == NULL || set == Py_None) {
1228         Py_XDECREF(set);
1229         set = pold->prop_set ? pold->prop_set : Py_None;
1230     }
1231     if (del == NULL || del == Py_None) {
1232         Py_XDECREF(del);
1233         del = pold->prop_del ? pold->prop_del : Py_None;
1234     }
1235     if (pold->getter_doc && get != Py_None) {
1236         /* make _init use __doc__ from getter */
1237         doc = Py_None;
1238     }
1239     else {
1240         doc = pold->prop_doc ? pold->prop_doc : Py_None;
1241     }
1242
1243     new =  PyObject_CallFunction(type, "OOOO", get, set, del, doc);
1244     Py_DECREF(type);
1245     if (new == NULL)
1246         return NULL;
1247     return new;
1248 }
1249
1250 static int
1251 property_init(PyObject *self, PyObject *args, PyObject *kwds)
1252 {
1253     PyObject *get = NULL, *set = NULL, *del = NULL, *doc = NULL;
1254     static char *kwlist[] = {"fget", "fset", "fdel", "doc", 0};
1255     propertyobject *prop = (propertyobject *)self;
1256
1257     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO:property",
1258                                      kwlist, &get, &set, &del, &doc))
1259         return -1;
1260
1261     if (get == Py_None)
1262         get = NULL;
1263     if (set == Py_None)
1264         set = NULL;
1265     if (del == Py_None)
1266         del = NULL;
1267
1268     Py_XINCREF(get);
1269     Py_XINCREF(set);
1270     Py_XINCREF(del);
1271     Py_XINCREF(doc);
1272
1273     prop->prop_get = get;
1274     prop->prop_set = set;
1275     prop->prop_del = del;
1276     prop->prop_doc = doc;
1277     prop->getter_doc = 0;
1278
1279     /* if no docstring given and the getter has one, use that one */
1280     if ((doc == NULL || doc == Py_None) && get != NULL) {
1281         PyObject *get_doc = PyObject_GetAttrString(get, "__doc__");
1282         if (get_doc) {
1283             if (Py_TYPE(self) == &PyProperty_Type) {
1284                 Py_XDECREF(prop->prop_doc);
1285                 prop->prop_doc = get_doc;
1286             }
1287             else {
1288                 /* If this is a property subclass, put __doc__
1289                 in dict of the subclass instance instead,
1290                 otherwise it gets shadowed by __doc__ in the
1291                 class's dict. */
1292                 int err = PyObject_SetAttrString(self, "__doc__", get_doc);
1293                 Py_DECREF(get_doc);
1294                 if (err < 0)
1295                     return -1;
1296             }
1297             prop->getter_doc = 1;
1298         }
1299         else if (PyErr_ExceptionMatches(PyExc_Exception)) {
1300             PyErr_Clear();
1301         }
1302         else {
1303             return -1;
1304         }
1305     }
1306
1307     return 0;
1308 }
1309
1310 PyDoc_STRVAR(property_doc,
1311 "property(fget=None, fset=None, fdel=None, doc=None) -> property attribute\n"
1312 "\n"
1313 "fget is a function to be used for getting an attribute value, and likewise\n"
1314 "fset is a function for setting, and fdel a function for del'ing, an\n"
1315 "attribute.  Typical use is to define a managed attribute x:\n"
1316 "class C(object):\n"
1317 "    def getx(self): return self._x\n"
1318 "    def setx(self, value): self._x = value\n"
1319 "    def delx(self): del self._x\n"
1320 "    x = property(getx, setx, delx, \"I'm the 'x' property.\")\n"
1321 "\n"
1322 "Decorators make defining new properties or modifying existing ones easy:\n"
1323 "class C(object):\n"
1324 "    @property\n"
1325 "    def x(self): return self._x\n"
1326 "    @x.setter\n"
1327 "    def x(self, value): self._x = value\n"
1328 "    @x.deleter\n"
1329 "    def x(self): del self._x\n"
1330 );
1331
1332 static int
1333 property_traverse(PyObject *self, visitproc visit, void *arg)
1334 {
1335     propertyobject *pp = (propertyobject *)self;
1336     Py_VISIT(pp->prop_get);
1337     Py_VISIT(pp->prop_set);
1338     Py_VISIT(pp->prop_del);
1339     Py_VISIT(pp->prop_doc);
1340     return 0;
1341 }
1342
1343 PyTypeObject PyProperty_Type = {
1344     PyVarObject_HEAD_INIT(&PyType_Type, 0)
1345     "property",                                 /* tp_name */
1346     sizeof(propertyobject),                     /* tp_basicsize */
1347     0,                                          /* tp_itemsize */
1348     /* methods */
1349     property_dealloc,                           /* tp_dealloc */
1350     0,                                          /* tp_print */
1351     0,                                          /* tp_getattr */
1352     0,                                          /* tp_setattr */
1353     0,                                          /* tp_compare */
1354     0,                                          /* tp_repr */
1355     0,                                          /* tp_as_number */
1356     0,                                          /* tp_as_sequence */
1357     0,                                          /* tp_as_mapping */
1358     0,                                          /* tp_hash */
1359     0,                                          /* tp_call */
1360     0,                                          /* tp_str */
1361     PyObject_GenericGetAttr,                    /* tp_getattro */
1362     0,                                          /* tp_setattro */
1363     0,                                          /* tp_as_buffer */
1364     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
1365         Py_TPFLAGS_BASETYPE,                    /* tp_flags */
1366     property_doc,                               /* tp_doc */
1367     property_traverse,                          /* tp_traverse */
1368     0,                                          /* tp_clear */
1369     0,                                          /* tp_richcompare */
1370     0,                                          /* tp_weaklistoffset */
1371     0,                                          /* tp_iter */
1372     0,                                          /* tp_iternext */
1373     property_methods,                           /* tp_methods */
1374     property_members,                           /* tp_members */
1375     0,                                          /* tp_getset */
1376     0,                                          /* tp_base */
1377     0,                                          /* tp_dict */
1378     property_descr_get,                         /* tp_descr_get */
1379     property_descr_set,                         /* tp_descr_set */
1380     0,                                          /* tp_dictoffset */
1381     property_init,                              /* tp_init */
1382     PyType_GenericAlloc,                        /* tp_alloc */
1383     PyType_GenericNew,                          /* tp_new */
1384     PyObject_GC_Del,                            /* tp_free */
1385 };