flight/libraries/PyMite/lib/__bi.py

   1 # This file is Copyright 2003, 2006, 2007, 2009, 2010 Dean Hall.
   2 #
   3 # This file is part of the Python-on-a-Chip program.
   4 # Python-on-a-Chip is free software: you can redistribute it and/or modify
   5 # it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE Version 2.1.
   6 #
   7 # Python-on-a-Chip is distributed in the hope that it will be useful,
   8 # but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  10 # A copy of the GNU LESSER GENERAL PUBLIC LICENSE Version 2.1
  11 # is seen in the file COPYING in this directory.
  12
  13 ## @file
  14 #  @copybrief __bi
  15
  16 ## @package __bi
  17 #  @brief Provides PyMite's builtins module, __bi.
  18 #
  19 #  <b>USAGE</b>
  20 #
  21 #  The builtins are loaded by the interpreter.
  22 #  The user SHOULD NOT import this module directly.
  23
  24
  25 def abs(n):
  26 #    return n > 0 and n or -n
  27     return (n, -n)[n < 0]
  28
  29
  30 def chr(n):
  31     """__NATIVE__
  32     pPmObj_t ps;
  33     pPmObj_t pn;
  34     int32_t n;
  35     PmReturn_t retval;
  36
  37     /* If wrong number of args, raise TypeError */
  38     if (NATIVE_GET_NUM_ARGS() != 1)
  39     {
  40         PM_RAISE(retval, PM_RET_EX_TYPE);
  41         return retval;
  42     }
  43
  44     /* Raise TypeError if arg is not an int */
  45     pn = NATIVE_GET_LOCAL(0);
  46     if (OBJ_GET_TYPE(pn) != OBJ_TYPE_INT)
  47     {
  48         PM_RAISE(retval, PM_RET_EX_TYPE);
  49         return retval;
  50     }
  51
  52     /* Raise ValueError if arg is not int within range(256) */
  53     n = ((pPmInt_t)pn)->val;
  54     if ((n < 0) || (n > 255))
  55     {
  56         PM_RAISE(retval, PM_RET_EX_VAL);
  57         return retval;
  58     }
  59
  60     /* Create char string from  integer value */
  61     retval = string_newFromChar((uint8_t)n, &ps);
  62     NATIVE_SET_TOS(ps);
  63     return retval;
  64     """
  65     pass
  66
  67
  68 def dir(o):
  69     """__NATIVE__
  70     PmReturn_t retval = PM_RET_OK;
  71     pPmObj_t po;
  72     pPmObj_t pk;
  73     pPmObj_t pl;
  74     pSeglist_t psl;
  75     int16_t i;
  76     uint8_t objid;
  77
  78     /* Use globals if no arg given */
  79     if (NATIVE_GET_NUM_ARGS() == 0)
  80     {
  81         /* Get the globals dict */
  82         po = (pPmObj_t)NATIVE_GET_PFRAME()->fo_globals;
  83     }
  84
  85     /* Otherwise use the given arg */
  86     else if (NATIVE_GET_NUM_ARGS() == 1)
  87     {
  88         po = NATIVE_GET_LOCAL(0);
  89
  90         /* If object is a function or module, use its attrs dict */
  91         if ((OBJ_GET_TYPE(po) == OBJ_TYPE_FXN)
  92             || (OBJ_GET_TYPE(po) == OBJ_TYPE_MOD))
  93         {
  94             po = (pPmObj_t)((pPmFunc_t)po)->f_attrs;
  95         }
  96
  97 #ifdef HAVE_CLASSES
  98         else if (OBJ_GET_TYPE(po) == OBJ_TYPE_CLO)
  99         {
 100             po = (pPmObj_t)((pPmClass_t)po)->cl_attrs;
 101         }
 102         else if (OBJ_GET_TYPE(po) == OBJ_TYPE_CLI)
 103         {
 104             po = (pPmObj_t)((pPmInstance_t)po)->cli_attrs;
 105         }
 106         else if (OBJ_GET_TYPE(po) == OBJ_TYPE_MTH)
 107         {
 108             po = (pPmObj_t)((pPmMethod_t)po)->m_attrs;
 109         }
 110 #endif /* HAVE_CLASSES */
 111
 112         else
 113         {
 114             po = C_NULL;
 115         }
 116     }
 117
 118     /* Raise TypeError if wrong number of args */
 119     else
 120     {
 121         PM_RAISE(retval, PM_RET_EX_TYPE);
 122         return retval;
 123     }
 124
 125     if (po == C_NULL)
 126     {
 127         pl = PM_NONE;
 128     }
 129     else
 130     {
 131         /* Create new list */
 132         retval = list_new(&pl);
 133         PM_RETURN_IF_ERROR(retval);
 134
 135         /* Copy dict's keys to the list */
 136         psl = ((pPmDict_t)po)->d_keys;
 137         for (i = 0; i < ((pPmDict_t)po)->length; i++)
 138         {
 139             retval = seglist_getItem(psl, i, &pk);
 140             PM_RETURN_IF_ERROR(retval);
 141             heap_gcPushTempRoot(pl, &objid);
 142             retval = list_append(pl, pk);
 143             heap_gcPopTempRoot(objid);
 144             PM_RETURN_IF_ERROR(retval);
 145         }
 146     }
 147
 148     NATIVE_SET_TOS(pl);
 149     return retval;
 150     """
 151     pass
 152
 153
 154 #
 155 # Evaluates a given code object (created by Co()).
 156 # Optionally accepts a globals dict as the second parameter
 157 # Optionally accepts a locals dict as the third parameter
 158 #
 159 def eval(co, g, l):
 160     """__NATIVE__
 161     PmReturn_t retval;
 162     pPmObj_t pco;
 163     pPmObj_t pfunc;
 164     pPmObj_t pnewframe;
 165     pPmObj_t pg = C_NULL;
 166     pPmObj_t pl = C_NULL;
 167     uint8_t objid;
 168
 169     /* If wrong number of args, raise TypeError */
 170     if ((NATIVE_GET_NUM_ARGS() == 0) || (NATIVE_GET_NUM_ARGS() > 3))
 171     {
 172         PM_RAISE(retval, PM_RET_EX_TYPE);
 173         return retval;
 174     }
 175
 176     /* Raise ValueError if first arg is not a Code Object */
 177     pco = NATIVE_GET_LOCAL(0);
 178     if (OBJ_GET_TYPE(pco) != OBJ_TYPE_COB)
 179     {
 180         PM_RAISE(retval, PM_RET_EX_VAL);
 181         return retval;
 182     }
 183
 184     /* If 2nd arg exists, raise ValueError if it is not a Dict */
 185     if (NATIVE_GET_NUM_ARGS() >= 2)
 186     {
 187         pg = NATIVE_GET_LOCAL(1);
 188         if (OBJ_GET_TYPE(pg) != OBJ_TYPE_DIC)
 189         {
 190             PM_RAISE(retval, PM_RET_EX_VAL);
 191             return retval;
 192         }
 193     }
 194
 195     /* If no args are given, use the caller's globals for the function's */
 196     else
 197     {
 198         pg = (pPmObj_t)NATIVE_GET_PFRAME()->fo_globals;
 199     }
 200
 201     /* If 3rd arg exists, raise ValueError if it is not a Dict */
 202     if (NATIVE_GET_NUM_ARGS() >= 3)
 203     {
 204         pl = NATIVE_GET_LOCAL(2);
 205         if (OBJ_GET_TYPE(pl) != OBJ_TYPE_DIC)
 206         {
 207             PM_RAISE(retval, PM_RET_EX_VAL);
 208             return retval;
 209         }
 210     }
 211
 212     /* Create func from code object */
 213     retval = func_new(pco, pg, &pfunc);
 214     PM_RETURN_IF_ERROR(retval);
 215
 216     /* Create frame from module object; globals is set to null */
 217     heap_gcPushTempRoot(pfunc, &objid);
 218     retval = frame_new(pfunc, &pnewframe);
 219     heap_gcPopTempRoot(objid);
 220     PM_RETURN_IF_ERROR(retval);
 221
 222     /* TODO: Reclaim pnewframe's attrs dict created in frame_new */
 223     /*
 224      * By default use calling frame's attrs as local namespace.
 225      * This works for ipm because the interactive mode
 226      * needs a locals namespace that persists across calls to eval()
 227      */
 228     ((pPmFrame_t)pnewframe)->fo_attrs = NATIVE_GET_PFRAME()->fo_attrs;
 229
 230     /* If 2nd arg exists, use it as the global namespace for the new func */
 231     if (NATIVE_GET_NUM_ARGS() >= 2)
 232     {
 233         ((pPmFrame_t)pnewframe)->fo_globals = (pPmDict_t)pg;
 234
 235         /* If only globals is given, locals defaults to it */
 236         ((pPmFrame_t)pnewframe)->fo_attrs = (pPmDict_t)pg;
 237     }
 238
 239     /* If 3rd arg exists, use it as the local namespace for the new func */
 240     if (NATIVE_GET_NUM_ARGS() >= 3)
 241     {
 242         ((pPmFrame_t)pnewframe)->fo_attrs = (pPmDict_t)pl;
 243     }
 244
 245     /*
 246      * Set the fo_back frame so flow returns to eval()'s caller when completed.
 247      * Set the frame pointer so the new frame is interpreted immediately
 248      * after this function returns.
 249      */
 250     ((pPmFrame_t)pnewframe)->fo_back = NATIVE_GET_PFRAME();
 251     NATIVE_GET_PFRAME() = (pPmFrame_t)pnewframe;
 252     retval = PM_RET_FRAME_SWITCH;
 253
 254     return retval;
 255     """
 256     pass
 257
 258
 259 def filter(f, s):
 260     return [x for x in s if f(x)]
 261
 262
 263 def globals():
 264     """__NATIVE__
 265     pPmObj_t pr = C_NULL;
 266     PmReturn_t retval;
 267
 268     /* If wrong number of args, raise TypeError */
 269     if (NATIVE_GET_NUM_ARGS() != 0)
 270     {
 271         PM_RAISE(retval, PM_RET_EX_TYPE);
 272         return retval;
 273     }
 274
 275     /* Return calling frame's globals dict  on stack*/
 276     pr = (pPmObj_t)NATIVE_GET_PFRAME()->fo_globals;
 277     NATIVE_SET_TOS(pr);
 278
 279     return PM_RET_OK;
 280     """
 281     pass
 282
 283
 284 def id(o):
 285     """__NATIVE__
 286     PmReturn_t retval;
 287     pPmObj_t pr = C_NULL;
 288
 289     /* If wrong number of args, raise TypeError */
 290     if (NATIVE_GET_NUM_ARGS() != 1)
 291     {
 292         PM_RAISE(retval, PM_RET_EX_TYPE);
 293         return retval;
 294     }
 295
 296     /* Return object's address as an int on the stack */
 297     retval = int_new((intptr_t)NATIVE_GET_LOCAL(0), &pr);
 298     NATIVE_SET_TOS(pr);
 299
 300     return retval;
 301     """
 302     pass
 303
 304
 305 # Yields every (i)tem in the (s)equence; requires HAVE_GENERATORS
 306 #def iter(s):
 307 #    for i in s:
 308 #        yield i
 309
 310
 311 def len(s):
 312     """__NATIVE__
 313     PmReturn_t retval;
 314     pPmObj_t ps = C_NULL;
 315     pPmObj_t pr = C_NULL;
 316
 317     /* If wrong number of args, raise TypeError */
 318     if (NATIVE_GET_NUM_ARGS() != 1)
 319     {
 320         PM_RAISE(retval, PM_RET_EX_TYPE);
 321         return retval;
 322     }
 323
 324     /* Get first arg */
 325     ps = NATIVE_GET_LOCAL(0);
 326
 327 #ifdef HAVE_BYTEARRAY
 328     /* If object is an instance, get the thing it contains */
 329     if (OBJ_GET_TYPE(ps) == OBJ_TYPE_CLI)
 330     {
 331         retval = dict_getItem((pPmObj_t)((pPmInstance_t)ps)->cli_attrs,
 332                               PM_NONE,
 333                               &pr);
 334
 335         /* If None wasn't in attributes, obj is wrong type for len() */
 336         if (retval == PM_RET_EX_KEY) retval = PM_RET_EX_TYPE;
 337         PM_RETURN_IF_ERROR(retval);
 338         ps = pr;
 339     }
 340 #endif /* HAVE_BYTEARRAY */
 341
 342     /* Get the length of the arg based on its type */
 343     switch (OBJ_GET_TYPE(ps))
 344     {
 345         case OBJ_TYPE_STR:
 346             retval = int_new(((pPmString_t)ps)->length, &pr);
 347             break;
 348
 349         case OBJ_TYPE_TUP:
 350             retval = int_new(((pPmTuple_t)ps)->length, &pr);
 351             break;
 352
 353         case OBJ_TYPE_LST:
 354             retval = int_new(((pPmList_t)ps)->length, &pr);
 355             break;
 356
 357         case OBJ_TYPE_DIC:
 358             retval = int_new(((pPmDict_t)ps)->length, &pr);
 359             break;
 360
 361 #ifdef HAVE_BYTEARRAY
 362         case OBJ_TYPE_BYA:
 363             retval = int_new(((pPmBytearray_t)ps)->length, &pr);
 364             break;
 365 #endif /* HAVE_BYTEARRAY */
 366
 367         default:
 368             /* If not a string or sequence type, raise TypeError */
 369             PM_RAISE(retval, PM_RET_EX_TYPE);
 370     }
 371
 372     NATIVE_SET_TOS(pr);
 373     return retval;
 374     """
 375     pass
 376
 377
 378 def locals():
 379     """__NATIVE__
 380     pPmObj_t pr = C_NULL;
 381     PmReturn_t retval;
 382
 383     /* If wrong number of args, raise TypeError */
 384     if (NATIVE_GET_NUM_ARGS() != 0)
 385     {
 386         PM_RAISE(retval, PM_RET_EX_TYPE);
 387         return retval;
 388     }
 389
 390     /* Return calling frame's local attrs dict on the stack */
 391     pr = (pPmObj_t)NATIVE_GET_PFRAME()->fo_attrs;
 392     NATIVE_SET_TOS(pr);
 393
 394     return PM_RET_OK;
 395     """
 396     pass
 397
 398
 399 def map(f, s):
 400     # Allocate the array
 401     r = [None,] * len(s)
 402
 403     # Call function f once with each argument in sequence s
 404     i = 0
 405     for a in s:
 406         r[i] = f(a)
 407         i += 1
 408
 409     # Return list of results
 410     return r
 411
 412
 413 def ord(s):
 414     """__NATIVE__
 415     pPmObj_t ps;
 416     pPmObj_t pn;
 417     int32_t n;
 418     PmReturn_t retval;
 419
 420     /* If wrong number of args, raise TypeError */
 421     if (NATIVE_GET_NUM_ARGS() != 1)
 422     {
 423         PM_RAISE(retval, PM_RET_EX_TYPE);
 424         return retval;
 425     }
 426
 427     ps = NATIVE_GET_LOCAL(0);
 428
 429     /* Raise TypeError if arg is not string of length 1 */
 430     if ((OBJ_GET_TYPE(ps) != OBJ_TYPE_STR)
 431         || (((pPmString_t)ps)->length != 1))
 432
 433     {
 434         PM_RAISE(retval, PM_RET_EX_TYPE);
 435         return retval;
 436     }
 437
 438     /* Get integer value of character */
 439     n = ((pPmString_t)ps)->val[0];
 440     retval = int_new(n, &pn);
 441     NATIVE_SET_TOS(pn);
 442     return retval;
 443     """
 444     pass
 445
 446
 447 def pow(x, y):
 448     return x ** y
 449
 450
 451 def range(a, b, c):
 452     """__NATIVE__
 453     PmReturn_t retval;
 454     pPmObj_t pa = C_NULL;
 455     pPmObj_t pb = C_NULL;
 456     pPmObj_t pc = C_NULL;
 457     pPmObj_t pi = C_NULL;
 458     pPmObj_t pr = C_NULL;
 459     int16_t i = 0;
 460     uint8_t objid1, objid2;
 461
 462     switch (NATIVE_GET_NUM_ARGS())
 463     {
 464         case 1:
 465             pa = PM_ZERO;
 466             pb = NATIVE_GET_LOCAL(0);
 467             pc = PM_ONE;
 468             break;
 469
 470         case 2:
 471             pa = NATIVE_GET_LOCAL(0);
 472             pb = NATIVE_GET_LOCAL(1);
 473             pc = PM_ONE;
 474             break;
 475
 476         case 3:
 477             pa = NATIVE_GET_LOCAL(0);
 478             pb = NATIVE_GET_LOCAL(1);
 479             pc = NATIVE_GET_LOCAL(2);
 480
 481             /* If 3rd arg is 0, ValueError */
 482             if (((pPmInt_t)pc)->val == 0)
 483             {
 484                 PM_RAISE(retval, PM_RET_EX_VAL);
 485                 return retval;
 486             }
 487             break;
 488
 489         default:
 490             /* If wrong number of args, raise TypeError */
 491             PM_RAISE(retval, PM_RET_EX_TYPE);
 492             return retval;
 493     }
 494
 495     /* Allocate list */
 496     retval = list_new(&pr);
 497     PM_RETURN_IF_ERROR(retval);
 498
 499     /* Iterate depending on counting direction */
 500     if (((pPmInt_t)pc)->val > 0)
 501     {
 502         for (i = ((pPmInt_t)pa)->val;
 503              i < ((pPmInt_t)pb)->val;
 504              i += ((pPmInt_t)pc)->val)
 505         {
 506             heap_gcPushTempRoot(pr, &objid1);
 507             retval = int_new(i, &pi);
 508             if (retval != PM_RET_OK)
 509             {
 510                 heap_gcPopTempRoot(objid1);
 511                 return retval;
 512             }
 513
 514             heap_gcPushTempRoot(pi, &objid2);
 515             retval = list_append(pr, pi);
 516             heap_gcPopTempRoot(objid1);
 517             PM_RETURN_IF_ERROR(retval);
 518         }
 519     }
 520     else
 521     {
 522         for (i = ((pPmInt_t)pa)->val;
 523              i > ((pPmInt_t)pb)->val;
 524              i += ((pPmInt_t)pc)->val)
 525         {
 526             heap_gcPushTempRoot(pr, &objid1);
 527             retval = int_new(i, &pi);
 528             if (retval != PM_RET_OK)
 529             {
 530                 heap_gcPopTempRoot(objid1);
 531                 return retval;
 532             }
 533
 534             heap_gcPushTempRoot(pi, &objid2);
 535             retval = list_append(pr, pi);
 536             heap_gcPopTempRoot(objid1);
 537             PM_RETURN_IF_ERROR(retval);
 538         }
 539     }
 540
 541     /* Return list */
 542     NATIVE_SET_TOS(pr);
 543     return retval;
 544     """
 545     pass
 546
 547
 548 def sum(s):
 549     """__NATIVE__
 550     pPmObj_t ps;
 551     pPmObj_t pn;
 552     pPmObj_t po;
 553     int32_t n;
 554     uint16_t len;
 555     uint16_t i;
 556     PmReturn_t retval;
 557 #ifdef HAVE_FLOAT
 558     float f;
 559     uint8_t usefloat = C_FALSE;
 560 #endif /* HAVE_FLOAT */
 561
 562     /* If wrong number of args, raise TypeError */
 563     if (NATIVE_GET_NUM_ARGS() != 1)
 564     {
 565         PM_RAISE(retval, PM_RET_EX_TYPE);
 566         return retval;
 567     }
 568
 569     /* Get the length of the sequence */
 570     ps = NATIVE_GET_LOCAL(0);
 571     if (OBJ_GET_TYPE(ps) == OBJ_TYPE_TUP)
 572     {
 573         len = ((pPmTuple_t)ps)->length;
 574     }
 575     else if (OBJ_GET_TYPE(ps) == OBJ_TYPE_LST)
 576     {
 577         len = ((pPmList_t)ps)->length;
 578     }
 579
 580     /* Raise TypeError if arg is not a sequence */
 581     else
 582     {
 583         PM_RAISE(retval, PM_RET_EX_TYPE);
 584         return retval;
 585     }
 586
 587     /* Calculate the sum of the sequence */
 588     n = 0;
 589 #ifdef HAVE_FLOAT
 590     f = 0.0;
 591 #endif
 592     for (i = 0; i < len; i++)
 593     {
 594         retval = seq_getSubscript(ps, i, &po);
 595
 596         if (OBJ_GET_TYPE(po) == OBJ_TYPE_INT)
 597         {
 598             /* Add value to sum */
 599             n += ((pPmInt_t)po)->val;
 600 #ifdef HAVE_FLOAT
 601             f += (float)((pPmInt_t)po)->val;
 602 #endif /* HAVE_FLOAT */
 603         }
 604
 605 #ifdef HAVE_FLOAT
 606         else if (OBJ_GET_TYPE(po) == OBJ_TYPE_FLT)
 607         {
 608             /* Add value to sum */
 609             f += ((pPmFloat_t)po)->val;
 610             usefloat = C_TRUE;
 611         }
 612 #endif /* HAVE_FLOAT */
 613
 614         /* Raise TypeError if item is not an integer */
 615         else
 616         {
 617             PM_RAISE(retval, PM_RET_EX_TYPE);
 618             return retval;
 619         }
 620     }
 621
 622 #ifdef HAVE_FLOAT
 623     if (usefloat)
 624     {
 625         retval = float_new(f, &pn);
 626     }
 627     else
 628 #endif /* HAVE_FLOAT */
 629     {
 630         retval = int_new(n, &pn);
 631     }
 632     NATIVE_SET_TOS(pn);
 633     return retval;
 634     """
 635     pass
 636
 637
 638 def type(o):
 639     """__NATIVE__
 640     PmReturn_t retval;
 641     pPmObj_t po = C_NULL;
 642     pPmObj_t pr = C_NULL;
 643
 644     /* If wrong number of args, raise TypeError */
 645     if (NATIVE_GET_NUM_ARGS() != 1)
 646     {
 647         PM_RAISE(retval, PM_RET_EX_TYPE);
 648         return retval;
 649     }
 650
 651     /* Get arg */
 652     po = NATIVE_GET_LOCAL(0);
 653
 654     /* Create int from type enum */
 655     retval = int_new(OBJ_GET_TYPE(po), &pr);
 656     NATIVE_SET_TOS(pr);
 657     return retval;
 658     """
 659     pass
 660
 661
 662 # At this time, xrange() works in a for loop, but not in a generator expression
 663 # Yes: for i in xrange(42): pass
 664 # No:  [x for x in xrange(42)]
 665 #def xrange(n):
 666 #    i = 0
 667 #    while i < n:
 668 #        yield i
 669 #        i += 1
 670
 671
 672 #
 673 # Creates a code object from the given image string
 674 #
 675 def Co(i):
 676     """__NATIVE__
 677     PmReturn_t retval;
 678     pPmObj_t pimg;
 679     pPmObj_t pco;
 680
 681     /* If wrong number of args, raise TypeError */
 682     if (NATIVE_GET_NUM_ARGS() != 1)
 683     {
 684         PM_RAISE(retval, PM_RET_EX_TYPE);
 685         return retval;
 686     }
 687
 688     /* Raise ValueError if arg is not a string */
 689     pimg = NATIVE_GET_LOCAL(0);
 690     if (OBJ_GET_TYPE(pimg) != OBJ_TYPE_CIO)
 691     {
 692         PM_RAISE(retval, PM_RET_EX_VAL);
 693         return retval;
 694     }
 695
 696     /* Create a code object from the image */
 697     retval = obj_loadFromImgObj(pimg, &pco);
 698     PM_RETURN_IF_ERROR(retval);
 699
 700     /* Return the code object */
 701     NATIVE_SET_TOS(pco);
 702     return retval;
 703     """
 704     pass
 705
 706
 707 # This must be declared before any classes because LOAD_NAME(__name__) is
 708 # part of every class-declaration, so __name__ must exist.
 709 # This is a temporary workaround until __name__ is properly handled.
 710 __name__ = "TBD"
 711
 712
 713 #
 714 # Root object
 715 #
 716 class object():
 717     pass
 718
 719
 720 #
 721 # Exception classes
 722 #
 723 class Exception(object):
 724     pass
 725
 726 class AssertionError(Exception):
 727     pass
 728 AssertionError.code = 0xE4
 729
 730
 731 #
 732 # Generator class - used by the vm for generator-iterators,
 733 # generator-expressions and generator-coroutines
 734 #
 735 # #207: Add support for the yield keyword
 736 #
 737 # WARNING: unsupported methods: throw, close, __del__
 738 #
 739 class Generator(object):
 740
 741     def __init__(self, fa):
 742         """__NATIVE__
 743         PmReturn_t retval;
 744         pPmObj_t pself;
 745         pPmObj_t pfa;
 746         pPmObj_t pfunc;
 747         pPmObj_t pframe;
 748         uint8_t i;
 749         uint8_t objid;
 750
 751         /* Raise TypeError if wrong number of args */
 752         if (NATIVE_GET_NUM_ARGS() != 2)
 753         {
 754             PM_RAISE(retval, PM_RET_EX_TYPE);
 755             return retval;
 756         }
 757
 758         /* Raise ValueError if first args are not: instance, tuple */
 759         pself = NATIVE_GET_LOCAL(0);
 760         pfa = NATIVE_GET_LOCAL(1);
 761         if (OBJ_GET_TYPE(pself) != OBJ_TYPE_CLI)
 762         {
 763             PM_RAISE(retval, PM_RET_EX_VAL);
 764             return retval;
 765         }
 766         if (OBJ_GET_TYPE(pfa) != OBJ_TYPE_TUP)
 767         {
 768             PM_RAISE(retval, PM_RET_EX_VAL);
 769             return retval;
 770         }
 771
 772         /* Create a new frame for the function */
 773         pfunc = ((pPmTuple_t)pfa)->val[0];
 774         retval = frame_new(pfunc, &pframe);
 775         PM_RETURN_IF_ERROR(retval);
 776
 777         /* Copy args into frame's locals */
 778         for (i = 0; i < ((pPmTuple_t)pfa)->length - 1; i++)
 779         {
 780             /* The pfa tuple is (func, [arg0, ... argN]) */
 781             ((pPmFrame_t)pframe)->fo_locals[i] = ((pPmTuple_t)pfa)->val[i + 1];
 782         }
 783
 784         /* Store frame in None attr of instance */
 785         heap_gcPushTempRoot(pframe, &objid);
 786         retval = dict_setItem((pPmObj_t)((pPmInstance_t)pself)->cli_attrs,
 787                               PM_NONE, pframe);
 788         heap_gcPopTempRoot(objid);
 789
 790         NATIVE_SET_TOS(PM_NONE);
 791         return retval;
 792         """
 793         pass
 794
 795
 796     def next(self,):
 797         return self.send(None)
 798
 799
 800     def send(self, arg):
 801         """__NATIVE__
 802         PmReturn_t retval;
 803         pPmObj_t pself;
 804         pPmObj_t parg;
 805         pPmObj_t pgenframe;
 806
 807         /* Raise TypeError if wrong number of args */
 808         if (NATIVE_GET_NUM_ARGS() != 2)
 809         {
 810             PM_RAISE(retval, PM_RET_EX_TYPE);
 811             return retval;
 812         }
 813
 814         /* Raise ValueError if first arg is not an instance */
 815         pself = NATIVE_GET_LOCAL(0);
 816         parg = NATIVE_GET_LOCAL(1);
 817         if (OBJ_GET_TYPE(pself) != OBJ_TYPE_CLI)
 818         {
 819             PM_RAISE(retval, PM_RET_EX_VAL);
 820             return retval;
 821         }
 822
 823         /* Get the generator's frame */
 824         retval = dict_getItem((pPmObj_t)((pPmInstance_t)pself)->cli_attrs,
 825                               PM_NONE, &pgenframe);
 826         PM_RETURN_IF_ERROR(retval);
 827
 828         /* Push argument onto generator's frame's stack */
 829         *(((pPmFrame_t)pgenframe)->fo_sp) = parg;
 830         ((pPmFrame_t)pgenframe)->fo_sp++;
 831
 832         /* Set generator's frame's fo_back so yielded value goes to caller */
 833         ((pPmFrame_t)pgenframe)->fo_back = NATIVE_GET_PFRAME();
 834
 835         /* Set active frame to run generator */
 836         NATIVE_GET_PFRAME() = (pPmFrame_t)pgenframe;
 837
 838         return PM_RET_FRAME_SWITCH;
 839         """
 840         pass
 841
 842
 843 # WARNING: Untested.  Awaiting implementation of try/except/finally
 844 #
 845 #    def close(self,):
 846 #        """__NATIVE__
 847 #        PmReturn_t retval;
 848 #        pPmObj_t pself;
 849 #        pPmObj_t pgenframe;
 850 #
 851 #        /* Raise TypeError if wrong number of args */
 852 #        if (NATIVE_GET_NUM_ARGS() != 1)
 853 #        {
 854 #            PM_RAISE(retval, PM_RET_EX_TYPE);
 855 #            return retval;
 856 #        }
 857 #
 858 #        /* Raise ValueError if first arg is not an instance */
 859 #        pself = NATIVE_GET_LOCAL(0);
 860 #        if (OBJ_GET_TYPE(pself) != OBJ_TYPE_CLI)
 861 #        {
 862 #            PM_RAISE(retval, PM_RET_EX_VAL);
 863 #            return retval;
 864 #        }
 865 #
 866 #        /* Get the generator's frame */
 867 #        retval = dict_getItem((pPmObj_t)((pPmInstance_t)pself)->cli_attrs,
 868 #                              PM_NONE, &pgenframe);
 869 #        PM_RETURN_IF_ERROR(retval);
 870 #
 871 #        /* If there was no frame, assume generator already closed, do nothing */
 872 #        if (OBJ_GET_TYPE(pgenframe) != OBJ_TYPE_FRM)
 873 #        {
 874 #            return PM_RET_OK;
 875 #        }
 876 #
 877 #        /* Unbind the frame from the generator instance */
 878 #        retval = dict_setItem((pPmObj_t)((pPmInstance_t)pself)->cli_attrs,
 879 #                              PM_NONE, PM_NONE);
 880 #
 881 #        /* Push argument onto generator's frame's stack */
 882 #        *(((pPmFrame_t)pgenframe)->fo_sp) = PM_NONE;
 883 #        ((pPmFrame_t)pgenframe)->fo_sp++;
 884 #
 885 #        /* Set generator's frame's fo_back so yielded value goes to caller */
 886 #        ((pPmFrame_t)pgenframe)->fo_back = NATIVE_GET_PFRAME();
 887 #
 888 #        /* Set active frame to run generator */
 889 #        NATIVE_GET_PFRAME() = (pPmFrame_t)pgenframe;
 890 #
 891 #        /* Raise a GeneratorExit where the generator function was paused */
 892 #        PM_RAISE(retval, PM_RET_EX_GEN);
 893 #        return retval;
 894 #        """
 895 #        pass
 896
 897
 898 #
 899 # Returns True if called within a module being run as the main; False otherwise
 900 #
 901 def ismain():
 902     """__NATIVE__
 903
 904     NATIVE_SET_TOS((NATIVE_GET_PFRAME()->fo_isImport) ? PM_FALSE : PM_TRUE);
 905
 906     return PM_RET_OK;
 907     """
 908     pass
 909
 910
 911 #ifdef HAVE_BYTEARRAY
 912 #class bytearray(object):
 913 #    def __init__(self, o):
 914 #        """__NATIVE__
 915 #        PmReturn_t retval;
 916 #        pPmObj_t pself;
 917 #        pPmObj_t po;
 918 #        pPmObj_t pba;
 919 #        uint8_t objid;
 920 #
 921 #        /* If only the self arg, create zero-length bytearray */
 922 #        if (NATIVE_GET_NUM_ARGS() == 1)
 923 #        {
 924 #            po = PM_ZERO;
 925 #        }
 926 #
 927 #        /* If two args, get the second arg */
 928 #        else if (NATIVE_GET_NUM_ARGS() == 2)
 929 #        {
 930 #            po = NATIVE_GET_LOCAL(1);
 931 #        }
 932 #
 933 #        /* Raise TypeError if wrong number of args */
 934 #        else
 935 #        {
 936 #            PM_RAISE(retval, PM_RET_EX_TYPE);
 937 #            return retval;
 938 #        }
 939 #        pself = NATIVE_GET_LOCAL(0);
 940 #
 941 #        /* Create new bytearray object */
 942 #        retval = bytearray_new(po, &pba);
 943 #        PM_RETURN_IF_ERROR(retval);
 944 #
 945 #        /* Store bytearray in None attr of instance */
 946 #        heap_gcPushTempRoot(pba, &objid);
 947 #        retval = dict_setItem((pPmObj_t)((pPmInstance_t)pself)->cli_attrs,
 948 #                              PM_NONE, pba);
 949 #        heap_gcPopTempRoot(objid);
 950 #
 951 #        NATIVE_SET_TOS(PM_NONE);
 952 #        return retval;
 953 #        """
 954 #        pass
 955 #endif /* HAVE_BYTEARRAY */
 956
 957 #:mode=c: