flight/libraries/PyMite/vm/dict.c

   1 /*
   2 # This file is Copyright 2003, 2006, 2007, 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__ 0x02
  18
  19
  20 /**
  21  * \file
  22  * \brief Dict Object Type
  23  *
  24  * Dict object type operations.
  25  */
  26
  27
  28 #include "pm.h"
  29
  30
  31 PmReturn_t
  32 dict_new(pPmObj_t *r_pdict)
  33 {
  34     PmReturn_t retval = PM_RET_OK;
  35     pPmDict_t pdict = C_NULL;
  36     uint8_t *pchunk;
  37
  38     /* Allocate a dict */
  39     retval = heap_getChunk(sizeof(PmDict_t), &pchunk);
  40     PM_RETURN_IF_ERROR(retval);
  41
  42     /* Init dict fields */
  43     pdict = (pPmDict_t)pchunk;
  44     OBJ_SET_TYPE(pdict, OBJ_TYPE_DIC);
  45     pdict->length = 0;
  46     pdict->d_keys = C_NULL;
  47     pdict->d_vals = C_NULL;
  48
  49     *r_pdict = (pPmObj_t)pchunk;
  50     return retval;
  51 }
  52
  53
  54 PmReturn_t
  55 dict_clear(pPmObj_t pdict)
  56 {
  57     PmReturn_t retval = PM_RET_OK;
  58
  59     C_ASSERT(pdict != C_NULL);
  60
  61     /* Raise TypeError if arg is not a dict */
  62     if (OBJ_GET_TYPE(pdict) != OBJ_TYPE_DIC)
  63     {
  64         PM_RAISE(retval, PM_RET_EX_TYPE);
  65         return retval;
  66     }
  67
  68     /* clear length */
  69     ((pPmDict_t)pdict)->length = 0;
  70
  71     /* Free the keys and values seglists if needed */
  72     if (((pPmDict_t)pdict)->d_keys != C_NULL)
  73     {
  74         PM_RETURN_IF_ERROR(seglist_clear(((pPmDict_t)pdict)->d_keys));
  75         PM_RETURN_IF_ERROR(heap_freeChunk((pPmObj_t)
  76                                           ((pPmDict_t)pdict)->d_keys));
  77         ((pPmDict_t)pdict)->d_keys = C_NULL;
  78     }
  79     if (((pPmDict_t)pdict)->d_vals != C_NULL)
  80     {
  81         PM_RETURN_IF_ERROR(seglist_clear(((pPmDict_t)pdict)->d_vals));
  82         retval = heap_freeChunk((pPmObj_t)((pPmDict_t)pdict)->d_vals);
  83         ((pPmDict_t)pdict)->d_vals = C_NULL;
  84     }
  85     return retval;
  86 }
  87
  88
  89 /*
  90  * Sets a value in the dict using the given key.
  91  *
  92  * Scans dict for the key.  If key val found, replace old
  93  * with new val.  If no key found, add key/val pair to dict.
  94  */
  95 PmReturn_t
  96 dict_setItem(pPmObj_t pdict, pPmObj_t pkey, pPmObj_t pval)
  97 {
  98     PmReturn_t retval = PM_RET_OK;
  99     int16_t indx;
 100
 101     C_ASSERT(pdict != C_NULL);
 102     C_ASSERT(pkey != C_NULL);
 103     C_ASSERT(pval != C_NULL);
 104
 105     /* If it's not a dict, raise TypeError */
 106     if (OBJ_GET_TYPE(pdict) != OBJ_TYPE_DIC)
 107     {
 108         PM_RAISE(retval, PM_RET_EX_TYPE);
 109         return retval;
 110     }
 111
 112     /* #112: Force Dict keys to be of hashable type */
 113     /* If key is not hashable, raise TypeError */
 114     if (OBJ_GET_TYPE(pkey) > OBJ_TYPE_HASHABLE_MAX)
 115     {
 116         PM_RAISE(retval, PM_RET_EX_TYPE);
 117         return retval;
 118     }
 119
 120     /* #147: Change boolean keys to integers */
 121     if (pkey == PM_TRUE)
 122     {
 123         pkey = PM_ONE;
 124     }
 125     else if (pkey == PM_FALSE)
 126     {
 127         pkey = PM_ZERO;
 128     }
 129
 130     /*
 131      * #115: If this is the first key/value pair to be added to the Dict,
 132      * allocate the key and value seglists that hold those items
 133      */
 134     if (((pPmDict_t)pdict)->length == 0)
 135     {
 136         retval = seglist_new(&((pPmDict_t)pdict)->d_keys);
 137         PM_RETURN_IF_ERROR(retval);
 138         retval = seglist_new(&((pPmDict_t)pdict)->d_vals);
 139         PM_RETURN_IF_ERROR(retval);
 140     }
 141     else
 142     {
 143         /* Check for matching key */
 144         indx = 0;
 145         retval = seglist_findEqual(((pPmDict_t)pdict)->d_keys, pkey, &indx);
 146
 147         /* If found a matching key, replace val obj */
 148         if (retval == PM_RET_OK)
 149         {
 150             retval = seglist_setItem(((pPmDict_t)pdict)->d_vals, pval, indx);
 151             return retval;
 152         }
 153     }
 154
 155     /* Otherwise, insert the key,val pair */
 156     retval = seglist_insertItem(((pPmDict_t)pdict)->d_keys, pkey, 0);
 157     PM_RETURN_IF_ERROR(retval);
 158     retval = seglist_insertItem(((pPmDict_t)pdict)->d_vals, pval, 0);
 159     ((pPmDict_t)pdict)->length++;
 160
 161     return retval;
 162 }
 163
 164
 165 PmReturn_t
 166 dict_getItem(pPmObj_t pdict, pPmObj_t pkey, pPmObj_t *r_pobj)
 167 {
 168     PmReturn_t retval = PM_RET_OK;
 169     int16_t indx = 0;
 170
 171 /*    C_ASSERT(pdict != C_NULL);*/
 172
 173     /* if it's not a dict, raise TypeError */
 174     if (OBJ_GET_TYPE(pdict) != OBJ_TYPE_DIC)
 175     {
 176         PM_RAISE(retval, PM_RET_EX_TYPE);
 177         return retval;
 178     }
 179
 180     /* if dict is empty, raise KeyError */
 181     if (((pPmDict_t)pdict)->length <= 0)
 182     {
 183         PM_RAISE(retval, PM_RET_EX_KEY);
 184         return retval;
 185     }
 186
 187     /* #147: Change boolean keys to integers */
 188     if (pkey == PM_TRUE)
 189     {
 190         pkey = PM_ONE;
 191     }
 192     else if (pkey == PM_FALSE)
 193     {
 194         pkey = PM_ZERO;
 195     }
 196
 197     /* check for matching key */
 198     retval = seglist_findEqual(((pPmDict_t)pdict)->d_keys, pkey, &indx);
 199     /* if key not found, raise KeyError */
 200     if (retval == PM_RET_NO)
 201     {
 202         PM_RAISE(retval, PM_RET_EX_KEY);
 203     }
 204     /* return any other error */
 205     PM_RETURN_IF_ERROR(retval);
 206
 207     /* key was found, get obj from vals */
 208     retval = seglist_getItem(((pPmDict_t)pdict)->d_vals, indx, r_pobj);
 209     return retval;
 210 }
 211
 212
 213 #ifdef HAVE_DEL
 214 PmReturn_t
 215 dict_delItem(pPmObj_t pdict, pPmObj_t pkey)
 216 {
 217     PmReturn_t retval = PM_RET_OK;
 218     int16_t indx = 0;
 219
 220     C_ASSERT(pdict != C_NULL);
 221
 222     /* Check for matching key */
 223     retval = seglist_findEqual(((pPmDict_t)pdict)->d_keys, pkey, &indx);
 224
 225     /* Raise KeyError if key is not found */
 226     if (retval == PM_RET_NO)
 227     {
 228         PM_RAISE(retval, PM_RET_EX_KEY);
 229     }
 230
 231     /* Return any other error */
 232     PM_RETURN_IF_ERROR(retval);
 233
 234     /* Remove the key and value */
 235     retval = seglist_removeItem(((pPmDict_t)pdict)->d_keys, indx);
 236     PM_RETURN_IF_ERROR(retval);
 237     retval = seglist_removeItem(((pPmDict_t)pdict)->d_vals, indx);
 238
 239     /* Reduce the item count */
 240     ((pPmDict_t)pdict)->length--;
 241
 242     return retval;
 243 }
 244 #endif /* HAVE_DEL */
 245
 246
 247 #ifdef HAVE_PRINT
 248 PmReturn_t
 249 dict_print(pPmObj_t pdict)
 250 {
 251     PmReturn_t retval = PM_RET_OK;
 252     int16_t index;
 253     pSeglist_t keys,
 254       vals;
 255     pPmObj_t pobj1;
 256
 257     C_ASSERT(pdict != C_NULL);
 258
 259     /* if it's not a dict, raise TypeError */
 260     if (OBJ_GET_TYPE(pdict) != OBJ_TYPE_DIC)
 261     {
 262         PM_RAISE(retval, PM_RET_EX_TYPE);
 263         return retval;
 264     }
 265
 266     plat_putByte('{');
 267
 268     keys = ((pPmDict_t)pdict)->d_keys;
 269     vals = ((pPmDict_t)pdict)->d_vals;
 270
 271     /* if dict is empty, raise KeyError */
 272     for (index = 0; index < ((pPmDict_t)pdict)->length; index++)
 273     {
 274         if (index != 0)
 275         {
 276             plat_putByte(',');
 277             plat_putByte(' ');
 278         }
 279         retval = seglist_getItem(keys, index, &pobj1);
 280         PM_RETURN_IF_ERROR(retval);
 281         retval = obj_print(pobj1, C_FALSE, C_TRUE);
 282         PM_RETURN_IF_ERROR(retval);
 283
 284         plat_putByte(':');
 285         retval = seglist_getItem(vals, index, &pobj1);
 286         PM_RETURN_IF_ERROR(retval);
 287         retval = obj_print(pobj1, C_FALSE, C_TRUE);
 288         PM_RETURN_IF_ERROR(retval);
 289     }
 290
 291     return plat_putByte('}');
 292 }
 293 #endif /* HAVE_PRINT */
 294
 295 PmReturn_t
 296 dict_update(pPmObj_t pdestdict, pPmObj_t psourcedict)
 297 {
 298     PmReturn_t retval = PM_RET_OK;
 299     int16_t i;
 300     pPmObj_t pkey;
 301     pPmObj_t pval;
 302
 303     C_ASSERT(pdestdict != C_NULL);
 304     C_ASSERT(psourcedict != C_NULL);
 305
 306     /* If it's not a dict, raise TypeError */
 307     if (OBJ_GET_TYPE(pdestdict) != OBJ_TYPE_DIC)
 308     {
 309         PM_RAISE(retval, PM_RET_EX_TYPE);
 310         return retval;
 311     }
 312
 313     /* If it's not a dict, raise TypeError */
 314     if (OBJ_GET_TYPE(psourcedict) != OBJ_TYPE_DIC)
 315     {
 316         PM_RAISE(retval, PM_RET_EX_TYPE);
 317         return retval;
 318     }
 319
 320     /* Iterate over the add-on dict */
 321     for (i = 0; i < ((pPmDict_t)psourcedict)->length; i++)
 322     {
 323         /* Get the key,val from the add-on dict */
 324         retval = seglist_getItem(((pPmDict_t)psourcedict)->d_keys, i, &pkey);
 325         PM_RETURN_IF_ERROR(retval);
 326         retval = seglist_getItem(((pPmDict_t)psourcedict)->d_vals, i, &pval);
 327         PM_RETURN_IF_ERROR(retval);
 328
 329         /* Set the key,val to the destination dict */
 330         retval = dict_setItem(pdestdict, pkey, pval);
 331         PM_RETURN_IF_ERROR(retval);
 332     }
 333
 334     return retval;
 335 }