flight/libraries/PyMite/vm/obj.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__ 0x0F
  18
  19
  20 /**
  21  * \file
  22  * \brief Object Type
  23  *
  24  * Object type operations.
  25  */
  26
  27
  28 #include "pm.h"
  29
  30
  31 PmReturn_t
  32 obj_loadFromImg(PmMemSpace_t memspace,
  33                 uint8_t const **paddr, pPmObj_t *r_pobj)
  34 {
  35     PmReturn_t retval = PM_RET_OK;
  36     PmObj_t obj;
  37
  38
  39     /* Get the object descriptor */
  40     obj.od = (PmObjDesc_t)0x0000;
  41     OBJ_SET_TYPE(&obj, mem_getByte(memspace, paddr));
  42
  43     switch (OBJ_GET_TYPE(&obj))
  44     {
  45         case OBJ_TYPE_NON:
  46             /* If it's the None object, return global None */
  47             *r_pobj = PM_NONE;
  48             break;
  49
  50         case OBJ_TYPE_INT:
  51             /* Read an integer and create an integer object with the value */
  52             retval = int_new(mem_getInt(memspace, paddr), r_pobj);
  53             break;
  54
  55 #ifdef HAVE_FLOAT
  56         case OBJ_TYPE_FLT:
  57             /* Read a float and create an float object with the value */
  58             retval = float_new(mem_getFloat(memspace, paddr), r_pobj);
  59             break;
  60 #endif /* HAVE_FLOAT */
  61
  62         case OBJ_TYPE_STR:
  63             retval = string_loadFromImg(memspace, paddr, r_pobj);
  64             break;
  65
  66         case OBJ_TYPE_TUP:
  67             retval = tuple_loadFromImg(memspace, paddr, r_pobj);
  68             break;
  69
  70         case OBJ_TYPE_NIM:
  71             /* If it's a native code img, load into a code obj */
  72             retval = no_loadFromImg(memspace, paddr, r_pobj);
  73             break;
  74
  75         case OBJ_TYPE_CIM:
  76             /* If it's a code img, load into a code obj */
  77             retval = co_loadFromImg(memspace, paddr, r_pobj);
  78             break;
  79
  80         default:
  81             /* All other types should not be in an img obj */
  82             PM_RAISE(retval, PM_RET_EX_SYS);
  83             break;
  84     }
  85     return retval;
  86 }
  87
  88
  89 PmReturn_t
  90 obj_loadFromImgObj(pPmObj_t pimg, pPmObj_t *r_pobj)
  91 {
  92     uint8_t const *imgaddr;
  93     PmReturn_t retval;
  94
  95     C_ASSERT(OBJ_GET_TYPE(pimg) == OBJ_TYPE_CIO);
  96     imgaddr = (uint8_t const *)&(((pPmCodeImgObj_t)pimg)->val);
  97
  98     retval = obj_loadFromImg(MEMSPACE_RAM, &imgaddr, r_pobj);
  99     C_ASSERT(OBJ_GET_TYPE(*r_pobj) == OBJ_TYPE_COB);
 100
 101     /* All COs must reference the top of the code img obj
 102      * so the image is marked and prevented from being reclaimed */
 103     co_rSetCodeImgAddr((pPmCo_t)*r_pobj, (uint8_t const *)pimg);
 104
 105     return retval;
 106 }
 107
 108
 109 /* Returns true if the obj is false */
 110 int8_t
 111 obj_isFalse(pPmObj_t pobj)
 112 {
 113     C_ASSERT(pobj != C_NULL);
 114
 115     switch (OBJ_GET_TYPE(pobj))
 116     {
 117         case OBJ_TYPE_NON:
 118             /* None evaluates to false, so return true */
 119             return C_TRUE;
 120
 121         case OBJ_TYPE_INT:
 122             /* Only the integer zero is false */
 123             return ((pPmInt_t)pobj)->val == 0;
 124
 125 #ifdef HAVE_FLOAT
 126         case OBJ_TYPE_FLT:
 127             /* The floats 0.0 and -0.0 are false */
 128             return (((pPmFloat_t) pobj)->val == 0.0)
 129                 || (((pPmFloat_t) pobj)->val == -0.0);
 130 #endif /* HAVE_FLOAT */
 131
 132         case OBJ_TYPE_STR:
 133             /* An empty string is false */
 134             return ((pPmString_t)pobj)->length == 0;
 135
 136         case OBJ_TYPE_TUP:
 137             /* An empty tuple is false */
 138             return ((pPmTuple_t)pobj)->length == 0;
 139
 140         case OBJ_TYPE_LST:
 141             /* An empty list is false */
 142             return ((pPmList_t)pobj)->length == 0;
 143
 144         case OBJ_TYPE_DIC:
 145             /* An empty dict is false */
 146             return ((pPmDict_t)pobj)->length == 0;
 147
 148         case OBJ_TYPE_BOOL:
 149             /* C int zero means false */
 150             return ((pPmBoolean_t) pobj)->val == 0;
 151
 152         default:
 153             /*
 154              * The following types are always not false:
 155              * CodeObj, Function, Module, Class, ClassInstance.
 156              */
 157             return C_FALSE;
 158     }
 159 }
 160
 161
 162 /* Returns true if the item is in the container object */
 163 PmReturn_t
 164 obj_isIn(pPmObj_t pobj, pPmObj_t pitem)
 165 {
 166     PmReturn_t retval = PM_RET_NO;
 167     pPmObj_t ptestItem;
 168     int16_t i;
 169     uint8_t c;
 170
 171     switch (OBJ_GET_TYPE(pobj))
 172     {
 173         case OBJ_TYPE_TUP:
 174             /* Iterate over tuple to find item */
 175             for (i = 0; i < ((pPmTuple_t)pobj)->length; i++)
 176             {
 177                 PM_RETURN_IF_ERROR(tuple_getItem(pobj, i, &ptestItem));
 178
 179                 if (obj_compare(pitem, ptestItem) == C_SAME)
 180                 {
 181                     retval = PM_RET_OK;
 182                     break;
 183                 }
 184             }
 185             break;
 186
 187         case OBJ_TYPE_STR:
 188             /* Raise a TypeError if item is not a string */
 189             if ((OBJ_GET_TYPE(pitem) != OBJ_TYPE_STR))
 190             {
 191                 retval = PM_RET_EX_TYPE;
 192                 break;
 193             }
 194
 195             /* Empty string is alway present */
 196             if (((pPmString_t)pitem)->length == 0)
 197             {
 198                 retval = PM_RET_OK;
 199                 break;
 200             }
 201
 202             /* Raise a ValueError if the string is more than 1 char */
 203             else if (((pPmString_t)pitem)->length != 1)
 204             {
 205                 retval = PM_RET_EX_VAL;
 206                 break;
 207             }
 208
 209             /* Iterate over string to find char */
 210             c = ((pPmString_t)pitem)->val[0];
 211             for (i = 0; i < ((pPmString_t)pobj)->length; i++)
 212             {
 213                 if (c == ((pPmString_t)pobj)->val[i])
 214                 {
 215                     retval = PM_RET_OK;
 216                     break;
 217                 }
 218             }
 219             break;
 220
 221         case OBJ_TYPE_LST:
 222             /* Iterate over list to find item */
 223             for (i = 0; i < ((pPmList_t)pobj)->length; i++)
 224             {
 225                 PM_RETURN_IF_ERROR(list_getItem(pobj, i, &ptestItem));
 226
 227                 if (obj_compare(pitem, ptestItem) == C_SAME)
 228                 {
 229                     retval = PM_RET_OK;
 230                     break;
 231                 }
 232             }
 233             break;
 234
 235         case OBJ_TYPE_DIC:
 236             /* Check if the item is one of the keys of the dict */
 237             retval = dict_getItem(pobj, pitem, &ptestItem);
 238             if (retval == PM_RET_EX_KEY)
 239             {
 240                 retval = PM_RET_NO;
 241             }
 242             break;
 243
 244         default:
 245             retval = PM_RET_EX_TYPE;
 246             break;
 247     }
 248
 249     return retval;
 250 }
 251
 252
 253 int8_t
 254 obj_compare(pPmObj_t pobj1, pPmObj_t pobj2)
 255 {
 256 #ifdef HAVE_BYTEARRAY
 257     PmReturn_t retval;
 258     pPmObj_t pobj;
 259 #endif /* HAVE_BYTEARRAY */
 260
 261     C_ASSERT(pobj1 != C_NULL);
 262     C_ASSERT(pobj2 != C_NULL);
 263
 264     /* Check if pointers are same */
 265     if (pobj1 == pobj2)
 266     {
 267         return C_SAME;
 268     }
 269
 270     /* If types are different, objs must differ */
 271     if (OBJ_GET_TYPE(pobj1) != OBJ_GET_TYPE(pobj2))
 272     {
 273         return C_DIFFER;
 274     }
 275
 276 #ifdef HAVE_BYTEARRAY
 277     /* If object is an instance, get the thing it contains */
 278     if (OBJ_GET_TYPE(pobj1) == OBJ_TYPE_CLI)
 279     {
 280         retval = dict_getItem((pPmObj_t)((pPmInstance_t)pobj1)->cli_attrs,
 281                               PM_NONE,
 282                               &pobj);
 283         PM_RETURN_IF_ERROR(retval);
 284         pobj1 = pobj;
 285     }
 286     if (OBJ_GET_TYPE(pobj2) == OBJ_TYPE_CLI)
 287     {
 288         retval = dict_getItem((pPmObj_t)((pPmInstance_t)pobj2)->cli_attrs,
 289                               PM_NONE,
 290                               &pobj);
 291         PM_RETURN_IF_ERROR(retval);
 292         pobj2 = pobj;
 293     }
 294
 295     /* If types are different, objs must differ */
 296     if (OBJ_GET_TYPE(pobj1) != OBJ_GET_TYPE(pobj2))
 297     {
 298         return C_DIFFER;
 299     }
 300 #endif /* HAVE_BYTEARRAY */
 301
 302     /* Otherwise handle types individually */
 303     switch (OBJ_GET_TYPE(pobj1))
 304     {
 305         case OBJ_TYPE_NON:
 306             return C_SAME;
 307
 308         case OBJ_TYPE_INT:
 309             return ((pPmInt_t)pobj1)->val ==
 310                 ((pPmInt_t)pobj2)->val ? C_SAME : C_DIFFER;
 311
 312 #ifdef HAVE_FLOAT
 313         case OBJ_TYPE_FLT:
 314         {
 315             pPmObj_t r_pobj;
 316
 317             float_compare(pobj1, pobj2, &r_pobj, COMP_EQ);
 318             return (r_pobj == PM_TRUE) ? C_SAME : C_DIFFER;
 319         }
 320 #endif /* HAVE_FLOAT */
 321
 322         case OBJ_TYPE_STR:
 323             return string_compare((pPmString_t)pobj1, (pPmString_t)pobj2);
 324
 325         case OBJ_TYPE_TUP:
 326         case OBJ_TYPE_LST:
 327 #ifdef HAVE_BYTEARRAY
 328         case OBJ_TYPE_BYA:
 329 #endif /* HAVE_BYTEARRAY */
 330             return seq_compare(pobj1, pobj2);
 331
 332         case OBJ_TYPE_DIC:
 333             /* #17: PyMite does not support Dict comparisons (yet) */
 334         default:
 335             break;
 336     }
 337
 338     /* All other types would need same pointer to be true */
 339     return C_DIFFER;
 340 }
 341
 342
 343 #ifdef HAVE_PRINT
 344 PmReturn_t
 345 obj_print(pPmObj_t pobj, uint8_t is_expr_repr, uint8_t is_nested)
 346 {
 347     PmReturn_t retval = PM_RET_OK;
 348
 349     C_ASSERT(pobj != C_NULL);
 350
 351     /* Something gets printed unless it's None in an unnested expression */
 352     if (!((OBJ_GET_TYPE(pobj) == OBJ_TYPE_NON) && is_expr_repr && !is_nested))
 353     {
 354         gVmGlobal.somethingPrinted = C_TRUE;
 355     }
 356
 357     switch (OBJ_GET_TYPE(pobj))
 358     {
 359         case OBJ_TYPE_NON:
 360             if (!is_expr_repr || is_nested)
 361             {
 362                 plat_putByte('N');
 363                 plat_putByte('o');
 364                 plat_putByte('n');
 365                 retval = plat_putByte('e');
 366             }
 367             break;
 368         case OBJ_TYPE_INT:
 369             retval = int_print(pobj);
 370             break;
 371 #ifdef HAVE_FLOAT
 372         case OBJ_TYPE_FLT:
 373             retval = float_print(pobj);
 374             break;
 375 #endif /* HAVE_FLOAT */
 376         case OBJ_TYPE_STR:
 377             retval = string_print(pobj, (is_expr_repr || is_nested));
 378             break;
 379         case OBJ_TYPE_TUP:
 380             retval = tuple_print(pobj);
 381             break;
 382         case OBJ_TYPE_LST:
 383             retval = list_print(pobj);
 384             break;
 385         case OBJ_TYPE_DIC:
 386             retval = dict_print(pobj);
 387             break;
 388         case OBJ_TYPE_BOOL:
 389             if (((pPmBoolean_t) pobj)->val == C_TRUE)
 390             {
 391                 plat_putByte('T');
 392                 plat_putByte('r');
 393                 plat_putByte('u');
 394             }
 395             else
 396             {
 397                 plat_putByte('F');
 398                 plat_putByte('a');
 399                 plat_putByte('l');
 400                 plat_putByte('s');
 401             }
 402             retval = plat_putByte('e');
 403             break;
 404
 405         case OBJ_TYPE_CLI:
 406 #ifdef HAVE_BYTEARRAY
 407             {
 408                 pPmObj_t pobj2;
 409
 410                 retval = dict_getItem((pPmObj_t)((pPmInstance_t)pobj)->cli_attrs,
 411                                       PM_NONE,
 412                                       (pPmObj_t *)&pobj2);
 413                 if ((retval == PM_RET_OK)
 414                     && (OBJ_GET_TYPE(pobj2) == OBJ_TYPE_BYA))
 415                 {
 416                     retval = bytearray_print(pobj2);
 417                     break;
 418                 }
 419             }
 420 #endif /* HAVE_BYTEARRAY */
 421
 422         case OBJ_TYPE_COB:
 423         case OBJ_TYPE_MOD:
 424         case OBJ_TYPE_CLO:
 425         case OBJ_TYPE_FXN:
 426         case OBJ_TYPE_CIM:
 427         case OBJ_TYPE_NIM:
 428         case OBJ_TYPE_NOB:
 429         case OBJ_TYPE_THR:
 430         case OBJ_TYPE_CIO:
 431         case OBJ_TYPE_MTH:
 432         case OBJ_TYPE_SQI:
 433             plat_putByte('<');
 434             plat_putByte('o');
 435             plat_putByte('b');
 436             plat_putByte('j');
 437             plat_putByte(' ');
 438             plat_putByte('t');
 439             plat_putByte('y');
 440             plat_putByte('p');
 441             plat_putByte('e');
 442             plat_putByte(' ');
 443             plat_putByte('0');
 444             plat_putByte('x');
 445             int_printHexByte(OBJ_GET_TYPE(pobj));
 446             plat_putByte(' ');
 447             plat_putByte('@');
 448             plat_putByte(' ');
 449             plat_putByte('0');
 450             plat_putByte('x');
 451             _int_printHex((intptr_t)pobj);
 452             retval = plat_putByte('>');
 453             break;
 454
 455         default:
 456             /* Otherwise raise a TypeError */
 457             PM_RAISE(retval, PM_RET_EX_TYPE);
 458             break;
 459     }
 460     return retval;
 461 }
 462 #endif /* HAVE_PRINT */
 463
 464
 465 #ifdef HAVE_BACKTICK
 466 PmReturn_t
 467 obj_repr(pPmObj_t pobj, pPmObj_t *r_pstr)
 468 {
 469     uint8_t tBuffer[32];
 470     uint8_t bytesWritten = 0;
 471     PmReturn_t retval = PM_RET_OK;
 472     uint8_t const *pcstr = (uint8_t *)tBuffer;;
 473
 474     C_ASSERT(pobj != C_NULL);
 475
 476     switch (OBJ_GET_TYPE(pobj))
 477     {
 478         case OBJ_TYPE_INT:
 479             bytesWritten = snprintf((char *)&tBuffer, sizeof(tBuffer), "%li",
 480                                     (long)((pPmInt_t)pobj)->val);
 481             retval = string_new(&pcstr, r_pstr);
 482             break;
 483
 484 #ifdef HAVE_FLOAT
 485         case OBJ_TYPE_FLT:
 486             bytesWritten = snprintf((char *)&tBuffer, sizeof(tBuffer), "%f",
 487                                     ((pPmFloat_t)pobj)->val);
 488             retval = string_new(&pcstr, r_pstr);
 489             break;
 490 #endif /* HAVE_FLOAT */
 491
 492         default:
 493             /* Otherwise raise a TypeError */
 494             PM_RAISE(retval, PM_RET_EX_TYPE);
 495             break;
 496     }
 497
 498     /* Sanity check */
 499     C_ASSERT(bytesWritten < sizeof(tBuffer));
 500
 501     return retval;
 502 }
 503 #endif /* HAVE_BACKTICK */