src/lib/embryo_amx.c

   1 /*  Abstract Machine for the Small compiler
   2  *
   3  *  Copyright (c) ITB CompuPhase, 1997-2003
   4  *  Portions Copyright (c) Carsten Haitzler, 2004 <raster@rasterman.com>
   5  *
   6  *  This software is provided "as-is", without any express or implied warranty.
   7  *  In no event will the authors be held liable for any damages arising from
   8  *  the use of this software.
   9  *
  10  *  Permission is granted to anyone to use this software for any purpose,
  11  *  including commercial applications, and to alter it and redistribute it
  12  *  freely, subject to the following restrictions:
  13  *
  14  *  1.  The origin of this software must not be misrepresented; you must not
  15  *      claim that you wrote the original software. If you use this software in
  16  *      a product, an acknowledgment in the product documentation would be
  17  *      appreciated but is not required.
  18  *  2.  Altered source versions must be plainly marked as such, and must not be
  19  *      misrepresented as being the original software.
  20  *  3.  This notice may not be removed or altered from any source distribution.
  21  */
  22
  23 /*
  24  * vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <stdlib.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34
  35 #ifdef HAVE_EVIL
  36 # include <Evil.h>
  37 #endif
  38
  39 #include "Embryo.h"
  40 #include "embryo_private.h"
  41
  42
  43 #define JUMPABS(base, ip)     ((Embryo_Cell *)(code + (*ip)))
  44
  45 #ifdef WORDS_BIGENDIAN
  46 static void _embryo_byte_swap_16 (unsigned short *v);
  47 static void _embryo_byte_swap_32 (unsigned int *v);
  48 #endif
  49 static int  _embryo_native_call  (Embryo_Program *ep, Embryo_Cell index, Embryo_Cell *result, Embryo_Cell *params);
  50 static int  _embryo_func_get     (Embryo_Program *ep, int index, char *funcname);
  51 static int  _embryo_var_get      (Embryo_Program *ep, int index, char *varname, Embryo_Cell *ep_addr);
  52 static int  _embryo_program_init (Embryo_Program *ep, void *code);
  53
  54 #ifdef WORDS_BIGENDIAN
  55 static void
  56 _embryo_byte_swap_16(unsigned short *v)
  57 {
  58    unsigned char *s, t;
  59
  60    s = (unsigned char *)v;
  61    t = s[0]; s[0] = s[1]; s[1] = t;
  62 }
  63
  64 static void
  65 _embryo_byte_swap_32(unsigned int *v)
  66 {
  67    unsigned char *s, t;
  68
  69    s = (unsigned char *)v;
  70    t = s[0]; s[0] = s[3]; s[3] = t;
  71    t = s[1]; s[1] = s[2]; s[2] = t;
  72 }
  73 #endif
  74
  75 static int
  76 _embryo_native_call(Embryo_Program *ep, Embryo_Cell index, Embryo_Cell *result, Embryo_Cell *params)
  77 {
  78    Embryo_Header    *hdr;
  79    Embryo_Func_Stub *func_entry;
  80    Embryo_Native     f;
  81
  82    hdr = (Embryo_Header *)ep->base;
  83    func_entry = GETENTRY(hdr, natives, index);
  84    if ((func_entry->address <= 0) ||
  85        (func_entry->address > ep->native_calls_size))
  86      {
  87         ep->error = EMBRYO_ERROR_CALLBACK;
  88         return ep->error;
  89      }
  90    f = ep->native_calls[func_entry->address - 1];
  91    if (!f)
  92      {
  93         ep->error = EMBRYO_ERROR_CALLBACK;
  94         return ep->error;
  95      }
  96    ep->error = EMBRYO_ERROR_NONE;
  97    *result = f(ep, params);
  98    return ep->error;
  99 }
 100
 101 static int
 102 _embryo_func_get(Embryo_Program *ep, int index, char *funcname)
 103 {
 104    Embryo_Header    *hdr;
 105    Embryo_Func_Stub *func;
 106
 107    hdr = (Embryo_Header *)ep->code;
 108    if (index >= (Embryo_Cell)NUMENTRIES(hdr, publics, natives))
 109      return EMBRYO_ERROR_INDEX;
 110
 111    func = GETENTRY(hdr, publics, index);
 112    strcpy(funcname, GETENTRYNAME(hdr, func));
 113    return EMBRYO_ERROR_NONE;
 114 }
 115
 116 static int
 117 _embryo_var_get(Embryo_Program *ep, int index, char *varname, Embryo_Cell *ep_addr)
 118 {
 119
 120   Embryo_Header    *hdr;
 121   Embryo_Func_Stub *var;
 122
 123   hdr=(Embryo_Header *)ep->base;
 124   if (index >= (Embryo_Cell)NUMENTRIES(hdr, pubvars, tags))
 125      return EMBRYO_ERROR_INDEX;
 126
 127   var = GETENTRY(hdr, pubvars, index);
 128   strcpy(varname, GETENTRYNAME(hdr, var));
 129   *ep_addr = var->address;
 130   return EMBRYO_ERROR_NONE;
 131 }
 132
 133 static int
 134 _embryo_program_init(Embryo_Program *ep, void *code)
 135 {
 136    Embryo_Header    *hdr;
 137
 138    if ((ep->flags & EMBRYO_FLAG_RELOC)) return 1;
 139    ep->code = (unsigned char *)code;
 140    hdr = (Embryo_Header *)ep->code;
 141 #ifdef WORDS_BIGENDIAN
 142    embryo_swap_32((unsigned int *)&hdr->size);
 143    embryo_swap_16((unsigned short *)&hdr->magic);
 144    embryo_swap_16((unsigned short *)&hdr->flags);
 145    embryo_swap_16((unsigned short *)&hdr->defsize);
 146    embryo_swap_32((unsigned int *)&hdr->cod);
 147    embryo_swap_32((unsigned int *)&hdr->dat);
 148    embryo_swap_32((unsigned int *)&hdr->hea);
 149    embryo_swap_32((unsigned int *)&hdr->stp);
 150    embryo_swap_32((unsigned int *)&hdr->cip);
 151    embryo_swap_32((unsigned int *)&hdr->publics);
 152    embryo_swap_32((unsigned int *)&hdr->natives);
 153    embryo_swap_32((unsigned int *)&hdr->libraries);
 154    embryo_swap_32((unsigned int *)&hdr->pubvars);
 155    embryo_swap_32((unsigned int *)&hdr->tags);
 156    embryo_swap_32((unsigned int *)&hdr->nametable);
 157 #endif
 158
 159    if (hdr->magic != EMBRYO_MAGIC) return 0;
 160    if ((hdr->file_version < MIN_FILE_VERSION) ||
 161       (hdr->ep_version > CUR_FILE_VERSION)) return 0;
 162    if ((hdr->defsize != sizeof(Embryo_Func_Stub)) &&
 163       (hdr->defsize != (2 * sizeof(unsigned int)))) return 0;
 164    if (hdr->defsize == (2 * sizeof(unsigned int)))
 165      {
 166         unsigned short *len;
 167
 168         len = (unsigned short*)((unsigned char*)ep->code + hdr->nametable);
 169 #ifdef WORDS_BIGENDIAN
 170         embryo_swap_16((unsigned short *)len);
 171 #endif
 172         if (*len > sNAMEMAX) return 0;
 173      }
 174    if (hdr->stp <= 0) return 0;
 175    if ((hdr->flags & EMBRYO_FLAG_COMPACT)) return 0;
 176
 177 #ifdef WORDS_BIGENDIAN
 178      {
 179         Embryo_Func_Stub *fs;
 180         int i, num;
 181
 182         /* also align all addresses in the public function, public variable and */
 183         /* public tag tables */
 184         fs = GETENTRY(hdr, publics, 0);
 185         num = NUMENTRIES(hdr, publics, natives);
 186         for (i = 0; i < num; i++)
 187           {
 188              embryo_swap_32(&(fs->address));
 189              fs = (Embryo_Func_Stub *)((unsigned char *)fs + hdr->defsize);
 190           }
 191
 192         fs = GETENTRY(hdr, pubvars, 0);
 193         num = NUMENTRIES(hdr, pubvars, tags);
 194         for (i = 0; i < num; i++)
 195           {
 196              embryo_swap_32(&(fs->address));
 197              fs = (Embryo_Func_Stub *)((unsigned char *)fs + hdr->defsize);
 198           }
 199
 200         fs = GETENTRY(hdr, tags, 0);
 201         num = NUMENTRIES(hdr, tags, nametable);
 202         for (i = 0; i < num; i++)
 203           {
 204              embryo_swap_32(&(fs->address));
 205              fs = (Embryo_Func_Stub *)((unsigned char *)fs + hdr->defsize);
 206           }
 207      }
 208 #endif
 209    ep->flags = EMBRYO_FLAG_RELOC;
 210
 211      {
 212         Embryo_Cell cip, code_size;
 213         Embryo_Cell *code;
 214
 215         code_size = hdr->dat - hdr->cod;
 216         code = (Embryo_Cell *)((unsigned char *)ep->code + (int)hdr->cod);
 217         for (cip = 0; cip < (code_size / sizeof(Embryo_Cell)); cip++)
 218           {
 219 /* move this here - later we probably want something that verifies opcodes
 220  * are valid and ok...
 221  */
 222 #ifdef WORDS_BIGENDIAN
 223              embryo_swap_32(&(code[cip]));
 224 #endif
 225
 226           }
 227      }
 228    /* init native api for handling floating point - default in embryo */
 229    _embryo_args_init(ep);
 230    _embryo_fp_init(ep);
 231    _embryo_rand_init(ep);
 232    _embryo_str_init(ep);
 233    _embryo_time_init(ep);
 234    return 1;
 235 }
 236
 237 /*** EXPORTED CALLS ***/
 238
 239 /**
 240  * @defgroup Embryo_Program_Creation_Group Program Creation and Destruction Functions
 241  *
 242  * Functions that set up programs, and destroy them.
 243  */
 244
 245 /**
 246  * Creates a new Embryo program, with bytecode data that can be freed.
 247  * @param   data Pointer to the bytecode of the program.
 248  * @param   size Number of bytes of bytecode.
 249  * @return  A new Embryo program.
 250  * @ingroup Embryo_Program_Creation_Group
 251  */
 252 EAPI Embryo_Program *
 253 embryo_program_new(void *data, int size)
 254 {
 255    Embryo_Program *ep;
 256    void *code_data;
 257
 258    if (size < (int)sizeof(Embryo_Header)) return NULL;
 259
 260    ep = calloc(1, sizeof(Embryo_Program));
 261    if (!ep) return NULL;
 262
 263    code_data = malloc(size);
 264    if (!code_data)
 265      {
 266         free(ep);
 267         return NULL;
 268      }
 269    memcpy(code_data, data, size);
 270    if (_embryo_program_init(ep, code_data)) return ep;
 271    free(code_data);
 272    free(ep);
 273    return NULL;
 274 }
 275
 276 /**
 277  * Creates a new Embryo program, with bytecode data that cannot be
 278  * freed.
 279  * @param   data Pointer to the bytecode of the program.
 280  * @param   size Number of bytes of bytecode.
 281  * @return  A new Embryo program.
 282  * @ingroup Embryo_Program_Creation_Group
 283  */
 284 EAPI Embryo_Program *
 285 embryo_program_const_new(void *data, int size)
 286 {
 287    Embryo_Program *ep;
 288
 289    if (size < (int)sizeof(Embryo_Header)) return NULL;
 290
 291    ep = calloc(1, sizeof(Embryo_Program));
 292    if (!ep) return NULL;
 293
 294    if (_embryo_program_init(ep, data))
 295      {
 296         ep->dont_free_code = 1;
 297         return ep;
 298      }
 299    free(ep);
 300    return NULL;
 301 }
 302
 303 /**
 304  * Creates a new Embryo program based on the bytecode data stored in the
 305  * given file.
 306  * @param   file Filename of the given file.
 307  * @return  A new Embryo program.
 308  * @ingroup Embryo_Program_Creation_Group
 309  */
 310 EAPI Embryo_Program *
 311 embryo_program_load(char *file)
 312 {
 313    Embryo_Program *ep;
 314    Embryo_Header   hdr;
 315    FILE *f;
 316    void *program = NULL;
 317    int program_size = 0;
 318
 319    f = fopen(file, "rb");
 320    if (!f) return NULL;
 321    fseek(f, 0, SEEK_END);
 322    program_size = ftell(f);
 323    rewind(f);
 324    if (program_size < (int)sizeof(Embryo_Header))
 325      {
 326         fclose(f);
 327         return NULL;
 328      }
 329    if (fread(&hdr, sizeof(Embryo_Header), 1, f) != 1)
 330      {
 331         fclose(f);
 332         return NULL;
 333      }
 334    rewind(f);
 335 #ifdef WORDS_BIGENDIAN
 336    embryo_swap_32((unsigned int *)(&hdr.size));
 337 #endif
 338    if ((int)hdr.size < program_size) program_size = hdr.size;
 339    program = malloc(program_size);
 340    if (!program)
 341      {
 342         fclose(f);
 343         return NULL;
 344      }
 345    if (fread(program, program_size, 1, f) != 1)
 346      {
 347         free(program);
 348         fclose(f);
 349         return NULL;
 350      }
 351    ep = embryo_program_new(program, program_size);
 352    free(program);
 353    fclose(f);
 354    return ep;
 355 }
 356
 357 /**
 358  * Frees the given Embryo program.
 359  * @param   ep The given program.
 360  * @ingroup Embryo_Program_Creation_Group
 361  */
 362 EAPI void
 363 embryo_program_free(Embryo_Program *ep)
 364 {
 365    int i;
 366
 367    if (ep->base) free(ep->base);
 368    if ((!ep->dont_free_code) && (ep->code)) free(ep->code);
 369    if (ep->native_calls) free(ep->native_calls);
 370    for (i = 0; i < ep->params_size; i++)
 371      {
 372         if (ep->params[i].string) free(ep->params[i].string);
 373         if (ep->params[i].cell_array) free(ep->params[i].cell_array);
 374      }
 375    if (ep->params) free(ep->params);
 376    free(ep);
 377 }
 378
 379 /**
 380  * @defgroup Embryo_Func_Group Function Functions
 381  *
 382  * Functions that deal with Embryo program functions.
 383  */
 384
 385 /**
 386  * Adds a native program call to the given Embryo program.
 387  * @param   ep   The given Embryo program.
 388  * @param   name The name for the call used in the script.
 389  * @param   func The function to use when the call is made.
 390  * @ingroup Embryo_Func_Group
 391  */
 392 EAPI void
 393 embryo_program_native_call_add(Embryo_Program *ep, const char *name, Embryo_Cell (*func) (Embryo_Program *ep, Embryo_Cell *params))
 394 {
 395    Embryo_Func_Stub *func_entry;
 396    Embryo_Header    *hdr;
 397    int               i, num;
 398
 399    if ((ep == NULL ) || (name == NULL) || (func == NULL)) return;
 400    if (strlen(name) > sNAMEMAX) return;
 401
 402    hdr = (Embryo_Header *)ep->code;
 403    if (hdr->defsize < 1) return;
 404    num = NUMENTRIES(hdr, natives, libraries);
 405    if (num <= 0) return;
 406
 407    ep->native_calls_size++;
 408    if (ep->native_calls_size > ep->native_calls_alloc)
 409      {
 410         Embryo_Native *calls;
 411
 412         ep->native_calls_alloc += 16;
 413         calls = realloc(ep->native_calls,
 414                         ep->native_calls_alloc * sizeof(Embryo_Native));
 415         if (!calls)
 416           {
 417              ep->native_calls_size--;
 418              ep->native_calls_alloc -= 16;
 419              return;
 420           }
 421         ep->native_calls = calls;
 422      }
 423    ep->native_calls[ep->native_calls_size - 1] = func;
 424
 425    func_entry = GETENTRY(hdr, natives, 0);
 426    for (i = 0; i < num; i++)
 427      {
 428         if (func_entry->address == 0)
 429           {
 430              char *entry_name;
 431
 432              entry_name = GETENTRYNAME(hdr, func_entry);
 433              if ((entry_name) && (!strcmp(entry_name, name)))
 434                {
 435                   func_entry->address = ep->native_calls_size;
 436                   /* FIXME: embryo_cc is putting in multiple native */
 437                   /* function call entries - so we need to fill in all */
 438                   /* of them!!! */
 439                   /* return; */
 440                }
 441           }
 442         func_entry =
 443           (Embryo_Func_Stub *)((unsigned char *)func_entry + hdr->defsize);
 444      }
 445 }
 446
 447 /**
 448  * @defgroup Embryo_Program_VM_Group Virtual Machine Functions
 449  *
 450  * Functions that deal with creating and destroying virtual machine sessions
 451  * for a given program.
 452  *
 453  * A given embryo program can have multiple virtual machine sessions running.
 454  * This is useful when you have a native call that in turn calls a function in
 455  * the embryo program.  The native call can start a new virtual machine
 456  * session to run the function it needs.  Once completed, the session can be
 457  * popped off the program's stack, and the native call can return its value
 458  * to the old session.
 459  *
 460  * A new virtual machine session is created by pushing a new virtual machine
 461  * onto the session stack of a program using @ref embryo_program_vm_push.
 462  * The current virtual machine session can be destroyed by calling
 463  * @ref embryo_program_vm_pop.
 464  */
 465
 466 /**
 467  * Resets the current virtual machine session of the given program.
 468  * @param   ep The given program.
 469  * @ingroup Embryo_Program_VM_Group
 470  */
 471 EAPI void
 472 embryo_program_vm_reset(Embryo_Program *ep)
 473 {
 474    Embryo_Header *hdr;
 475
 476    if ((!ep) || (!ep->base)) return;
 477    hdr = (Embryo_Header *)ep->code;
 478    memcpy(ep->base, hdr, hdr->size);
 479    *(Embryo_Cell *)(ep->base + (int)hdr->stp - sizeof(Embryo_Cell)) = 0;
 480
 481    ep->hlw = hdr->hea - hdr->dat; /* stack and heap relative to data segment */
 482    ep->stp = hdr->stp - hdr->dat - sizeof(Embryo_Cell);
 483    ep->hea = ep->hlw;
 484    ep->stk = ep->stp;
 485 }
 486
 487 /**
 488  * Starts a new virtual machine session for the given program.
 489  *
 490  * See @ref Embryo_Program_VM_Group for more information about how this works.
 491  *
 492  * @param   ep The given program.
 493  * @ingroup Embryo_Program_VM_Group
 494  */
 495 EAPI void
 496 embryo_program_vm_push(Embryo_Program *ep)
 497 {
 498    Embryo_Header *hdr;
 499
 500    if (!ep) return;
 501    ep->pushes++;
 502    if (ep->pushes > 1)
 503      {
 504         embryo_program_vm_reset(ep);
 505         return;
 506      }
 507    hdr = (Embryo_Header *)ep->code;
 508    ep->base = malloc(hdr->stp);
 509    if (!ep->base)
 510      {
 511         ep->pushes = 0;
 512         return;
 513      }
 514    embryo_program_vm_reset(ep);
 515 }
 516
 517 /**
 518  * Frees the current virtual machine session associated with the given program.
 519  *
 520  * See @ref Embryo_Program_VM_Group for more information about how this works.
 521  * Note that you will need to retrieve any return data or data on the stack
 522  * before you pop.
 523  *
 524  * @param   ep The given program.
 525  * @ingroup Embryo_Program_VM_Group
 526  */
 527 EAPI void
 528 embryo_program_vm_pop(Embryo_Program *ep)
 529 {
 530    if ((!ep) || (!ep->base)) return;
 531    ep->pushes--;
 532    if (ep->pushes >= 1) return;
 533    free(ep->base);
 534    ep->base = NULL;
 535 }
 536
 537 /**
 538  * @defgroup Embryo_Swap_Group Byte Swapping Functions
 539  *
 540  * Functions that are used to ensure that integers passed to the
 541  * virtual machine are in small endian format.  These functions are
 542  * used to ensure that the virtual machine operates correctly on big
 543  * endian machines.
 544  */
 545
 546 /**
 547  * Ensures that the given unsigned short integer is in the small
 548  * endian format.
 549  * @param   v Pointer to the given integer.
 550  * @ingroup Embryo_Swap_Group
 551  */
 552 EAPI void
 553 embryo_swap_16(unsigned short *v)
 554 {
 555 #ifdef WORDS_BIGENDIAN
 556    _embryo_byte_swap_16(v);
 557 #endif
 558 }
 559
 560 /**
 561  * Ensures that the given unsigned integer is in the small endian
 562  * format.
 563  * @param   v Pointer to the given integer.
 564  * @ingroup Embryo_Swap_Group
 565  */
 566 EAPI void
 567 embryo_swap_32(unsigned int *v)
 568 {
 569 #ifdef WORDS_BIGENDIAN
 570    _embryo_byte_swap_32(v);
 571 #endif
 572 }
 573
 574 /**
 575  * Returns the function in the given program with the given name.
 576  * @param   ep The given program.
 577  * @param   name The given function name.
 578  * @return  The function if successful.  Otherwise, @c EMBRYO_FUNCTION_NONE.
 579  * @ingroup Embryo_Func_Group
 580  */
 581 EAPI Embryo_Function
 582 embryo_program_function_find(Embryo_Program *ep, const char *name)
 583 {
 584    int            first, last, mid, result;
 585    char           pname[sNAMEMAX + 1];
 586    Embryo_Header *hdr;
 587
 588    if (!ep) return EMBRYO_FUNCTION_NONE;
 589    hdr = (Embryo_Header *)ep->code;
 590    last = NUMENTRIES(hdr, publics, natives) - 1;
 591    first = 0;
 592    /* binary search */
 593    while (first <= last)
 594      {
 595         mid = (first + last) / 2;
 596         if (_embryo_func_get(ep, mid, pname) == EMBRYO_ERROR_NONE)
 597           result = strcmp(pname, name);
 598         else
 599           return EMBRYO_FUNCTION_NONE;
 600 /*        result = -1;*/
 601         if (result > 0) last = mid - 1;
 602         else if (result < 0) first = mid + 1;
 603         else return mid;
 604      }
 605    return EMBRYO_FUNCTION_NONE;
 606 }
 607
 608 /**
 609  * @defgroup Embryo_Public_Variable_Group Public Variable Access Functions
 610  *
 611  * In an Embryo program, a global variable can be declared public, as
 612  * described in @ref Small_Scope_Subsection.  The functions here allow
 613  * the host program to access these public variables.
 614  */
 615
 616 /**
 617  * Retrieves the location of the public variable in the given program
 618  * with the given name.
 619  * @param   ep   The given program.
 620  * @param   name The given name.
 621  * @return  The address of the variable if found.  @c EMBRYO_CELL_NONE
 622  *          otherwise.
 623  * @ingroup Embryo_Public_Variable_Group
 624  */
 625 EAPI Embryo_Cell
 626 embryo_program_variable_find(Embryo_Program *ep, const char *name)
 627 {
 628    int            first, last, mid, result;
 629    char           pname[sNAMEMAX + 1];
 630    Embryo_Cell    paddr;
 631    Embryo_Header *hdr;
 632
 633    if (!ep) return EMBRYO_CELL_NONE;
 634    if (!ep->base) return EMBRYO_CELL_NONE;
 635    hdr = (Embryo_Header *)ep->base;
 636    last = NUMENTRIES(hdr, pubvars, tags) - 1;
 637    first = 0;
 638    /* binary search */
 639    while (first <= last)
 640      {
 641         mid = (first + last) / 2;
 642         if (_embryo_var_get(ep, mid, pname, &paddr) == EMBRYO_ERROR_NONE)
 643           result = strcmp(pname, name);
 644         else
 645           return EMBRYO_CELL_NONE;
 646 /*        result = -1;*/
 647         if (result > 0) last = mid - 1;
 648         else if (result < 0) first = mid + 1;
 649         else return paddr;
 650      }
 651    return EMBRYO_CELL_NONE;
 652 }
 653
 654 /**
 655  * Retrieves the number of public variables in the given program.
 656  * @param   ep The given program.
 657  * @return  The number of public variables.
 658  * @ingroup Embryo_Public_Variable_Group
 659  */
 660 EAPI int
 661 embryo_program_variable_count_get(Embryo_Program *ep)
 662 {
 663    Embryo_Header *hdr;
 664
 665    if (!ep) return 0;
 666    if (!ep->base) return 0;
 667    hdr = (Embryo_Header *)ep->base;
 668    return NUMENTRIES(hdr, pubvars, tags);
 669 }
 670
 671 /**
 672  * Retrieves the location of the public variable in the given program
 673  * with the given identifier.
 674  * @param   ep  The given program.
 675  * @param   num The identifier of the public variable.
 676  * @return  The virtual machine address of the variable if found.
 677  *          @c EMBRYO_CELL_NONE otherwise.
 678  * @ingroup Embryo_Public_Variable_Group
 679  */
 680 EAPI Embryo_Cell
 681 embryo_program_variable_get(Embryo_Program *ep, int num)
 682 {
 683    Embryo_Cell    paddr;
 684    char           pname[sNAMEMAX + 1];
 685
 686    if (!ep) return EMBRYO_CELL_NONE;
 687    if (!ep->base) return EMBRYO_CELL_NONE;
 688    if (_embryo_var_get(ep, num, pname, &paddr) == EMBRYO_ERROR_NONE)
 689      return paddr;
 690    return EMBRYO_CELL_NONE;
 691 }
 692
 693 /**
 694  * @defgroup Embryo_Error_Group Error Functions
 695  *
 696  * Functions that set and retrieve error codes in Embryo programs.
 697  */
 698
 699 /**
 700  * Sets the error code for the given program to the given code.
 701  * @param   ep The given program.
 702  * @param   error The given error code.
 703  * @ingroup Embryo_Error_Group
 704  */
 705 EAPI void
 706 embryo_program_error_set(Embryo_Program *ep, int error)
 707 {
 708    if (!ep) return;
 709    ep->error = error;
 710 }
 711
 712 /**
 713  * Retrieves the current error code for the given program.
 714  * @param   ep The given program.
 715  * @return  The current error code.
 716  * @ingroup Embryo_Error_Group
 717  */
 718 EAPI int
 719 embryo_program_error_get(Embryo_Program *ep)
 720 {
 721    if (!ep) return EMBRYO_ERROR_NONE;
 722    return ep->error;
 723 }
 724
 725 /**
 726  * @defgroup Embryo_Program_Data_Group Program Data Functions
 727  *
 728  * Functions that set and retrieve data associated with the given
 729  * program.
 730  */
 731
 732 /**
 733  * Sets the data associated to the given program.
 734  * @param   ep   The given program.
 735  * @param   data New bytecode data.
 736  * @ingroup Embryo_Program_Data_Group
 737  */
 738 EAPI void
 739 embryo_program_data_set(Embryo_Program *ep, void *data)
 740 {
 741    if (!ep) return;
 742    ep->data = data;
 743 }
 744
 745 /**
 746  * Retrieves the data associated to the given program.
 747  * @param   ep The given program.
 748  * @ingroup Embryo_Program_Data_Group
 749  */
 750 EAPI void *
 751 embryo_program_data_get(Embryo_Program *ep)
 752 {
 753    if (!ep) return NULL;
 754    return ep->data;
 755 }
 756
 757 /**
 758  * Retrieves a string describing the given error code.
 759  * @param   error The given error code.
 760  * @return  String describing the given error code.  If the given code is not
 761  *          known, the string "(unknown)" is returned.
 762  * @ingroup Embryo_Error_Group
 763  */
 764 EAPI const char *
 765 embryo_error_string_get(int error)
 766 {
 767    const char *messages[] =
 768      {
 769         /* EMBRYO_ERROR_NONE      */ "(none)",
 770           /* EMBRYO_ERROR_EXIT      */ "Forced exit",
 771           /* EMBRYO_ERROR_ASSERT    */ "Assertion failed",
 772           /* EMBRYO_ERROR_STACKERR  */ "Stack/heap collision (insufficient stack size)",
 773           /* EMBRYO_ERROR_BOUNDS    */ "Array index out of bounds",
 774           /* EMBRYO_ERROR_MEMACCESS */ "Invalid memory access",
 775           /* EMBRYO_ERROR_INVINSTR  */ "Invalid instruction",
 776           /* EMBRYO_ERROR_STACKLOW  */ "Stack underflow",
 777           /* EMBRYO_ERROR_HEAPLOW   */ "Heap underflow",
 778           /* EMBRYO_ERROR_CALLBACK  */ "No (valid) native function callback",
 779           /* EMBRYO_ERROR_NATIVE    */ "Native function failed",
 780           /* EMBRYO_ERROR_DIVIDE    */ "Divide by zero",
 781           /* EMBRYO_ERROR_SLEEP     */ "(sleep mode)",
 782           /* 13 */                     "(reserved)",
 783           /* 14 */                     "(reserved)",
 784           /* 15 */                     "(reserved)",
 785           /* EMBRYO_ERROR_MEMORY    */ "Out of memory",
 786           /* EMBRYO_ERROR_FORMAT    */ "Invalid/unsupported P-code file format",
 787           /* EMBRYO_ERROR_VERSION   */ "File is for a newer version of the Embryo_Program",
 788           /* EMBRYO_ERROR_NOTFOUND  */ "Native/Public function is not found",
 789           /* EMBRYO_ERROR_INDEX     */ "Invalid index parameter (bad entry point)",
 790           /* EMBRYO_ERROR_DEBUG     */ "Debugger cannot run",
 791           /* EMBRYO_ERROR_INIT      */ "Embryo_Program not initialized (or doubly initialized)",
 792           /* EMBRYO_ERROR_USERDATA  */ "Unable to set user data field (table full)",
 793           /* EMBRYO_ERROR_INIT_JIT  */ "Cannot initialize the JIT",
 794           /* EMBRYO_ERROR_PARAMS    */ "Parameter error",
 795      };
 796    if ((error < 0) || (error >= (int)(sizeof(messages) / sizeof(messages[0]))))
 797      return (const char *)"(unknown)";
 798    return messages[error];
 799 }
 800
 801 /**
 802  * @defgroup Embryo_Data_String_Group Embryo Data String Functions
 803  *
 804  * Functions that operate on strings in the memory of a virtual machine.
 805  */
 806
 807 /**
 808  * Retrieves the length of the string starting at the given cell.
 809  * @param   ep       The program the cell is part of.
 810  * @param   str_cell Pointer to the first cell of the string.
 811  * @return  The length of the string.  @c 0 is returned if there is an error.
 812  * @ingroup Embryo_Data_String_Group
 813  */
 814 EAPI int
 815 embryo_data_string_length_get(Embryo_Program *ep, Embryo_Cell *str_cell)
 816 {
 817    int            len;
 818    Embryo_Header *hdr;
 819
 820    if ((!ep) || (!ep->base)) return 0;
 821    hdr = (Embryo_Header *)ep->base;
 822    if ((!str_cell) ||
 823        ((void *)str_cell >= (void *)(ep->base + hdr->stp)) ||
 824        ((void *)str_cell < (void *)ep->base))
 825      return 0;
 826    for (len = 0; str_cell[len] != 0; len++);
 827    return len;
 828 }
 829
 830 /**
 831  * Copies the string starting at the given cell to the given buffer.
 832  * @param   ep       The program the cell is part of.
 833  * @param   str_cell Pointer to the first cell of the string.
 834  * @param   dst      The given buffer.
 835  * @ingroup Embryo_Data_String_Group
 836  */
 837 EAPI void
 838 embryo_data_string_get(Embryo_Program *ep, Embryo_Cell *str_cell, char *dst)
 839 {
 840    int            i;
 841    Embryo_Header *hdr;
 842
 843    if (!dst) return;
 844    if ((!ep) || (!ep->base))
 845      {
 846         dst[0] = 0;
 847         return;
 848      }
 849    hdr = (Embryo_Header *)ep->base;
 850    if ((!str_cell) ||
 851        ((void *)str_cell >= (void *)(ep->base + hdr->stp)) ||
 852        ((void *)str_cell < (void *)ep->base))
 853      {
 854         dst[0] = 0;
 855         return;
 856      }
 857    for (i = 0; str_cell[i] != 0; i++)
 858      {
 859 #ifdef WORDS_BIGENDIAN
 860           {
 861              Embryo_Cell tmp;
 862
 863              tmp = str_cell[i];
 864              _embryo_byte_swap_32(&tmp);
 865              dst[i] = tmp;
 866           }
 867 #else
 868         dst[i] = str_cell[i];
 869 #endif
 870      }
 871    dst[i] = 0;
 872 }
 873
 874 /**
 875  * Copies string in the given buffer into the virtual machine memory
 876  * starting at the given cell.
 877  * @param ep       The program the cell is part of.
 878  * @param src      The given buffer.
 879  * @param str_cell Pointer to the first cell to copy the string to.
 880  * @ingroup Embryo_Data_String_Group
 881  */
 882 EAPI void
 883 embryo_data_string_set(Embryo_Program *ep, const char *src, Embryo_Cell *str_cell)
 884 {
 885    int            i;
 886    Embryo_Header *hdr;
 887
 888    if (!ep) return;
 889    if (!ep->base) return;
 890    hdr = (Embryo_Header *)ep->base;
 891    if ((!str_cell) ||
 892        ((void *)str_cell >= (void *)(ep->base + hdr->stp)) ||
 893        ((void *)str_cell < (void *)ep->base))
 894      return;
 895    if (!src)
 896      {
 897         str_cell[0] = 0;
 898         return;
 899      }
 900    for (i = 0; src[i] != 0; i++)
 901      {
 902         if ((void *)(&(str_cell[i])) >= (void *)(ep->base + hdr->stp)) return;
 903         else if ((void *)(&(str_cell[i])) == (void *)(ep->base + hdr->stp - 1))
 904           {
 905              str_cell[i] = 0;
 906              return;
 907           }
 908 #ifdef WORDS_BIGENDIAN
 909           {
 910              Embryo_Cell tmp;
 911
 912              tmp = src[i];
 913              _embryo_byte_swap_32(&tmp);
 914              str_cell[i] = tmp;
 915           }
 916 #else
 917         str_cell[i] = src[i];
 918 #endif
 919      }
 920    str_cell[i] = 0;
 921 }
 922
 923 /**
 924  * Retreives a pointer to the address in the virtual machine given by the
 925  * given cell.
 926  * @param   ep   The program whose virtual machine address is being queried.
 927  * @param   addr The given cell.
 928  * @return  A pointer to the cell at the given address.
 929  * @ingroup Embryo_Data_String_Group
 930  */
 931 EAPI Embryo_Cell *
 932 embryo_data_address_get(Embryo_Program *ep, Embryo_Cell addr)
 933 {
 934    Embryo_Header *hdr;
 935    unsigned char *data;
 936
 937    if ((!ep) || (!ep->base)) return NULL;
 938    hdr = (Embryo_Header *)ep->base;
 939    data = ep->base + (int)hdr->dat;
 940    if ((addr < 0) || (addr >= hdr->stp)) return NULL;
 941    return (Embryo_Cell *)(data + (int)addr);
 942 }
 943
 944 /**
 945  * @defgroup Embryo_Heap_Group Heap Functions
 946  *
 947  * The heap is an area of memory that can be allocated for program
 948  * use at runtime.  The heap functions here change the amount of heap
 949  * memory available.
 950  */
 951
 952 /**
 953  * Increases the size of the heap of the given virtual machine by the given
 954  * number of Embryo_Cells.
 955  * @param   ep    The program with the given virtual machine.
 956  * @param   cells The given number of Embryo_Cells.
 957  * @return  The address of the new memory region on success.
 958  *          @c EMBRYO_CELL_NONE otherwise.
 959  * @ingroup Embryo_Heap_Group
 960  */
 961 EAPI Embryo_Cell
 962 embryo_data_heap_push(Embryo_Program *ep, int cells)
 963 {
 964    Embryo_Header *hdr;
 965    Embryo_Cell    addr;
 966
 967    if ((!ep) || (!ep->base)) return EMBRYO_CELL_NONE;
 968    hdr = (Embryo_Header *)ep->base;
 969    if (ep->stk - ep->hea - (cells * sizeof(Embryo_Cell)) < STKMARGIN)
 970      return EMBRYO_CELL_NONE;
 971    addr = ep->hea;
 972    ep->hea += (cells * sizeof(Embryo_Cell));
 973    return addr;
 974 }
 975
 976 /**
 977  * Decreases the size of the heap of the given virtual machine down to the
 978  * given size.
 979  * @param   ep      The program with the given virtual machine.
 980  * @param   down_to The given size.
 981  * @ingroup Embryo_Heap_Group
 982  */
 983 EAPI void
 984 embryo_data_heap_pop(Embryo_Program *ep, Embryo_Cell down_to)
 985 {
 986    if (!ep) return;
 987    if (down_to < 0) down_to = 0;
 988    if (ep->hea > down_to) ep->hea = down_to;
 989 }
 990
 991 /**
 992  * @defgroup Embryo_Run_Group Program Run Functions
 993  *
 994  * Functions that are involved in actually running functions in an
 995  * Embryo program.
 996  */
 997
 998 /**
 999  * Returns the number of virtual machines are running for the given program.
1000  * @param   ep The given program.
1001  * @return  The number of virtual machines running.
1002  * @ingroup Embryo_Run_Group
1003  */
1004 EAPI int
1005 embryo_program_recursion_get(Embryo_Program *ep)
1006 {
1007    return ep->run_count;
1008 }
1009
1010 #ifdef __GNUC__
1011 #if 1
1012 #define EMBRYO_EXEC_JUMPTABLE
1013 #endif
1014 #endif
1015
1016 /* jump table optimization - only works for gcc though */
1017 #ifdef EMBRYO_EXEC_JUMPTABLE
1018 #define SWITCH(x) while (1) { goto *switchtable[x];
1019 #define SWITCHEND break; }
1020 #define CASE(x) SWITCHTABLE_##x:
1021 #define BREAK break;
1022 #else
1023 #define SWITCH(x) switch (x) {
1024 #define SWITCHEND }
1025 #define CASE(x) case x:
1026 #define BREAK break
1027 #endif
1028
1029 /**
1030  * Runs the given function of the given Embryo program in the current
1031  * virtual machine.  The parameter @p fn can be found using
1032  * @ref embryo_program_function_find.
1033  *
1034  * @note For Embryo to be able to run a function, it must have been
1035  *       declared @c public in the Small source code.
1036  *
1037  * @param   ep The given program.
1038  * @param   fn The given function.  Normally "main", in which case the
1039  *             constant @c EMBRYO_FUNCTION_MAIN can be used.
1040  * @return  @c EMBRYO_PROGRAM_OK on success.  @c EMBRYO_PROGRAM_SLEEP if the
1041  *          program is halted by the Small @c sleep call.
1042  *          @c EMBRYO_PROGRAM_FAIL if there is an error.
1043  *          @c EMBRYO_PROGRAM_TOOLONG if the program executes for longer than
1044  *          it is allowed to in abstract machine instruction count.
1045  * @ingroup Embryo_Run_Group
1046  */
1047 EAPI int
1048 embryo_program_run(Embryo_Program *ep, Embryo_Function fn)
1049 {
1050    Embryo_Header    *hdr;
1051    Embryo_Func_Stub *func;
1052    unsigned char    *code, *data;
1053    Embryo_Cell      pri, alt, stk, frm, hea, hea_start;
1054    Embryo_Cell      reset_stk, reset_hea, *cip;
1055    Embryo_UCell     codesize;
1056    int              i;
1057    unsigned char    op;
1058    Embryo_Cell      offs;
1059    int              num;
1060    int              max_run_cycles;
1061    int              cycle_count;
1062 #ifdef EMBRYO_EXEC_JUMPTABLE
1063    /* we limit the jumptable to 256 elements. why? above we forced "op" to be
1064     * a unsigned char - that means 256 max values. we limit opcode overflow
1065     * here, so eliminating crashes on table lookups with bad/corrupt bytecode.
1066     * no need to atuall do compares, branches etc. the datatype does the work
1067     * for us. so that means EXCESS elements are all declared as OP_NONE to
1068     * keep them innocuous.
1069     */
1070    static const void *switchtable[256] =
1071      {
1072            &&SWITCHTABLE_EMBRYO_OP_NONE,
1073                &&SWITCHTABLE_EMBRYO_OP_LOAD_PRI,
1074                &&SWITCHTABLE_EMBRYO_OP_LOAD_ALT,
1075                &&SWITCHTABLE_EMBRYO_OP_LOAD_S_PRI,
1076                &&SWITCHTABLE_EMBRYO_OP_LOAD_S_ALT,
1077                &&SWITCHTABLE_EMBRYO_OP_LREF_PRI,
1078                &&SWITCHTABLE_EMBRYO_OP_LREF_ALT,
1079                &&SWITCHTABLE_EMBRYO_OP_LREF_S_PRI,
1080                &&SWITCHTABLE_EMBRYO_OP_LREF_S_ALT,
1081                &&SWITCHTABLE_EMBRYO_OP_LOAD_I,
1082                &&SWITCHTABLE_EMBRYO_OP_LODB_I,
1083                &&SWITCHTABLE_EMBRYO_OP_CONST_PRI,
1084                &&SWITCHTABLE_EMBRYO_OP_CONST_ALT,
1085                &&SWITCHTABLE_EMBRYO_OP_ADDR_PRI,
1086                &&SWITCHTABLE_EMBRYO_OP_ADDR_ALT,
1087                &&SWITCHTABLE_EMBRYO_OP_STOR_PRI,
1088                &&SWITCHTABLE_EMBRYO_OP_STOR_ALT,
1089                &&SWITCHTABLE_EMBRYO_OP_STOR_S_PRI,
1090                &&SWITCHTABLE_EMBRYO_OP_STOR_S_ALT,
1091                &&SWITCHTABLE_EMBRYO_OP_SREF_PRI,
1092                &&SWITCHTABLE_EMBRYO_OP_SREF_ALT,
1093                &&SWITCHTABLE_EMBRYO_OP_SREF_S_PRI,
1094                &&SWITCHTABLE_EMBRYO_OP_SREF_S_ALT,
1095                &&SWITCHTABLE_EMBRYO_OP_STOR_I,
1096                &&SWITCHTABLE_EMBRYO_OP_STRB_I,
1097                &&SWITCHTABLE_EMBRYO_OP_LIDX,
1098                &&SWITCHTABLE_EMBRYO_OP_LIDX_B,
1099                &&SWITCHTABLE_EMBRYO_OP_IDXADDR,
1100                &&SWITCHTABLE_EMBRYO_OP_IDXADDR_B,
1101                &&SWITCHTABLE_EMBRYO_OP_ALIGN_PRI,
1102                &&SWITCHTABLE_EMBRYO_OP_ALIGN_ALT,
1103                &&SWITCHTABLE_EMBRYO_OP_LCTRL,
1104                &&SWITCHTABLE_EMBRYO_OP_SCTRL,
1105                &&SWITCHTABLE_EMBRYO_OP_MOVE_PRI,
1106                &&SWITCHTABLE_EMBRYO_OP_MOVE_ALT,
1107                &&SWITCHTABLE_EMBRYO_OP_XCHG,
1108                &&SWITCHTABLE_EMBRYO_OP_PUSH_PRI,
1109                &&SWITCHTABLE_EMBRYO_OP_PUSH_ALT,
1110                &&SWITCHTABLE_EMBRYO_OP_PUSH_R,
1111                &&SWITCHTABLE_EMBRYO_OP_PUSH_C,
1112                &&SWITCHTABLE_EMBRYO_OP_PUSH,
1113                &&SWITCHTABLE_EMBRYO_OP_PUSH_S,
1114                &&SWITCHTABLE_EMBRYO_OP_POP_PRI,
1115                &&SWITCHTABLE_EMBRYO_OP_POP_ALT,
1116                &&SWITCHTABLE_EMBRYO_OP_STACK,
1117                &&SWITCHTABLE_EMBRYO_OP_HEAP,
1118                &&SWITCHTABLE_EMBRYO_OP_PROC,
1119                &&SWITCHTABLE_EMBRYO_OP_RET,
1120                &&SWITCHTABLE_EMBRYO_OP_RETN,
1121                &&SWITCHTABLE_EMBRYO_OP_CALL,
1122                &&SWITCHTABLE_EMBRYO_OP_CALL_PRI,
1123                &&SWITCHTABLE_EMBRYO_OP_JUMP,
1124                &&SWITCHTABLE_EMBRYO_OP_JREL,
1125                &&SWITCHTABLE_EMBRYO_OP_JZER,
1126                &&SWITCHTABLE_EMBRYO_OP_JNZ,
1127                &&SWITCHTABLE_EMBRYO_OP_JEQ,
1128                &&SWITCHTABLE_EMBRYO_OP_JNEQ,
1129                &&SWITCHTABLE_EMBRYO_OP_JLESS,
1130                &&SWITCHTABLE_EMBRYO_OP_JLEQ,
1131                &&SWITCHTABLE_EMBRYO_OP_JGRTR,
1132                &&SWITCHTABLE_EMBRYO_OP_JGEQ,
1133                &&SWITCHTABLE_EMBRYO_OP_JSLESS,
1134                &&SWITCHTABLE_EMBRYO_OP_JSLEQ,
1135                &&SWITCHTABLE_EMBRYO_OP_JSGRTR,
1136                &&SWITCHTABLE_EMBRYO_OP_JSGEQ,
1137                &&SWITCHTABLE_EMBRYO_OP_SHL,
1138                &&SWITCHTABLE_EMBRYO_OP_SHR,
1139                &&SWITCHTABLE_EMBRYO_OP_SSHR,
1140                &&SWITCHTABLE_EMBRYO_OP_SHL_C_PRI,
1141                &&SWITCHTABLE_EMBRYO_OP_SHL_C_ALT,
1142                &&SWITCHTABLE_EMBRYO_OP_SHR_C_PRI,
1143                &&SWITCHTABLE_EMBRYO_OP_SHR_C_ALT,
1144                &&SWITCHTABLE_EMBRYO_OP_SMUL,
1145                &&SWITCHTABLE_EMBRYO_OP_SDIV,
1146                &&SWITCHTABLE_EMBRYO_OP_SDIV_ALT,
1147                &&SWITCHTABLE_EMBRYO_OP_UMUL,
1148                &&SWITCHTABLE_EMBRYO_OP_UDIV,
1149                &&SWITCHTABLE_EMBRYO_OP_UDIV_ALT,
1150                &&SWITCHTABLE_EMBRYO_OP_ADD,
1151                &&SWITCHTABLE_EMBRYO_OP_SUB,
1152                &&SWITCHTABLE_EMBRYO_OP_SUB_ALT,
1153                &&SWITCHTABLE_EMBRYO_OP_AND,
1154                &&SWITCHTABLE_EMBRYO_OP_OR,
1155                &&SWITCHTABLE_EMBRYO_OP_XOR,
1156                &&SWITCHTABLE_EMBRYO_OP_NOT,
1157                &&SWITCHTABLE_EMBRYO_OP_NEG,
1158                &&SWITCHTABLE_EMBRYO_OP_INVERT,
1159                &&SWITCHTABLE_EMBRYO_OP_ADD_C,
1160                &&SWITCHTABLE_EMBRYO_OP_SMUL_C,
1161                &&SWITCHTABLE_EMBRYO_OP_ZERO_PRI,
1162                &&SWITCHTABLE_EMBRYO_OP_ZERO_ALT,
1163                &&SWITCHTABLE_EMBRYO_OP_ZERO,
1164                &&SWITCHTABLE_EMBRYO_OP_ZERO_S,
1165                &&SWITCHTABLE_EMBRYO_OP_SIGN_PRI,
1166                &&SWITCHTABLE_EMBRYO_OP_SIGN_ALT,
1167                &&SWITCHTABLE_EMBRYO_OP_EQ,
1168                &&SWITCHTABLE_EMBRYO_OP_NEQ,
1169                &&SWITCHTABLE_EMBRYO_OP_LESS,
1170                &&SWITCHTABLE_EMBRYO_OP_LEQ,
1171                &&SWITCHTABLE_EMBRYO_OP_GRTR,
1172                &&SWITCHTABLE_EMBRYO_OP_GEQ,
1173                &&SWITCHTABLE_EMBRYO_OP_SLESS,
1174                &&SWITCHTABLE_EMBRYO_OP_SLEQ,
1175                &&SWITCHTABLE_EMBRYO_OP_SGRTR,
1176                &&SWITCHTABLE_EMBRYO_OP_SGEQ,
1177                &&SWITCHTABLE_EMBRYO_OP_EQ_C_PRI,
1178                &&SWITCHTABLE_EMBRYO_OP_EQ_C_ALT,
1179                &&SWITCHTABLE_EMBRYO_OP_INC_PRI,
1180                &&SWITCHTABLE_EMBRYO_OP_INC_ALT,
1181                &&SWITCHTABLE_EMBRYO_OP_INC,
1182                &&SWITCHTABLE_EMBRYO_OP_INC_S,
1183                &&SWITCHTABLE_EMBRYO_OP_INC_I,
1184                &&SWITCHTABLE_EMBRYO_OP_DEC_PRI,
1185                &&SWITCHTABLE_EMBRYO_OP_DEC_ALT,
1186                &&SWITCHTABLE_EMBRYO_OP_DEC,
1187                &&SWITCHTABLE_EMBRYO_OP_DEC_S,
1188                &&SWITCHTABLE_EMBRYO_OP_DEC_I,
1189                &&SWITCHTABLE_EMBRYO_OP_MOVS,
1190                &&SWITCHTABLE_EMBRYO_OP_CMPS,
1191                &&SWITCHTABLE_EMBRYO_OP_FILL,
1192                &&SWITCHTABLE_EMBRYO_OP_HALT,
1193                &&SWITCHTABLE_EMBRYO_OP_BOUNDS,
1194                &&SWITCHTABLE_EMBRYO_OP_SYSREQ_PRI,
1195                &&SWITCHTABLE_EMBRYO_OP_SYSREQ_C,
1196                &&SWITCHTABLE_EMBRYO_OP_FILE,
1197                &&SWITCHTABLE_EMBRYO_OP_LINE,
1198                &&SWITCHTABLE_EMBRYO_OP_SYMBOL,
1199                &&SWITCHTABLE_EMBRYO_OP_SRANGE,
1200                &&SWITCHTABLE_EMBRYO_OP_JUMP_PRI,
1201                &&SWITCHTABLE_EMBRYO_OP_SWITCH,
1202                &&SWITCHTABLE_EMBRYO_OP_CASETBL,
1203                &&SWITCHTABLE_EMBRYO_OP_SWAP_PRI,
1204                &&SWITCHTABLE_EMBRYO_OP_SWAP_ALT,
1205                &&SWITCHTABLE_EMBRYO_OP_PUSHADDR,
1206                &&SWITCHTABLE_EMBRYO_OP_NOP,
1207                &&SWITCHTABLE_EMBRYO_OP_SYSREQ_D,
1208                &&SWITCHTABLE_EMBRYO_OP_SYMTAG,
1209           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1210           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1211           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1212           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1213           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1214           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1215           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1216           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1217           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1218           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1219           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1220           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1221           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1222           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1223           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1224           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1225           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1226           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1227           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1228           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1229           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1230           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1231           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
1232           &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE
1233      };
1234 #endif
1235    if (!ep) return EMBRYO_PROGRAM_FAIL;
1236    if (!(ep->flags & EMBRYO_FLAG_RELOC))
1237      {
1238         ep->error = EMBRYO_ERROR_INIT;
1239         return EMBRYO_PROGRAM_FAIL;
1240      }
1241    if (!ep->base)
1242      {
1243         ep->error = EMBRYO_ERROR_INIT;
1244         return EMBRYO_PROGRAM_FAIL;
1245      }
1246    if (ep->run_count > 0)
1247      {
1248         /* return EMBRYO_PROGRAM_BUSY; */
1249         /* FIXME: test C->vm->C->vm recursion more fully */
1250         /* it seems to work... just fine!!! - strange! */
1251      }
1252
1253    /* set up the registers */
1254    hdr = (Embryo_Header *)ep->base;
1255    codesize = (Embryo_UCell)(hdr->dat - hdr->cod);
1256    code = ep->base + (int)hdr->cod;
1257    data = ep->base + (int)hdr->dat;
1258    hea_start = hea = ep->hea;
1259    stk = ep->stk;
1260    reset_stk = stk;
1261    reset_hea = hea;
1262    frm = alt = pri = 0;
1263
1264    /* get the start address */
1265    if (fn == EMBRYO_FUNCTION_MAIN)
1266      {
1267         if (hdr->cip < 0)
1268           {
1269              ep->error = EMBRYO_ERROR_INDEX;
1270              return EMBRYO_PROGRAM_FAIL;
1271           }
1272         cip = (Embryo_Cell *)(code + (int)hdr->cip);
1273      }
1274    else if (fn == EMBRYO_FUNCTION_CONT)
1275      {
1276         /* all registers: pri, alt, frm, cip, hea, stk, reset_stk, reset_hea */
1277         frm = ep->frm;
1278         stk = ep->stk;
1279         hea = ep->hea;
1280         pri = ep->pri;
1281         alt = ep->alt;
1282         reset_stk = ep->reset_stk;
1283         reset_hea = ep->reset_hea;
1284         cip = (Embryo_Cell *)(code + (int)ep->cip);
1285      }
1286    else if (fn < 0)
1287      {
1288         ep->error = EMBRYO_ERROR_INDEX;
1289         return EMBRYO_PROGRAM_FAIL;
1290      }
1291    else
1292      {
1293         if (fn >= (Embryo_Cell)NUMENTRIES(hdr, publics, natives))
1294           {
1295              ep->error = EMBRYO_ERROR_INDEX;
1296              return EMBRYO_PROGRAM_FAIL;
1297           }
1298         func = GETENTRY(hdr, publics, fn);
1299         cip = (Embryo_Cell *)(code + (int)func->address);
1300      }
1301    /* check values just copied */
1302    CHKSTACK();
1303    CHKHEAP();
1304
1305    if (fn != EMBRYO_FUNCTION_CONT)
1306      {
1307         int i;
1308
1309         for (i = ep->params_size - 1; i >= 0; i--)
1310           {
1311              Embryo_Param *pr;
1312
1313              pr = &(ep->params[i]);
1314              if (pr->string)
1315                {
1316                   int len;
1317                   Embryo_Cell ep_addr, *addr;
1318
1319                   len = strlen(pr->string);
1320                   ep_addr = embryo_data_heap_push(ep, len + 1);
1321                   if (ep_addr == EMBRYO_CELL_NONE)
1322                     {
1323                        ep->error = EMBRYO_ERROR_HEAPLOW;
1324                        return EMBRYO_PROGRAM_FAIL;
1325                     }
1326                   addr = embryo_data_address_get(ep, ep_addr);
1327                   if (addr)
1328                     embryo_data_string_set(ep, pr->string, addr);
1329                   else
1330                     {
1331                        ep->error = EMBRYO_ERROR_HEAPLOW;
1332                        return EMBRYO_PROGRAM_FAIL;
1333                     }
1334                   PUSH(ep_addr);
1335                   free(pr->string);
1336                }
1337              else if (pr->cell_array)
1338                {
1339                   int len;
1340                   Embryo_Cell ep_addr, *addr;
1341
1342                   len = pr->cell_array_size;
1343                   ep_addr = embryo_data_heap_push(ep, len + 1);
1344                   if (ep_addr == EMBRYO_CELL_NONE)
1345                     {
1346                        ep->error = EMBRYO_ERROR_HEAPLOW;
1347                        return EMBRYO_PROGRAM_FAIL;
1348                     }
1349                   addr = embryo_data_address_get(ep, ep_addr);
1350                   if (addr)
1351                     memcpy(addr, pr->cell_array,
1352                            pr->cell_array_size * sizeof(Embryo_Cell));
1353                   else
1354                     {
1355                        ep->error = EMBRYO_ERROR_HEAPLOW;
1356                        return EMBRYO_PROGRAM_FAIL;
1357                     }
1358                   PUSH(ep_addr);
1359                   free(pr->cell_array);
1360                }
1361              else
1362                {
1363                   PUSH(pr->cell);
1364                }
1365           }
1366         PUSH(ep->params_size * sizeof(Embryo_Cell));
1367         PUSH(0);
1368         if (ep->params)
1369           {
1370              free(ep->params);
1371              ep->params = NULL;
1372           }
1373         ep->params_size = ep->params_alloc = 0;
1374      }
1375    /* check stack/heap before starting to run */
1376    CHKMARGIN();
1377
1378    /* track recursion depth */
1379    ep->run_count++;
1380
1381    max_run_cycles = ep->max_run_cycles;
1382    /* start running */
1383    for (cycle_count = 0;;)
1384      {
1385         if (max_run_cycles > 0)
1386           {
1387              if (cycle_count >= max_run_cycles)
1388                {
1389                   TOOLONG(ep);
1390                }
1391              cycle_count++;
1392           }
1393         op = (Embryo_Opcode)*cip++;
1394         SWITCH(op);
1395         CASE(EMBRYO_OP_LOAD_PRI);
1396         GETPARAM(offs);
1397         pri = *(Embryo_Cell *)(data + (int)offs);
1398         BREAK;
1399         CASE(EMBRYO_OP_LOAD_ALT);
1400         GETPARAM(offs);
1401         alt = *(Embryo_Cell *)(data + (int)offs);
1402         BREAK;
1403         CASE(EMBRYO_OP_LOAD_S_PRI);
1404         GETPARAM(offs);
1405         pri = *(Embryo_Cell *)(data + (int)frm + (int)offs);
1406         BREAK;
1407         CASE(EMBRYO_OP_LOAD_S_ALT);
1408         GETPARAM(offs);
1409         alt = *(Embryo_Cell *)(data + (int)frm + (int)offs);
1410         BREAK;
1411         CASE(EMBRYO_OP_LREF_PRI);
1412         GETPARAM(offs);
1413         offs = *(Embryo_Cell *)(data + (int)offs);
1414         pri = *(Embryo_Cell *)(data + (int)offs);
1415         BREAK;
1416         CASE(EMBRYO_OP_LREF_ALT);
1417         GETPARAM(offs);
1418         offs = *(Embryo_Cell *)(data + (int)offs);
1419         alt = *(Embryo_Cell *)(data + (int)offs);
1420         BREAK;
1421         CASE(EMBRYO_OP_LREF_S_PRI);
1422         GETPARAM(offs);
1423         offs = *(Embryo_Cell *)(data + (int)frm + (int)offs);
1424         pri = *(Embryo_Cell *)(data + (int)offs);
1425         BREAK;
1426         CASE(EMBRYO_OP_LREF_S_ALT);
1427         GETPARAM(offs);
1428         offs = *(Embryo_Cell *)(data + (int)frm + (int)offs);
1429         alt = *(Embryo_Cell *)(data + (int)offs);
1430         BREAK;
1431         CASE(EMBRYO_OP_LOAD_I);
1432         CHKMEM(pri);
1433         pri = *(Embryo_Cell *)(data + (int)pri);
1434         BREAK;
1435         CASE(EMBRYO_OP_LODB_I);
1436         GETPARAM(offs);
1437         CHKMEM(pri);
1438         switch (offs)
1439           {
1440            case 1:
1441              pri = *(data + (int)pri);
1442              break;
1443            case 2:
1444              pri = *(unsigned short *)(data + (int)pri);
1445              break;
1446            case 4:
1447              pri = *(unsigned int *)(data + (int)pri);
1448              break;
1449            default:
1450              ABORT(ep, EMBRYO_ERROR_INVINSTR);
1451              break;
1452           }
1453         BREAK;
1454         CASE(EMBRYO_OP_CONST_PRI);
1455         GETPARAM(pri);
1456         BREAK;
1457         CASE(EMBRYO_OP_CONST_ALT);
1458         GETPARAM(alt);
1459         BREAK;
1460         CASE(EMBRYO_OP_ADDR_PRI);
1461         GETPARAM(pri);
1462         pri += frm;
1463         BREAK;
1464         CASE(EMBRYO_OP_ADDR_ALT);
1465         GETPARAM(alt);
1466         alt += frm;
1467         BREAK;
1468         CASE(EMBRYO_OP_STOR_PRI);
1469         GETPARAM(offs);
1470         *(Embryo_Cell *)(data + (int)offs) = pri;
1471         BREAK;
1472         CASE(EMBRYO_OP_STOR_ALT);
1473         GETPARAM(offs);
1474         *(Embryo_Cell *)(data + (int)offs) = alt;
1475         BREAK;
1476         CASE(EMBRYO_OP_STOR_S_PRI);
1477         GETPARAM(offs);
1478         *(Embryo_Cell *)(data + (int)frm + (int)offs) = pri;
1479         BREAK;
1480         CASE(EMBRYO_OP_STOR_S_ALT);
1481         GETPARAM(offs);
1482         *(Embryo_Cell *)(data + (int)frm + (int)offs) = alt;
1483         BREAK;
1484         CASE(EMBRYO_OP_SREF_PRI);
1485         GETPARAM(offs);
1486         offs = *(Embryo_Cell *)(data + (int)offs);
1487         *(Embryo_Cell *)(data + (int)offs) = pri;
1488         BREAK;
1489         CASE(EMBRYO_OP_SREF_ALT);
1490         GETPARAM(offs);
1491         offs = *(Embryo_Cell *)(data + (int)offs);
1492         *(Embryo_Cell *)(data + (int)offs) = alt;
1493         BREAK;
1494         CASE(EMBRYO_OP_SREF_S_PRI);
1495         GETPARAM(offs);
1496         offs = *(Embryo_Cell *)(data + (int)frm + (int)offs);
1497         *(Embryo_Cell *)(data + (int)offs) = pri;
1498         BREAK;
1499         CASE(EMBRYO_OP_SREF_S_ALT);
1500         GETPARAM(offs);
1501         offs = *(Embryo_Cell *)(data + (int)frm + (int)offs);
1502         *(Embryo_Cell *)(data + (int)offs) = alt;
1503         BREAK;
1504         CASE(EMBRYO_OP_STOR_I);
1505         CHKMEM(alt);
1506         *(Embryo_Cell *)(data + (int)alt) = pri;
1507         BREAK;
1508         CASE(EMBRYO_OP_STRB_I);
1509         GETPARAM(offs);
1510         CHKMEM(alt);
1511         switch (offs)
1512           {
1513            case 1:
1514              *(data + (int)alt) = (unsigned char)pri;
1515              break;
1516            case 2:
1517              *(unsigned short *)(data + (int)alt) = (unsigned short)pri;
1518              break;
1519            case 4:
1520              *(unsigned int *)(data + (int)alt) = (unsigned int)pri;
1521              break;
1522            default:
1523              ABORT(ep, EMBRYO_ERROR_INVINSTR);
1524              break;
1525           }
1526         BREAK;
1527         CASE(EMBRYO_OP_LIDX);
1528         offs = (pri * sizeof(Embryo_Cell)) + alt;
1529         CHKMEM(offs);
1530         pri = *(Embryo_Cell *)(data + (int)offs);
1531         BREAK;
1532         CASE(EMBRYO_OP_LIDX_B);
1533         GETPARAM(offs);
1534         offs = (pri << (int)offs) + alt;
1535         CHKMEM(offs);
1536         pri = *(Embryo_Cell *)(data + (int)offs);
1537         BREAK;
1538         CASE(EMBRYO_OP_IDXADDR);
1539         pri = (pri * sizeof(Embryo_Cell)) + alt;
1540         BREAK;
1541         CASE(EMBRYO_OP_IDXADDR_B);
1542         GETPARAM(offs);
1543         pri = (pri << (int)offs) + alt;
1544         BREAK;
1545         CASE(EMBRYO_OP_ALIGN_PRI);
1546         GETPARAM(offs);
1547 #ifdef WORDS_BIGENDIAN
1548         if ((size_t)offs < sizeof(Embryo_Cell))
1549           pri ^= sizeof(Embryo_Cell) - offs;
1550 #endif
1551         BREAK;
1552         CASE(EMBRYO_OP_ALIGN_ALT);
1553         GETPARAM(offs);
1554 #ifdef WORDS_BIGENDIAN
1555         if ((size_t)offs < sizeof(Embryo_Cell))
1556           alt ^= sizeof(Embryo_Cell) - offs;
1557 #endif
1558         BREAK;
1559         CASE(EMBRYO_OP_LCTRL);
1560         GETPARAM(offs);
1561         switch (offs)
1562           {
1563            case 0:
1564              pri = hdr->cod;
1565              break;
1566            case 1:
1567              pri = hdr->dat;
1568              break;
1569            case 2:
1570              pri = hea;
1571              break;
1572            case 3:
1573              pri = ep->stp;
1574              break;
1575            case 4:
1576              pri = stk;
1577              break;
1578            case 5:
1579              pri = frm;
1580              break;
1581            case 6:
1582              pri = (Embryo_Cell)((unsigned char *)cip - code);
1583              break;
1584            default:
1585              ABORT(ep, EMBRYO_ERROR_INVINSTR);
1586              break;
1587           }
1588         BREAK;
1589         CASE(EMBRYO_OP_SCTRL);
1590         GETPARAM(offs);
1591         switch (offs)
1592           {
1593            case 0:
1594            case 1:
1595            case 2:
1596              hea = pri;
1597              break;
1598            case 3:
1599              /* cannot change these parameters */
1600              break;
1601            case 4:
1602              stk = pri;
1603              break;
1604            case 5:
1605              frm = pri;
1606              break;
1607            case 6:
1608              cip = (Embryo_Cell *)(code + (int)pri);
1609              break;
1610            default:
1611              ABORT(ep, EMBRYO_ERROR_INVINSTR);
1612              break;
1613           }
1614         BREAK;
1615         CASE(EMBRYO_OP_MOVE_PRI);
1616         pri = alt;
1617         BREAK;
1618         CASE(EMBRYO_OP_MOVE_ALT);
1619         alt = pri;
1620         BREAK;
1621         CASE(EMBRYO_OP_XCHG);
1622         offs = pri;         /* offs is a temporary variable */
1623         pri = alt;
1624         alt = offs;
1625         BREAK;
1626         CASE(EMBRYO_OP_PUSH_PRI);
1627         PUSH(pri);
1628         BREAK;
1629         CASE(EMBRYO_OP_PUSH_ALT);
1630         PUSH(alt);
1631         BREAK;
1632         CASE(EMBRYO_OP_PUSH_C);
1633         GETPARAM(offs);
1634         PUSH(offs);
1635         BREAK;
1636         CASE(EMBRYO_OP_PUSH_R);
1637         GETPARAM(offs);
1638         while (offs--) PUSH(pri);
1639         BREAK;
1640         CASE(EMBRYO_OP_PUSH);
1641         GETPARAM(offs);
1642         PUSH(*(Embryo_Cell *)(data + (int)offs));
1643         BREAK;
1644         CASE(EMBRYO_OP_PUSH_S);
1645         GETPARAM(offs);
1646         PUSH(*(Embryo_Cell *)(data + (int)frm + (int)offs));
1647         BREAK;
1648         CASE(EMBRYO_OP_POP_PRI);
1649         POP(pri);
1650         BREAK;
1651         CASE(EMBRYO_OP_POP_ALT);
1652         POP(alt);
1653         BREAK;
1654         CASE(EMBRYO_OP_STACK);
1655         GETPARAM(offs);
1656         alt = stk;
1657         stk += offs;
1658         CHKMARGIN();
1659         CHKSTACK();
1660         BREAK;
1661         CASE(EMBRYO_OP_HEAP);
1662         GETPARAM(offs);
1663         alt = hea;
1664         hea += offs;
1665         CHKMARGIN();
1666         CHKHEAP();
1667         BREAK;
1668         CASE(EMBRYO_OP_PROC);
1669         PUSH(frm);
1670         frm = stk;
1671         CHKMARGIN();
1672         BREAK;
1673         CASE(EMBRYO_OP_RET);
1674         POP(frm);
1675         POP(offs);
1676         if ((Embryo_UCell)offs >= codesize)
1677           ABORT(ep, EMBRYO_ERROR_MEMACCESS);
1678         cip = (Embryo_Cell *)(code + (int)offs);
1679         BREAK;
1680         CASE(EMBRYO_OP_RETN);
1681         POP(frm);
1682         POP(offs);
1683         if ((Embryo_UCell)offs >= codesize)
1684           ABORT(ep, EMBRYO_ERROR_MEMACCESS);
1685         cip = (Embryo_Cell *)(code + (int)offs);
1686         stk += *(Embryo_Cell *)(data + (int)stk) + sizeof(Embryo_Cell); /* remove parameters from the stack */
1687         ep->stk = stk;
1688         BREAK;
1689         CASE(EMBRYO_OP_CALL);
1690         PUSH(((unsigned char *)cip - code) + sizeof(Embryo_Cell));/* skip address */
1691         cip = JUMPABS(code, cip); /* jump to the address */
1692         BREAK;
1693         CASE(EMBRYO_OP_CALL_PRI);
1694         PUSH((unsigned char *)cip - code);
1695         cip = (Embryo_Cell *)(code + (int)pri);
1696         BREAK;
1697         CASE(EMBRYO_OP_JUMP);
1698         /* since the GETPARAM() macro modifies cip, you cannot
1699          * do GETPARAM(cip) directly */
1700         cip = JUMPABS(code, cip);
1701         BREAK;
1702         CASE(EMBRYO_OP_JREL);
1703         offs = *cip;
1704         cip = (Embryo_Cell *)((unsigned char *)cip + (int)offs + sizeof(Embryo_Cell));
1705         BREAK;
1706         CASE(EMBRYO_OP_JZER);
1707         if (pri == 0)
1708           cip = JUMPABS(code, cip);
1709         else
1710           cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1711         BREAK;
1712         CASE(EMBRYO_OP_JNZ);
1713         if (pri != 0)
1714           cip = JUMPABS(code, cip);
1715         else
1716           cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1717         BREAK;
1718         CASE(EMBRYO_OP_JEQ);
1719         if (pri==alt)
1720           cip = JUMPABS(code, cip);
1721         else
1722           cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1723         BREAK;
1724         CASE(EMBRYO_OP_JNEQ);
1725         if (pri != alt)
1726           cip = JUMPABS(code, cip);
1727         else
1728           cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1729         BREAK;
1730         CASE(EMBRYO_OP_JLESS);
1731         if ((Embryo_UCell)pri < (Embryo_UCell)alt)
1732           cip = JUMPABS(code, cip);
1733         else
1734           cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1735         BREAK;
1736         CASE(EMBRYO_OP_JLEQ);
1737         if ((Embryo_UCell)pri <= (Embryo_UCell)alt)
1738           cip = JUMPABS(code, cip);
1739         else
1740           cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1741         BREAK;
1742         CASE(EMBRYO_OP_JGRTR);
1743         if ((Embryo_UCell)pri > (Embryo_UCell)alt)
1744           cip = JUMPABS(code, cip);
1745         else
1746           cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1747         BREAK;
1748         CASE(EMBRYO_OP_JGEQ);
1749         if ((Embryo_UCell)pri >= (Embryo_UCell)alt)
1750           cip = JUMPABS(code, cip);
1751         else
1752           cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1753         BREAK;
1754         CASE(EMBRYO_OP_JSLESS);
1755         if (pri < alt)
1756           cip = JUMPABS(code, cip);
1757         else
1758           cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1759         BREAK;
1760         CASE(EMBRYO_OP_JSLEQ);
1761         if (pri <= alt)
1762           cip = JUMPABS(code, cip);
1763         else
1764           cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1765         BREAK;
1766         CASE(EMBRYO_OP_JSGRTR);
1767         if (pri > alt)
1768           cip = JUMPABS(code, cip);
1769         else
1770           cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1771         BREAK;
1772         CASE(EMBRYO_OP_JSGEQ);
1773         if (pri >= alt)
1774           cip = JUMPABS(code, cip);
1775         else
1776           cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1777         BREAK;
1778         CASE(EMBRYO_OP_SHL);
1779         pri <<= alt;
1780         BREAK;
1781         CASE(EMBRYO_OP_SHR);
1782         pri = (Embryo_UCell)pri >> (int)alt;
1783         BREAK;
1784         CASE(EMBRYO_OP_SSHR);
1785         pri >>= alt;
1786         BREAK;
1787         CASE(EMBRYO_OP_SHL_C_PRI);
1788         GETPARAM(offs);
1789         pri <<= offs;
1790         BREAK;
1791         CASE(EMBRYO_OP_SHL_C_ALT);
1792         GETPARAM(offs);
1793         alt <<= offs;
1794         BREAK;
1795         CASE(EMBRYO_OP_SHR_C_PRI);
1796         GETPARAM(offs);
1797         pri = (Embryo_UCell)pri >> (int)offs;
1798         BREAK;
1799         CASE(EMBRYO_OP_SHR_C_ALT);
1800         GETPARAM(offs);
1801         alt = (Embryo_UCell)alt >> (int)offs;
1802         BREAK;
1803         CASE(EMBRYO_OP_SMUL);
1804         pri *= alt;
1805         BREAK;
1806         CASE(EMBRYO_OP_SDIV);
1807         if (alt == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE);
1808         /* divide must always round down; this is a bit
1809          * involved to do in a machine-independent way.
1810          */
1811         offs = ((pri % alt) + alt) % alt; /* true modulus */
1812         pri = (pri - offs) / alt;         /* division result */
1813         alt = offs;
1814         BREAK;
1815         CASE(EMBRYO_OP_SDIV_ALT);
1816         if (pri == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE);
1817         /* divide must always round down; this is a bit
1818          * involved to do in a machine-independent way.
1819          */
1820         offs = ((alt % pri) + pri) % pri; /* true modulus */
1821         pri = (alt - offs) / pri;         /* division result */
1822         alt = offs;
1823         BREAK;
1824         CASE(EMBRYO_OP_UMUL);
1825         pri = (Embryo_UCell)pri * (Embryo_UCell)alt;
1826         BREAK;
1827         CASE(EMBRYO_OP_UDIV);
1828         if (alt == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE);
1829         offs = (Embryo_UCell)pri % (Embryo_UCell)alt; /* temporary storage */
1830         pri = (Embryo_UCell)pri / (Embryo_UCell)alt;
1831         alt = offs;
1832         BREAK;
1833         CASE(EMBRYO_OP_UDIV_ALT);
1834         if (pri == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE);
1835         offs = (Embryo_UCell)alt % (Embryo_UCell)pri; /* temporary storage */
1836         pri = (Embryo_UCell)alt / (Embryo_UCell)pri;
1837         alt = offs;
1838         BREAK;
1839         CASE(EMBRYO_OP_ADD);
1840         pri += alt;
1841         BREAK;
1842         CASE(EMBRYO_OP_SUB);
1843         pri -= alt;
1844         BREAK;
1845         CASE(EMBRYO_OP_SUB_ALT);
1846         pri = alt - pri;
1847         BREAK;
1848         CASE(EMBRYO_OP_AND);
1849         pri &= alt;
1850         BREAK;
1851         CASE(EMBRYO_OP_OR);
1852         pri |= alt;
1853         BREAK;
1854         CASE(EMBRYO_OP_XOR);
1855         pri ^= alt;
1856         BREAK;
1857         CASE(EMBRYO_OP_NOT);
1858         pri = !pri;
1859         BREAK;
1860         CASE(EMBRYO_OP_NEG);
1861         pri = -pri;
1862         BREAK;
1863         CASE(EMBRYO_OP_INVERT);
1864         pri = ~pri;
1865         BREAK;
1866         CASE(EMBRYO_OP_ADD_C);
1867         GETPARAM(offs);
1868         pri += offs;
1869         BREAK;
1870         CASE(EMBRYO_OP_SMUL_C);
1871         GETPARAM(offs);
1872         pri *= offs;
1873         BREAK;
1874         CASE(EMBRYO_OP_ZERO_PRI);
1875         pri = 0;
1876         BREAK;
1877         CASE(EMBRYO_OP_ZERO_ALT);
1878         alt = 0;
1879         BREAK;
1880         CASE(EMBRYO_OP_ZERO);
1881         GETPARAM(offs);
1882         *(Embryo_Cell *)(data + (int)offs) = 0;
1883         BREAK;
1884         CASE(EMBRYO_OP_ZERO_S);
1885         GETPARAM(offs);
1886         *(Embryo_Cell *)(data + (int)frm + (int)offs) = 0;
1887         BREAK;
1888         CASE(EMBRYO_OP_SIGN_PRI);
1889         if ((pri & 0xff) >= 0x80) pri |= ~(Embryo_UCell)0xff;
1890         BREAK;
1891         CASE(EMBRYO_OP_SIGN_ALT);
1892         if ((alt & 0xff) >= 0x80) alt |= ~(Embryo_UCell)0xff;
1893         BREAK;
1894         CASE(EMBRYO_OP_EQ);
1895         pri = (pri == alt) ? 1 : 0;
1896         BREAK;
1897         CASE(EMBRYO_OP_NEQ);
1898         pri = (pri != alt) ? 1 : 0;
1899         BREAK;
1900         CASE(EMBRYO_OP_LESS);
1901         pri = ((Embryo_UCell)pri < (Embryo_UCell)alt) ? 1 : 0;
1902         BREAK;
1903         CASE(EMBRYO_OP_LEQ);
1904         pri = ((Embryo_UCell)pri <= (Embryo_UCell)alt) ? 1 : 0;
1905         BREAK;
1906         CASE(EMBRYO_OP_GRTR);
1907         pri = ((Embryo_UCell)pri > (Embryo_UCell)alt) ? 1 : 0;
1908         BREAK;
1909         CASE(EMBRYO_OP_GEQ);
1910         pri = ((Embryo_UCell)pri >= (Embryo_UCell)alt) ? 1 : 0;
1911         BREAK;
1912         CASE(EMBRYO_OP_SLESS);
1913         pri = (pri < alt) ? 1 : 0;
1914         BREAK;
1915         CASE(EMBRYO_OP_SLEQ);
1916         pri = (pri <= alt) ? 1 : 0;
1917         BREAK;
1918         CASE(EMBRYO_OP_SGRTR);
1919         pri = (pri > alt) ? 1 : 0;
1920         BREAK;
1921         CASE(EMBRYO_OP_SGEQ);
1922         pri = (pri >= alt) ? 1 : 0;
1923         BREAK;
1924         CASE(EMBRYO_OP_EQ_C_PRI);
1925         GETPARAM(offs);
1926         pri = (pri == offs) ? 1 : 0;
1927         BREAK;
1928         CASE(EMBRYO_OP_EQ_C_ALT);
1929         GETPARAM(offs);
1930         pri = (alt == offs) ? 1 : 0;
1931         BREAK;
1932         CASE(EMBRYO_OP_INC_PRI);
1933         pri++;
1934         BREAK;
1935         CASE(EMBRYO_OP_INC_ALT);
1936         alt++;
1937         BREAK;
1938         CASE(EMBRYO_OP_INC);
1939         GETPARAM(offs);
1940         *(Embryo_Cell *)(data + (int)offs) += 1;
1941         BREAK;
1942         CASE(EMBRYO_OP_INC_S);
1943         GETPARAM(offs);
1944         *(Embryo_Cell *)(data + (int)frm + (int)offs) += 1;
1945         BREAK;
1946         CASE(EMBRYO_OP_INC_I);
1947         *(Embryo_Cell *)(data + (int)pri) += 1;
1948         BREAK;
1949         CASE(EMBRYO_OP_DEC_PRI);
1950         pri--;
1951         BREAK;
1952         CASE(EMBRYO_OP_DEC_ALT);
1953         alt--;
1954         BREAK;
1955         CASE(EMBRYO_OP_DEC);
1956         GETPARAM(offs);
1957         *(Embryo_Cell *)(data + (int)offs) -= 1;
1958         BREAK;
1959         CASE(EMBRYO_OP_DEC_S);
1960         GETPARAM(offs);
1961         *(Embryo_Cell *)(data + (int)frm + (int)offs) -= 1;
1962         BREAK;
1963         CASE(EMBRYO_OP_DEC_I);
1964         *(Embryo_Cell *)(data + (int)pri) -= 1;
1965         BREAK;
1966         CASE(EMBRYO_OP_MOVS);
1967         GETPARAM(offs);
1968         CHKMEM(pri);
1969         CHKMEM(pri + offs);
1970         CHKMEM(alt);
1971         CHKMEM(alt + offs);
1972         memcpy(data+(int)alt, data+(int)pri, (int)offs);
1973         BREAK;
1974         CASE(EMBRYO_OP_CMPS);
1975         GETPARAM(offs);
1976         CHKMEM(pri);
1977         CHKMEM(pri + offs);
1978         CHKMEM(alt);
1979         CHKMEM(alt + offs);
1980         pri = memcmp(data + (int)alt, data + (int)pri, (int)offs);
1981         BREAK;
1982         CASE(EMBRYO_OP_FILL);
1983         GETPARAM(offs);
1984         CHKMEM(alt);
1985         CHKMEM(alt + offs);
1986         for (i = (int)alt;
1987              (size_t)offs >= sizeof(Embryo_Cell);
1988              i += sizeof(Embryo_Cell), offs -= sizeof(Embryo_Cell))
1989           *(Embryo_Cell *)(data + i) = pri;
1990         BREAK;
1991         CASE(EMBRYO_OP_HALT);
1992         GETPARAM(offs);
1993         ep->retval = pri;
1994         /* store complete status */
1995         ep->frm = frm;
1996         ep->stk = stk;
1997         ep->hea = hea;
1998         ep->pri = pri;
1999         ep->alt = alt;
2000         ep->cip = (Embryo_Cell)((unsigned char*)cip - code);
2001         if (offs == EMBRYO_ERROR_SLEEP)
2002           {
2003              ep->reset_stk = reset_stk;
2004              ep->reset_hea = reset_hea;
2005              ep->run_count--;
2006              return EMBRYO_PROGRAM_SLEEP;
2007           }
2008         OK(ep, (int)offs);
2009         CASE(EMBRYO_OP_BOUNDS);
2010         GETPARAM(offs);
2011         if ((Embryo_UCell)pri > (Embryo_UCell)offs)
2012           ABORT(ep, EMBRYO_ERROR_BOUNDS);
2013         BREAK;
2014         CASE(EMBRYO_OP_SYSREQ_PRI);
2015         /* save a few registers */
2016         ep->cip = (Embryo_Cell)((unsigned char *)cip - code);
2017         ep->hea = hea;
2018         ep->frm = frm;
2019         ep->stk = stk;
2020         num = _embryo_native_call(ep, pri, &pri, (Embryo_Cell *)(data + (int)stk));
2021         if (num != EMBRYO_ERROR_NONE)
2022           {
2023              if (num == EMBRYO_ERROR_SLEEP)
2024                {
2025                   ep->pri = pri;
2026                   ep->alt = alt;
2027                   ep->reset_stk = reset_stk;
2028                   ep->reset_hea = reset_hea;
2029                   ep->run_count--;
2030                   return EMBRYO_PROGRAM_SLEEP;
2031                }
2032              ABORT(ep, num);
2033           }
2034         BREAK;
2035         CASE(EMBRYO_OP_SYSREQ_C);
2036         GETPARAM(offs);
2037         /* save a few registers */
2038         ep->cip = (Embryo_Cell)((unsigned char *)cip - code);
2039         ep->hea = hea;
2040         ep->frm = frm;
2041         ep->stk = stk;
2042         num = _embryo_native_call(ep, offs, &pri, (Embryo_Cell *)(data + (int)stk));
2043         if (num != EMBRYO_ERROR_NONE)
2044           {
2045              if (num == EMBRYO_ERROR_SLEEP)
2046                {
2047                   ep->pri = pri;
2048                   ep->alt = alt;
2049                   ep->reset_stk = reset_stk;
2050                   ep->reset_hea = reset_hea;
2051                   ep->run_count--;
2052                   return EMBRYO_PROGRAM_SLEEP;
2053                }
2054                {
2055                   Embryo_Header    *hdr;
2056                   int i, num;
2057                   Embryo_Func_Stub *func_entry;
2058
2059                   hdr = (Embryo_Header *)ep->code;
2060                   num = NUMENTRIES(hdr, natives, libraries);
2061                   func_entry = GETENTRY(hdr, natives, 0);
2062                   for (i = 0; i < num; i++)
2063                     {
2064                        char *entry_name;
2065
2066                        entry_name = GETENTRYNAME(hdr, func_entry);
2067                        if (i == offs)
2068                          printf("EMBRYO: CALL [%i] %s() non-existant!\n", i, entry_name);
2069                        func_entry =
2070                          (Embryo_Func_Stub *)((unsigned char *)func_entry + hdr->defsize);
2071                     }
2072                }
2073              ABORT(ep, num);
2074           }
2075         BREAK;
2076         CASE(EMBRYO_OP_SYSREQ_D);
2077         GETPARAM(offs);
2078         /* save a few registers */
2079         ep->cip = (Embryo_Cell)((unsigned char *)cip - code);
2080         ep->hea = hea;
2081         ep->frm = frm;
2082         ep->stk = stk;
2083         num = _embryo_native_call(ep, offs, &pri, (Embryo_Cell *)(data + (int)stk));
2084         if (num != EMBRYO_ERROR_NONE)
2085           {
2086              if (num == EMBRYO_ERROR_SLEEP)
2087                {
2088                   ep->pri = pri;
2089                   ep->alt = alt;
2090                   ep->reset_stk = reset_stk;
2091                   ep->reset_hea = reset_hea;
2092                   ep->run_count--;
2093                   return EMBRYO_PROGRAM_SLEEP;
2094                }
2095              ABORT(ep, ep->error);
2096           }
2097         BREAK;
2098         CASE(EMBRYO_OP_JUMP_PRI);
2099         cip = (Embryo_Cell *)(code + (int)pri);
2100         BREAK;
2101         CASE(EMBRYO_OP_SWITCH);
2102           {
2103              Embryo_Cell *cptr;
2104
2105              /* +1, to skip the "casetbl" opcode */
2106              cptr = (Embryo_Cell *)(code + (*cip)) + 1;
2107              /* number of records in the case table */
2108              num = (int)(*cptr);
2109              /* preset to "none-matched" case */
2110              cip = (Embryo_Cell *)(code + *(cptr + 1));
2111              for (cptr += 2;
2112                   (num > 0) && (*cptr != pri);
2113                   num--, cptr += 2);
2114              /* case found */
2115              if (num > 0)
2116                cip = (Embryo_Cell *)(code + *(cptr + 1));
2117           }
2118         BREAK;
2119         CASE(EMBRYO_OP_SWAP_PRI);
2120         offs = *(Embryo_Cell *)(data + (int)stk);
2121         *(Embryo_Cell *)(data + (int)stk) = pri;
2122         pri = offs;
2123         BREAK;
2124         CASE(EMBRYO_OP_SWAP_ALT);
2125         offs = *(Embryo_Cell *)(data + (int)stk);
2126         *(Embryo_Cell *)(data + (int)stk) = alt;
2127         alt = offs;
2128         BREAK;
2129         CASE(EMBRYO_OP_PUSHADDR);
2130         GETPARAM(offs);
2131         PUSH(frm + offs);
2132         BREAK;
2133         CASE(EMBRYO_OP_NOP);
2134         BREAK;
2135         CASE(EMBRYO_OP_NONE);
2136         CASE(EMBRYO_OP_FILE);
2137         CASE(EMBRYO_OP_LINE);
2138         CASE(EMBRYO_OP_SYMBOL);
2139         CASE(EMBRYO_OP_SRANGE);
2140         CASE(EMBRYO_OP_CASETBL);
2141         CASE(EMBRYO_OP_SYMTAG);
2142         BREAK;
2143 #ifndef EMBRYO_EXEC_JUMPTABLE
2144       default:
2145         ABORT(ep, EMBRYO_ERROR_INVINSTR);
2146 #endif
2147         SWITCHEND;
2148      }
2149    ep->max_run_cycles = max_run_cycles;
2150    ep->run_count--;
2151    ep->hea = hea_start;
2152    return EMBRYO_PROGRAM_OK;
2153 }
2154
2155 /**
2156  * Retreives the return value of the last called function of the given
2157  * program.
2158  * @param   ep The given program.
2159  * @return  An Embryo_Cell representing the return value of the function
2160  *          that was last called.
2161  * @ingroup Embryo_Run_Group
2162  */
2163 EAPI Embryo_Cell
2164 embryo_program_return_value_get(Embryo_Program *ep)
2165 {
2166    if (!ep) return 0;
2167    return ep->retval;
2168 }
2169
2170 /**
2171  * Sets the maximum number of abstract machine cycles any given program run
2172  * can execute before being put to sleep and returning.
2173  *
2174  * @param   ep The given program.
2175  * @param   max The number of machine cycles as a limit.
2176  *
2177  * This sets the maximum number of abstract machine (virtual machine)
2178  * instructions that a single run of an embryo function (even if its main)
2179  * can use before embryo embryo_program_run() reutrns with the value
2180  * EMBRYO_PROGRAM_TOOLONG. If the function fully executes within this number
2181  * of cycles, embryo_program_run() will return as normal with either
2182  * EMBRYO_PROGRAM_OK, EMBRYO_PROGRAM_FAIL or EMBRYO_PROGRAM_SLEEP. If the
2183  * run exceeds this instruction count, then EMBRYO_PROGRAM_TOOLONG will be
2184  * returned indicating the program exceeded its run count. If the app wishes
2185  * to continue running this anyway - it is free to process its own events or
2186  * whatever it wants and continue the function by calling
2187  * embryo_program_run(program, EMBRYO_FUNCTION_CONT); which will start the
2188  * run again until the instruction count is reached. This can keep being done
2189  * to allow the calling program to still be able to control things outside the
2190  * embryo function being called. If the maximum run cycle count is 0 then the
2191  * program is allowed to run forever only returning when it is done.
2192  *
2193  * It is important to note that abstract machine cycles are NOT the same as
2194  * the host machine cpu cycles. They are not fixed in runtime per cycle, so
2195  * this is more of a helper tool than a way to HARD-FORCE a script to only
2196  * run for a specific period of time. If the cycle count is set to something
2197  * low like 5000 or 1000, then every 1000 (or 5000) cycles control will be
2198  * returned to the calling process where it can check a timer to see if a
2199  * physical runtime limit has been elapsed and then abort runing further
2200  * assuming a "runaway script" or keep continuing the script run. This
2201  * limits resolution to only that many cycles which do not take a determined
2202  * amount of time to execute, as this varies from cpu to cpu and also depends
2203  * on how loaded the system is. Making the max cycle run too low will
2204  * impact performance requiring the abstract machine to do setup and teardown
2205  * cycles too often comapred to cycles actually executed.
2206  *
2207  * Also note it does NOT include nested abstract machines. IF this abstract
2208  * machine run calls embryo script that calls a native function that in turn
2209  * calls more embryo script, then the 2nd (and so on) levels are not included
2210  * in this run count. They can set their own max instruction count values
2211  * separately.
2212  *
2213  * The default max cycle run value is 0 in any program until set with this
2214  * function.
2215  *
2216  * @ingroup Embryo_Run_Group
2217  */
2218 EAPI void
2219 embryo_program_max_cycle_run_set(Embryo_Program *ep, int max)
2220 {
2221    if (!ep) return;
2222    if (max < 0) max = 0;
2223    ep->max_run_cycles = max;
2224 }
2225
2226 /**
2227  * Retreives the maximum number of abstract machine cycles a program is allowed
2228  * to run.
2229  * @param   ep The given program.
2230  * @return  The number of cycles a run cycle is allowed to run for this
2231  *          program.
2232  *
2233  * This returns the value set by embryo_program_max_cycle_run_set(). See
2234  * embryo_program_max_cycle_run_set() for more information.
2235  *
2236  * @ingroup Embryo_Run_Group
2237  */
2238 EAPI int
2239 embryo_program_max_cycle_run_get(Embryo_Program *ep)
2240 {
2241    if (!ep) return 0;
2242    return ep->max_run_cycles;
2243 }
2244
2245 /**
2246  * @defgroup Embryo_Parameter_Group Function Parameter Functions
2247  *
2248  * Functions that set parameters for the next function that is called.
2249  */
2250
2251 /**
2252  * Pushes an Embryo_Cell onto the function stack to use as a parameter for
2253  * the next function that is called in the given program.
2254  * @param   ep   The given program.
2255  * @param   cell The Embryo_Cell to push onto the stack.
2256  * @return  @c 1 if successful.  @c 0 otherwise.
2257  * @ingroup Embryo_Parameter_Group
2258  */
2259 EAPI int
2260 embryo_parameter_cell_push(Embryo_Program *ep, Embryo_Cell cell)
2261 {
2262    Embryo_Param *pr;
2263
2264    ep->params_size++;
2265    if (ep->params_size > ep->params_alloc)
2266      {
2267         ep->params_alloc += 8;
2268         pr = realloc(ep->params, ep->params_alloc * sizeof(Embryo_Param));
2269         if (!pr) return 0;
2270         ep->params = pr;
2271      }
2272    pr = &(ep->params[ep->params_size - 1]);
2273    pr->string = NULL;
2274    pr->cell_array = NULL;
2275    pr->cell_array_size = 0;
2276    pr->cell = 0;
2277    pr->cell = cell;
2278    return 1;
2279 }
2280
2281 /**
2282  * Pushes a string onto the function stack to use as a parameter for the
2283  * next function that is called in the given program.
2284  * @param   ep The given program.
2285  * @param   str The string to push onto the stack.
2286  * @return  @c 1 if successful.  @c 0 otherwise.
2287  * @ingroup Embryo_Parameter_Group
2288  */
2289 EAPI int
2290 embryo_parameter_string_push(Embryo_Program *ep, const char *str)
2291 {
2292    Embryo_Param *pr;
2293    char *str_dup;
2294
2295    if (!str)
2296      return embryo_parameter_string_push(ep, "");
2297    str_dup = strdup(str);
2298    if (!str_dup) return 0;
2299    ep->params_size++;
2300    if (ep->params_size > ep->params_alloc)
2301      {
2302         ep->params_alloc += 8;
2303         pr = realloc(ep->params, ep->params_alloc * sizeof(Embryo_Param));
2304         if (!pr)
2305           {
2306              free(str_dup);
2307              return 0;
2308           }
2309         ep->params = pr;
2310      }
2311    pr = &(ep->params[ep->params_size - 1]);
2312    pr->string = NULL;
2313    pr->cell_array = NULL;
2314    pr->cell_array_size = 0;
2315    pr->cell = 0;
2316    pr->string = str_dup;
2317    return 1;
2318 }
2319
2320 /**
2321  * Pushes an array of Embryo_Cells onto the function stack to be used as
2322  * parameters for the next function that is called in the given program.
2323  * @param   ep    The given program.
2324  * @param   cells The array of Embryo_Cells.
2325  * @param   num   The number of cells in @p cells.
2326  * @return  @c 1 if successful.  @c 0 otherwise.
2327  * @ingroup Embryo_Parameter_Group
2328  */
2329 EAPI int
2330 embryo_parameter_cell_array_push(Embryo_Program *ep, Embryo_Cell *cells, int num)
2331 {
2332    Embryo_Param *pr;
2333    Embryo_Cell *cell_array;
2334
2335    cell_array = malloc(num * sizeof(Embryo_Cell));
2336    if ((!cells) || (num <= 0))
2337      return embryo_parameter_cell_push(ep, 0);
2338    ep->params_size++;
2339    if (ep->params_size > ep->params_alloc)
2340      {
2341         ep->params_alloc += 8;
2342         pr = realloc(ep->params, ep->params_alloc * sizeof(Embryo_Param));
2343         if (!pr)
2344           {
2345              free(cell_array);
2346              return 0;
2347           }
2348         ep->params = pr;
2349      }
2350    pr = &(ep->params[ep->params_size - 1]);
2351    pr->string = NULL;
2352    pr->cell_array = NULL;
2353    pr->cell_array_size = 0;
2354    pr->cell = 0;
2355    pr->cell_array = cell_array;
2356    pr->cell_array_size = num;
2357    memcpy(pr->cell_array, cells, num * sizeof(Embryo_Cell));
2358    return 1;
2359 }