flight/libraries/PyMite/vm/class.c

   1 /*
   2 # This file is Copyright 2009, 2010 Dean Hall.
   3 #
   4 # This file is part of the PyMite VM.
   5 # The PyMite VM is free software: you can redistribute it and/or modify
   6 # it under the terms of the GNU GENERAL PUBLIC LICENSE Version 2.
   7 #
   8 # The PyMite VM is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11 # A copy of the GNU GENERAL PUBLIC LICENSE Version 2
  12 # is seen in the file COPYING in this directory.
  13 */
  14
  15
  16 #undef __FILE_ID__
  17 #define __FILE_ID__ 0x18
  18
  19
  20 /**
  21  * \file
  22  * \brief Class Object Type
  23  *
  24  * Class object type operations.
  25  */
  26
  27
  28 #include "pm.h"
  29
  30
  31 PmReturn_t
  32 class_new(pPmObj_t pattrs, pPmObj_t pbases, pPmObj_t pname, pPmObj_t *r_pclass)
  33 {
  34     PmReturn_t retval = PM_RET_OK;
  35     uint8_t *pchunk;
  36     pPmObj_t pobj;
  37
  38     /* Ensure types */
  39     if ((OBJ_GET_TYPE(pattrs) != OBJ_TYPE_DIC)
  40         || (OBJ_GET_TYPE(pbases) != OBJ_TYPE_TUP)
  41         || (OBJ_GET_TYPE(pname) != OBJ_TYPE_STR))
  42     {
  43         PM_RAISE(retval, PM_RET_EX_TYPE);
  44         return retval;
  45     }
  46
  47     /* Allocate a class obj */
  48     retval = heap_getChunk(sizeof(PmClass_t), &pchunk);
  49     PM_RETURN_IF_ERROR(retval);
  50     pobj = (pPmObj_t)pchunk;
  51     OBJ_SET_TYPE(pobj, OBJ_TYPE_CLO);
  52
  53     /* Class has no access to its CO */
  54     ((pPmClass_t)pobj)->cl_attrs = (pPmDict_t)pattrs;
  55     ((pPmClass_t)pobj)->cl_bases = (pPmTuple_t)pbases;
  56
  57     *r_pclass = pobj;
  58
  59     return retval;
  60 }
  61
  62
  63 /* Returns an instance of the class by reference */
  64 PmReturn_t
  65 class_instantiate(pPmObj_t pclass, pPmObj_t *r_pobj)
  66 {
  67     PmReturn_t retval = PM_RET_OK;
  68     uint8_t *pchunk;
  69     pPmObj_t pobj;
  70     pPmObj_t pattrs;
  71     uint8_t objid;
  72
  73     /* Allocate a class instance */
  74     retval = heap_getChunk(sizeof(PmInstance_t), &pchunk);
  75     PM_RETURN_IF_ERROR(retval);
  76     pobj = (pPmObj_t)pchunk;
  77     OBJ_SET_TYPE(pobj, OBJ_TYPE_CLI);
  78
  79     /* Set the instance's class */
  80     ((pPmInstance_t)pobj)->cli_class = (pPmClass_t)pclass;
  81
  82     /* Create the attributes dict */
  83     heap_gcPushTempRoot(pobj, &objid);
  84     retval = dict_new(&pattrs);
  85     heap_gcPopTempRoot(objid);
  86     ((pPmInstance_t)pobj)->cli_attrs = (pPmDict_t)pattrs;
  87
  88     /* TODO: Store pclass in __class__ attr */
  89
  90     *r_pobj = pobj;
  91     return retval;
  92 }
  93
  94
  95 PmReturn_t
  96 class_method(pPmObj_t pinstance, pPmObj_t pfunc, pPmObj_t *r_pmeth)
  97 {
  98     PmReturn_t retval = PM_RET_OK;
  99     uint8_t *pchunk;
 100     pPmMethod_t pmeth;
 101     pPmObj_t pattrs;
 102     uint8_t objid;
 103
 104     /* Allocate a method */
 105     retval = heap_getChunk(sizeof(PmMethod_t), &pchunk);
 106     PM_RETURN_IF_ERROR(retval);
 107     OBJ_SET_TYPE(pchunk, OBJ_TYPE_MTH);
 108
 109     /* Set method fields */
 110     pmeth = (pPmMethod_t)pchunk;
 111     pmeth->m_instance = (pPmInstance_t)pinstance;
 112     pmeth->m_func = (pPmFunc_t)pfunc;
 113
 114     /* Create the attributes dict */
 115     heap_gcPushTempRoot((pPmObj_t)pmeth, &objid);
 116     retval = dict_new(&pattrs);
 117     heap_gcPopTempRoot(objid);
 118     pmeth->m_attrs = (pPmDict_t)pattrs;
 119
 120     *r_pmeth = (pPmObj_t)pmeth;
 121     return retval;
 122 }
 123
 124
 125 PmReturn_t
 126 class_getAttr(pPmObj_t pobj, pPmObj_t pname, pPmObj_t *r_pobj)
 127 {
 128     PmReturn_t retval;
 129     uint16_t i;
 130     pPmObj_t pparent;
 131
 132     /* If the given obj is an instance, check its attrs */
 133     if (OBJ_GET_TYPE(pobj) == OBJ_TYPE_CLI)
 134     {
 135         retval = dict_getItem((pPmObj_t)((pPmInstance_t)pobj)->cli_attrs, pname,
 136                               r_pobj);
 137         if (retval == PM_RET_OK)
 138         {
 139             return retval;
 140         }
 141
 142         /* Otherwise, check the instance's class */
 143         pobj = (pPmObj_t)((pPmInstance_t)pobj)->cli_class;
 144     }
 145
 146     C_ASSERT(OBJ_GET_TYPE(pobj) == OBJ_TYPE_CLO);
 147
 148     retval = dict_getItem((pPmObj_t)((pPmClass_t)pobj)->cl_attrs, pname,
 149                           r_pobj);
 150
 151     /* If attr is not found, search parent(s) */
 152     if ((retval == PM_RET_EX_KEY) && (((pPmClass_t)pobj)->cl_bases != C_NULL))
 153     {
 154         for (i = 0; i < ((pPmClass_t)pobj)->cl_bases->length; i++)
 155         {
 156             pparent = ((pPmClass_t)pobj)->cl_bases->val[i];
 157             retval = class_getAttr(pparent, pname, r_pobj);
 158             if (retval == PM_RET_OK)
 159             {
 160                 break;
 161             }
 162         }
 163     }
 164
 165     return retval;
 166 }
 167
 168
 169 uint8_t /* boolean */
 170 class_isSubclass(pPmObj_t ptest_class, pPmObj_t pbase_class)
 171 {
 172     uint8_t i;
 173     uint8_t retval;
 174
 175     retval = C_FALSE;
 176
 177     if (ptest_class == pbase_class)
 178     {
 179         return C_TRUE;
 180     }
 181
 182     /* Recursively check if test class has a matching base class */
 183     if (((pPmClass_t)ptest_class)->cl_bases != C_NULL)
 184     {
 185         for (i = 0; i < ((pPmClass_t)ptest_class)->cl_bases->length; i++)
 186         {
 187             retval = class_isSubclass(((pPmClass_t)ptest_class)->cl_bases->val[i],
 188                                         pbase_class);
 189             if (retval)
 190             {
 191                 break;
 192             }
 193         }
 194     }
 195     return retval;
 196 }