home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pyth_os2.zip / python-1.0.2 / Objects / classobject.c < prev    next >
C/C++ Source or Header  |  1994-01-04  |  25KB  |  1,140 lines
  1. /***********************************************************
  2. Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
  3. Amsterdam, 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 not be used in advertising or publicity pertaining to
  13. distribution of the software without specific, written prior permission.
  14.  
  15. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18. FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19. WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20. ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21. OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  
  23. ******************************************************************/
  24.  
  25. /* Class object implementation */
  26.  
  27. #include "allobjects.h"
  28. #include "modsupport.h"
  29. #include "structmember.h"
  30. #include "ceval.h"
  31.  
  32. object *
  33. newclassobject(bases, dict, name)
  34.     object *bases; /* NULL or tuple of classobjects! */
  35.     object *dict;
  36.     object *name; /* String; NULL if unknown */
  37. {
  38.     int pos;
  39.     object *key, *value;
  40.     classobject *op;
  41.     if (bases == NULL) {
  42.         bases = newtupleobject(0);
  43.         if (bases == NULL)
  44.             return NULL;
  45.     }
  46.     else
  47.         INCREF(bases);
  48.     op = NEWOBJ(classobject, &Classtype);
  49.     if (op == NULL) {
  50.         DECREF(bases);
  51.         return NULL;
  52.     }
  53.     op->cl_bases = bases;
  54.     INCREF(dict);
  55.     op->cl_dict = dict;
  56.     XINCREF(name);
  57.     op->cl_name = name;
  58.     pos = 0;
  59.     while (mappinggetnext(dict, &pos, &key, &value)) {
  60.         if (is_accessobject(value))
  61.             setaccessowner(value, (object *)op);
  62.     }
  63.     return (object *) op;
  64. }
  65.  
  66. /* Class methods */
  67.  
  68. static void
  69. class_dealloc(op)
  70.     classobject *op;
  71. {
  72.     DECREF(op->cl_bases);
  73.     DECREF(op->cl_dict);
  74.     XDECREF(op->cl_name);
  75.     free((ANY *)op);
  76. }
  77.  
  78. static object *
  79. class_lookup(cp, name, pclass)
  80.     classobject *cp;
  81.     char *name;
  82.     classobject **pclass;
  83. {
  84.     int i, n;
  85.     object *value = dictlookup(cp->cl_dict, name);
  86.     if (value != NULL) {
  87.         *pclass = cp;
  88.         return value;
  89.     }
  90.     n = gettuplesize(cp->cl_bases);
  91.     for (i = 0; i < n; i++) {
  92.         object *v = class_lookup((classobject *)
  93.                  gettupleitem(cp->cl_bases, i), name, pclass);
  94.         if (v != NULL)
  95.             return v;
  96.     }
  97.     return NULL;
  98. }
  99.  
  100. static object *
  101. class_getattr(op, name)
  102.     register classobject *op;
  103.     register char *name;
  104. {
  105.     register object *v;
  106.     object *class;
  107.     if (strcmp(name, "__dict__") == 0) {
  108.         INCREF(op->cl_dict);
  109.         return op->cl_dict;
  110.     }
  111.     if (strcmp(name, "__bases__") == 0) {
  112.         INCREF(op->cl_bases);
  113.         return op->cl_bases;
  114.     }
  115.     if (strcmp(name, "__name__") == 0) {
  116.         if (op->cl_name == NULL)
  117.             v = None;
  118.         else
  119.             v = op->cl_name;
  120.         INCREF(v);
  121.         return v;
  122.     }
  123.     v = class_lookup(op, name, &class);
  124.     if (v == NULL) {
  125.         err_setstr(AttributeError, name);
  126.         return NULL;
  127.     }
  128.     if (is_accessobject(v)) {
  129.         v = getaccessvalue(v, getowner());
  130.         if (v == NULL)
  131.             return NULL;
  132.     }
  133.     else
  134.         INCREF(v);
  135.     if (is_funcobject(v)) {
  136.         object *w = newinstancemethodobject(v, (object *)NULL,
  137.                             (object *)class);
  138.         DECREF(v);
  139.         v = w;
  140.     }
  141.     return v;
  142. }
  143.  
  144. static int
  145. class_setattr(op, name, v)
  146.     classobject *op;
  147.     char *name;
  148.     object *v;
  149. {
  150.     object *ac;
  151.     if (name[0] == '_' && name[1] == '_') {
  152.         int n = strlen(name);
  153.         if (name[n-1] == '_' && name[n-2] == '_') {
  154.             err_setstr(TypeError, "read-only special attribute");
  155.             return -1;
  156.         }
  157.     }
  158.     ac = dictlookup(op->cl_dict, name);
  159.     if (ac != NULL && is_accessobject(ac))
  160.         return setaccessvalue(ac, getowner(), v);
  161.     if (v == NULL) {
  162.         int rv = dictremove(op->cl_dict, name);
  163.         if (rv < 0)
  164.             err_setstr(AttributeError,
  165.                    "delete non-existing class attribute");
  166.         return rv;
  167.     }
  168.     else
  169.         return dictinsert(op->cl_dict, name, v);
  170. }
  171.  
  172. static object *
  173. class_repr(op)
  174.     classobject *op;
  175. {
  176.     char buf[140];
  177.     char *name;
  178.     if (op->cl_name == NULL || !is_stringobject(op->cl_name))
  179.         name = "?";
  180.     else
  181.         name = getstringvalue(op->cl_name);
  182.     sprintf(buf, "<class %.100s at %lx>", name, (long)op);
  183.     return newstringobject(buf);
  184. }
  185.  
  186. typeobject Classtype = {
  187.     OB_HEAD_INIT(&Typetype)
  188.     0,
  189.     "class",
  190.     sizeof(classobject),
  191.     0,
  192.     (destructor)class_dealloc, /*tp_dealloc*/
  193.     0,        /*tp_print*/
  194.     (getattrfunc)class_getattr, /*tp_getattr*/
  195.     (setattrfunc)class_setattr, /*tp_setattr*/
  196.     0,        /*tp_compare*/
  197.     (reprfunc)class_repr, /*tp_repr*/
  198.     0,        /*tp_as_number*/
  199.     0,        /*tp_as_sequence*/
  200.     0,        /*tp_as_mapping*/
  201. };
  202.  
  203. int
  204. issubclass(class, base)
  205.     object *class;
  206.     object *base;
  207. {
  208.     int i, n;
  209.     classobject *cp;
  210.     if (class == base)
  211.         return 1;
  212.     if (class == NULL || !is_classobject(class))
  213.         return 0;
  214.     cp = (classobject *)class;
  215.     n = gettuplesize(cp->cl_bases);
  216.     for (i = 0; i < n; i++) {
  217.         if (issubclass(gettupleitem(cp->cl_bases, i), base))
  218.             return 1;
  219.     }
  220.     return 0;
  221. }
  222.  
  223.  
  224. /* Instance objects */
  225.  
  226. static object *instance_getattr PROTO((instanceobject *, char *));
  227.  
  228. static int
  229. addaccess(class, inst)
  230.     classobject *class;
  231.     instanceobject *inst;
  232. {
  233.     int i, n, pos, ret;
  234.     object *key, *value, *ac;
  235.     
  236.     n = gettuplesize(class->cl_bases);
  237.     for (i = 0; i < n; i++) {
  238.         if (addaccess(gettupleitem(class->cl_bases, i), inst) < 0)
  239.             return -1;
  240.     }
  241.     
  242.     pos = 0;
  243.     while (mappinggetnext(class->cl_dict, &pos, &key, &value)) {
  244.         object *v;
  245.         if (!is_accessobject(value))
  246.             continue;
  247.         if (hasaccessvalue(value))
  248.             continue;
  249.         ac = dict2lookup(inst->in_dict, key);
  250.         if (ac != NULL && is_accessobject(ac)) {
  251.             err_setval(ConflictError, key);
  252.             return -1;
  253.         }
  254.         ac = cloneaccessobject(value);
  255.         if (ac == NULL)
  256.             return -1;
  257.         ret = dict2insert(inst->in_dict, key, ac);
  258.         DECREF(ac);
  259.         if (ret != 0)
  260.             return -1;
  261.         }
  262.     return 0;
  263. }
  264.  
  265. object *
  266. newinstanceobject(class, arg)
  267.     object *class;
  268.     object *arg;
  269. {
  270.     register instanceobject *inst;
  271.     object *v;
  272.     object *init;
  273.     if (!is_classobject(class)) {
  274.         err_badcall();
  275.         return NULL;
  276.     }
  277.     inst = NEWOBJ(instanceobject, &Instancetype);
  278.     if (inst == NULL)
  279.         return NULL;
  280.     INCREF(class);
  281.     inst->in_class = (classobject *)class;
  282.     inst->in_dict = newdictobject();
  283.     if (inst->in_dict == NULL ||
  284.         addaccess((classobject *)class, inst) != 0) {
  285.         DECREF(inst);
  286.         return NULL;
  287.     }
  288.     init = instance_getattr(inst, "__init__");
  289.     if (init == NULL) {
  290.         err_clear();
  291.         if (arg != NULL && !(is_tupleobject(arg) &&
  292.                      gettuplesize(arg) == 0)) {
  293.             err_setstr(TypeError,
  294.                 "this classobject() takes no arguments");
  295.             DECREF(inst);
  296.             inst = NULL;
  297.         }
  298.     }
  299.     else {
  300.         object *res = call_object(init, arg);
  301.         DECREF(init);
  302.         if (res == NULL) {
  303.             DECREF(inst);
  304.             inst = NULL;
  305.         }
  306.         else {
  307.             if (res != None) {
  308.                 err_setstr(TypeError,
  309.                        "__init__() should return None");
  310.                 DECREF(inst);
  311.                 inst = NULL;
  312.             }
  313.             DECREF(res);
  314.         }
  315.     }
  316.     return (object *)inst;
  317. }
  318.  
  319. /* Instance methods */
  320.  
  321. static void
  322. instance_dealloc(inst)
  323.     register instanceobject *inst;
  324. {
  325.     object *error_type, *error_value;
  326.     object *del;
  327.     /* Call the __del__ method if it exists.  First temporarily
  328.        revive the object and save the current exception, if any. */
  329.     INCREF(inst);
  330.     err_get(&error_type, &error_value);
  331.     if ((del = instance_getattr(inst, "__del__")) != NULL) {
  332.         object *args = newtupleobject(0);
  333.         object *res = args;
  334.         if (res != NULL)
  335.             res = call_object(del, args);
  336.         XDECREF(args);
  337.         DECREF(del);
  338.         XDECREF(res);
  339.         /* XXX If __del__ raised an exception, it is ignored! */
  340.     }
  341.     /* Restore the saved exception and undo the temporary revival */
  342.     err_setval(error_type, error_value);
  343.     /* Can't use DECREF here, it would cause a recursive call */
  344.     if (--inst->ob_refcnt > 0)
  345.         return; /* __del__ added a reference; don't delete now */
  346.     DECREF(inst->in_class);
  347.     XDECREF(inst->in_dict);
  348.     free((ANY *)inst);
  349. }
  350.  
  351. static object *
  352. instance_getattr(inst, name)
  353.     register instanceobject *inst;
  354.     register char *name;
  355. {
  356.     register object *v;
  357.     classobject *class;
  358.     if (name[0] == '_' && name[1] == '_') {
  359.         if (strcmp(name, "__dict__") == 0) {
  360.             INCREF(inst->in_dict);
  361.             return inst->in_dict;
  362.         }
  363.         if (strcmp(name, "__class__") == 0) {
  364.             INCREF(inst->in_class);
  365.             return (object *)inst->in_class;
  366.         }
  367.     }
  368.     class = NULL;
  369.     v = dictlookup(inst->in_dict, name);
  370.     if (v == NULL) {
  371.         v = class_lookup(inst->in_class, name, &class);
  372.         if (v == NULL) {
  373.             err_setstr(AttributeError, name);
  374.             return NULL;
  375.         }
  376.     }
  377.     if (is_accessobject(v)) {
  378.         v = getaccessvalue(v, getowner());
  379.         if (v == NULL)
  380.             return NULL;
  381.     }
  382.     else
  383.         INCREF(v);
  384.     if (class != NULL) {
  385.         if (is_funcobject(v)) {
  386.             object *w = newinstancemethodobject(v, (object *)inst,
  387.                                 (object *)class);
  388.             DECREF(v);
  389.             v = w;
  390.         }
  391.         else if (is_instancemethodobject(v)) {
  392.             object *im_class = instancemethodgetclass(v);
  393.             /* Only if classes are compatible */
  394.             if (issubclass((object *)class, im_class)) {
  395.                 object *im_func = instancemethodgetfunc(v);
  396.                 object *w = newinstancemethodobject(im_func,
  397.                         (object *)inst, im_class);
  398.                 DECREF(v);
  399.                 v = w;
  400.             }
  401.         }
  402.     }
  403.     return v;
  404. }
  405.  
  406. static int
  407. instance_setattr(inst, name, v)
  408.     instanceobject *inst;
  409.     char *name;
  410.     object *v;
  411. {
  412.     object *ac;
  413.     if (name[0] == '_' && name[1] == '_') {
  414.         int n = strlen(name);
  415.         if (name[n-1] == '_' && name[n-2] == '_') {
  416.             err_setstr(TypeError, "read-only special attribute");
  417.             return -1;
  418.         }
  419.     }
  420.     ac = dictlookup(inst->in_dict, name);
  421.     if (ac != NULL && is_accessobject(ac))
  422.         return setaccessvalue(ac, getowner(), v);
  423.     if (v == NULL) {
  424.         int rv = dictremove(inst->in_dict, name);
  425.         if (rv < 0)
  426.             err_setstr(AttributeError,
  427.                    "delete non-existing instance attribute");
  428.         return rv;
  429.     }
  430.     else
  431.         return dictinsert(inst->in_dict, name, v);
  432. }
  433.  
  434. static object *
  435. instance_repr(inst)
  436.     instanceobject *inst;
  437. {
  438.     object *func;
  439.     object *res;
  440.  
  441.     func = instance_getattr(inst, "__repr__");
  442.     if (func == NULL) {
  443.         char buf[140];
  444.         object *classname = inst->in_class->cl_name;
  445.         char *cname;
  446.         if (classname != NULL && is_stringobject(classname))
  447.             cname = getstringvalue(classname);
  448.         else
  449.             cname = "?";
  450.         err_clear();
  451.         sprintf(buf, "<%.100s instance at %lx>", cname, (long)inst);
  452.         return newstringobject(buf);
  453.     }
  454.     res = call_object(func, (object *)NULL);
  455.     DECREF(func);
  456.     return res;
  457. }
  458.  
  459. static int
  460. instance_compare(inst, other)
  461.     instanceobject *inst, *other;
  462. {
  463.     object *func;
  464.     object *res;
  465.     int outcome;
  466.  
  467.     func = instance_getattr(inst, "__cmp__");
  468.     if (func == NULL) {
  469.         err_clear();
  470.         if (inst < other)
  471.             return -1;
  472.         if (inst > other)
  473.             return 1;
  474.         return 0;
  475.     }
  476.     res = call_object(func, (object *)other);
  477.     DECREF(func);
  478.     if (res == NULL) {
  479.         err_clear(); /* XXX Should report the error, bot how...??? */
  480.         return 0;
  481.     }
  482.     if (is_intobject(res))
  483.         outcome = getintvalue(res);
  484.     else
  485.         outcome = 0; /* XXX Should report the error, bot how...??? */
  486.     DECREF(res);
  487.     return outcome;
  488. }
  489.  
  490. static long
  491. instance_hash(inst)
  492.     instanceobject *inst;
  493. {
  494.     object *func;
  495.     object *res;
  496.     long outcome;
  497.  
  498.     func = instance_getattr(inst, "__hash__");
  499.     if (func == NULL) {
  500.         /* If there is no __cmp__ method, we hash on the address.
  501.            If a __cmp__ method exists, there must be a __hash__. */
  502.         err_clear();
  503.         func = instance_getattr(inst, "__cmp__");
  504.         if (func == NULL) {
  505.             err_clear();
  506.             outcome = (long)inst;
  507.             if (outcome == -1)
  508.                 outcome = -2;
  509.             return outcome;
  510.         }
  511.         err_setstr(TypeError, "unhashable instance");
  512.         return -1;
  513.     }
  514.     res = call_object(func, (object *)NULL);
  515.     DECREF(func);
  516.     if (res == NULL)
  517.         return -1;
  518.     if (is_intobject(res)) {
  519.         outcome = getintvalue(res);
  520.         if (outcome == -1)
  521.             outcome = -2;
  522.     }
  523.     else {
  524.         err_setstr(TypeError, "__hash__() should return an int");
  525.         outcome = -1;
  526.     }
  527.     DECREF(res);
  528.     return outcome;
  529. }
  530.  
  531. static int
  532. instance_length(inst)
  533.     instanceobject *inst;
  534. {
  535.     object *func;
  536.     object *res;
  537.     int outcome;
  538.  
  539.     func = instance_getattr(inst, "__len__");
  540.     if (func == NULL)
  541.         return -1;
  542.     res = call_object(func, (object *)NULL);
  543.     DECREF(func);
  544.     if (res == NULL)
  545.         return -1;
  546.     if (is_intobject(res)) {
  547.         outcome = getintvalue(res);
  548.         if (outcome < 0)
  549.             err_setstr(ValueError, "__len__() should return >= 0");
  550.     }
  551.     else {
  552.         err_setstr(TypeError, "__len__() should return an int");
  553.         outcome = -1;
  554.     }
  555.     DECREF(res);
  556.     return outcome;
  557. }
  558.  
  559. static object *
  560. instance_subscript(inst, key)
  561.     instanceobject *inst;
  562.     object *key;
  563. {
  564.     object *func;
  565.     object *arg;
  566.     object *res;
  567.  
  568.     func = instance_getattr(inst, "__getitem__");
  569.     if (func == NULL)
  570.         return NULL;
  571.     arg = mkvalue("(O)", key);
  572.     if (arg == NULL) {
  573.         DECREF(func);
  574.         return NULL;
  575.     }
  576.     res = call_object(func, arg);
  577.     DECREF(func);
  578.     DECREF(arg);
  579.     return res;
  580. }
  581.  
  582. static int
  583. instance_ass_subscript(inst, key, value)
  584.     instanceobject*inst;
  585.     object *key;
  586.     object *value;
  587. {
  588.     object *func;
  589.     object *arg;
  590.     object *res;
  591.  
  592.     if (value == NULL)
  593.         func = instance_getattr(inst, "__delitem__");
  594.     else
  595.         func = instance_getattr(inst, "__setitem__");
  596.     if (func == NULL)
  597.         return -1;
  598.     if (value == NULL)
  599.         arg = mkvalue("(O)", key);
  600.     else
  601.         arg = mkvalue("(OO)", key, value);
  602.     if (arg == NULL) {
  603.         DECREF(func);
  604.         return -1;
  605.     }
  606.     res = call_object(func, arg);
  607.     DECREF(func);
  608.     DECREF(arg);
  609.     if (res == NULL)
  610.         return -1;
  611.     DECREF(res);
  612.     return 0;
  613. }
  614.  
  615. static mapping_methods instance_as_mapping = {
  616.     (inquiry)instance_length, /*mp_length*/
  617.     (binaryfunc)instance_subscript, /*mp_subscript*/
  618.     (objobjargproc)instance_ass_subscript, /*mp_ass_subscript*/
  619. };
  620.  
  621. static object *
  622. instance_concat(inst, other)
  623.     instanceobject *inst, *other;
  624. {
  625.     object *func, *arg, *res;
  626.  
  627.     func = instance_getattr(inst, "__add__");
  628.     if (func == NULL)
  629.         return NULL;
  630.     arg = mkvalue("(O)", other);
  631.     if (arg == NULL) {
  632.         DECREF(func);
  633.         return NULL;
  634.     }
  635.     res = call_object(func, arg);
  636.     DECREF(func);
  637.     DECREF(arg);
  638.     return res;
  639. }
  640.  
  641. static object *
  642. instance_repeat(inst, count)
  643.     instanceobject *inst;
  644.     int count;
  645. {
  646.     object *func, *arg, *res;
  647.  
  648.     func = instance_getattr(inst, "__mul__");
  649.     if (func == NULL)
  650.         return NULL;
  651.     arg = newintobject((long)count);
  652.     if (arg == NULL) {
  653.         DECREF(func);
  654.         return NULL;
  655.     }
  656.     res = call_object(func, arg);
  657.     DECREF(func);
  658.     DECREF(arg);
  659.     return res;
  660. }
  661.  
  662. static object *
  663. instance_item(inst, i)
  664.     instanceobject *inst;
  665.     int i;
  666. {
  667.     object *func, *arg, *res;
  668.  
  669.     func = instance_getattr(inst, "__getitem__");
  670.     if (func == NULL)
  671.         return NULL;
  672.     arg = newintobject((long)i);
  673.     if (arg == NULL) {
  674.         DECREF(func);
  675.         return NULL;
  676.     }
  677.     res = call_object(func, arg);
  678.     DECREF(func);
  679.     DECREF(arg);
  680.     return res;
  681. }
  682.  
  683. static object *
  684. instance_slice(inst, i, j)
  685.     instanceobject *inst;
  686.     int i, j;
  687. {
  688.     object *func, *arg, *res;
  689.  
  690.     func = instance_getattr(inst, "__getslice__");
  691.     if (func == NULL)
  692.         return NULL;
  693.     arg = mkvalue("(ii)", i, j);
  694.     if (arg == NULL) {
  695.         DECREF(func);
  696.         return NULL;
  697.     }
  698.     res = call_object(func, arg);
  699.     DECREF(func);
  700.     DECREF(arg);
  701.     return res;
  702. }
  703.  
  704. static int
  705. instance_ass_item(inst, i, item)
  706.     instanceobject *inst;
  707.     int i;
  708.     object *item;
  709. {
  710.     object *func, *arg, *res;
  711.  
  712.     if (item == NULL)
  713.         func = instance_getattr(inst, "__delitem__");
  714.     else
  715.         func = instance_getattr(inst, "__setitem__");
  716.     if (func == NULL)
  717.         return -1;
  718.     if (item == NULL)
  719.         arg = mkvalue("i", i);
  720.     else
  721.         arg = mkvalue("(iO)", i, item);
  722.     if (arg == NULL) {
  723.         DECREF(func);
  724.         return -1;
  725.     }
  726.     res = call_object(func, arg);
  727.     DECREF(func);
  728.     DECREF(arg);
  729.     if (res == NULL)
  730.         return -1;
  731.     DECREF(res);
  732.     return 0;
  733. }
  734.  
  735. static int
  736. instance_ass_slice(inst, i, j, value)
  737.     instanceobject *inst;
  738.     int i, j;
  739.     object *value;
  740. {
  741.     object *func, *arg, *res;
  742.  
  743.     if (value == NULL)
  744.         func = instance_getattr(inst, "__delslice__");
  745.     else
  746.         func = instance_getattr(inst, "__setslice__");
  747.     if (func == NULL)
  748.         return -1;
  749.     if (value == NULL)
  750.         arg = mkvalue("(ii)", i, j);
  751.     else
  752.         arg = mkvalue("(iiO)", i, j, value);
  753.     if (arg == NULL) {
  754.         DECREF(func);
  755.         return -1;
  756.     }
  757.     res = call_object(func, arg);
  758.     DECREF(func);
  759.     DECREF(arg);
  760.     if (res == NULL)
  761.         return -1;
  762.     DECREF(res);
  763.     return 0;
  764. }
  765.  
  766. static sequence_methods instance_as_sequence = {
  767.     (inquiry)instance_length, /*sq_length*/
  768.     (binaryfunc)instance_concat, /*sq_concat*/
  769.     (intargfunc)instance_repeat, /*sq_repeat*/
  770.     (intargfunc)instance_item, /*sq_item*/
  771.     (intintargfunc)instance_slice, /*sq_slice*/
  772.     (intobjargproc)instance_ass_item, /*sq_ass_item*/
  773.     (intintobjargproc)instance_ass_slice, /*sq_ass_slice*/
  774. };
  775.  
  776. static object *
  777. generic_binary_op(self, other, methodname)
  778.     instanceobject *self;
  779.     object *other;
  780.     char *methodname;
  781. {
  782.     object *func, *arg, *res;
  783.  
  784.     if ((func = instance_getattr(self, methodname)) == NULL)
  785.         return NULL;
  786.     arg = mkvalue("O", other);
  787.     if (arg == NULL) {
  788.         DECREF(func);
  789.         return NULL;
  790.     }
  791.     res = call_object(func, arg);
  792.     DECREF(func);
  793.     DECREF(arg);
  794.     return res;
  795. }
  796.  
  797. static object *
  798. generic_unary_op(self, methodname)
  799.     instanceobject *self;
  800.     char *methodname;
  801. {
  802.     object *func, *res;
  803.  
  804.     if ((func = instance_getattr(self, methodname)) == NULL)
  805.         return NULL;
  806.     res = call_object(func, (object *)NULL);
  807.     DECREF(func);
  808.     return res;
  809. }
  810.  
  811. #define BINARY(funcname, methodname) \
  812. static object * funcname(self, other) instanceobject *self; object *other; { \
  813.     return generic_binary_op(self, other, methodname); \
  814. }
  815.  
  816. #define UNARY(funcname, methodname) \
  817. static object *funcname(self) instanceobject *self; { \
  818.     return generic_unary_op(self, methodname); \
  819. }
  820.  
  821. BINARY(instance_add, "__add__")
  822. BINARY(instance_sub, "__sub__")
  823. BINARY(instance_mul, "__mul__")
  824. BINARY(instance_div, "__div__")
  825. BINARY(instance_mod, "__mod__")
  826. BINARY(instance_divmod, "__divmod__")
  827. BINARY(instance_pow, "__pow__")
  828. UNARY(instance_neg, "__neg__")
  829. UNARY(instance_pos, "__pos__")
  830. UNARY(instance_abs, "__abs__")
  831.  
  832. static int
  833. instance_nonzero(self)
  834.     instanceobject *self;
  835. {
  836.     object *func, *res;
  837.     long outcome;
  838.  
  839.     if ((func = instance_getattr(self, "__nonzero__")) == NULL) {
  840.         err_clear();
  841.         if ((func = instance_getattr(self, "__len__")) == NULL) {
  842.             err_clear();
  843.             /* Fall back to the default behavior:
  844.                all instances are nonzero */
  845.             return 1;
  846.         }
  847.     }
  848.     res = call_object(func, (object *)NULL);
  849.     DECREF(func);
  850.     if (res == NULL)
  851.         return -1;
  852.     if (!is_intobject(res)) {
  853.         DECREF(res);
  854.         err_setstr(TypeError, "__nonzero__ should return an int");
  855.         return -1;
  856.     }
  857.     outcome = getintvalue(res);
  858.     DECREF(res);
  859.     if (outcome < 0) {
  860.         err_setstr(ValueError, "__nonzero__ should return >= 0");
  861.         return -1;
  862.     }
  863.     return outcome > 0;
  864. }
  865.  
  866. UNARY(instance_invert, "__invert__")
  867. BINARY(instance_lshift, "__lshift__")
  868. BINARY(instance_rshift, "__rshift__")
  869. BINARY(instance_and, "__and__")
  870. BINARY(instance_xor, "__xor__")
  871. BINARY(instance_or, "__or__")
  872.  
  873. static int
  874. instance_coerce(pv, pw)
  875.     object **pv, **pw;
  876. {
  877.     object *v =  *pv;
  878.     object *w = *pw;
  879.     object *func;
  880.     object *res;
  881.     int outcome;
  882.  
  883.     if (!is_instanceobject(v))
  884.         return 1; /* XXX shouldn't be possible */
  885.     func = instance_getattr((instanceobject *)v, "__coerce__");
  886.     if (func == NULL) {
  887.         err_clear();
  888.         return 1;
  889.     }
  890.     res = call_object(func, w);
  891.     if (res == NULL)
  892.         return -1;
  893.     if (res == None) {
  894.         DECREF(res);
  895.         return 1;
  896.     }
  897.     outcome = getargs(res, "(OO)", &v, &w);
  898.     if (!outcome || v->ob_type != w->ob_type ||
  899.             v->ob_type->tp_as_number == NULL) {
  900.         DECREF(res);
  901.         err_setstr(TypeError, "bad __coerce__ result");
  902.         return -1;
  903.     }
  904.     INCREF(v);
  905.     INCREF(w);
  906.     DECREF(res);
  907.     *pv = v;
  908.     *pw = w;
  909.     return 0;
  910. }
  911.  
  912. UNARY(instance_int, "__int__")
  913. UNARY(instance_long, "__long__")
  914. UNARY(instance_float, "__float__")
  915. UNARY(instance_oct, "__oct__")
  916. UNARY(instance_hex, "__hex__")
  917.  
  918. static number_methods instance_as_number = {
  919.     (binaryfunc)instance_add, /*nb_add*/
  920.     (binaryfunc)instance_sub, /*nb_subtract*/
  921.     (binaryfunc)instance_mul, /*nb_multiply*/
  922.     (binaryfunc)instance_div, /*nb_divide*/
  923.     (binaryfunc)instance_mod, /*nb_remainder*/
  924.     (binaryfunc)instance_divmod, /*nb_divmod*/
  925.     (binaryfunc)instance_pow, /*nb_power*/
  926.     (unaryfunc)instance_neg, /*nb_negative*/
  927.     (unaryfunc)instance_pos, /*nb_positive*/
  928.     (unaryfunc)instance_abs, /*nb_absolute*/
  929.     (inquiry)instance_nonzero, /*nb_nonzero*/
  930.     (unaryfunc)instance_invert, /*nb_invert*/
  931.     (binaryfunc)instance_lshift, /*nb_lshift*/
  932.     (binaryfunc)instance_rshift, /*nb_rshift*/
  933.     (binaryfunc)instance_and, /*nb_and*/
  934.     (binaryfunc)instance_xor, /*nb_xor*/
  935.     (binaryfunc)instance_or, /*nb_or*/
  936.     (coercion)instance_coerce, /*nb_coerce*/
  937.     (unaryfunc)instance_int, /*nb_int*/
  938.     (unaryfunc)instance_long, /*nb_long*/
  939.     (unaryfunc)instance_float, /*nb_float*/
  940.     (unaryfunc)instance_oct, /*nb_oct*/
  941.     (unaryfunc)instance_hex, /*nb_hex*/
  942. };
  943.  
  944. typeobject Instancetype = {
  945.     OB_HEAD_INIT(&Typetype)
  946.     0,
  947.     "instance",
  948.     sizeof(instanceobject),
  949.     0,
  950.     (destructor)instance_dealloc, /*tp_dealloc*/
  951.     0,            /*tp_print*/
  952.     (object * (*) FPROTO((object *, char *)))
  953.     (getattrfunc)instance_getattr, /*tp_getattr*/
  954.     (setattrfunc)instance_setattr, /*tp_setattr*/
  955.     (cmpfunc)instance_compare, /*tp_compare*/
  956.     (reprfunc)instance_repr, /*tp_repr*/
  957.     &instance_as_number,    /*tp_as_number*/
  958.     &instance_as_sequence,    /*tp_as_sequence*/
  959.     &instance_as_mapping,    /*tp_as_mapping*/
  960.     (hashfunc)instance_hash, /*tp_hash*/
  961. };
  962.  
  963.  
  964. /* Instance method objects are used for two purposes:
  965.    (a) as bound instance methods (returned by instancename.methodname)
  966.    (b) as unbound methods (returned by ClassName.methodname)
  967.    In case (b), im_self is NULL
  968. */
  969.  
  970. typedef struct {
  971.     OB_HEAD
  972.     object    *im_func;    /* The function implementing the method */
  973.     object    *im_self;    /* The instance it is bound to, or NULL */
  974.     object    *im_class;    /* The class that defined the method */
  975. } instancemethodobject;
  976.  
  977. object *
  978. newinstancemethodobject(func, self, class)
  979.     object *func;
  980.     object *self;
  981.     object *class;
  982. {
  983.     register instancemethodobject *im;
  984.     if (!is_funcobject(func)) {
  985.         err_badcall();
  986.         return NULL;
  987.     }
  988.     im = NEWOBJ(instancemethodobject, &Instancemethodtype);
  989.     if (im == NULL)
  990.         return NULL;
  991.     INCREF(func);
  992.     im->im_func = func;
  993.     XINCREF(self);
  994.     im->im_self = self;
  995.     INCREF(class);
  996.     im->im_class = class;
  997.     return (object *)im;
  998. }
  999.  
  1000. object *
  1001. instancemethodgetfunc(im)
  1002.     register object *im;
  1003. {
  1004.     if (!is_instancemethodobject(im)) {
  1005.         err_badcall();
  1006.         return NULL;
  1007.     }
  1008.     return ((instancemethodobject *)im)->im_func;
  1009. }
  1010.  
  1011. object *
  1012. instancemethodgetself(im)
  1013.     register object *im;
  1014. {
  1015.     if (!is_instancemethodobject(im)) {
  1016.         err_badcall();
  1017.         return NULL;
  1018.     }
  1019.     return ((instancemethodobject *)im)->im_self;
  1020. }
  1021.  
  1022. object *
  1023. instancemethodgetclass(im)
  1024.     register object *im;
  1025. {
  1026.     if (!is_instancemethodobject(im)) {
  1027.         err_badcall();
  1028.         return NULL;
  1029.     }
  1030.     return ((instancemethodobject *)im)->im_class;
  1031. }
  1032.  
  1033. /* Class method methods */
  1034.  
  1035. #define OFF(x) offsetof(instancemethodobject, x)
  1036.  
  1037. static struct memberlist instancemethod_memberlist[] = {
  1038.     {"im_func",    T_OBJECT,    OFF(im_func)},
  1039.     {"im_self",    T_OBJECT,    OFF(im_self)},
  1040.     {"im_class",    T_OBJECT,    OFF(im_class)},
  1041.     {NULL}    /* Sentinel */
  1042. };
  1043.  
  1044. static object *
  1045. instancemethod_getattr(im, name)
  1046.     register instancemethodobject *im;
  1047.     char *name;
  1048. {
  1049.     return getmember((char *)im, instancemethod_memberlist, name);
  1050. }
  1051.  
  1052. static void
  1053. instancemethod_dealloc(im)
  1054.     register instancemethodobject *im;
  1055. {
  1056.     DECREF(im->im_func);
  1057.     XDECREF(im->im_self);
  1058.     DECREF(im->im_class);
  1059.     free((ANY *)im);
  1060. }
  1061.  
  1062. static int
  1063. instancemethod_compare(a, b)
  1064.     instancemethodobject *a, *b;
  1065. {
  1066.     int cmp = cmpobject(a->im_self, b->im_self);
  1067.     if (cmp == 0)
  1068.         cmp = cmpobject(a->im_func, b->im_func);
  1069.     return cmp;
  1070. }
  1071.  
  1072. static object *
  1073. instancemethod_repr(a)
  1074.     instancemethodobject *a;
  1075. {
  1076.     char buf[240];
  1077.     instanceobject *self = (instanceobject *)(a->im_self);
  1078.     funcobject *func = (funcobject *)(a->im_func);
  1079.     classobject *class = (classobject *)(a->im_class);
  1080.     object *fclassname, *iclassname, *funcname;
  1081.     char *fcname, *icname, *fname;
  1082.     fclassname = class->cl_name;
  1083.     funcname = func->func_name;
  1084.     if (fclassname != NULL && is_stringobject(fclassname))
  1085.         fcname = getstringvalue(fclassname);
  1086.     else
  1087.         fcname = "?";
  1088.     if (funcname != NULL && is_stringobject(funcname))
  1089.         fname = getstringvalue(funcname);
  1090.     else
  1091.         fname = "?";
  1092.     if (self == NULL)
  1093.         sprintf(buf, "<unbound method %.100s.%.100s>", fcname, fname);
  1094.     else {
  1095.         iclassname = self->in_class->cl_name;
  1096.         if (iclassname != NULL && is_stringobject(iclassname))
  1097.             icname = getstringvalue(iclassname);
  1098.         else
  1099.             icname = "?";
  1100.         sprintf(buf, "<method %.60s.%.60s of %.60s instance at %lx>",
  1101.             fcname, fname, icname, (long)self);
  1102.     }
  1103.     return newstringobject(buf);
  1104. }
  1105.  
  1106. static long
  1107. instancemethod_hash(a)
  1108.     instancemethodobject *a;
  1109. {
  1110.     long x, y;
  1111.     if (a->im_self == NULL)
  1112.         x = hashobject(None);
  1113.     else
  1114.         x = hashobject(a->im_self);
  1115.     if (x == -1)
  1116.         return -1;
  1117.     y = hashobject(a->im_func);
  1118.     if (y == -1)
  1119.         return -1;
  1120.     return x ^ y;
  1121. }
  1122.  
  1123. typeobject Instancemethodtype = {
  1124.     OB_HEAD_INIT(&Typetype)
  1125.     0,
  1126.     "instance method",
  1127.     sizeof(instancemethodobject),
  1128.     0,
  1129.     (destructor)instancemethod_dealloc, /*tp_dealloc*/
  1130.     0,            /*tp_print*/
  1131.     (getattrfunc)instancemethod_getattr, /*tp_getattr*/
  1132.     0,            /*tp_setattr*/
  1133.     (cmpfunc)instancemethod_compare, /*tp_compare*/
  1134.     (reprfunc)instancemethod_repr, /*tp_repr*/
  1135.     0,            /*tp_as_number*/
  1136.     0,            /*tp_as_sequence*/
  1137.     0,            /*tp_as_mapping*/
  1138.     (hashfunc)instancemethod_hash, /*tp_hash*/
  1139. };
  1140.