home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 4 / AACD04.ISO / AACD / Programming / Python / Source / Objects / classobject.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-04-25  |  37.8 KB  |  1,641 lines
  1. /***********************************************************
  2. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its
  8. documentation for any purpose and without fee is hereby granted,
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI or Corporation for National Research Initiatives or
  13. CNRI not be used in advertising or publicity pertaining to
  14. distribution of the software without specific, written prior
  15. permission.
  16.  
  17. While CWI is the initial source for this software, a modified version
  18. is made available by the Corporation for National Research Initiatives
  19. (CNRI) at the Internet address ftp://ftp.python.org.
  20.  
  21. STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22. REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23. MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24. CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26. PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27. TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28. PERFORMANCE OF THIS SOFTWARE.
  29.  
  30. ******************************************************************/
  31.  
  32. /* Class object implementation */
  33.  
  34. #include "Python.h"
  35. #include "structmember.h"
  36.  
  37. /* Forward */
  38. #include "protos/classobject.h"
  39. static PyObject *class_lookup
  40.     Py_PROTO((PyClassObject *, PyObject *, PyClassObject **));
  41. static PyObject *instance_getattr1 Py_PROTO((PyInstanceObject *, PyObject *));
  42.  
  43. static PyObject *getattrstr, *setattrstr, *delattrstr;
  44.  
  45. PyObject *
  46. PyClass_New(bases, dict, name)
  47.     PyObject *bases; /* NULL or tuple of classobjects! */
  48.     PyObject *dict;
  49.     PyObject *name;
  50. {
  51.     PyClassObject *op, *dummy;
  52.     static PyObject *docstr, *modstr, *namestr;
  53.     if (docstr == NULL) {
  54.         docstr= PyString_InternFromString("__doc__");
  55.         if (docstr == NULL)
  56.             return NULL;
  57.     }
  58.     if (modstr == NULL) {
  59.         modstr= PyString_InternFromString("__module__");
  60.         if (modstr == NULL)
  61.             return NULL;
  62.     }
  63.     if (namestr == NULL) {
  64.         namestr= PyString_InternFromString("__name__");
  65.         if (namestr == NULL)
  66.             return NULL;
  67.     }
  68.     if (name == NULL || !PyString_Check(name)) {
  69.         PyErr_SetString(PyExc_SystemError,
  70.                 "PyClass_New: name must be a string");
  71.         return NULL;
  72.     }
  73.     if (dict == NULL || !PyDict_Check(dict)) {
  74.         PyErr_SetString(PyExc_SystemError,
  75.                 "PyClass_New: dict must be a dictionary");
  76.         return NULL;
  77.     }
  78.     if (PyDict_GetItem(dict, docstr) == NULL) {
  79.         if (PyDict_SetItem(dict, docstr, Py_None) < 0)
  80.             return NULL;
  81.     }
  82.     if (PyDict_GetItem(dict, modstr) == NULL) {
  83.         PyObject *globals = PyEval_GetGlobals();
  84.         if (globals != NULL) {
  85.             PyObject *modname = PyDict_GetItem(globals, namestr);
  86.             if (modname != NULL) {
  87.                 if (PyDict_SetItem(dict, modstr, modname) < 0)
  88.                     return NULL;
  89.             }
  90.         }
  91.     }
  92.     if (bases == NULL) {
  93.         bases = PyTuple_New(0);
  94.         if (bases == NULL)
  95.             return NULL;
  96.     }
  97.     else {
  98.         int i;
  99.         if (!PyTuple_Check(bases)) {
  100.             PyErr_SetString(PyExc_SystemError,
  101.                     "PyClass_New: bases must be a tuple");
  102.             return NULL;
  103.         }
  104.         i = PyTuple_Size(bases);
  105.         while (--i >= 0) {
  106.             if (!PyClass_Check(PyTuple_GetItem(bases, i))) {
  107.                 PyErr_SetString(PyExc_SystemError,
  108.                     "PyClass_New: base must be a class");
  109.                 return NULL;
  110.             }
  111.         }
  112.         Py_INCREF(bases);
  113.     }
  114.     op = PyObject_NEW(PyClassObject, &PyClass_Type);
  115.     if (op == NULL) {
  116.         Py_DECREF(bases);
  117.         return NULL;
  118.     }
  119.     op->cl_bases = bases;
  120.     Py_INCREF(dict);
  121.     op->cl_dict = dict;
  122.     Py_XINCREF(name);
  123.     op->cl_name = name;
  124.     if (getattrstr == NULL) {
  125.         getattrstr = PyString_InternFromString("__getattr__");
  126.         setattrstr = PyString_InternFromString("__setattr__");
  127.         delattrstr = PyString_InternFromString("__delattr__");
  128.     }
  129.     op->cl_getattr = class_lookup(op, getattrstr, &dummy);
  130.     op->cl_setattr = class_lookup(op, setattrstr, &dummy);
  131.     op->cl_delattr = class_lookup(op, delattrstr, &dummy);
  132.     Py_XINCREF(op->cl_getattr);
  133.     Py_XINCREF(op->cl_setattr);
  134.     Py_XINCREF(op->cl_delattr);
  135.     return (PyObject *) op;
  136. }
  137.  
  138. /* Class methods */
  139.  
  140. static void
  141. class_dealloc(op)
  142.     PyClassObject *op;
  143. {
  144.     Py_DECREF(op->cl_bases);
  145.     Py_DECREF(op->cl_dict);
  146.     Py_XDECREF(op->cl_name);
  147.     Py_XDECREF(op->cl_getattr);
  148.     Py_XDECREF(op->cl_setattr);
  149.     Py_XDECREF(op->cl_delattr);
  150.     free((ANY *)op);
  151. }
  152.  
  153. static PyObject *
  154. class_lookup(cp, name, pclass)
  155.     PyClassObject *cp;
  156.     PyObject *name;
  157.     PyClassObject **pclass;
  158. {
  159.     int i, n;
  160.     PyObject *value = PyDict_GetItem(cp->cl_dict, name);
  161.     if (value != NULL) {
  162.         *pclass = cp;
  163.         return value;
  164.     }
  165.     n = PyTuple_Size(cp->cl_bases);
  166.     for (i = 0; i < n; i++) {
  167.         /* XXX What if one of the bases is not a class? */
  168.         PyObject *v = class_lookup(
  169.             (PyClassObject *)
  170.             PyTuple_GetItem(cp->cl_bases, i), name, pclass);
  171.         if (v != NULL)
  172.             return v;
  173.     }
  174.     return NULL;
  175. }
  176.  
  177. static PyObject *
  178. class_getattr(op, name)
  179.     register PyClassObject *op;
  180.     PyObject *name;
  181. {
  182.     register PyObject *v;
  183.     register char *sname = PyString_AsString(name);
  184.     PyClassObject *class;
  185.     if (sname[0] == '_' && sname[1] == '_') {
  186.         if (strcmp(sname, "__dict__") == 0) {
  187.             if (PyEval_GetRestricted()) {
  188.                 PyErr_SetString(PyExc_RuntimeError,
  189.                "class.__dict__ not accessible in restricted mode");
  190.                 return NULL;
  191.             }
  192.             Py_INCREF(op->cl_dict);
  193.             return op->cl_dict;
  194.         }
  195.         if (strcmp(sname, "__bases__") == 0) {
  196.             Py_INCREF(op->cl_bases);
  197.             return op->cl_bases;
  198.         }
  199.         if (strcmp(sname, "__name__") == 0) {
  200.             if (op->cl_name == NULL)
  201.                 v = Py_None;
  202.             else
  203.                 v = op->cl_name;
  204.             Py_INCREF(v);
  205.             return v;
  206.         }
  207.     }
  208.     v = class_lookup(op, name, &class);
  209.     if (v == NULL) {
  210.         PyErr_SetObject(PyExc_AttributeError, name);
  211.         return NULL;
  212.     }
  213.     Py_INCREF(v);
  214.     if (PyFunction_Check(v)) {
  215.         PyObject *w = PyMethod_New(v, (PyObject *)NULL,
  216.                             (PyObject *)class);
  217.         Py_DECREF(v);
  218.         v = w;
  219.     }
  220.     return v;
  221. }
  222.  
  223. static void
  224. set_slot(slot, v)
  225.     PyObject **slot;
  226.     PyObject *v;
  227. {
  228.     PyObject *temp = *slot;
  229.     Py_XINCREF(v);
  230.     *slot = v;
  231.     Py_XDECREF(temp);
  232. }
  233.  
  234. static void
  235. set_attr_slots(c)
  236.     PyClassObject *c;
  237. {
  238.     PyClassObject *dummy;
  239.  
  240.     set_slot(&c->cl_getattr, class_lookup(c, getattrstr, &dummy));
  241.     set_slot(&c->cl_setattr, class_lookup(c, setattrstr, &dummy));
  242.     set_slot(&c->cl_delattr, class_lookup(c, delattrstr, &dummy));
  243. }
  244.  
  245. static char *
  246. set_dict(c, v)
  247.     PyClassObject *c;
  248.     PyObject *v;
  249. {
  250.     if (v == NULL || !PyDict_Check(v))
  251.         return "__dict__ must be a dictionary object";
  252.     set_slot(&c->cl_dict, v);
  253.     set_attr_slots(c);
  254.     return "";
  255. }
  256.  
  257. static char *
  258. set_bases(c, v)
  259.     PyClassObject *c;
  260.     PyObject *v;
  261. {
  262.     int i, n;
  263.  
  264.     if (v == NULL || !PyTuple_Check(v))
  265.         return "__bases__ must be a tuple object";
  266.     n = PyTuple_Size(v);
  267.     for (i = 0; i < n; i++) {
  268.         PyObject *x = PyTuple_GET_ITEM(v, i);
  269.         if (!PyClass_Check(x))
  270.             return "__bases__ items must be classes";
  271.         if (PyClass_IsSubclass(x, (PyObject *)c))
  272.             return "a __bases__ item causes an inheritance cycle";
  273.     }
  274.     set_slot(&c->cl_bases, v);
  275.     set_attr_slots(c);
  276.     return "";
  277. }
  278.  
  279. static char *
  280. set_name(c, v)
  281.     PyClassObject *c;
  282.     PyObject *v;
  283. {
  284.     if (v == NULL || !PyString_Check(v))
  285.         return "__name__ must be a string object";
  286.     if ((long)strlen(PyString_AS_STRING(v)) != PyString_GET_SIZE(v))
  287.         return "__name__ must not contain null bytes";
  288.     set_slot(&c->cl_name, v);
  289.     return "";
  290. }
  291.  
  292. static int
  293. class_setattr(op, name, v)
  294.     PyClassObject *op;
  295.     PyObject *name;
  296.     PyObject *v;
  297. {
  298.     char *sname;
  299.     if (PyEval_GetRestricted()) {
  300.         PyErr_SetString(PyExc_RuntimeError,
  301.                "classes are read-only in restricted mode");
  302.         return -1;
  303.     }
  304.     sname = PyString_AsString(name);
  305.     if (sname[0] == '_' && sname[1] == '_') {
  306.         int n = PyString_Size(name);
  307.         if (sname[n-1] == '_' && sname[n-2] == '_') {
  308.             char *err = NULL;
  309.             if (strcmp(sname, "__dict__") == 0)
  310.                 err = set_dict(op, v);
  311.             else if (strcmp(sname, "__bases__") == 0)
  312.                 err = set_bases(op, v);
  313.             else if (strcmp(sname, "__name__") == 0)
  314.                 err = set_name(op, v);
  315.             else if (strcmp(sname, "__getattr__") == 0)
  316.                 set_slot(&op->cl_getattr, v);
  317.             else if (strcmp(sname, "__setattr__") == 0)
  318.                 set_slot(&op->cl_setattr, v);
  319.             else if (strcmp(sname, "__delattr__") == 0)
  320.                 set_slot(&op->cl_delattr, v);
  321.             /* For the last three, we fall through to update the
  322.                dictionary as well. */
  323.             if (err != NULL) {
  324.                 if (*err == '\0')
  325.                     return 0;
  326.                 PyErr_SetString(PyExc_TypeError, err);
  327.                 return -1;
  328.             }
  329.         }
  330.     }
  331.     if (v == NULL) {
  332.         int rv = PyDict_DelItem(op->cl_dict, name);
  333.         if (rv < 0)
  334.             PyErr_SetString(PyExc_AttributeError,
  335.                    "delete non-existing class attribute");
  336.         return rv;
  337.     }
  338.     else
  339.         return PyDict_SetItem(op->cl_dict, name, v);
  340. }
  341.  
  342. static PyObject *
  343. class_repr(op)
  344.     PyClassObject *op;
  345. {
  346.     PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
  347.     char buf[140];
  348.     char *name;
  349.     if (op->cl_name == NULL || !PyString_Check(op->cl_name))
  350.         name = "?";
  351.     else
  352.         name = PyString_AsString(op->cl_name);
  353.     if (mod == NULL || !PyString_Check(mod))
  354.         sprintf(buf, "<class ?.%.100s at %lx>", name, (long)op);
  355.     else
  356.         sprintf(buf, "<class %.50s.%.50s at %lx>",
  357.             PyString_AsString(mod),
  358.             name, (long)op);
  359.     return PyString_FromString(buf);
  360. }
  361.  
  362. static PyObject *
  363. class_str(op)
  364.     PyClassObject *op;
  365. {
  366.     PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
  367.     PyObject *name = op->cl_name;
  368.     PyObject *res;
  369.     int m, n;
  370.  
  371.     if (name == NULL || !PyString_Check(name))
  372.         return class_repr(op);
  373.     if (mod == NULL || !PyString_Check(mod)) {
  374.         Py_INCREF(name);
  375.         return name;
  376.     }
  377.     m = PyString_Size(mod);
  378.     n = PyString_Size(name);
  379.     res = PyString_FromStringAndSize((char *)NULL, m+1+n);
  380.     if (res != NULL) {
  381.         char *s = PyString_AsString(res);
  382.         memcpy(s, PyString_AsString(mod), m);
  383.         s += m;
  384.         *s++ = '.';
  385.         memcpy(s, PyString_AsString(name), n);
  386.     }
  387.     return res;
  388. }
  389.  
  390. PyTypeObject PyClass_Type = {
  391.     PyObject_HEAD_INIT(&PyType_Type)
  392.     0,
  393.     "class",
  394.     sizeof(PyClassObject),
  395.     0,
  396.     (destructor)class_dealloc, /*tp_dealloc*/
  397.     0,        /*tp_print*/
  398.     0,        /*tp_getattr*/
  399.     0,        /*tp_setattr*/
  400.     0,        /*tp_compare*/
  401.     (reprfunc)class_repr, /*tp_repr*/
  402.     0,        /*tp_as_number*/
  403.     0,        /*tp_as_sequence*/
  404.     0,        /*tp_as_mapping*/
  405.     0,        /*tp_hash*/
  406.     0,        /*tp_call*/
  407.     (reprfunc)class_str, /*tp_str*/
  408.     (getattrofunc)class_getattr, /*tp_getattro*/
  409.     (setattrofunc)class_setattr, /*tp_setattro*/
  410. };
  411.  
  412. int
  413. PyClass_IsSubclass(class, base)
  414.     PyObject *class;
  415.     PyObject *base;
  416. {
  417.     int i, n;
  418.     PyClassObject *cp;
  419.     if (class == base)
  420.         return 1;
  421.     if (class == NULL || !PyClass_Check(class))
  422.         return 0;
  423.     cp = (PyClassObject *)class;
  424.     n = PyTuple_Size(cp->cl_bases);
  425.     for (i = 0; i < n; i++) {
  426.         if (PyClass_IsSubclass(PyTuple_GetItem(cp->cl_bases, i), base))
  427.             return 1;
  428.     }
  429.     return 0;
  430. }
  431.  
  432.  
  433. /* Instance objects */
  434.  
  435. PyObject *
  436. PyInstance_New(class, arg, kw)
  437.     PyObject *class;
  438.     PyObject *arg;
  439.     PyObject *kw;
  440. {
  441.     register PyInstanceObject *inst;
  442.     PyObject *init;
  443.     static PyObject *initstr;
  444.     if (!PyClass_Check(class)) {
  445.         PyErr_BadInternalCall();
  446.         return NULL;
  447.     }
  448.     inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
  449.     if (inst == NULL)
  450.         return NULL;
  451.     Py_INCREF(class);
  452.     inst->in_class = (PyClassObject *)class;
  453.     inst->in_dict = PyDict_New();
  454.     if (inst->in_dict == NULL) {
  455.         Py_DECREF(inst);
  456.         return NULL;
  457.     }
  458.     if (initstr == NULL)
  459.         initstr = PyString_InternFromString("__init__");
  460.     init = instance_getattr1(inst, initstr);
  461.     if (init == NULL) {
  462.         PyErr_Clear();
  463.         if ((arg != NULL && (!PyTuple_Check(arg) ||
  464.                      PyTuple_Size(arg) != 0))
  465.             || (kw != NULL && (!PyDict_Check(kw) ||
  466.                       PyDict_Size(kw) != 0))) {
  467.             PyErr_SetString(PyExc_TypeError,
  468.                    "this constructor takes no arguments");
  469.             Py_DECREF(inst);
  470.             inst = NULL;
  471.         }
  472.     }
  473.     else {
  474.         PyObject *res = PyEval_CallObjectWithKeywords(init, arg, kw);
  475.         Py_DECREF(init);
  476.         if (res == NULL) {
  477.             Py_DECREF(inst);
  478.             inst = NULL;
  479.         }
  480.         else {
  481.             if (res != Py_None) {
  482.                 PyErr_SetString(PyExc_TypeError,
  483.                        "__init__() should return None");
  484.                 Py_DECREF(inst);
  485.                 inst = NULL;
  486.             }
  487.             Py_DECREF(res);
  488.         }
  489.     }
  490.     return (PyObject *)inst;
  491. }
  492.  
  493. /* Instance methods */
  494.  
  495. static void
  496. instance_dealloc(inst)
  497.     register PyInstanceObject *inst;
  498. {
  499.     PyObject *error_type, *error_value, *error_traceback;
  500.     PyObject *del;
  501.     static PyObject *delstr;
  502.     /* Call the __del__ method if it exists.  First temporarily
  503.        revive the object and save the current exception, if any. */
  504. #ifdef Py_TRACE_REFS
  505.     /* much too complicated if Py_TRACE_REFS defined */
  506.     extern long _Py_RefTotal;
  507.     inst->ob_type = &PyInstance_Type;
  508.     _Py_NewReference(inst);
  509.     _Py_RefTotal--;        /* compensate for increment in NEWREF */
  510. #ifdef COUNT_ALLOCS
  511.     inst->ob_type->tp_alloc--; /* ditto */
  512. #endif
  513. #else /* !Py_TRACE_REFS */
  514.     Py_INCREF(inst);
  515. #endif /* !Py_TRACE_REFS */
  516.     PyErr_Fetch(&error_type, &error_value, &error_traceback);
  517.     if (delstr == NULL)
  518.         delstr = PyString_InternFromString("__del__");
  519.     if ((del = instance_getattr1(inst, delstr)) != NULL) {
  520.         PyObject *res = PyEval_CallObject(del, (PyObject *)NULL);
  521.         if (res == NULL) {
  522.             PyObject *f, *t, *v, *tb;
  523.              PyErr_Fetch(&t, &v, &tb);
  524.             f = PySys_GetObject("stderr");
  525.             if (f != NULL) {
  526.                 PyFile_WriteString("Exception ", f);
  527.                 if (t) {
  528.                     PyFile_WriteObject(t, f, Py_PRINT_RAW);
  529.                     if (v && v != Py_None) {
  530.                         PyFile_WriteString(": ", f);
  531.                         PyFile_WriteObject(v, f, 0);
  532.                     }
  533.                 }
  534.                 PyFile_WriteString(" in ", f);
  535.                 PyFile_WriteObject(del, f, 0);
  536.                 PyFile_WriteString(" ignored\n", f);
  537.                 PyErr_Clear(); /* Just in case */
  538.             }
  539.             Py_XDECREF(t);
  540.             Py_XDECREF(v);
  541.             Py_XDECREF(tb);
  542.         }
  543.         else
  544.             Py_DECREF(res);
  545.         Py_DECREF(del);
  546.     }
  547.     /* Restore the saved exception and undo the temporary revival */
  548.     PyErr_Restore(error_type, error_value, error_traceback);
  549.     /* Can't use DECREF here, it would cause a recursive call */
  550.     if (--inst->ob_refcnt > 0) {
  551. #ifdef COUNT_ALLOCS
  552.         inst->ob_type->tp_free--;
  553. #endif
  554.         return; /* __del__ added a reference; don't delete now */
  555.     }
  556. #ifdef Py_TRACE_REFS
  557. #ifdef COUNT_ALLOCS
  558.     inst->ob_type->tp_free--;    /* compensate for increment in UNREF */
  559. #endif
  560.     _Py_ForgetReference(inst);
  561.     inst->ob_type = NULL;
  562. #endif /* Py_TRACE_REFS */
  563.     Py_DECREF(inst->in_class);
  564.     Py_XDECREF(inst->in_dict);
  565.     free((ANY *)inst);
  566. }
  567.  
  568. static PyObject *
  569. instance_getattr1(inst, name)
  570.     register PyInstanceObject *inst;
  571.     PyObject *name;
  572. {
  573.     register PyObject *v;
  574.     register char *sname = PyString_AsString(name);
  575.     PyClassObject *class;
  576.     if (sname[0] == '_' && sname[1] == '_') {
  577.         if (strcmp(sname, "__dict__") == 0) {
  578.             if (PyEval_GetRestricted()) {
  579.                 PyErr_SetString(PyExc_RuntimeError,
  580.             "instance.__dict__ not accessible in restricted mode");
  581.                 return NULL;
  582.             }
  583.             Py_INCREF(inst->in_dict);
  584.             return inst->in_dict;
  585.         }
  586.         if (strcmp(sname, "__class__") == 0) {
  587.             Py_INCREF(inst->in_class);
  588.             return (PyObject *)inst->in_class;
  589.         }
  590.     }
  591.     class = NULL;
  592.     v = PyDict_GetItem(inst->in_dict, name);
  593.     if (v == NULL) {
  594.         v = class_lookup(inst->in_class, name, &class);
  595.         if (v == NULL) {
  596.             PyErr_SetObject(PyExc_AttributeError, name);
  597.             return NULL;
  598.         }
  599.     }
  600.     Py_INCREF(v);
  601.     if (class != NULL) {
  602.         if (PyFunction_Check(v)) {
  603.             PyObject *w = PyMethod_New(v, (PyObject *)inst,
  604.                                 (PyObject *)class);
  605.             Py_DECREF(v);
  606.             v = w;
  607.         }
  608.         else if (PyMethod_Check(v)) {
  609.             PyObject *im_class = PyMethod_Class(v);
  610.             /* Only if classes are compatible */
  611.             if (PyClass_IsSubclass((PyObject *)class, im_class)) {
  612.                 PyObject *im_func = PyMethod_Function(v);
  613.                 PyObject *w = PyMethod_New(im_func,
  614.                         (PyObject *)inst, im_class);
  615.                 Py_DECREF(v);
  616.                 v = w;
  617.             }
  618.         }
  619.     }
  620.     return v;
  621. }
  622.  
  623. static PyObject *
  624. instance_getattr(inst, name)
  625.     register PyInstanceObject *inst;
  626.     PyObject *name;
  627. {
  628.     register PyObject *func, *res;
  629.     res = instance_getattr1(inst, name);
  630.     if (res == NULL && (func = inst->in_class->cl_getattr) != NULL) {
  631.         PyObject *args;
  632.         PyErr_Clear();
  633.         args = Py_BuildValue("(OO)", inst, name);
  634.         if (args == NULL)
  635.             return NULL;
  636.         res = PyEval_CallObject(func, args);
  637.         Py_DECREF(args);
  638.     }
  639.     return res;
  640. }
  641.  
  642. static int
  643. instance_setattr1(inst, name, v)
  644.     PyInstanceObject *inst;
  645.     PyObject *name;
  646.     PyObject *v;
  647. {
  648.     if (v == NULL) {
  649.         int rv = PyDict_DelItem(inst->in_dict, name);
  650.         if (rv < 0)
  651.             PyErr_SetString(PyExc_AttributeError,
  652.                    "delete non-existing instance attribute");
  653.         return rv;
  654.     }
  655.     else
  656.         return PyDict_SetItem(inst->in_dict, name, v);
  657. }
  658.  
  659. static int
  660. instance_setattr(inst, name, v)
  661.     PyInstanceObject *inst;
  662.     PyObject *name;
  663.     PyObject *v;
  664. {
  665.     PyObject *func, *args, *res, *tmp;
  666.     char *sname = PyString_AsString(name);
  667.     if (sname[0] == '_' && sname[1] == '_') {
  668.         int n = PyString_Size(name);
  669.         if (sname[n-1] == '_' && sname[n-2] == '_') {
  670.             if (strcmp(sname, "__dict__") == 0) {
  671.                 if (PyEval_GetRestricted()) {
  672.                     PyErr_SetString(PyExc_RuntimeError,
  673.                  "__dict__ not accessible in restricted mode");
  674.                     return -1;
  675.                 }
  676.                 if (v == NULL || !PyDict_Check(v)) {
  677.                     PyErr_SetString(PyExc_TypeError,
  678.                        "__dict__ must be set to a dictionary");
  679.                     return -1;
  680.                 }
  681.                 tmp = inst->in_dict;
  682.                 Py_INCREF(v);
  683.                 inst->in_dict = v;
  684.                 Py_DECREF(tmp);
  685.                 return 0;
  686.             }
  687.             if (strcmp(sname, "__class__") == 0) {
  688.                 if (PyEval_GetRestricted()) {
  689.                     PyErr_SetString(PyExc_RuntimeError,
  690.                 "__class__ not accessible in restricted mode");
  691.                     return -1;
  692.                 }
  693.                 if (v == NULL || !PyClass_Check(v)) {
  694.                     PyErr_SetString(PyExc_TypeError,
  695.                        "__class__ must be set to a class");
  696.                     return -1;
  697.                 }
  698.                 tmp = (PyObject *)(inst->in_class);
  699.                 Py_INCREF(v);
  700.                 inst->in_class = (PyClassObject *)v;
  701.                 Py_DECREF(tmp);
  702.                 return 0;
  703.             }
  704.         }
  705.     }
  706.     if (v == NULL)
  707.         func = inst->in_class->cl_delattr;
  708.     else
  709.         func = inst->in_class->cl_setattr;
  710.     if (func == NULL)
  711.         return instance_setattr1(inst, name, v);
  712.     if (v == NULL)
  713.         args = Py_BuildValue("(OO)", inst, name);
  714.     else
  715.         args = Py_BuildValue("(OOO)", inst, name, v);
  716.     if (args == NULL)
  717.         return -1;
  718.     res = PyEval_CallObject(func, args);
  719.     Py_DECREF(args);
  720.     if (res == NULL)
  721.         return -1;
  722.     Py_DECREF(res);
  723.     return 0;
  724. }
  725.  
  726. static PyObject *
  727. instance_repr(inst)
  728.     PyInstanceObject *inst;
  729. {
  730.     PyObject *func;
  731.     PyObject *res;
  732.     static PyObject *reprstr;
  733.  
  734.     if (reprstr == NULL)
  735.         reprstr = PyString_InternFromString("__repr__");
  736.     func = instance_getattr(inst, reprstr);
  737.     if (func == NULL) {
  738.         char buf[140];
  739.         PyObject *classname = inst->in_class->cl_name;
  740.         PyObject *mod = PyDict_GetItemString(
  741.             inst->in_class->cl_dict, "__module__");
  742.         char *cname;
  743.         if (classname != NULL && PyString_Check(classname))
  744.             cname = PyString_AsString(classname);
  745.         else
  746.             cname = "?";
  747.         PyErr_Clear();
  748.         if (mod == NULL || !PyString_Check(mod))
  749.             sprintf(buf, "<?.%.100s instance at %lx>",
  750.                 cname, (long)inst);
  751.         else
  752.             sprintf(buf, "<%.50s.%.50s instance at %lx>",
  753.                 PyString_AsString(mod),
  754.                 cname, (long)inst);
  755.         return PyString_FromString(buf);
  756.     }
  757.     res = PyEval_CallObject(func, (PyObject *)NULL);
  758.     Py_DECREF(func);
  759.     return res;
  760. }
  761.  
  762. static PyObject *
  763. instance_compare1(inst, other)
  764.     PyObject *inst, *other;
  765. {
  766.     return PyInstance_DoBinOp(inst, other, "__cmp__", "__rcmp__",
  767.                  instance_compare1);
  768. }
  769.  
  770. static int
  771. instance_compare(inst, other)
  772.     PyObject *inst, *other;
  773. {
  774.     PyObject *result;
  775.     long outcome;
  776.     result = instance_compare1(inst, other);
  777.     if (result == NULL)
  778.         return -1;
  779.     if (!PyInt_Check(result)) {
  780.         Py_DECREF(result);
  781.         PyErr_SetString(PyExc_TypeError,
  782.                 "comparison did not return an int");
  783.         return -1;
  784.     }
  785.     outcome = PyInt_AsLong(result);
  786.     Py_DECREF(result);
  787.     if (outcome < 0)
  788.         return -1;
  789.     else if (outcome > 0)
  790.         return 1;
  791.     return 0;
  792. }
  793.  
  794. static long
  795. instance_hash(inst)
  796.     PyInstanceObject *inst;
  797. {
  798.     PyObject *func;
  799.     PyObject *res;
  800.     long outcome;
  801.     static PyObject *hashstr, *cmpstr;
  802.  
  803.     if (hashstr == NULL)
  804.         hashstr = PyString_InternFromString("__hash__");
  805.     func = instance_getattr(inst, hashstr);
  806.     if (func == NULL) {
  807.         /* If there is no __cmp__ method, we hash on the address.
  808.            If a __cmp__ method exists, there must be a __hash__. */
  809.         PyErr_Clear();
  810.         if (cmpstr == NULL)
  811.             cmpstr = PyString_InternFromString("__cmp__");
  812.         func = instance_getattr(inst, cmpstr);
  813.         if (func == NULL) {
  814.             PyErr_Clear();
  815.             outcome = (long)inst;
  816.             if (outcome == -1)
  817.                 outcome = -2;
  818.             return outcome;
  819.         }
  820.         PyErr_SetString(PyExc_TypeError, "unhashable instance");
  821.         return -1;
  822.     }
  823.     res = PyEval_CallObject(func, (PyObject *)NULL);
  824.     Py_DECREF(func);
  825.     if (res == NULL)
  826.         return -1;
  827.     if (PyInt_Check(res)) {
  828.         outcome = PyInt_AsLong(res);
  829.         if (outcome == -1)
  830.             outcome = -2;
  831.     }
  832.     else {
  833.         PyErr_SetString(PyExc_TypeError,
  834.                 "__hash__() should return an int");
  835.         outcome = -1;
  836.     }
  837.     Py_DECREF(res);
  838.     return outcome;
  839. }
  840.  
  841. static PyObject *getitemstr, *setitemstr, *delitemstr, *lenstr;
  842.  
  843. static int
  844. instance_length(inst)
  845.     PyInstanceObject *inst;
  846. {
  847.     PyObject *func;
  848.     PyObject *res;
  849.     int outcome;
  850.  
  851.     if (lenstr == NULL)
  852.         lenstr = PyString_InternFromString("__len__");
  853.     func = instance_getattr(inst, lenstr);
  854.     if (func == NULL)
  855.         return -1;
  856.     res = PyEval_CallObject(func, (PyObject *)NULL);
  857.     Py_DECREF(func);
  858.     if (res == NULL)
  859.         return -1;
  860.     if (PyInt_Check(res)) {
  861.         outcome = PyInt_AsLong(res);
  862.         if (outcome < 0)
  863.             PyErr_SetString(PyExc_ValueError,
  864.                     "__len__() should return >= 0");
  865.     }
  866.     else {
  867.         PyErr_SetString(PyExc_TypeError,
  868.                 "__len__() should return an int");
  869.         outcome = -1;
  870.     }
  871.     Py_DECREF(res);
  872.     return outcome;
  873. }
  874.  
  875. static PyObject *
  876. instance_subscript(inst, key)
  877.     PyInstanceObject *inst;
  878.     PyObject *key;
  879. {
  880.     PyObject *func;
  881.     PyObject *arg;
  882.     PyObject *res;
  883.  
  884.     if (getitemstr == NULL)
  885.         getitemstr = PyString_InternFromString("__getitem__");
  886.     func = instance_getattr(inst, getitemstr);
  887.     if (func == NULL)
  888.         return NULL;
  889.     arg = Py_BuildValue("(O)", key);
  890.     if (arg == NULL) {
  891.         Py_DECREF(func);
  892.         return NULL;
  893.     }
  894.     res = PyEval_CallObject(func, arg);
  895.     Py_DECREF(func);
  896.     Py_DECREF(arg);
  897.     return res;
  898. }
  899.  
  900. static int
  901. instance_ass_subscript(inst, key, value)
  902.     PyInstanceObject*inst;
  903.     PyObject *key;
  904.     PyObject *value;
  905. {
  906.     PyObject *func;
  907.     PyObject *arg;
  908.     PyObject *res;
  909.  
  910.     if (value == NULL) {
  911.         if (delitemstr == NULL)
  912.             delitemstr = PyString_InternFromString("__delitem__");
  913.         func = instance_getattr(inst, delitemstr);
  914.     }
  915.     else {
  916.         if (setitemstr == NULL)
  917.             setitemstr = PyString_InternFromString("__setitem__");
  918.         func = instance_getattr(inst, setitemstr);
  919.     }
  920.     if (func == NULL)
  921.         return -1;
  922.     if (value == NULL)
  923.         arg = Py_BuildValue("(O)", key);
  924.     else
  925.         arg = Py_BuildValue("(OO)", key, value);
  926.     if (arg == NULL) {
  927.         Py_DECREF(func);
  928.         return -1;
  929.     }
  930.     res = PyEval_CallObject(func, arg);
  931.     Py_DECREF(func);
  932.     Py_DECREF(arg);
  933.     if (res == NULL)
  934.         return -1;
  935.     Py_DECREF(res);
  936.     return 0;
  937. }
  938.  
  939. static PyMappingMethods instance_as_mapping = {
  940.     (inquiry)instance_length, /*mp_length*/
  941.     (binaryfunc)instance_subscript, /*mp_subscript*/
  942.     (objobjargproc)instance_ass_subscript, /*mp_ass_subscript*/
  943. };
  944.  
  945. static PyObject *
  946. instance_item(inst, i)
  947.     PyInstanceObject *inst;
  948.     int i;
  949. {
  950.     PyObject *func, *arg, *res;
  951.  
  952.     if (getitemstr == NULL)
  953.         getitemstr = PyString_InternFromString("__getitem__");
  954.     func = instance_getattr(inst, getitemstr);
  955.     if (func == NULL)
  956.         return NULL;
  957.     arg = Py_BuildValue("(i)", i);
  958.     if (arg == NULL) {
  959.         Py_DECREF(func);
  960.         return NULL;
  961.     }
  962.     res = PyEval_CallObject(func, arg);
  963.     Py_DECREF(func);
  964.     Py_DECREF(arg);
  965.     return res;
  966. }
  967.  
  968. static PyObject *
  969. instance_slice(inst, i, j)
  970.     PyInstanceObject *inst;
  971.     int i, j;
  972. {
  973.     PyObject *func, *arg, *res;
  974.     static PyObject *getslicestr;
  975.  
  976.     if (getslicestr == NULL)
  977.         getslicestr = PyString_InternFromString("__getslice__");
  978.     func = instance_getattr(inst, getslicestr);
  979.     if (func == NULL)
  980.         return NULL;
  981.     arg = Py_BuildValue("(ii)", i, j);
  982.     if (arg == NULL) {
  983.         Py_DECREF(func);
  984.         return NULL;
  985.     }
  986.     res = PyEval_CallObject(func, arg);
  987.     Py_DECREF(func);
  988.     Py_DECREF(arg);
  989.     return res;
  990. }
  991.  
  992. static int
  993. instance_ass_item(inst, i, item)
  994.     PyInstanceObject *inst;
  995.     int i;
  996.     PyObject *item;
  997. {
  998.     PyObject *func, *arg, *res;
  999.  
  1000.     if (item == NULL) {
  1001.         if (delitemstr == NULL)
  1002.             delitemstr = PyString_InternFromString("__delitem__");
  1003.         func = instance_getattr(inst, delitemstr);
  1004.     }
  1005.     else {
  1006.         if (setitemstr == NULL)
  1007.             setitemstr = PyString_InternFromString("__setitem__");
  1008.         func = instance_getattr(inst, setitemstr);
  1009.     }
  1010.     if (func == NULL)
  1011.         return -1;
  1012.     if (item == NULL)
  1013.         arg = Py_BuildValue("i", i);
  1014.     else
  1015.         arg = Py_BuildValue("(iO)", i, item);
  1016.     if (arg == NULL) {
  1017.         Py_DECREF(func);
  1018.         return -1;
  1019.     }
  1020.     res = PyEval_CallObject(func, arg);
  1021.     Py_DECREF(func);
  1022.     Py_DECREF(arg);
  1023.     if (res == NULL)
  1024.         return -1;
  1025.     Py_DECREF(res);
  1026.     return 0;
  1027. }
  1028.  
  1029. static int
  1030. instance_ass_slice(inst, i, j, value)
  1031.     PyInstanceObject *inst;
  1032.     int i, j;
  1033.     PyObject *value;
  1034. {
  1035.     PyObject *func, *arg, *res;
  1036.     static PyObject *setslicestr, *delslicestr;
  1037.  
  1038.     if (value == NULL) {
  1039.         if (delslicestr == NULL)
  1040.             delslicestr =
  1041.                 PyString_InternFromString("__delslice__");
  1042.         func = instance_getattr(inst, delslicestr);
  1043.     }
  1044.     else {
  1045.         if (setslicestr == NULL)
  1046.             setslicestr =
  1047.                 PyString_InternFromString("__setslice__");
  1048.         func = instance_getattr(inst, setslicestr);
  1049.     }
  1050.     if (func == NULL)
  1051.         return -1;
  1052.     if (value == NULL)
  1053.         arg = Py_BuildValue("(ii)", i, j);
  1054.     else
  1055.         arg = Py_BuildValue("(iiO)", i, j, value);
  1056.     if (arg == NULL) {
  1057.         Py_DECREF(func);
  1058.         return -1;
  1059.     }
  1060.     res = PyEval_CallObject(func, arg);
  1061.     Py_DECREF(func);
  1062.     Py_DECREF(arg);
  1063.     if (res == NULL)
  1064.         return -1;
  1065.     Py_DECREF(res);
  1066.     return 0;
  1067. }
  1068.  
  1069. static PySequenceMethods instance_as_sequence = {
  1070.     (inquiry)instance_length, /*sq_length*/
  1071.     0, /*sq_concat*/
  1072.     0, /*sq_repeat*/
  1073.     (intargfunc)instance_item, /*sq_item*/
  1074.     (intintargfunc)instance_slice, /*sq_slice*/
  1075.     (intobjargproc)instance_ass_item, /*sq_ass_item*/
  1076.     (intintobjargproc)instance_ass_slice, /*sq_ass_slice*/
  1077. };
  1078.  
  1079. static PyObject *
  1080. generic_unary_op(self, methodname)
  1081.     PyInstanceObject *self;
  1082.     PyObject *methodname;
  1083. {
  1084.     PyObject *func, *res;
  1085.  
  1086.     if ((func = instance_getattr(self, methodname)) == NULL)
  1087.         return NULL;
  1088.     res = PyEval_CallObject(func, (PyObject *)NULL);
  1089.     Py_DECREF(func);
  1090.     return res;
  1091. }
  1092.  
  1093.  
  1094. /* Forward */
  1095. static int halfbinop Py_PROTO((PyObject *, PyObject *, char *, PyObject **,
  1096.         PyObject * (*) Py_PROTO((PyObject *, PyObject *)), int ));
  1097.  
  1098.  
  1099. /* Implement a binary operator involving at least one class instance. */
  1100.  
  1101. PyObject *
  1102. PyInstance_DoBinOp(v, w, opname, ropname, thisfunc)
  1103.     PyObject *v;
  1104.     PyObject *w;
  1105.     char *opname;
  1106.     char *ropname;
  1107.     PyObject * (*thisfunc) Py_PROTO((PyObject *, PyObject *));
  1108. {
  1109.     char buf[256];
  1110.     PyObject *result = NULL;
  1111.     if (halfbinop(v, w, opname, &result, thisfunc, 0) <= 0)
  1112.         return result;
  1113.     if (halfbinop(w, v, ropname, &result, thisfunc, 1) <= 0)
  1114.         return result;
  1115.     /* Sigh -- special case for comnparisons */
  1116.     if (strcmp(opname, "__cmp__") == 0) {
  1117.         long c = (v < w) ? -1 : (v > w) ? 1 : 0;
  1118.         return PyInt_FromLong(c);
  1119.     }
  1120.     sprintf(buf, "%s nor %s defined for these operands", opname, ropname);
  1121.     PyErr_SetString(PyExc_TypeError, buf);
  1122.     return NULL;
  1123. }
  1124.  
  1125.  
  1126. /* Try one half of a binary operator involving a class instance.
  1127.    Return value:
  1128.    -1 if an exception is to be reported right away
  1129.    0  if we have a valid result
  1130.    1  if we could try another operation
  1131. */
  1132.  
  1133. static PyObject *coerce_obj;
  1134.  
  1135. static int
  1136. halfbinop(v, w, opname, r_result, thisfunc, swapped)
  1137.     PyObject *v;
  1138.     PyObject *w;
  1139.     char *opname;
  1140.     PyObject **r_result;
  1141.     PyObject * (*thisfunc) Py_PROTO((PyObject *, PyObject *));
  1142.     int swapped;
  1143. {
  1144.     PyObject *func;
  1145.     PyObject *args;
  1146.     PyObject *coercefunc;
  1147.     PyObject *coerced = NULL;
  1148.     PyObject *v1;
  1149.     
  1150.     if (!PyInstance_Check(v))
  1151.         return 1;
  1152.     if (coerce_obj == NULL) {
  1153.         coerce_obj = PyString_InternFromString("__coerce__");
  1154.         if (coerce_obj == NULL)
  1155.             return -1;
  1156.     }
  1157.     coercefunc = PyObject_GetAttr(v, coerce_obj);
  1158.     if (coercefunc == NULL) {
  1159.         PyErr_Clear();
  1160.     }
  1161.     else {
  1162.         args = Py_BuildValue("(O)", w);
  1163.         if (args == NULL) {
  1164.             return -1;
  1165.         }
  1166.         coerced = PyEval_CallObject(coercefunc, args);
  1167.         Py_DECREF(args);
  1168.         Py_DECREF(coercefunc);
  1169.         if (coerced == NULL) {
  1170.             return -1;
  1171.         }
  1172.         if (coerced == Py_None) {
  1173.             Py_DECREF(coerced);
  1174.             return 1;
  1175.         }
  1176.         if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
  1177.             Py_DECREF(coerced);
  1178.             PyErr_SetString(PyExc_TypeError,
  1179.                    "coercion should return None or 2-tuple");
  1180.             return -1;
  1181.         }
  1182.         v1 = PyTuple_GetItem(coerced, 0);
  1183.         w = PyTuple_GetItem(coerced, 1);
  1184.         if (v1 != v) {
  1185.             v = v1;
  1186.             if (!PyInstance_Check(v) && !PyInstance_Check(w)) {
  1187.                 if (swapped)
  1188.                     *r_result = (*thisfunc)(w, v);
  1189.                 else
  1190.                     *r_result = (*thisfunc)(v, w);
  1191.                 Py_DECREF(coerced);
  1192.                 return *r_result == NULL ? -1 : 0;
  1193.             }
  1194.         }
  1195.     }
  1196.     func = PyObject_GetAttrString(v, opname);
  1197.     if (func == NULL) {
  1198.         Py_XDECREF(coerced);
  1199.         if (!PyErr_ExceptionMatches(PyExc_AttributeError))
  1200.             return -1;
  1201.         PyErr_Clear();
  1202.         return 1;
  1203.     }
  1204.     args = Py_BuildValue("(O)", w);
  1205.     if (args == NULL) {
  1206.         Py_DECREF(func);
  1207.         Py_XDECREF(coerced);
  1208.         return -1;
  1209.     }
  1210.     *r_result = PyEval_CallObject(func, args);
  1211.     Py_DECREF(args);
  1212.     Py_DECREF(func);
  1213.     Py_XDECREF(coerced);
  1214.     return *r_result == NULL ? -1 : 0;
  1215. }
  1216.  
  1217. static int
  1218. instance_coerce(pv, pw)
  1219.     PyObject **pv;
  1220.     PyObject **pw;
  1221. {
  1222.     PyObject *v = *pv;
  1223.     PyObject *w = *pw;
  1224.     PyObject *coercefunc;
  1225.     PyObject *args;
  1226.     PyObject *coerced;
  1227.  
  1228.     if (coerce_obj == NULL) {
  1229.         coerce_obj = PyString_InternFromString("__coerce__");
  1230.         if (coerce_obj == NULL)
  1231.             return -1;
  1232.     }
  1233.     coercefunc = PyObject_GetAttr(v, coerce_obj);
  1234.     if (coercefunc == NULL) {
  1235.         /* No __coerce__ method: always OK */
  1236.         PyErr_Clear();
  1237.         Py_INCREF(v);
  1238.         Py_INCREF(w);
  1239.         return 0;
  1240.     }
  1241.     /* Has __coerce__ method: call it */
  1242.     args = Py_BuildValue("(O)", w);
  1243.     if (args == NULL) {
  1244.         return -1;
  1245.     }
  1246.     coerced = PyEval_CallObject(coercefunc, args);
  1247.     Py_DECREF(args);
  1248.     Py_DECREF(coercefunc);
  1249.     if (coerced == NULL) {
  1250.         /* __coerce__ call raised an exception */
  1251.         return -1;
  1252.     }
  1253.     if (coerced == Py_None) {
  1254.         /* __coerce__ says "I can't do it" */
  1255.         Py_DECREF(coerced);
  1256.         return 1;
  1257.     }
  1258.     if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
  1259.         /* __coerce__ return value is malformed */
  1260.         Py_DECREF(coerced);
  1261.         PyErr_SetString(PyExc_TypeError,
  1262.                "coercion should return None or 2-tuple");
  1263.         return -1;
  1264.     }
  1265.     /* __coerce__ returned two new values */
  1266.     *pv = PyTuple_GetItem(coerced, 0);
  1267.     *pw = PyTuple_GetItem(coerced, 1);
  1268.     Py_INCREF(*pv);
  1269.     Py_INCREF(*pw);
  1270.     Py_DECREF(coerced);
  1271.     return 0;
  1272. }
  1273.  
  1274.  
  1275. #ifdef __SASC
  1276. #define UNARY(funcname, methodname) \
  1277. static PyObject *funcname(PyInstanceObject *self) { \
  1278.     static PyObject *o; \
  1279.     if (o == NULL) o = PyString_InternFromString(methodname); \
  1280.     return generic_unary_op(self, o); \
  1281. }
  1282. #else /* !__SASC */
  1283. #define UNARY(funcname, methodname) \
  1284. static PyObject *funcname(self) PyInstanceObject *self; { \
  1285.     static PyObject *o; \
  1286.     if (o == NULL) o = PyString_InternFromString(methodname); \
  1287.     return generic_unary_op(self, o); \
  1288. }
  1289. #endif
  1290.  
  1291. UNARY(instance_neg, "__neg__")
  1292. UNARY(instance_pos, "__pos__")
  1293. UNARY(instance_abs, "__abs__")
  1294.  
  1295. static int
  1296. instance_nonzero(self)
  1297.     PyInstanceObject *self;
  1298. {
  1299.     PyObject *func, *res;
  1300.     long outcome;
  1301.     static PyObject *nonzerostr;
  1302.  
  1303.     if (nonzerostr == NULL)
  1304.         nonzerostr = PyString_InternFromString("__nonzero__");
  1305.     if ((func = instance_getattr(self, nonzerostr)) == NULL) {
  1306.         PyErr_Clear();
  1307.         if (lenstr == NULL)
  1308.             lenstr = PyString_InternFromString("__len__");
  1309.         if ((func = instance_getattr(self, lenstr)) == NULL) {
  1310.             PyErr_Clear();
  1311.             /* Fall back to the default behavior:
  1312.                all instances are nonzero */
  1313.             return 1;
  1314.         }
  1315.     }
  1316.     res = PyEval_CallObject(func, (PyObject *)NULL);
  1317.     Py_DECREF(func);
  1318.     if (res == NULL)
  1319.         return -1;
  1320.     if (!PyInt_Check(res)) {
  1321.         Py_DECREF(res);
  1322.         PyErr_SetString(PyExc_TypeError,
  1323.                 "__nonzero__ should return an int");
  1324.         return -1;
  1325.     }
  1326.     outcome = PyInt_AsLong(res);
  1327.     Py_DECREF(res);
  1328.     if (outcome < 0) {
  1329.         PyErr_SetString(PyExc_ValueError,
  1330.                 "__nonzero__ should return >= 0");
  1331.         return -1;
  1332.     }
  1333.     return outcome > 0;
  1334. }
  1335.  
  1336. UNARY(instance_invert, "__invert__")
  1337. UNARY(instance_int, "__int__")
  1338. UNARY(instance_long, "__long__")
  1339. UNARY(instance_float, "__float__")
  1340. UNARY(instance_oct, "__oct__")
  1341. UNARY(instance_hex, "__hex__")
  1342.  
  1343. /* This version is for ternary calls only (z != None) */
  1344. static PyObject *
  1345. instance_pow(v, w, z)
  1346.     PyObject *v;
  1347.     PyObject *w;
  1348.     PyObject *z;
  1349. {
  1350.     /* XXX Doesn't do coercions... */
  1351.     PyObject *func;
  1352.     PyObject *args;
  1353.     PyObject *result;
  1354.     static PyObject *powstr;
  1355.  
  1356.     if (powstr == NULL)
  1357.         powstr = PyString_InternFromString("__pow__");
  1358.     func = PyObject_GetAttr(v, powstr);
  1359.     if (func == NULL)
  1360.         return NULL;
  1361.     args = Py_BuildValue("(OO)", w, z);
  1362.     if (args == NULL) {
  1363.         Py_DECREF(func);
  1364.         return NULL;
  1365.     }
  1366.     result = PyEval_CallObject(func, args);
  1367.     Py_DECREF(func);
  1368.     Py_DECREF(args);
  1369.     return result;
  1370. }
  1371.  
  1372. static PyNumberMethods instance_as_number = {
  1373.     0, /*nb_add*/
  1374.     0, /*nb_subtract*/
  1375.     0, /*nb_multiply*/
  1376.     0, /*nb_divide*/
  1377.     0, /*nb_remainder*/
  1378.     0, /*nb_divmod*/
  1379.     (ternaryfunc)instance_pow, /*nb_power*/
  1380.     (unaryfunc)instance_neg, /*nb_negative*/
  1381.     (unaryfunc)instance_pos, /*nb_positive*/
  1382.     (unaryfunc)instance_abs, /*nb_absolute*/
  1383.     (inquiry)instance_nonzero, /*nb_nonzero*/
  1384.     (unaryfunc)instance_invert, /*nb_invert*/
  1385.     0, /*nb_lshift*/
  1386.     0, /*nb_rshift*/
  1387.     0, /*nb_and*/
  1388.     0, /*nb_xor*/
  1389.     0, /*nb_or*/
  1390.     (coercion)instance_coerce, /*nb_coerce*/
  1391.     (unaryfunc)instance_int, /*nb_int*/
  1392.     (unaryfunc)instance_long, /*nb_long*/
  1393.     (unaryfunc)instance_float, /*nb_float*/
  1394.     (unaryfunc)instance_oct, /*nb_oct*/
  1395.     (unaryfunc)instance_hex, /*nb_hex*/
  1396. };
  1397.  
  1398. PyTypeObject PyInstance_Type = {
  1399.     PyObject_HEAD_INIT(&PyType_Type)
  1400.     0,
  1401.     "instance",
  1402.     sizeof(PyInstanceObject),
  1403.     0,
  1404.     (destructor)instance_dealloc, /*tp_dealloc*/
  1405.     0,            /*tp_print*/
  1406.     0,            /*tp_getattr*/
  1407.     0,            /*tp_setattr*/
  1408.     instance_compare,    /*tp_compare*/
  1409.     (reprfunc)instance_repr, /*tp_repr*/
  1410.     &instance_as_number,    /*tp_as_number*/
  1411.     &instance_as_sequence,    /*tp_as_sequence*/
  1412.     &instance_as_mapping,    /*tp_as_mapping*/
  1413.     (hashfunc)instance_hash, /*tp_hash*/
  1414.     0,            /*tp_call*/
  1415.     0,            /*tp_str*/
  1416.     (getattrofunc)instance_getattr, /*tp_getattro*/
  1417.     (setattrofunc)instance_setattr, /*tp_setattro*/
  1418. };
  1419.  
  1420.  
  1421. /* Instance method objects are used for two purposes:
  1422.    (a) as bound instance methods (returned by instancename.methodname)
  1423.    (b) as unbound methods (returned by ClassName.methodname)
  1424.    In case (b), im_self is NULL
  1425. */
  1426.  
  1427. static PyMethodObject *free_list;
  1428.  
  1429. PyObject *
  1430. PyMethod_New(func, self, class)
  1431.     PyObject *func;
  1432.     PyObject *self;
  1433.     PyObject *class;
  1434. {
  1435.     register PyMethodObject *im;
  1436.     if (!PyCallable_Check(func)) {
  1437.         PyErr_BadInternalCall();
  1438.         return NULL;
  1439.     }
  1440.     im = free_list;
  1441.     if (im != NULL) {
  1442.         free_list = (PyMethodObject *)(im->im_self);
  1443.         im->ob_type = &PyMethod_Type;
  1444.         _Py_NewReference(im);
  1445.     }
  1446.     else {
  1447.         im = PyObject_NEW(PyMethodObject, &PyMethod_Type);
  1448.         if (im == NULL)
  1449.             return NULL;
  1450.     }
  1451.     Py_INCREF(func);
  1452.     im->im_func = func;
  1453.     Py_XINCREF(self);
  1454.     im->im_self = self;
  1455.     Py_INCREF(class);
  1456.     im->im_class = class;
  1457.     return (PyObject *)im;
  1458. }
  1459.  
  1460. PyObject *
  1461. PyMethod_Function(im)
  1462.     register PyObject *im;
  1463. {
  1464.     if (!PyMethod_Check(im)) {
  1465.         PyErr_BadInternalCall();
  1466.         return NULL;
  1467.     }
  1468.     return ((PyMethodObject *)im)->im_func;
  1469. }
  1470.  
  1471. PyObject *
  1472. PyMethod_Self(im)
  1473.     register PyObject *im;
  1474. {
  1475.     if (!PyMethod_Check(im)) {
  1476.         PyErr_BadInternalCall();
  1477.         return NULL;
  1478.     }
  1479.     return ((PyMethodObject *)im)->im_self;
  1480. }
  1481.  
  1482. PyObject *
  1483. PyMethod_Class(im)
  1484.     register PyObject *im;
  1485. {
  1486.     if (!PyMethod_Check(im)) {
  1487.         PyErr_BadInternalCall();
  1488.         return NULL;
  1489.     }
  1490.     return ((PyMethodObject *)im)->im_class;
  1491. }
  1492.  
  1493. /* Class method methods */
  1494.  
  1495. #define OFF(x) offsetof(PyMethodObject, x)
  1496.  
  1497. static struct memberlist instancemethod_memberlist[] = {
  1498.     {"im_func",    T_OBJECT,    OFF(im_func)},
  1499.     {"im_self",    T_OBJECT,    OFF(im_self)},
  1500.     {"im_class",    T_OBJECT,    OFF(im_class)},
  1501.     /* Dummies that are not handled by getattr() except for __members__ */
  1502.     {"__doc__",    T_INT,        0},
  1503.     {"__name__",    T_INT,        0},
  1504.     {NULL}    /* Sentinel */
  1505. };
  1506.  
  1507. static PyObject *
  1508. instancemethod_getattr(im, name)
  1509.     register PyMethodObject *im;
  1510.     PyObject *name;
  1511. {
  1512.     char *sname = PyString_AsString(name);
  1513.     if (sname[0] == '_') {
  1514.         /* Inherit __name__ and __doc__ from the callable object
  1515.            implementing the method */
  1516.             if (strcmp(sname, "__name__") == 0 ||
  1517.             strcmp(sname, "__doc__") == 0)
  1518.             return PyObject_GetAttr(im->im_func, name);
  1519.     }
  1520.     if (PyEval_GetRestricted()) {
  1521.         PyErr_SetString(PyExc_RuntimeError,
  1522.         "instance-method attributes not accessible in restricted mode");
  1523.         return NULL;
  1524.     }
  1525.     return PyMember_Get((char *)im, instancemethod_memberlist, sname);
  1526. }
  1527.  
  1528. static void
  1529. instancemethod_dealloc(im)
  1530.     register PyMethodObject *im;
  1531. {
  1532.     Py_DECREF(im->im_func);
  1533.     Py_XDECREF(im->im_self);
  1534.     Py_DECREF(im->im_class);
  1535.     im->im_self = (PyObject *)free_list;
  1536.     free_list = im;
  1537. }
  1538.  
  1539. static int
  1540. instancemethod_compare(a, b)
  1541.     PyMethodObject *a, *b;
  1542. {
  1543.     if (a->im_self != b->im_self)
  1544.         return (a->im_self < b->im_self) ? -1 : 1;
  1545.     return PyObject_Compare(a->im_func, b->im_func);
  1546. }
  1547.  
  1548. static PyObject *
  1549. instancemethod_repr(a)
  1550.     PyMethodObject *a;
  1551. {
  1552.     char buf[240];
  1553.     PyInstanceObject *self = (PyInstanceObject *)(a->im_self);
  1554.     PyObject *func = a->im_func;
  1555.     PyClassObject *class = (PyClassObject *)(a->im_class);
  1556.     PyObject *fclassname, *iclassname, *funcname;
  1557.     char *fcname, *icname, *fname;
  1558.     fclassname = class->cl_name;
  1559.     if (PyFunction_Check(func)) {
  1560.         funcname = ((PyFunctionObject *)func)->func_name;
  1561.         Py_INCREF(funcname);
  1562.     }
  1563.     else {
  1564.         funcname = PyObject_GetAttrString(func,"__name__");
  1565.         if (funcname == NULL)
  1566.             PyErr_Clear();
  1567.     }
  1568.     if (funcname != NULL && PyString_Check(funcname))
  1569.         fname = PyString_AS_STRING(funcname);
  1570.     else
  1571.         fname = "?";
  1572.     Py_XDECREF(funcname);
  1573.     if (fclassname != NULL && PyString_Check(fclassname))
  1574.         fcname = PyString_AsString(fclassname);
  1575.     else
  1576.         fcname = "?";
  1577.     if (self == NULL)
  1578.         sprintf(buf, "<unbound method %.100s.%.100s>", fcname, fname);
  1579.     else {
  1580.         iclassname = self->in_class->cl_name;
  1581.         if (iclassname != NULL && PyString_Check(iclassname))
  1582.             icname = PyString_AsString(iclassname);
  1583.         else
  1584.             icname = "?";
  1585.         sprintf(buf, "<method %.60s.%.60s of %.60s instance at %lx>",
  1586.             fcname, fname, icname, (long)self);
  1587.     }
  1588.     return PyString_FromString(buf);
  1589. }
  1590.  
  1591. static long
  1592. instancemethod_hash(a)
  1593.     PyMethodObject *a;
  1594. {
  1595.     long x, y;
  1596.     if (a->im_self == NULL)
  1597.         x = PyObject_Hash(Py_None);
  1598.     else
  1599.         x = PyObject_Hash(a->im_self);
  1600.     if (x == -1)
  1601.         return -1;
  1602.     y = PyObject_Hash(a->im_func);
  1603.     if (y == -1)
  1604.         return -1;
  1605.     return x ^ y;
  1606. }
  1607.  
  1608. PyTypeObject PyMethod_Type = {
  1609.     PyObject_HEAD_INIT(&PyType_Type)
  1610.     0,
  1611.     "instance method",
  1612.     sizeof(PyMethodObject),
  1613.     0,
  1614.     (destructor)instancemethod_dealloc, /*tp_dealloc*/
  1615.     0,            /*tp_print*/
  1616.     0,            /*tp_getattr*/
  1617.     0,            /*tp_setattr*/
  1618.     (cmpfunc)instancemethod_compare, /*tp_compare*/
  1619.     (reprfunc)instancemethod_repr, /*tp_repr*/
  1620.     0,            /*tp_as_number*/
  1621.     0,            /*tp_as_sequence*/
  1622.     0,            /*tp_as_mapping*/
  1623.     (hashfunc)instancemethod_hash, /*tp_hash*/
  1624.     0,            /*tp_call*/
  1625.     0,            /*tp_str*/
  1626.     (getattrofunc)instancemethod_getattr, /*tp_getattro*/
  1627.     0,            /*tp_setattro*/
  1628. };
  1629.  
  1630. /* Clear out the free list */
  1631.  
  1632. void
  1633. PyMethod_Fini()
  1634. {
  1635.     while (free_list) {
  1636.         PyMethodObject *v = free_list;
  1637.         free_list = (PyMethodObject *)(v->im_self);
  1638.         PyMem_DEL(v);
  1639.     }
  1640. }
  1641.