11 files changed, 5016 insertions, 0 deletions

diff --git a/libraries/embryo/src/lib/Embryo.h b/libraries/embryo/src/lib/Embryo.h
new file mode 100644
index 0000000..ea273cf
--- /dev/null
+++ b/libraries/embryo/src/lib/Embryo.h
@@ -0,0 +1,901 @@
+/** 
+@brief Embryo Library
+ 
+These routines are used for Embryo.
+
+@mainpage Embryo Library Documentation
+
+@image html  e_big.png
+
+@version 1.0.0
+@author Carsten Haitzler <raster\@rasterman.com>
+@author Compuphase http://www.compuphase.com
+@date 2004-2011
+
+@section intro What is Embryo?
+
+Embryo is a tiny library designed to interpret limited Small programs
+compiled by the included compiler, @c embryo_cc.  It is mostly a cleaned
+up and smaller version of the original Small abstract machine.  The
+compiler is mostly untouched.
+
+Small was renamed to Pawn.
+For more information about the Pawn language, see 
+@htmlonly <a href=http://www.compuphase.com/pawn/pawn.htm>Pawn</a>
+@endhtmlonly
+@latexonly http://www.compuphase.com/pawn/pawn.htm @endlatexonly
+For the basics about the Small language, see @ref Small_Page.
+
+@section How_to_Use How to Use Embryo?
+
+To use Embryo in your code, you need to do at least the following:
+
+@li Include @ref Embryo.h.
+@li Load the Embryo program using one of the 
+    @ref Embryo_Program_Creation_Group.
+@li Set up the native calls with @ref embryo_program_native_call_add.
+@li Create a virtual machine with @ref embryo_program_vm_push.
+@li Then run the program with @ref embryo_program_run.
+
+@todo Clean up compiler code.
+@todo Proper overview of the operation of the interpreter, that is how
+      the heap, stack, virtual machines, etc fit together.
+
+@page Small_Page Brief Introduction to Small
+
+This section describes the basics of Small, as compiled and interpreted
+with Embryo.
+
+This summary assumes that you are familar with C.  For a full list of
+differences between C and Small, again, see the full documentation.
+
+@section Small_Variables_Section Variables
+
+@subsection Small_Type_Subsection Types
+
+There is only one type, known as the "cell", which can hold an integer.
+
+@subsection Small_Scope_Subsection Scope
+
+The scope and usage of a variable depends on its declaration.
+
+@li A local variable is normally declared with the @c new keyword. E.g.
+    @code new variable @endcode
+@li A static function variable is defined within a function with the
+    @c static keyword.
+@li A global static variable is one that is only available within the
+    file it was declared in.  Again, use the @c static keyword, but outside
+    of any function.
+@li A stock variable is one that may not be compiled into a program if it
+    is not used.  It is declared using @c stock.
+@li A public variable is one that can be read by the host program using
+    @ref embryo_program_variable_find.  It is declared using @c public
+    keyword.
+
+Remember that the keywords above are to be used on their own.  That is,
+for example: @code public testvar @endcode not:
+@code new public testvar @endcode
+
+@subsection Small_Constants_Subsection Constants
+
+You can declare constants in two ways:
+@li Using the preprocessor macro @c \#define.
+@li By inserting @c const between the keyword and variable name of a
+    variable declaration.  For example, to declare the variable @c var1
+    constant, you type @code new const var1 = 2 @endcode  Now @c var1
+    cannot be changed.
+
+@subsection Small_Arrays_Subsection Arrays
+
+To declare an array, append square brackets to the end of the variable
+name.  The following examples show how to declare arrays.  Note the
+use of the ellipsis operator, which bases the array based on the last two
+declared values:
+
+@code
+new msg[] = "A message."
+new ints[] = {1, 3, 4}
+new ints2[20] = {1, 3}         // All other elements 0.
+new ints3[10] = {1, ... }      // All elements = 1
+new ints4[10] = {10, 20, ... } // Elements = 10 -> 100.
+                               // The difference can be negative.
+new ints5[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
+@endcode
+
+@note Array initialisers need to be constant.
+
+@section Small_Func_Calls_Section Function Calls
+
+A typical function declaration is as follows:
+
+@code
+testfunc(param) {
+  // Do something ...
+  // over a couple of lines.
+}
+@endcode
+
+You can pass by reference.  That is, the parameter you pass is changed
+outside of the function.  For example:
+
+@code
+testfunc(&param) {
+  param = 10
+  // The passed variable will be set to 10 outside of the function.
+}
+@endcode
+
+To pass an array:
+
+@code
+testfunc(param[]) {
+  // Do something to the array
+}
+@endcode
+
+@note Arrays are passed by reference.
+
+@section Small_Control_Subsection Control Structures.
+
+Small has the following control structures, which similar to their C
+counterparts:
+@li @code if (expression) statement1 else statement2 @endcode
+@li @code switch (expression) {
+  case 0:
+    statement1 // Can only be one statement.  Look Ma, no breaks!
+  case 1..3:   // For values between 1 and 3 inclusive.
+    statement2
+  default:     // Optional
+    statement3
+}
+@endcode
+@li @code while(expression) statement @endcode
+@li @code do statement while (expression) @endcode
+@li @code for (init_expression; before_iter_test_expression; after_iter_expression) statement @endcode
+
+@section Small_Preprocessor_Section Preprocessor
+
+The following preprocessor directives are available:
+@li @code #assert constant_expression @endcode
+@li @code #define pattern replacement @endcode
+@li @code #define pattern(%1,%2,...) replacement @endcode
+@li @code #include filename @endcode
+@li @code #if constant_expression
+  // Various bits of code
+#else
+  // Other bits of code
+#endif 
+@endcode
+@li @code #undef pattern @endcode
+
+
+@page Available_Native_Calls_Page Available Calls
+
+Embryo provides a minimal set of native calls that can be used within
+any Embryo script.  Those calls are detailed here.
+
+@note Some of the "core" functions here are also described in the full
+      Small documentation given 
+
+@todo Finish this section.
+
+@section Args_ANC_Section Argument Functions
+
+@subsection Numargs_Desc numargs
+
+Returns the number of arguments passed to a function.  Useful
+when dealing with variable argument lists.
+
+@subsection Getargs_Desc getarg(arg, index=0)
+
+Retrieves the argument number @c arg.  If the argument is an array,
+use @c index to specify the index of the array to return.
+
+@subsection Setargs_Desc setargs(arg, index=0, value)
+
+Sets the argument number @c arg to the given @c arg.  @c index specifies
+the index of @c arg to set if @c arg is an array.
+
+@section String_ANC_Section String Functions
+
+Functions that work on strings.
+
+@subsection Atoi_Desc atoi
+
+Translates an number in string form into an integer.
+
+@subsection Fnmatch_Desc fnmatch
+
+Buggered if I know what this does?
+
+@subsection Strcmp_Desc strcmp
+
+String comparing function.
+
+
+@section Float_ANC_Section Float Functions
+
+@subsection Float_Desc float
+
+@subsection Atof_Desc atof
+
+@subsection Float_Mul_Desc float_mul
+
+@subsection Float_Div_Desc float_div
+
+@subsection Float_Add_Desc float_add
+
+@subsection Float_Sub_Desc float_sub
+
+@subsection Fract_Desc fract
+
+@subsection Round_Desc round
+
+@subsection Float_Cmp_Desc float_cmp
+
+@subsection Sqrt_Desc sqrt
+
+@subsection Pow_Desc pow
+
+@subsection Log_Desc log
+
+@subsection Sin_Desc sin
+
+@subsection Cos_Desc cos
+
+@subsection Tan_Desc tan
+
+@subsection Abs_Desc abs
+
+Returns the absolute value of the given float.
+
+@section Time_ANC_Section Time Functions
+
+@subsection Seconds_Desc seconds()
+
+@subsection Date_Desc date
+
+
+@section Rand_ANC_Section Random Functions
+
+@subsection Rand_Desc rand()
+
+Returns a random integer.
+
+@subsection Randf_Desc randf()
+
+Returns a random float.
+
+@file Embryo.h
+@brief Embryo virtual machine library.
+
+This file includes the routines needed for Embryo library interaction.
+This is the @e only file you need to include.
+
+*/
+
+// The following definitions are in Embryo.h, but I did not want to
+// mess up the formatting of the file
+
+/**
+  @def EMBRYO_FUNCTION_NONE 
+  An invalid/non-existent function.
+*/
+
+/**
+  @def EMBRYO_FUNCTION_MAIN
+  Start at program entry point.  For use with @ref embryo_program_run.
+*/
+
+/**
+  @def EMBRYO_FUNCTION_CONT
+  Continue from last address.  For use with @ref embryo_program_run.
+*/
+
+/**
+  @def EMBRYO_PROGRAM_OK
+  Program was run successfully.
+*/
+
+/**
+  @def EMBRYO_PROGRAM_SLEEP
+  The program's execution was interrupted by a Small @c sleep command.
+*/
+
+/**
+  @def EMBRYO_PROGRAM_FAIL
+  An error in the program caused it to fail.
+*/
+
+#ifndef _EMBRYO_H
+#define _EMBRYO_H
+
+#ifdef EAPI
+# undef EAPI
+#endif
+
+#ifdef _WIN32
+# ifdef EFL_EMBRYO_BUILD
+#  ifdef DLL_EXPORT
+#   define EAPI __declspec(dllexport)
+#  else
+#   define EAPI
+#  endif /* ! DLL_EXPORT */
+# else
+#  define EAPI __declspec(dllimport)
+# endif /* ! EFL_EMBRYO_BUILD */
+#else
+# ifdef __GNUC__
+#  if __GNUC__ >= 4
+#   define EAPI __attribute__ ((visibility("default")))
+#  else
+#   define EAPI
+#  endif
+# else
+#  define EAPI
+# endif
+#endif /* ! _WIN32 */
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#define EMBRYO_VERSION_MAJOR 1
+#define EMBRYO_VERSION_MINOR 0
+   
+   typedef struct _Embryo_Version
+     {
+        int major;
+        int minor;
+        int micro;
+        int revision;
+     } Embryo_Version;
+   
+   EAPI extern Embryo_Version *embryo_version;
+   
+   /* potential error values */
+   typedef enum _Embryo_Error
+     {
+        EMBRYO_ERROR_NONE,
+          /* reserve the first 15 error codes for exit codes of the abstract machine */
+          EMBRYO_ERROR_EXIT,         /** Forced exit */
+          EMBRYO_ERROR_ASSERT,       /** Assertion failed */
+          EMBRYO_ERROR_STACKERR,     /** Stack/heap collision */
+          EMBRYO_ERROR_BOUNDS,       /** Index out of bounds */
+          EMBRYO_ERROR_MEMACCESS,    /** Invalid memory access */
+          EMBRYO_ERROR_INVINSTR,     /** Invalid instruction */
+          EMBRYO_ERROR_STACKLOW,     /** Stack underflow */
+          EMBRYO_ERROR_HEAPLOW,      /** Heap underflow */
+          EMBRYO_ERROR_CALLBACK,     /** No callback, or invalid callback */
+          EMBRYO_ERROR_NATIVE,       /** Native function failed */
+          EMBRYO_ERROR_DIVIDE,       /** Divide by zero */
+          EMBRYO_ERROR_SLEEP,        /** Go into sleepmode - code can be restarted */
+
+          EMBRYO_ERROR_MEMORY = 16,  /** Out of memory */
+          EMBRYO_ERROR_FORMAT,       /** Invalid file format */
+          EMBRYO_ERROR_VERSION,      /** File is for a newer version of the Embryo_Program */
+          EMBRYO_ERROR_NOTFOUND,     /** Function not found */
+          EMBRYO_ERROR_INDEX,        /** Invalid index parameter (bad entry point) */
+          EMBRYO_ERROR_DEBUG,        /** Debugger cannot run */
+          EMBRYO_ERROR_INIT,         /** Embryo_Program not initialized (or doubly initialized) */
+          EMBRYO_ERROR_USERDATA,     /** Unable to set user data field (table full) */
+          EMBRYO_ERROR_INIT_JIT,     /** Cannot initialize the JIT */
+          EMBRYO_ERROR_PARAMS,       /** Parameter error */
+          EMBRYO_ERROR_DOMAIN,       /** Domain error, expression result does not fit in range */
+     } Embryo_Error;
+
+   /* program run return values */
+   typedef enum _Embryo_Status
+     {
+        EMBRYO_PROGRAM_FAIL = 0,
+        EMBRYO_PROGRAM_OK = 1,
+        EMBRYO_PROGRAM_SLEEP = 2,
+        EMBRYO_PROGRAM_BUSY = 3,
+        EMBRYO_PROGRAM_TOOLONG = 4
+     } Embryo_Status;
+   
+   typedef unsigned int                Embryo_UCell;
+   typedef int                         Embryo_Cell;
+  /** An invalid cell reference */
+#define EMBRYO_CELL_NONE     0x7fffffff
+   
+   typedef struct _Embryo_Program      Embryo_Program;
+   typedef int                         Embryo_Function;
+   /* possible function type values that are enumerated */
+#define EMBRYO_FUNCTION_NONE 0x7fffffff /* An invalid/non existent function */
+#define EMBRYO_FUNCTION_MAIN -1         /* Start at program entry point */
+#define EMBRYO_FUNCTION_CONT -2         /* Continue from last address */
+
+   typedef union
+     {
+        float       f;
+        Embryo_Cell c;
+     } Embryo_Float_Cell;
+
+#if defined _MSC_VER || defined __SUNPRO_C
+/** Float to Embryo_Cell */
+# define EMBRYO_FLOAT_TO_CELL(f) (((Embryo_Float_Cell *)&(f))->c)
+/** Embryo_Cell to float */
+# define EMBRYO_CELL_TO_FLOAT(c) (((Embryo_Float_Cell *)&(c))->f)
+#else
+/** Float to Embryo_Cell */
+# define EMBRYO_FLOAT_TO_CELL(f) ((Embryo_Float_Cell) f).c
+/** Embryo_Cell to float */
+# define EMBRYO_CELL_TO_FLOAT(c) ((Embryo_Float_Cell) c).f
+#endif
+
+   /**
+    * @defgroup Embryo_Library_Group Library Maintenance Functions
+    *
+    * Functions that start up and shutdown the Embryo library.
+    */
+   
+   
+/**
+ * Initialises the Embryo library.
+ * @return  The number of times the library has been initialised without being
+ *          shut down.
+ * @ingroup Embryo_Library_Group
+ */
+EAPI int              embryo_init(void);
+   
+/**
+ * Shuts down the Embryo library.
+ * @return  The number of times the library has been initialised without being
+ *          shutdown.
+ * @ingroup Embryo_Library_Group
+ */
+EAPI int              embryo_shutdown(void);
+
+   /**
+    * @defgroup Embryo_Program_Creation_Group Program Creation and Destruction Functions
+    *
+    * Functions that set up programs, and destroy them.
+    */
+   
+/**
+ * Creates a new Embryo program, with bytecode data that can be freed.
+ * @param   data Pointer to the bytecode of the program.
+ * @param   size Number of bytes of bytecode.
+ * @return  A new Embryo program.
+ * @ingroup Embryo_Program_Creation_Group
+ */
+EAPI Embryo_Program  *embryo_program_new(void *data, int size);
+   
+/**
+ * Creates a new Embryo program, with bytecode data that cannot be
+ * freed.
+ * @param   data Pointer to the bytecode of the program.
+ * @param   size Number of bytes of bytecode.
+ * @return  A new Embryo program.
+ * @ingroup Embryo_Program_Creation_Group
+ */
+EAPI Embryo_Program  *embryo_program_const_new(void *data, int size);
+   
+/**
+ * Creates a new Embryo program based on the bytecode data stored in the
+ * given file.
+ * @param   file Filename of the given file.
+ * @return  A new Embryo program.
+ * @ingroup Embryo_Program_Creation_Group
+ */
+EAPI Embryo_Program  *embryo_program_load(const char *file);
+   
+/**
+ * Frees the given Embryo program.
+ * @param   ep The given program.
+ * @ingroup Embryo_Program_Creation_Group
+ */
+EAPI void             embryo_program_free(Embryo_Program *ep);
+   
+/**
+ * Adds a native program call to the given Embryo program.
+ * @param   ep   The given Embryo program.
+ * @param   name The name for the call used in the script.
+ * @param   func The function to use when the call is made.
+ * @ingroup Embryo_Func_Group
+ */
+
+/**
+ * @defgroup Embryo_Func_Group Function Functions
+ *
+ * Functions that deal with Embryo program functions.
+ */
+EAPI void             embryo_program_native_call_add(Embryo_Program *ep, const char *name, Embryo_Cell (*func) (Embryo_Program *ep, Embryo_Cell *params));
+   
+/**
+ * Resets the current virtual machine session of the given program.
+ * @param   ep The given program.
+ * @ingroup Embryo_Program_VM_Group
+ */
+
+/**
+ * @defgroup Embryo_Program_VM_Group Virtual Machine Functions
+ *
+ * Functions that deal with creating and destroying virtual machine sessions
+ * for a given program.
+ *
+ * A given embryo program can have multiple virtual machine sessions running.
+ * This is useful when you have a native call that in turn calls a function in
+ * the embryo program.  The native call can start a new virtual machine
+ * session to run the function it needs.  Once completed, the session can be
+ * popped off the program's stack, and the native call can return its value
+ * to the old session.
+ *
+ * A new virtual machine session is created by pushing a new virtual machine
+ * onto the session stack of a program using @ref embryo_program_vm_push.
+ * The current virtual machine session can be destroyed by calling
+ * @ref embryo_program_vm_pop.
+ */
+EAPI void             embryo_program_vm_reset(Embryo_Program *ep);
+   
+/**
+ * Starts a new virtual machine session for the given program.
+ *
+ * See @ref Embryo_Program_VM_Group for more information about how this works.
+ *
+ * @param   ep The given program.
+ * @ingroup Embryo_Program_VM_Group
+ */
+EAPI void             embryo_program_vm_push(Embryo_Program *ep);
+   
+/**
+ * Frees the current virtual machine session associated with the given program.
+ *
+ * See @ref Embryo_Program_VM_Group for more information about how this works.
+ * Note that you will need to retrieve any return data or data on the stack
+ * before you pop.
+ *
+ * @param   ep The given program.
+ * @ingroup Embryo_Program_VM_Group
+ */
+EAPI void             embryo_program_vm_pop(Embryo_Program *ep);
+   
+/**
+ * Ensures that the given unsigned short integer is in the small
+ * endian format.
+ * @param   v Pointer to the given integer.
+ * @ingroup Embryo_Swap_Group
+ */
+
+/**
+ * @defgroup Embryo_Swap_Group Byte Swapping Functions
+ *
+ * Functions that are used to ensure that integers passed to the
+ * virtual machine are in small endian format.  These functions are
+ * used to ensure that the virtual machine operates correctly on big
+ * endian machines.
+ */
+EAPI void             embryo_swap_16(unsigned short *v);
+   
+/**
+ * Ensures that the given unsigned integer is in the small endian
+ * format.
+ * @param   v Pointer to the given integer.
+ * @ingroup Embryo_Swap_Group
+ */
+EAPI void             embryo_swap_32(unsigned int *v);
+   
+/**
+ * Returns the function in the given program with the given name.
+ * @param   ep The given program.
+ * @param   name The given function name.
+ * @return  The function if successful.  Otherwise, @c EMBRYO_FUNCTION_NONE.
+ * @ingroup Embryo_Func_Group
+ */
+EAPI Embryo_Function  embryo_program_function_find(Embryo_Program *ep, const char *name);
+   
+/**
+ * Retrieves the location of the public variable in the given program
+ * with the given name.
+ * @param   ep   The given program.
+ * @param   name The given name.
+ * @return  The address of the variable if found.  @c EMBRYO_CELL_NONE
+ *          otherwise.
+ * @ingroup Embryo_Public_Variable_Group
+ */
+
+/**
+ * @defgroup Embryo_Public_Variable_Group Public Variable Access Functions
+ *
+ * In an Embryo program, a global variable can be declared public, as
+ * described in @ref Small_Scope_Subsection.  The functions here allow
+ * the host program to access these public variables.
+ */
+EAPI Embryo_Cell      embryo_program_variable_find(Embryo_Program *ep, const char *name);
+   
+/**
+ * Retrieves the number of public variables in the given program.
+ * @param   ep The given program.
+ * @return  The number of public variables.
+ * @ingroup Embryo_Public_Variable_Group
+ */
+EAPI int              embryo_program_variable_count_get(Embryo_Program *ep);
+   
+/**
+ * Retrieves the location of the public variable in the given program
+ * with the given identifier.
+ * @param   ep  The given program.
+ * @param   num The identifier of the public variable.
+ * @return  The virtual machine address of the variable if found.
+ *          @c EMBRYO_CELL_NONE otherwise.
+ * @ingroup Embryo_Public_Variable_Group
+ */
+EAPI Embryo_Cell      embryo_program_variable_get(Embryo_Program *ep, int num);
+   
+/**
+ * Sets the error code for the given program to the given code.
+ * @param   ep The given program.
+ * @param   error The given error code.
+ * @ingroup Embryo_Error_Group
+ */
+
+/**
+ * @defgroup Embryo_Error_Group Error Functions
+ *
+ * Functions that set and retrieve error codes in Embryo programs.
+ */
+EAPI void             embryo_program_error_set(Embryo_Program *ep, Embryo_Error error);
+   
+/**
+ * Retrieves the current error code for the given program.
+ * @param   ep The given program.
+ * @return  The current error code.
+ * @ingroup Embryo_Error_Group
+ */
+EAPI Embryo_Error     embryo_program_error_get(Embryo_Program *ep);
+   
+/**
+ * Sets the data associated to the given program.
+ * @param   ep   The given program.
+ * @param   data New bytecode data.
+ * @ingroup Embryo_Program_Data_Group
+ */
+
+/**
+ * @defgroup Embryo_Program_Data_Group Program Data Functions
+ *
+ * Functions that set and retrieve data associated with the given
+ * program.
+ */
+EAPI void             embryo_program_data_set(Embryo_Program *ep, void *data);
+   
+/**
+ * Retrieves the data associated to the given program.
+ * @param   ep The given program.
+ * @ingroup Embryo_Program_Data_Group
+ */
+EAPI void            *embryo_program_data_get(Embryo_Program *ep);
+   
+/**
+ * Retrieves a string describing the given error code.
+ * @param   error The given error code.
+ * @return  String describing the given error code.  If the given code is not
+ *          known, the string "(unknown)" is returned.
+ * @ingroup Embryo_Error_Group
+ */
+EAPI const char      *embryo_error_string_get(Embryo_Error error);
+   
+/**
+ * Retrieves the length of the string starting at the given cell.
+ * @param   ep       The program the cell is part of.
+ * @param   str_cell Pointer to the first cell of the string.
+ * @return  The length of the string.  @c 0 is returned if there is an error.
+ * @ingroup Embryo_Data_String_Group
+ */
+
+/**
+ * @defgroup Embryo_Data_String_Group Embryo Data String Functions
+ *
+ * Functions that operate on strings in the memory of a virtual machine.
+ */
+EAPI int              embryo_data_string_length_get(Embryo_Program *ep, Embryo_Cell *str_cell);
+   
+/**
+ * Copies the string starting at the given cell to the given buffer.
+ * @param   ep       The program the cell is part of.
+ * @param   str_cell Pointer to the first cell of the string.
+ * @param   dst      The given buffer.
+ * @ingroup Embryo_Data_String_Group
+ */
+EAPI void             embryo_data_string_get(Embryo_Program *ep, Embryo_Cell *str_cell, char *dst);
+   
+/**
+ * Copies string in the given buffer into the virtual machine memory
+ * starting at the given cell.
+ * @param ep       The program the cell is part of.
+ * @param src      The given buffer.
+ * @param str_cell Pointer to the first cell to copy the string to.
+ * @ingroup Embryo_Data_String_Group
+ */
+EAPI void             embryo_data_string_set(Embryo_Program *ep, const char *src, Embryo_Cell *str_cell);
+   
+/**
+ * Retreives a pointer to the address in the virtual machine given by the
+ * given cell.
+ * @param   ep   The program whose virtual machine address is being queried.
+ * @param   addr The given cell.
+ * @return  A pointer to the cell at the given address.
+ * @ingroup Embryo_Data_String_Group
+ */
+EAPI Embryo_Cell     *embryo_data_address_get(Embryo_Program *ep, Embryo_Cell addr);
+   
+/**
+ * Increases the size of the heap of the given virtual machine by the given
+ * number of Embryo_Cells.
+ * @param   ep    The program with the given virtual machine.
+ * @param   cells The given number of Embryo_Cells.
+ * @return  The address of the new memory region on success.
+ *          @c EMBRYO_CELL_NONE otherwise.
+ * @ingroup Embryo_Heap_Group
+ */
+
+/**
+ * @defgroup Embryo_Heap_Group Heap Functions
+ *
+ * The heap is an area of memory that can be allocated for program
+ * use at runtime.  The heap functions here change the amount of heap
+ * memory available.
+ */
+EAPI Embryo_Cell      embryo_data_heap_push(Embryo_Program *ep, int cells);
+   
+/**
+ * Decreases the size of the heap of the given virtual machine down to the
+ * given size.
+ * @param   ep      The program with the given virtual machine.
+ * @param   down_to The given size.
+ * @ingroup Embryo_Heap_Group
+ */
+EAPI void             embryo_data_heap_pop(Embryo_Program *ep, Embryo_Cell down_to);
+   
+/**
+ * Returns the number of virtual machines are running for the given program.
+ * @param   ep The given program.
+ * @return  The number of virtual machines running.
+ * @ingroup Embryo_Run_Group
+ */
+
+/**
+ * @defgroup Embryo_Run_Group Program Run Functions
+ *
+ * Functions that are involved in actually running functions in an
+ * Embryo program.
+ */
+EAPI int              embryo_program_recursion_get(Embryo_Program *ep);
+   
+/**
+ * Runs the given function of the given Embryo program in the current
+ * virtual machine.  The parameter @p fn can be found using
+ * @ref embryo_program_function_find.
+ *
+ * @note For Embryo to be able to run a function, it must have been
+ *       declared @c public in the Small source code.
+ *
+ * @param   ep The given program.
+ * @param   fn The given function.  Normally "main", in which case the
+ *             constant @c EMBRYO_FUNCTION_MAIN can be used.
+ * @return  @c EMBRYO_PROGRAM_OK on success.  @c EMBRYO_PROGRAM_SLEEP if the
+ *          program is halted by the Small @c sleep call.
+ *          @c EMBRYO_PROGRAM_FAIL if there is an error.
+ *          @c EMBRYO_PROGRAM_TOOLONG if the program executes for longer than
+ *          it is allowed to in abstract machine instruction count.
+ * @ingroup Embryo_Run_Group
+ */
+EAPI Embryo_Status    embryo_program_run(Embryo_Program *ep, Embryo_Function func);
+   
+/**
+ * Retreives the return value of the last called function of the given
+ * program.
+ * @param   ep The given program.
+ * @return  An Embryo_Cell representing the return value of the function
+ *          that was last called.
+ * @ingroup Embryo_Run_Group
+ */
+EAPI Embryo_Cell      embryo_program_return_value_get(Embryo_Program *ep);
+   
+/**
+ * Sets the maximum number of abstract machine cycles any given program run
+ * can execute before being put to sleep and returning.
+ *
+ * @param   ep The given program.
+ * @param   max The number of machine cycles as a limit.
+ *
+ * This sets the maximum number of abstract machine (virtual machine)
+ * instructions that a single run of an embryo function (even if its main)
+ * can use before embryo embryo_program_run() reutrns with the value
+ * EMBRYO_PROGRAM_TOOLONG. If the function fully executes within this number
+ * of cycles, embryo_program_run() will return as normal with either
+ * EMBRYO_PROGRAM_OK, EMBRYO_PROGRAM_FAIL or EMBRYO_PROGRAM_SLEEP. If the
+ * run exceeds this instruction count, then EMBRYO_PROGRAM_TOOLONG will be
+ * returned indicating the program exceeded its run count. If the app wishes
+ * to continue running this anyway - it is free to process its own events or
+ * whatever it wants and continue the function by calling
+ * embryo_program_run(program, EMBRYO_FUNCTION_CONT); which will start the
+ * run again until the instruction count is reached. This can keep being done
+ * to allow the calling program to still be able to control things outside the
+ * embryo function being called. If the maximum run cycle count is 0 then the
+ * program is allowed to run forever only returning when it is done.
+ *
+ * It is important to note that abstract machine cycles are NOT the same as
+ * the host machine cpu cycles. They are not fixed in runtime per cycle, so
+ * this is more of a helper tool than a way to HARD-FORCE a script to only
+ * run for a specific period of time. If the cycle count is set to something
+ * low like 5000 or 1000, then every 1000 (or 5000) cycles control will be
+ * returned to the calling process where it can check a timer to see if a
+ * physical runtime limit has been elapsed and then abort running further
+ * assuming a "runaway script" or keep continuing the script run. This
+ * limits resolution to only that many cycles which do not take a determined
+ * amount of time to execute, as this varies from cpu to cpu and also depends
+ * on how loaded the system is. Making the max cycle run too low will
+ * impact performance requiring the abstract machine to do setup and teardown
+ * cycles too often comapred to cycles actually executed.
+ *
+ * Also note it does NOT include nested abstract machines. IF this abstract
+ * machine run calls embryo script that calls a native function that in turn
+ * calls more embryo script, then the 2nd (and so on) levels are not included
+ * in this run count. They can set their own max instruction count values
+ * separately.
+ *
+ * The default max cycle run value is 0 in any program until set with this
+ * function.
+ *
+ * @ingroup Embryo_Run_Group
+ */
+EAPI void             embryo_program_max_cycle_run_set(Embryo_Program *ep, int max);
+   
+/**
+ * Retreives the maximum number of abstract machine cycles a program is allowed
+ * to run.
+ * @param   ep The given program.
+ * @return  The number of cycles a run cycle is allowed to run for this
+ *          program.
+ *
+ * This returns the value set by embryo_program_max_cycle_run_set(). See
+ * embryo_program_max_cycle_run_set() for more information.
+ *
+ * @ingroup Embryo_Run_Group
+ */
+EAPI int              embryo_program_max_cycle_run_get(Embryo_Program *ep);
+   
+/**
+ * Pushes an Embryo_Cell onto the function stack to use as a parameter for
+ * the next function that is called in the given program.
+ * @param   ep   The given program.
+ * @param   cell The Embryo_Cell to push onto the stack.
+ * @return  @c 1 if successful.  @c 0 otherwise.
+ * @ingroup Embryo_Parameter_Group
+ */
+
+/**
+ * @defgroup Embryo_Parameter_Group Function Parameter Functions
+ *
+ * Functions that set parameters for the next function that is called.
+ */
+EAPI int              embryo_parameter_cell_push(Embryo_Program *ep, Embryo_Cell cell);
+   
+/**
+ * Pushes a string onto the function stack to use as a parameter for the
+ * next function that is called in the given program.
+ * @param   ep The given program.
+ * @param   str The string to push onto the stack.
+ * @return  @c 1 if successful.  @c 0 otherwise.
+ * @ingroup Embryo_Parameter_Group
+ */
+EAPI int              embryo_parameter_string_push(Embryo_Program *ep, const char *str);
+   
+/**
+ * Pushes an array of Embryo_Cells onto the function stack to be used as
+ * parameters for the next function that is called in the given program.
+ * @param   ep    The given program.
+ * @param   cells The array of Embryo_Cells.
+ * @param   num   The number of cells in @p cells.
+ * @return  @c 1 if successful.  @c 0 otherwise.
+ * @ingroup Embryo_Parameter_Group
+ */
+EAPI int              embryo_parameter_cell_array_push(Embryo_Program *ep, Embryo_Cell *cells, int num);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/libraries/embryo/src/lib/Makefile.am b/libraries/embryo/src/lib/Makefile.am
new file mode 100644
index 0000000..f5c78aa
--- /dev/null
+++ b/libraries/embryo/src/lib/Makefile.am
@@ -0,0 +1,35 @@
+
+MAINTAINERCLEANFILES = Makefile.in
+
+AM_CPPFLAGS = \
+-I. \
+-I$(top_srcdir)/src/lib \
+-I$(top_builddir) \
+-I$(top_srcdir)/src/lib \
+-I$(top_srcdir)/src/lib/include \
+-DPACKAGE_BIN_DIR=\"$(bindir)\" \
+-DPACKAGE_LIB_DIR=\"$(libdir)\" \
+-DPACKAGE_DATA_DIR=\"$(datadir)/$(PACKAGE)\" \
+@EVIL_CFLAGS@ \
+@EMBRYO_CPPFLAGS@ \
+@EFL_EMBRYO_BUILD@
+
+includes_HEADERS = Embryo.h
+includesdir = $(includedir)/embryo-@VMAJ@
+
+lib_LTLIBRARIES = libembryo.la
+
+libembryo_la_SOURCES  = \
+embryo_amx.c \
+embryo_args.c \
+embryo_float.c \
+embryo_main.c \
+embryo_rand.c \
+embryo_str.c \
+embryo_time.c
+
+libembryo_la_CFLAGS = @EMBRYO_CFLAGS@
+libembryo_la_LIBADD = @EVIL_LIBS@ -lm
+libembryo_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@
+
+EXTRA_DIST = embryo_private.h
diff --git a/libraries/embryo/src/lib/Makefile.in b/libraries/embryo/src/lib/Makefile.in
new file mode 100644
index 0000000..56e9f26
--- /dev/null
+++ b/libraries/embryo/src/lib/Makefile.in
@@ -0,0 +1,682 @@
+# Makefile.in generated by automake 1.11.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009  Free Software Foundation,
+# Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src/lib
+DIST_COMMON = $(includes_HEADERS) $(srcdir)/Makefile.am \
+        $(srcdir)/Makefile.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_attribute.m4 \
+        $(top_srcdir)/m4/efl_binary.m4 $(top_srcdir)/m4/efl_doxygen.m4 \
+        $(top_srcdir)/m4/efl_fnmatch.m4 \
+        $(top_srcdir)/m4/efl_path_max.m4 $(top_srcdir)/m4/libtool.m4 \
+        $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
+        $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
+        $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+        $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(includesdir)"
+LTLIBRARIES = $(lib_LTLIBRARIES)
+libembryo_la_DEPENDENCIES =
+am_libembryo_la_OBJECTS = libembryo_la-embryo_amx.lo \
+        libembryo_la-embryo_args.lo libembryo_la-embryo_float.lo \
+        libembryo_la-embryo_main.lo libembryo_la-embryo_rand.lo \
+        libembryo_la-embryo_str.lo libembryo_la-embryo_time.lo
+libembryo_la_OBJECTS = $(am_libembryo_la_OBJECTS)
+AM_V_lt = $(am__v_lt_$(V))
+am__v_lt_ = $(am__v_lt_$(AM_DEFAULT_VERBOSITY))
+am__v_lt_0 = --silent
+libembryo_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+        $(LIBTOOLFLAGS) --mode=link $(CCLD) $(libembryo_la_CFLAGS) \
+        $(CFLAGS) $(libembryo_la_LDFLAGS) $(LDFLAGS) -o $@
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+        $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+        $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+        $(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_$(V))
+am__v_CC_ = $(am__v_CC_$(AM_DEFAULT_VERBOSITY))
+am__v_CC_0 = @echo "  CC    " $@;
+AM_V_at = $(am__v_at_$(V))
+am__v_at_ = $(am__v_at_$(AM_DEFAULT_VERBOSITY))
+am__v_at_0 = @
+CCLD = $(CC)
+LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+        $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+        $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_$(V))
+am__v_CCLD_ = $(am__v_CCLD_$(AM_DEFAULT_VERBOSITY))
+am__v_CCLD_0 = @echo "  CCLD  " $@;
+AM_V_GEN = $(am__v_GEN_$(V))
+am__v_GEN_ = $(am__v_GEN_$(AM_DEFAULT_VERBOSITY))
+am__v_GEN_0 = @echo "  GEN   " $@;
+SOURCES = $(libembryo_la_SOURCES)
+DIST_SOURCES = $(libembryo_la_SOURCES)
+HEADERS = $(includes_HEADERS)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+ALLOCA = @ALLOCA@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EFL_EMBRYO_BUILD = @EFL_EMBRYO_BUILD@
+EFL_FNMATCH_LIBS = @EFL_FNMATCH_LIBS@
+EGREP = @EGREP@
+EINA_CFLAGS = @EINA_CFLAGS@
+EINA_LIBS = @EINA_LIBS@
+EMBRYO_CC_PRG = @EMBRYO_CC_PRG@
+EMBRYO_CFLAGS = @EMBRYO_CFLAGS@
+EMBRYO_CPPFLAGS = @EMBRYO_CPPFLAGS@
+EVIL_CFLAGS = @EVIL_CFLAGS@
+EVIL_LIBS = @EVIL_LIBS@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PKG_CONFIG = @PKG_CONFIG@
+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+VMAJ = @VMAJ@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+efl_doxygen = @efl_doxygen@
+efl_have_doxygen = @efl_have_doxygen@
+embryoincludedir = @embryoincludedir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+lt_ECHO = @lt_ECHO@
+lt_enable_auto_import = @lt_enable_auto_import@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgconfig_requires_private = @pkgconfig_requires_private@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+release_info = @release_info@
+requirement_embryo = @requirement_embryo@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+version_info = @version_info@
+MAINTAINERCLEANFILES = Makefile.in
+AM_CPPFLAGS = \
+-I. \
+-I$(top_srcdir)/src/lib \
+-I$(top_builddir) \
+-I$(top_srcdir)/src/lib \
+-I$(top_srcdir)/src/lib/include \
+-DPACKAGE_BIN_DIR=\"$(bindir)\" \
+-DPACKAGE_LIB_DIR=\"$(libdir)\" \
+-DPACKAGE_DATA_DIR=\"$(datadir)/$(PACKAGE)\" \
+@EVIL_CFLAGS@ \
+@EMBRYO_CPPFLAGS@ \
+@EFL_EMBRYO_BUILD@
+
+includes_HEADERS = Embryo.h
+includesdir = $(includedir)/embryo-@VMAJ@
+lib_LTLIBRARIES = libembryo.la
+libembryo_la_SOURCES = \
+embryo_amx.c \
+embryo_args.c \
+embryo_float.c \
+embryo_main.c \
+embryo_rand.c \
+embryo_str.c \
+embryo_time.c
+
+libembryo_la_CFLAGS = @EMBRYO_CFLAGS@
+libembryo_la_LIBADD = @EVIL_LIBS@ -lm
+libembryo_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@
+EXTRA_DIST = embryo_private.h
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+        @for dep in $?; do \
+          case '$(am__configure_deps)' in \
+            *$$dep*) \
+              ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+                && { if test -f $@; then exit 0; else break; fi; }; \
+              exit 1;; \
+          esac; \
+        done; \
+        echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/lib/Makefile'; \
+        $(am__cd) $(top_srcdir) && \
+          $(AUTOMAKE) --gnu src/lib/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+        @case '$?' in \
+          *config.status*) \
+            cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+          *) \
+            echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+            cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+        esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+        cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+        cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+        cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+        @$(NORMAL_INSTALL)
+        test -z "$(libdir)" || $(MKDIR_P) "$(DESTDIR)$(libdir)"
+        @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+        list2=; for p in $$list; do \
+          if test -f $$p; then \
+            list2="$$list2 $$p"; \
+          else :; fi; \
+        done; \
+        test -z "$$list2" || { \
+          echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+          $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+        }
+
+uninstall-libLTLIBRARIES:
+        @$(NORMAL_UNINSTALL)
+        @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+        for p in $$list; do \
+          $(am__strip_dir) \
+          echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+          $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+        done
+
+clean-libLTLIBRARIES:
+        -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+        @list='$(lib_LTLIBRARIES)'; for p in $$list; do \
+          dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
+          test "$$dir" != "$$p" || dir=.; \
+          echo "rm -f \"$${dir}/so_locations\""; \
+          rm -f "$${dir}/so_locations"; \
+        done
+libembryo.la: $(libembryo_la_OBJECTS) $(libembryo_la_DEPENDENCIES) 
+        $(AM_V_CCLD)$(libembryo_la_LINK) -rpath $(libdir) $(libembryo_la_OBJECTS) $(libembryo_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+        -rm -f *.$(OBJEXT)
+
+distclean-compile:
+        -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libembryo_la-embryo_amx.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libembryo_la-embryo_args.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libembryo_la-embryo_float.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libembryo_la-embryo_main.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libembryo_la-embryo_rand.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libembryo_la-embryo_str.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libembryo_la-embryo_time.Plo@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@am__fastdepCC_FALSE@   $(AM_V_CC) @AM_BACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(COMPILE) -c $<
+
+.c.obj:
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@am__fastdepCC_FALSE@   $(AM_V_CC) @AM_BACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+@am__fastdepCC_FALSE@   $(AM_V_CC) @AM_BACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(LTCOMPILE) -c -o $@ $<
+
+libembryo_la-embryo_amx.lo: embryo_amx.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libembryo_la_CFLAGS) $(CFLAGS) -MT libembryo_la-embryo_amx.lo -MD -MP -MF $(DEPDIR)/libembryo_la-embryo_amx.Tpo -c -o libembryo_la-embryo_amx.lo `test -f 'embryo_amx.c' || echo '$(srcdir)/'`embryo_amx.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libembryo_la-embryo_amx.Tpo $(DEPDIR)/libembryo_la-embryo_amx.Plo
+@am__fastdepCC_FALSE@   $(AM_V_CC) @AM_BACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       source='embryo_amx.c' object='libembryo_la-embryo_amx.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libembryo_la_CFLAGS) $(CFLAGS) -c -o libembryo_la-embryo_amx.lo `test -f 'embryo_amx.c' || echo '$(srcdir)/'`embryo_amx.c
+
+libembryo_la-embryo_args.lo: embryo_args.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libembryo_la_CFLAGS) $(CFLAGS) -MT libembryo_la-embryo_args.lo -MD -MP -MF $(DEPDIR)/libembryo_la-embryo_args.Tpo -c -o libembryo_la-embryo_args.lo `test -f 'embryo_args.c' || echo '$(srcdir)/'`embryo_args.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libembryo_la-embryo_args.Tpo $(DEPDIR)/libembryo_la-embryo_args.Plo
+@am__fastdepCC_FALSE@   $(AM_V_CC) @AM_BACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       source='embryo_args.c' object='libembryo_la-embryo_args.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libembryo_la_CFLAGS) $(CFLAGS) -c -o libembryo_la-embryo_args.lo `test -f 'embryo_args.c' || echo '$(srcdir)/'`embryo_args.c
+
+libembryo_la-embryo_float.lo: embryo_float.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libembryo_la_CFLAGS) $(CFLAGS) -MT libembryo_la-embryo_float.lo -MD -MP -MF $(DEPDIR)/libembryo_la-embryo_float.Tpo -c -o libembryo_la-embryo_float.lo `test -f 'embryo_float.c' || echo '$(srcdir)/'`embryo_float.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libembryo_la-embryo_float.Tpo $(DEPDIR)/libembryo_la-embryo_float.Plo
+@am__fastdepCC_FALSE@   $(AM_V_CC) @AM_BACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       source='embryo_float.c' object='libembryo_la-embryo_float.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libembryo_la_CFLAGS) $(CFLAGS) -c -o libembryo_la-embryo_float.lo `test -f 'embryo_float.c' || echo '$(srcdir)/'`embryo_float.c
+
+libembryo_la-embryo_main.lo: embryo_main.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libembryo_la_CFLAGS) $(CFLAGS) -MT libembryo_la-embryo_main.lo -MD -MP -MF $(DEPDIR)/libembryo_la-embryo_main.Tpo -c -o libembryo_la-embryo_main.lo `test -f 'embryo_main.c' || echo '$(srcdir)/'`embryo_main.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libembryo_la-embryo_main.Tpo $(DEPDIR)/libembryo_la-embryo_main.Plo
+@am__fastdepCC_FALSE@   $(AM_V_CC) @AM_BACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       source='embryo_main.c' object='libembryo_la-embryo_main.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libembryo_la_CFLAGS) $(CFLAGS) -c -o libembryo_la-embryo_main.lo `test -f 'embryo_main.c' || echo '$(srcdir)/'`embryo_main.c
+
+libembryo_la-embryo_rand.lo: embryo_rand.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libembryo_la_CFLAGS) $(CFLAGS) -MT libembryo_la-embryo_rand.lo -MD -MP -MF $(DEPDIR)/libembryo_la-embryo_rand.Tpo -c -o libembryo_la-embryo_rand.lo `test -f 'embryo_rand.c' || echo '$(srcdir)/'`embryo_rand.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libembryo_la-embryo_rand.Tpo $(DEPDIR)/libembryo_la-embryo_rand.Plo
+@am__fastdepCC_FALSE@   $(AM_V_CC) @AM_BACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       source='embryo_rand.c' object='libembryo_la-embryo_rand.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libembryo_la_CFLAGS) $(CFLAGS) -c -o libembryo_la-embryo_rand.lo `test -f 'embryo_rand.c' || echo '$(srcdir)/'`embryo_rand.c
+
+libembryo_la-embryo_str.lo: embryo_str.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libembryo_la_CFLAGS) $(CFLAGS) -MT libembryo_la-embryo_str.lo -MD -MP -MF $(DEPDIR)/libembryo_la-embryo_str.Tpo -c -o libembryo_la-embryo_str.lo `test -f 'embryo_str.c' || echo '$(srcdir)/'`embryo_str.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libembryo_la-embryo_str.Tpo $(DEPDIR)/libembryo_la-embryo_str.Plo
+@am__fastdepCC_FALSE@   $(AM_V_CC) @AM_BACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       source='embryo_str.c' object='libembryo_la-embryo_str.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libembryo_la_CFLAGS) $(CFLAGS) -c -o libembryo_la-embryo_str.lo `test -f 'embryo_str.c' || echo '$(srcdir)/'`embryo_str.c
+
+libembryo_la-embryo_time.lo: embryo_time.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libembryo_la_CFLAGS) $(CFLAGS) -MT libembryo_la-embryo_time.lo -MD -MP -MF $(DEPDIR)/libembryo_la-embryo_time.Tpo -c -o libembryo_la-embryo_time.lo `test -f 'embryo_time.c' || echo '$(srcdir)/'`embryo_time.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libembryo_la-embryo_time.Tpo $(DEPDIR)/libembryo_la-embryo_time.Plo
+@am__fastdepCC_FALSE@   $(AM_V_CC) @AM_BACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       source='embryo_time.c' object='libembryo_la-embryo_time.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libembryo_la_CFLAGS) $(CFLAGS) -c -o libembryo_la-embryo_time.lo `test -f 'embryo_time.c' || echo '$(srcdir)/'`embryo_time.c
+
+mostlyclean-libtool:
+        -rm -f *.lo
+
+clean-libtool:
+        -rm -rf .libs _libs
+install-includesHEADERS: $(includes_HEADERS)
+        @$(NORMAL_INSTALL)
+        test -z "$(includesdir)" || $(MKDIR_P) "$(DESTDIR)$(includesdir)"
+        @list='$(includes_HEADERS)'; test -n "$(includesdir)" || list=; \
+        for p in $$list; do \
+          if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+          echo "$$d$$p"; \
+        done | $(am__base_list) | \
+        while read files; do \
+          echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(includesdir)'"; \
+          $(INSTALL_HEADER) $$files "$(DESTDIR)$(includesdir)" || exit $$?; \
+        done
+
+uninstall-includesHEADERS:
+        @$(NORMAL_UNINSTALL)
+        @list='$(includes_HEADERS)'; test -n "$(includesdir)" || list=; \
+        files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+        test -n "$$files" || exit 0; \
+        echo " ( cd '$(DESTDIR)$(includesdir)' && rm -f" $$files ")"; \
+        cd "$(DESTDIR)$(includesdir)" && rm -f $$files
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+        list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+        unique=`for i in $$list; do \
+            if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+          done | \
+          $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+              END { if (nonempty) { for (i in files) print i; }; }'`; \
+        mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+                $(TAGS_FILES) $(LISP)
+        set x; \
+        here=`pwd`; \
+        list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+        unique=`for i in $$list; do \
+            if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+          done | \
+          $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+              END { if (nonempty) { for (i in files) print i; }; }'`; \
+        shift; \
+        if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+          test -n "$$unique" || unique=$$empty_fix; \
+          if test $$# -gt 0; then \
+            $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+              "$$@" $$unique; \
+          else \
+            $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+              $$unique; \
+          fi; \
+        fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+                $(TAGS_FILES) $(LISP)
+        list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+        unique=`for i in $$list; do \
+            if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+          done | \
+          $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+              END { if (nonempty) { for (i in files) print i; }; }'`; \
+        test -z "$(CTAGS_ARGS)$$unique" \
+          || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+             $$unique
+
+GTAGS:
+        here=`$(am__cd) $(top_builddir) && pwd` \
+          && $(am__cd) $(top_srcdir) \
+          && gtags -i $(GTAGS_ARGS) "$$here"
+
+distclean-tags:
+        -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+        @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+        topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+        list='$(DISTFILES)'; \
+          dist_files=`for file in $$list; do echo $$file; done | \
+          sed -e "s|^$$srcdirstrip/||;t" \
+              -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+        case $$dist_files in \
+          */*) $(MKDIR_P) `echo "$$dist_files" | \
+                           sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+                           sort -u` ;; \
+        esac; \
+        for file in $$dist_files; do \
+          if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+          if test -d $$d/$$file; then \
+            dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+            if test -d "$(distdir)/$$file"; then \
+              find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+            fi; \
+            if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+              cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+              find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+            fi; \
+            cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+          else \
+            test -f "$(distdir)/$$file" \
+            || cp -p $$d/$$file "$(distdir)/$$file" \
+            || exit 1; \
+          fi; \
+        done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES) $(HEADERS)
+installdirs:
+        for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(includesdir)"; do \
+          test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+        done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+        @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+        $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+          install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+          `test -z '$(STRIP)' || \
+            echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+        -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+        -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+        @echo "This command is intended for maintainers to use"
+        @echo "it deletes files that may require special tools to rebuild."
+        -test -z "$(MAINTAINERCLEANFILES)" || rm -f $(MAINTAINERCLEANFILES)
+clean: clean-am
+
+clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
+        mostlyclean-am
+
+distclean: distclean-am
+        -rm -rf ./$(DEPDIR)
+        -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+        distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-includesHEADERS
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+        -rm -rf ./$(DEPDIR)
+        -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+        mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-includesHEADERS uninstall-libLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+        clean-libLTLIBRARIES clean-libtool ctags distclean \
+        distclean-compile distclean-generic distclean-libtool \
+        distclean-tags distdir dvi dvi-am html html-am info info-am \
+        install install-am install-data install-data-am install-dvi \
+        install-dvi-am install-exec install-exec-am install-html \
+        install-html-am install-includesHEADERS install-info \
+        install-info-am install-libLTLIBRARIES install-man install-pdf \
+        install-pdf-am install-ps install-ps-am install-strip \
+        installcheck installcheck-am installdirs maintainer-clean \
+        maintainer-clean-generic mostlyclean mostlyclean-compile \
+        mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+        tags uninstall uninstall-am uninstall-includesHEADERS \
+        uninstall-libLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/libraries/embryo/src/lib/embryo_amx.c b/libraries/embryo/src/lib/embryo_amx.c
new file mode 100644
index 0000000..4fa84c5
--- /dev/null
+++ b/libraries/embryo/src/lib/embryo_amx.c
@@ -0,0 +1,1991 @@
+/*  Abstract Machine for the Small compiler
+ *
+ *  Copyright (c) ITB CompuPhase, 1997-2003
+ *  Portions Copyright (c) Carsten Haitzler, 2004-2010 <raster@rasterman.com>
+ *
+ *  This software is provided "as-is", without any express or implied warranty.
+ *  In no event will the authors be held liable for any damages arising from
+ *  the use of this software.
+ *
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ *
+ *  1.  The origin of this software must not be misrepresented; you must not
+ *      claim that you wrote the original software. If you use this software in
+ *      a product, an acknowledgment in the product documentation would be
+ *      appreciated but is not required.
+ *  2.  Altered source versions must be plainly marked as such, and must not be
+ *      misrepresented as being the original software.
+ *  3.  This notice may not be removed or altered from any source distribution.
+ */
+
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "Embryo.h"
+#include "embryo_private.h"
+
+
+#define JUMPABS(base, ip)     ((Embryo_Cell *)(code + (*ip)))
+
+#ifdef WORDS_BIGENDIAN
+static void _embryo_byte_swap_16 (unsigned short *v);
+static void _embryo_byte_swap_32 (unsigned int *v);
+#endif
+static int  _embryo_native_call  (Embryo_Program *ep, Embryo_Cell index, Embryo_Cell *result, Embryo_Cell *params);
+static int  _embryo_func_get     (Embryo_Program *ep, int index, char *funcname);
+static int  _embryo_var_get      (Embryo_Program *ep, int index, char *varname, Embryo_Cell *ep_addr);
+static int  _embryo_program_init (Embryo_Program *ep, void *code);
+
+#ifdef WORDS_BIGENDIAN
+static void
+_embryo_byte_swap_16(unsigned short *v)
+{
+   unsigned char *s, t;
+
+   s = (unsigned char *)v;
+   t = s[0]; s[0] = s[1]; s[1] = t;
+}
+
+static void
+_embryo_byte_swap_32(unsigned int *v)
+{
+   unsigned char *s, t;
+
+   s = (unsigned char *)v;
+   t = s[0]; s[0] = s[3]; s[3] = t;
+   t = s[1]; s[1] = s[2]; s[2] = t;
+}
+#endif
+
+static int
+_embryo_native_call(Embryo_Program *ep, Embryo_Cell index, Embryo_Cell *result, Embryo_Cell *params)
+{
+   Embryo_Header    *hdr;
+   Embryo_Func_Stub *func_entry;
+   Embryo_Native     f;
+
+   hdr = (Embryo_Header *)ep->base;
+   func_entry = GETENTRY(hdr, natives, index);
+   if ((func_entry->address <= 0) ||
+       (func_entry->address > ep->native_calls_size))
+     {
+        ep->error = EMBRYO_ERROR_CALLBACK;
+        return ep->error;
+     }
+   f = ep->native_calls[func_entry->address - 1];
+   if (!f)
+     {
+        ep->error = EMBRYO_ERROR_CALLBACK;
+        return ep->error;
+     }
+   ep->error = EMBRYO_ERROR_NONE;
+   *result = f(ep, params);
+   return ep->error;
+}
+
+static int
+_embryo_func_get(Embryo_Program *ep, int index, char *funcname)
+{
+   Embryo_Header    *hdr;
+   Embryo_Func_Stub *func;
+
+   hdr = (Embryo_Header *)ep->code;
+   if (index >= (Embryo_Cell)NUMENTRIES(hdr, publics, natives))
+     return EMBRYO_ERROR_INDEX;
+
+   func = GETENTRY(hdr, publics, index);
+   strcpy(funcname, GETENTRYNAME(hdr, func));
+   return EMBRYO_ERROR_NONE;
+}
+
+static int
+_embryo_var_get(Embryo_Program *ep, int index, char *varname, Embryo_Cell *ep_addr)
+{
+
+  Embryo_Header    *hdr;
+  Embryo_Func_Stub *var;
+
+  hdr=(Embryo_Header *)ep->base;
+  if (index >= (Embryo_Cell)NUMENTRIES(hdr, pubvars, tags))
+     return EMBRYO_ERROR_INDEX;
+
+  var = GETENTRY(hdr, pubvars, index);
+  strcpy(varname, GETENTRYNAME(hdr, var));
+  *ep_addr = var->address;
+  return EMBRYO_ERROR_NONE;
+}
+
+static int
+_embryo_program_init(Embryo_Program *ep, void *code)
+{
+   Embryo_Header    *hdr;
+
+   if ((ep->flags & EMBRYO_FLAG_RELOC)) return 1;
+   ep->code = (unsigned char *)code;
+   hdr = (Embryo_Header *)ep->code;
+#ifdef WORDS_BIGENDIAN
+   embryo_swap_32((unsigned int *)&hdr->size);
+   embryo_swap_16((unsigned short *)&hdr->magic);
+   embryo_swap_16((unsigned short *)&hdr->flags);
+   embryo_swap_16((unsigned short *)&hdr->defsize);
+   embryo_swap_32((unsigned int *)&hdr->cod);
+   embryo_swap_32((unsigned int *)&hdr->dat);
+   embryo_swap_32((unsigned int *)&hdr->hea);
+   embryo_swap_32((unsigned int *)&hdr->stp);
+   embryo_swap_32((unsigned int *)&hdr->cip);
+   embryo_swap_32((unsigned int *)&hdr->publics);
+   embryo_swap_32((unsigned int *)&hdr->natives);
+   embryo_swap_32((unsigned int *)&hdr->libraries);
+   embryo_swap_32((unsigned int *)&hdr->pubvars);
+   embryo_swap_32((unsigned int *)&hdr->tags);
+   embryo_swap_32((unsigned int *)&hdr->nametable);
+#endif
+
+   if (hdr->magic != EMBRYO_MAGIC) return 0;
+   if ((hdr->file_version < MIN_FILE_VERSION) ||
+      (hdr->ep_version > CUR_FILE_VERSION)) return 0;
+   if ((hdr->defsize != sizeof(Embryo_Func_Stub)) &&
+      (hdr->defsize != (2 * sizeof(unsigned int)))) return 0;
+   if (hdr->defsize == (2 * sizeof(unsigned int)))
+     {
+        unsigned short *len;
+
+        len = (unsigned short*)((unsigned char*)ep->code + hdr->nametable);
+#ifdef WORDS_BIGENDIAN
+        embryo_swap_16((unsigned short *)len);
+#endif
+        if (*len > sNAMEMAX) return 0;
+     }
+   if (hdr->stp <= 0) return 0;
+   if ((hdr->flags & EMBRYO_FLAG_COMPACT)) return 0;
+
+#ifdef WORDS_BIGENDIAN
+     {
+        Embryo_Func_Stub *fs;
+        int i, num;
+
+        /* also align all addresses in the public function, public variable and */
+        /* public tag tables */
+        fs = GETENTRY(hdr, publics, 0);
+        num = NUMENTRIES(hdr, publics, natives);
+        for (i = 0; i < num; i++)
+          {
+             embryo_swap_32(&(fs->address));
+             fs = (Embryo_Func_Stub *)((unsigned char *)fs + hdr->defsize);
+          }
+
+        fs = GETENTRY(hdr, pubvars, 0);
+        num = NUMENTRIES(hdr, pubvars, tags);
+        for (i = 0; i < num; i++)
+          {
+             embryo_swap_32(&(fs->address));
+             fs = (Embryo_Func_Stub *)((unsigned char *)fs + hdr->defsize);
+          }
+
+        fs = GETENTRY(hdr, tags, 0);
+        num = NUMENTRIES(hdr, tags, nametable);
+        for (i = 0; i < num; i++)
+          {
+             embryo_swap_32(&(fs->address));
+             fs = (Embryo_Func_Stub *)((unsigned char *)fs + hdr->defsize);
+          }
+     }
+#endif
+   ep->flags = EMBRYO_FLAG_RELOC;
+
+     {
+        Embryo_Cell cip, code_size, cip_end;
+        Embryo_Cell *code;
+
+        code_size = hdr->dat - hdr->cod;
+        code = (Embryo_Cell *)((unsigned char *)ep->code + (int)hdr->cod);
+        cip_end = code_size / sizeof(Embryo_Cell);
+        for (cip = 0; cip < cip_end; cip++)
+          {
+/* move this here - later we probably want something that verifies opcodes
+ * are valid and ok...
+ */
+#ifdef WORDS_BIGENDIAN
+             embryo_swap_32(&(code[cip]));
+#endif
+
+          }
+     }
+   /* init native api for handling floating point - default in embryo */
+   _embryo_args_init(ep);
+   _embryo_fp_init(ep);
+   _embryo_rand_init(ep);
+   _embryo_str_init(ep);
+   _embryo_time_init(ep);
+   return 1;
+}
+
+/*** EXPORTED CALLS ***/
+
+EAPI Embryo_Program *
+embryo_program_new(void *data, int size)
+{
+   Embryo_Program *ep;
+   void *code_data;
+
+   if (size < (int)sizeof(Embryo_Header)) return NULL;
+
+   ep = calloc(1, sizeof(Embryo_Program));
+   if (!ep) return NULL;
+
+   code_data = malloc(size);
+   if (!code_data)
+     {
+        free(ep);
+        return NULL;
+     }
+   memcpy(code_data, data, size);
+   if (_embryo_program_init(ep, code_data)) return ep;
+   free(code_data);
+   free(ep);
+   return NULL;
+}
+
+EAPI Embryo_Program *
+embryo_program_const_new(void *data, int size)
+{
+   Embryo_Program *ep;
+
+   if (size < (int)sizeof(Embryo_Header)) return NULL;
+
+   ep = calloc(1, sizeof(Embryo_Program));
+   if (!ep) return NULL;
+
+   if (_embryo_program_init(ep, data))
+     {
+        ep->dont_free_code = 1;
+        return ep;
+     }
+   free(ep);
+   return NULL;
+}
+
+EAPI Embryo_Program *
+embryo_program_load(const char *file)
+{
+   Embryo_Program *ep;
+   Embryo_Header   hdr;
+   FILE *f;
+   void *program = NULL;
+   int program_size = 0;
+
+   f = fopen(file, "rb");
+   if (!f) return NULL;
+   fseek(f, 0, SEEK_END);
+   program_size = ftell(f);
+   fseek(f, 0L, SEEK_SET);
+   if (program_size < (int)sizeof(Embryo_Header))
+     {
+        fclose(f);
+        return NULL;
+     }
+   if (fread(&hdr, sizeof(Embryo_Header), 1, f) != 1)
+     {
+        fclose(f);
+        return NULL;
+     }
+   fseek(f, 0L, SEEK_SET);
+#ifdef WORDS_BIGENDIAN
+   embryo_swap_32((unsigned int *)(&hdr.size));
+#endif
+   if ((int)hdr.size < program_size) program_size = hdr.size;
+   program = malloc(program_size);
+   if (!program)
+     {
+        fclose(f);
+        return NULL;
+     }
+   if (fread(program, program_size, 1, f) != 1)
+     {
+        free(program);
+        fclose(f);
+        return NULL;
+     }
+   ep = embryo_program_new(program, program_size);
+   free(program);
+   fclose(f);
+   return ep;
+}
+
+EAPI void
+embryo_program_free(Embryo_Program *ep)
+{
+   int i;
+
+   if (ep->base) free(ep->base);
+   if ((!ep->dont_free_code) && (ep->code)) free(ep->code);
+   if (ep->native_calls) free(ep->native_calls);
+   for (i = 0; i < ep->params_size; i++)
+     {
+        if (ep->params[i].string) free(ep->params[i].string);
+        if (ep->params[i].cell_array) free(ep->params[i].cell_array);
+     }
+   if (ep->params) free(ep->params);
+   free(ep);
+}
+
+
+EAPI void
+embryo_program_native_call_add(Embryo_Program *ep, const char *name, Embryo_Cell (*func) (Embryo_Program *ep, Embryo_Cell *params))
+{
+   Embryo_Func_Stub *func_entry;
+   Embryo_Header    *hdr;
+   int               i, num;
+
+   if ((!ep ) || (!name) || (!func)) return;
+   if (strlen(name) > sNAMEMAX) return;
+
+   hdr = (Embryo_Header *)ep->code;
+   if (hdr->defsize < 1) return;
+   num = NUMENTRIES(hdr, natives, libraries);
+   if (num <= 0) return;
+
+   ep->native_calls_size++;
+   if (ep->native_calls_size > ep->native_calls_alloc)
+     {
+        Embryo_Native *calls;
+
+        ep->native_calls_alloc += 32;
+        calls = realloc(ep->native_calls,
+                        ep->native_calls_alloc * sizeof(Embryo_Native));
+        if (!calls)
+          {
+             ep->native_calls_size--;
+             ep->native_calls_alloc -= 32;
+             return;
+          }
+        ep->native_calls = calls;
+     }
+   ep->native_calls[ep->native_calls_size - 1] = func;
+
+   func_entry = GETENTRY(hdr, natives, 0);
+   for (i = 0; i < num; i++)
+     {
+        if (func_entry->address == 0)
+          {
+             char *entry_name;
+
+             entry_name = GETENTRYNAME(hdr, func_entry);
+             if ((entry_name) && (!strcmp(entry_name, name)))
+               {
+                  func_entry->address = ep->native_calls_size;
+                  /* FIXME: embryo_cc is putting in multiple native */
+                  /* function call entries - so we need to fill in all */
+                  /* of them!!! */
+                  /* return; */
+               }
+          }
+        func_entry =
+          (Embryo_Func_Stub *)((unsigned char *)func_entry + hdr->defsize);
+     }
+}
+
+
+EAPI void
+embryo_program_vm_reset(Embryo_Program *ep)
+{
+   Embryo_Header *hdr;
+
+   if ((!ep) || (!ep->base)) return;
+   hdr = (Embryo_Header *)ep->code;
+   memcpy(ep->base, hdr, hdr->size);
+   *(Embryo_Cell *)(ep->base + (int)hdr->stp - sizeof(Embryo_Cell)) = 0;
+
+   ep->hlw = hdr->hea - hdr->dat; /* stack and heap relative to data segment */
+   ep->stp = hdr->stp - hdr->dat - sizeof(Embryo_Cell);
+   ep->hea = ep->hlw;
+   ep->stk = ep->stp;
+}
+
+EAPI void
+embryo_program_vm_push(Embryo_Program *ep)
+{
+   Embryo_Header *hdr;
+
+   if (!ep) return;
+   ep->pushes++;
+   if (ep->pushes > 1)
+     {
+        embryo_program_vm_reset(ep);
+        return;
+     }
+   hdr = (Embryo_Header *)ep->code;
+   ep->base = malloc(hdr->stp);
+   if (!ep->base)
+     {
+        ep->pushes = 0;
+        return;
+     }
+   embryo_program_vm_reset(ep);
+}
+
+EAPI void
+embryo_program_vm_pop(Embryo_Program *ep)
+{
+   if ((!ep) || (!ep->base)) return;
+   ep->pushes--;
+   if (ep->pushes >= 1) return;
+   free(ep->base);
+   ep->base = NULL;
+}
+
+
+EAPI void
+embryo_swap_16(unsigned short *v
+#ifndef WORDS_BIGENDIAN
+               __UNUSED__
+#endif               
+              )
+{
+#ifdef WORDS_BIGENDIAN
+   _embryo_byte_swap_16(v);
+#endif
+}
+
+EAPI void
+embryo_swap_32(unsigned int *v
+#ifndef WORDS_BIGENDIAN
+               __UNUSED__
+#endif
+               )
+{
+#ifdef WORDS_BIGENDIAN
+   _embryo_byte_swap_32(v);
+#endif
+}
+
+EAPI Embryo_Function
+embryo_program_function_find(Embryo_Program *ep, const char *name)
+{
+   int            first, last, mid, result;
+   char           pname[sNAMEMAX + 1];
+   Embryo_Header *hdr;
+
+   if (!ep) return EMBRYO_FUNCTION_NONE;
+   hdr = (Embryo_Header *)ep->code;
+   last = NUMENTRIES(hdr, publics, natives) - 1;
+   first = 0;
+   /* binary search */
+   while (first <= last)
+     {
+        mid = (first + last) / 2;
+        if (_embryo_func_get(ep, mid, pname) == EMBRYO_ERROR_NONE)
+          result = strcmp(pname, name);
+        else
+          return EMBRYO_FUNCTION_NONE;
+/*        result = -1;*/
+        if (result > 0) last = mid - 1;
+        else if (result < 0) first = mid + 1;
+        else return mid;
+     }
+   return EMBRYO_FUNCTION_NONE;
+}
+
+
+EAPI Embryo_Cell
+embryo_program_variable_find(Embryo_Program *ep, const char *name)
+{
+   int            first, last, mid, result;
+   char           pname[sNAMEMAX + 1];
+   Embryo_Cell    paddr;
+   Embryo_Header *hdr;
+
+   if (!ep) return EMBRYO_CELL_NONE;
+   if (!ep->base) return EMBRYO_CELL_NONE;
+   hdr = (Embryo_Header *)ep->base;
+   last = NUMENTRIES(hdr, pubvars, tags) - 1;
+   first = 0;
+   /* binary search */
+   while (first <= last)
+     {
+        mid = (first + last) / 2;
+        if (_embryo_var_get(ep, mid, pname, &paddr) == EMBRYO_ERROR_NONE)
+          result = strcmp(pname, name);
+        else
+          return EMBRYO_CELL_NONE;
+/*        result = -1;*/
+        if (result > 0) last = mid - 1;
+        else if (result < 0) first = mid + 1;
+        else return paddr;
+     }
+   return EMBRYO_CELL_NONE;
+}
+
+EAPI int
+embryo_program_variable_count_get(Embryo_Program *ep)
+{
+   Embryo_Header *hdr;
+
+   if (!ep) return 0;
+   if (!ep->base) return 0;
+   hdr = (Embryo_Header *)ep->base;
+   return NUMENTRIES(hdr, pubvars, tags);
+}
+
+EAPI Embryo_Cell
+embryo_program_variable_get(Embryo_Program *ep, int num)
+{
+   Embryo_Cell    paddr;
+   char           pname[sNAMEMAX + 1];
+
+   if (!ep) return EMBRYO_CELL_NONE;
+   if (!ep->base) return EMBRYO_CELL_NONE;
+   if (_embryo_var_get(ep, num, pname, &paddr) == EMBRYO_ERROR_NONE)
+     return paddr;
+   return EMBRYO_CELL_NONE;
+}
+
+
+EAPI void
+embryo_program_error_set(Embryo_Program *ep, Embryo_Error error)
+{
+   if (!ep) return;
+   ep->error = error;
+}
+
+EAPI Embryo_Error
+embryo_program_error_get(Embryo_Program *ep)
+{
+   if (!ep) return EMBRYO_ERROR_NONE;
+   return ep->error;
+}
+
+
+EAPI void
+embryo_program_data_set(Embryo_Program *ep, void *data)
+{
+   if (!ep) return;
+   ep->data = data;
+}
+
+EAPI void *
+embryo_program_data_get(Embryo_Program *ep)
+{
+   if (!ep) return NULL;
+   return ep->data;
+}
+
+EAPI const char *
+embryo_error_string_get(Embryo_Error error)
+{
+   const char *messages[] =
+     {
+        /* EMBRYO_ERROR_NONE      */ "(none)",
+          /* EMBRYO_ERROR_EXIT      */ "Forced exit",
+          /* EMBRYO_ERROR_ASSERT    */ "Assertion failed",
+          /* EMBRYO_ERROR_STACKERR  */ "Stack/heap collision (insufficient stack size)",
+          /* EMBRYO_ERROR_BOUNDS    */ "Array index out of bounds",
+          /* EMBRYO_ERROR_MEMACCESS */ "Invalid memory access",
+          /* EMBRYO_ERROR_INVINSTR  */ "Invalid instruction",
+          /* EMBRYO_ERROR_STACKLOW  */ "Stack underflow",
+          /* EMBRYO_ERROR_HEAPLOW   */ "Heap underflow",
+          /* EMBRYO_ERROR_CALLBACK  */ "No (valid) native function callback",
+          /* EMBRYO_ERROR_NATIVE    */ "Native function failed",
+          /* EMBRYO_ERROR_DIVIDE    */ "Divide by zero",
+          /* EMBRYO_ERROR_SLEEP     */ "(sleep mode)",
+          /* 13 */                     "(reserved)",
+          /* 14 */                     "(reserved)",
+          /* 15 */                     "(reserved)",
+          /* EMBRYO_ERROR_MEMORY    */ "Out of memory",
+          /* EMBRYO_ERROR_FORMAT    */ "Invalid/unsupported P-code file format",
+          /* EMBRYO_ERROR_VERSION   */ "File is for a newer version of the Embryo_Program",
+          /* EMBRYO_ERROR_NOTFOUND  */ "Native/Public function is not found",
+          /* EMBRYO_ERROR_INDEX     */ "Invalid index parameter (bad entry point)",
+          /* EMBRYO_ERROR_DEBUG     */ "Debugger cannot run",
+          /* EMBRYO_ERROR_INIT      */ "Embryo_Program not initialized (or doubly initialized)",
+          /* EMBRYO_ERROR_USERDATA  */ "Unable to set user data field (table full)",
+          /* EMBRYO_ERROR_INIT_JIT  */ "Cannot initialize the JIT",
+          /* EMBRYO_ERROR_PARAMS    */ "Parameter error",
+     };
+   if (((int)error < 0) || 
+       ((int)error >= (int)(sizeof(messages) / sizeof(messages[0]))))
+     return (const char *)"(unknown)";
+   return messages[error];
+}
+
+
+EAPI int
+embryo_data_string_length_get(Embryo_Program *ep, Embryo_Cell *str_cell)
+{
+   int            len;
+   Embryo_Header *hdr;
+
+   if ((!ep) || (!ep->base)) return 0;
+   hdr = (Embryo_Header *)ep->base;
+   if ((!str_cell) ||
+       ((void *)str_cell >= (void *)(ep->base + hdr->stp)) ||
+       ((void *)str_cell < (void *)ep->base))
+     return 0;
+   for (len = 0; str_cell[len] != 0; len++);
+   return len;
+}
+
+EAPI void
+embryo_data_string_get(Embryo_Program *ep, Embryo_Cell *str_cell, char *dst)
+{
+   int            i;
+   Embryo_Header *hdr;
+
+   if (!dst) return;
+   if ((!ep) || (!ep->base))
+     {
+        dst[0] = 0;
+        return;
+     }
+   hdr = (Embryo_Header *)ep->base;
+   if ((!str_cell) ||
+       ((void *)str_cell >= (void *)(ep->base + hdr->stp)) ||
+       ((void *)str_cell < (void *)ep->base))
+     {
+        dst[0] = 0;
+        return;
+     }
+   for (i = 0; str_cell[i] != 0; i++)
+     {
+#ifdef WORDS_BIGENDIAN
+          {
+             Embryo_Cell tmp;
+
+             tmp = str_cell[i];
+             _embryo_byte_swap_32(&tmp);
+             dst[i] = tmp;
+          }
+#else
+        dst[i] = str_cell[i];
+#endif
+     }
+   dst[i] = 0;
+}
+
+EAPI void
+embryo_data_string_set(Embryo_Program *ep, const char *src, Embryo_Cell *str_cell)
+{
+   int            i;
+   Embryo_Header *hdr;
+
+   if (!ep) return;
+   if (!ep->base) return;
+   hdr = (Embryo_Header *)ep->base;
+   if ((!str_cell) ||
+       ((void *)str_cell >= (void *)(ep->base + hdr->stp)) ||
+       ((void *)str_cell < (void *)ep->base))
+     return;
+   if (!src)
+     {
+        str_cell[0] = 0;
+        return;
+     }
+   for (i = 0; src[i] != 0; i++)
+     {
+        if ((void *)(&(str_cell[i])) >= (void *)(ep->base + hdr->stp)) return;
+        else if ((void *)(&(str_cell[i])) == (void *)(ep->base + hdr->stp - 1))
+          {
+             str_cell[i] = 0;
+             return;
+          }
+#ifdef WORDS_BIGENDIAN
+          {
+             Embryo_Cell tmp;
+
+             tmp = src[i];
+             _embryo_byte_swap_32(&tmp);
+             str_cell[i] = tmp;
+          }
+#else
+        str_cell[i] = src[i];
+#endif
+     }
+   str_cell[i] = 0;
+}
+
+EAPI Embryo_Cell *
+embryo_data_address_get(Embryo_Program *ep, Embryo_Cell addr)
+{
+   Embryo_Header *hdr;
+   unsigned char *data;
+
+   if ((!ep) || (!ep->base)) return NULL;
+   hdr = (Embryo_Header *)ep->base;
+   data = ep->base + (int)hdr->dat;
+   if ((addr < 0) || (addr >= hdr->stp)) return NULL;
+   return (Embryo_Cell *)(data + (int)addr);
+}
+
+
+EAPI Embryo_Cell
+embryo_data_heap_push(Embryo_Program *ep, int cells)
+{
+   Embryo_Header *hdr;
+   Embryo_Cell    addr;
+
+   if ((!ep) || (!ep->base)) return EMBRYO_CELL_NONE;
+   hdr = (Embryo_Header *)ep->base;
+   if (ep->stk - ep->hea - (cells * sizeof(Embryo_Cell)) < STKMARGIN)
+     return EMBRYO_CELL_NONE;
+   addr = ep->hea;
+   ep->hea += (cells * sizeof(Embryo_Cell));
+   return addr;
+}
+
+EAPI void
+embryo_data_heap_pop(Embryo_Program *ep, Embryo_Cell down_to)
+{
+   if (!ep) return;
+   if (down_to < 0) down_to = 0;
+   if (ep->hea > down_to) ep->hea = down_to;
+}
+
+
+EAPI int
+embryo_program_recursion_get(Embryo_Program *ep)
+{
+   return ep->run_count;
+}
+
+#ifdef __GNUC__
+#if 1
+#define EMBRYO_EXEC_JUMPTABLE
+#endif
+#endif
+
+/* jump table optimization - only works for gcc though */
+#ifdef EMBRYO_EXEC_JUMPTABLE
+#define SWITCH(x) while (1) { goto *switchtable[x];
+#define SWITCHEND break; }
+#define CASE(x) SWITCHTABLE_##x:
+#define BREAK break;
+#else
+#define SWITCH(x) switch (x) {
+#define SWITCHEND }
+#define CASE(x) case x:
+#define BREAK break
+#endif
+
+EAPI Embryo_Status
+embryo_program_run(Embryo_Program *ep, Embryo_Function fn)
+{
+   Embryo_Header    *hdr;
+   Embryo_Func_Stub *func;
+   unsigned char    *code, *data;
+   Embryo_Cell      pri, alt, stk, frm, hea, hea_start;
+   Embryo_Cell      reset_stk, reset_hea, *cip;
+   Embryo_UCell     codesize;
+   int              i;
+   unsigned char    op;
+   Embryo_Cell      offs;
+   int              num;
+   int              max_run_cycles;
+   int              cycle_count;
+#ifdef EMBRYO_EXEC_JUMPTABLE
+   /* we limit the jumptable to 256 elements. why? above we forced "op" to be
+    * a unsigned char - that means 256 max values. we limit opcode overflow
+    * here, so eliminating crashes on table lookups with bad/corrupt bytecode.
+    * no need to atuall do compares, branches etc. the datatype does the work
+    * for us. so that means EXCESS elements are all declared as OP_NONE to
+    * keep them innocuous.
+    */
+   static const void *switchtable[256] =
+     {
+           &&SWITCHTABLE_EMBRYO_OP_NONE,
+               &&SWITCHTABLE_EMBRYO_OP_LOAD_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_LOAD_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_LOAD_S_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_LOAD_S_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_LREF_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_LREF_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_LREF_S_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_LREF_S_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_LOAD_I,
+               &&SWITCHTABLE_EMBRYO_OP_LODB_I,
+               &&SWITCHTABLE_EMBRYO_OP_CONST_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_CONST_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_ADDR_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_ADDR_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_STOR_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_STOR_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_STOR_S_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_STOR_S_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_SREF_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_SREF_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_SREF_S_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_SREF_S_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_STOR_I,
+               &&SWITCHTABLE_EMBRYO_OP_STRB_I,
+               &&SWITCHTABLE_EMBRYO_OP_LIDX,
+               &&SWITCHTABLE_EMBRYO_OP_LIDX_B,
+               &&SWITCHTABLE_EMBRYO_OP_IDXADDR,
+               &&SWITCHTABLE_EMBRYO_OP_IDXADDR_B,
+               &&SWITCHTABLE_EMBRYO_OP_ALIGN_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_ALIGN_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_LCTRL,
+               &&SWITCHTABLE_EMBRYO_OP_SCTRL,
+               &&SWITCHTABLE_EMBRYO_OP_MOVE_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_MOVE_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_XCHG,
+               &&SWITCHTABLE_EMBRYO_OP_PUSH_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_PUSH_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_PUSH_R,
+               &&SWITCHTABLE_EMBRYO_OP_PUSH_C,
+               &&SWITCHTABLE_EMBRYO_OP_PUSH,
+               &&SWITCHTABLE_EMBRYO_OP_PUSH_S,
+               &&SWITCHTABLE_EMBRYO_OP_POP_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_POP_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_STACK,
+               &&SWITCHTABLE_EMBRYO_OP_HEAP,
+               &&SWITCHTABLE_EMBRYO_OP_PROC,
+               &&SWITCHTABLE_EMBRYO_OP_RET,
+               &&SWITCHTABLE_EMBRYO_OP_RETN,
+               &&SWITCHTABLE_EMBRYO_OP_CALL,
+               &&SWITCHTABLE_EMBRYO_OP_CALL_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_JUMP,
+               &&SWITCHTABLE_EMBRYO_OP_JREL,
+               &&SWITCHTABLE_EMBRYO_OP_JZER,
+               &&SWITCHTABLE_EMBRYO_OP_JNZ,
+               &&SWITCHTABLE_EMBRYO_OP_JEQ,
+               &&SWITCHTABLE_EMBRYO_OP_JNEQ,
+               &&SWITCHTABLE_EMBRYO_OP_JLESS,
+               &&SWITCHTABLE_EMBRYO_OP_JLEQ,
+               &&SWITCHTABLE_EMBRYO_OP_JGRTR,
+               &&SWITCHTABLE_EMBRYO_OP_JGEQ,
+               &&SWITCHTABLE_EMBRYO_OP_JSLESS,
+               &&SWITCHTABLE_EMBRYO_OP_JSLEQ,
+               &&SWITCHTABLE_EMBRYO_OP_JSGRTR,
+               &&SWITCHTABLE_EMBRYO_OP_JSGEQ,
+               &&SWITCHTABLE_EMBRYO_OP_SHL,
+               &&SWITCHTABLE_EMBRYO_OP_SHR,
+               &&SWITCHTABLE_EMBRYO_OP_SSHR,
+               &&SWITCHTABLE_EMBRYO_OP_SHL_C_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_SHL_C_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_SHR_C_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_SHR_C_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_SMUL,
+               &&SWITCHTABLE_EMBRYO_OP_SDIV,
+               &&SWITCHTABLE_EMBRYO_OP_SDIV_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_UMUL,
+               &&SWITCHTABLE_EMBRYO_OP_UDIV,
+               &&SWITCHTABLE_EMBRYO_OP_UDIV_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_ADD,
+               &&SWITCHTABLE_EMBRYO_OP_SUB,
+               &&SWITCHTABLE_EMBRYO_OP_SUB_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_AND,
+               &&SWITCHTABLE_EMBRYO_OP_OR,
+               &&SWITCHTABLE_EMBRYO_OP_XOR,
+               &&SWITCHTABLE_EMBRYO_OP_NOT,
+               &&SWITCHTABLE_EMBRYO_OP_NEG,
+               &&SWITCHTABLE_EMBRYO_OP_INVERT,
+               &&SWITCHTABLE_EMBRYO_OP_ADD_C,
+               &&SWITCHTABLE_EMBRYO_OP_SMUL_C,
+               &&SWITCHTABLE_EMBRYO_OP_ZERO_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_ZERO_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_ZERO,
+               &&SWITCHTABLE_EMBRYO_OP_ZERO_S,
+               &&SWITCHTABLE_EMBRYO_OP_SIGN_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_SIGN_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_EQ,
+               &&SWITCHTABLE_EMBRYO_OP_NEQ,
+               &&SWITCHTABLE_EMBRYO_OP_LESS,
+               &&SWITCHTABLE_EMBRYO_OP_LEQ,
+               &&SWITCHTABLE_EMBRYO_OP_GRTR,
+               &&SWITCHTABLE_EMBRYO_OP_GEQ,
+               &&SWITCHTABLE_EMBRYO_OP_SLESS,
+               &&SWITCHTABLE_EMBRYO_OP_SLEQ,
+               &&SWITCHTABLE_EMBRYO_OP_SGRTR,
+               &&SWITCHTABLE_EMBRYO_OP_SGEQ,
+               &&SWITCHTABLE_EMBRYO_OP_EQ_C_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_EQ_C_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_INC_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_INC_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_INC,
+               &&SWITCHTABLE_EMBRYO_OP_INC_S,
+               &&SWITCHTABLE_EMBRYO_OP_INC_I,
+               &&SWITCHTABLE_EMBRYO_OP_DEC_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_DEC_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_DEC,
+               &&SWITCHTABLE_EMBRYO_OP_DEC_S,
+               &&SWITCHTABLE_EMBRYO_OP_DEC_I,
+               &&SWITCHTABLE_EMBRYO_OP_MOVS,
+               &&SWITCHTABLE_EMBRYO_OP_CMPS,
+               &&SWITCHTABLE_EMBRYO_OP_FILL,
+               &&SWITCHTABLE_EMBRYO_OP_HALT,
+               &&SWITCHTABLE_EMBRYO_OP_BOUNDS,
+               &&SWITCHTABLE_EMBRYO_OP_SYSREQ_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_SYSREQ_C,
+               &&SWITCHTABLE_EMBRYO_OP_FILE,
+               &&SWITCHTABLE_EMBRYO_OP_LINE,
+               &&SWITCHTABLE_EMBRYO_OP_SYMBOL,
+               &&SWITCHTABLE_EMBRYO_OP_SRANGE,
+               &&SWITCHTABLE_EMBRYO_OP_JUMP_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_SWITCH,
+               &&SWITCHTABLE_EMBRYO_OP_CASETBL,
+               &&SWITCHTABLE_EMBRYO_OP_SWAP_PRI,
+               &&SWITCHTABLE_EMBRYO_OP_SWAP_ALT,
+               &&SWITCHTABLE_EMBRYO_OP_PUSHADDR,
+               &&SWITCHTABLE_EMBRYO_OP_NOP,
+               &&SWITCHTABLE_EMBRYO_OP_SYSREQ_D,
+               &&SWITCHTABLE_EMBRYO_OP_SYMTAG,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE,
+          &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE
+     };
+#endif
+   if (!ep) return EMBRYO_PROGRAM_FAIL;
+   if (!(ep->flags & EMBRYO_FLAG_RELOC))
+     {
+        ep->error = EMBRYO_ERROR_INIT;
+        return EMBRYO_PROGRAM_FAIL;
+     }
+   if (!ep->base)
+     {
+        ep->error = EMBRYO_ERROR_INIT;
+        return EMBRYO_PROGRAM_FAIL;
+     }
+   if (ep->run_count > 0)
+     {
+        /* return EMBRYO_PROGRAM_BUSY; */
+        /* FIXME: test C->vm->C->vm recursion more fully */
+        /* it seems to work... just fine!!! - strange! */
+     }
+
+   /* set up the registers */
+   hdr = (Embryo_Header *)ep->base;
+   codesize = (Embryo_UCell)(hdr->dat - hdr->cod);
+   code = ep->base + (int)hdr->cod;
+   data = ep->base + (int)hdr->dat;
+   hea_start = hea = ep->hea;
+   stk = ep->stk;
+   reset_stk = stk;
+   reset_hea = hea;
+   frm = alt = pri = 0;
+
+   /* get the start address */
+   if (fn == EMBRYO_FUNCTION_MAIN)
+     {
+        if (hdr->cip < 0)
+          {
+             ep->error = EMBRYO_ERROR_INDEX;
+             return EMBRYO_PROGRAM_FAIL;
+          }
+        cip = (Embryo_Cell *)(code + (int)hdr->cip);
+     }
+   else if (fn == EMBRYO_FUNCTION_CONT)
+     {
+        /* all registers: pri, alt, frm, cip, hea, stk, reset_stk, reset_hea */
+        frm = ep->frm;
+        stk = ep->stk;
+        hea = ep->hea;
+        pri = ep->pri;
+        alt = ep->alt;
+        reset_stk = ep->reset_stk;
+        reset_hea = ep->reset_hea;
+        cip = (Embryo_Cell *)(code + (int)ep->cip);
+     }
+   else if (fn < 0)
+     {
+        ep->error = EMBRYO_ERROR_INDEX;
+        return EMBRYO_PROGRAM_FAIL;
+     }
+   else
+     {
+        if (fn >= (Embryo_Cell)NUMENTRIES(hdr, publics, natives))
+          {
+             ep->error = EMBRYO_ERROR_INDEX;
+             return EMBRYO_PROGRAM_FAIL;
+          }
+        func = GETENTRY(hdr, publics, fn);
+        cip = (Embryo_Cell *)(code + (int)func->address);
+     }
+   /* check values just copied */
+   CHKSTACK();
+   CHKHEAP();
+
+   if (fn != EMBRYO_FUNCTION_CONT)
+     {
+        int i;
+
+        for (i = ep->params_size - 1; i >= 0; i--)
+          {
+             Embryo_Param *pr;
+
+             pr = &(ep->params[i]);
+             if (pr->string)
+               {
+                  int len;
+                  Embryo_Cell ep_addr, *addr;
+
+                  len = strlen(pr->string);
+                  ep_addr = embryo_data_heap_push(ep, len + 1);
+                  if (ep_addr == EMBRYO_CELL_NONE)
+                    {
+                       ep->error = EMBRYO_ERROR_HEAPLOW;
+                       return EMBRYO_PROGRAM_FAIL;
+                    }
+                  addr = embryo_data_address_get(ep, ep_addr);
+                  if (addr)
+                    embryo_data_string_set(ep, pr->string, addr);
+                  else
+                    {
+                       ep->error = EMBRYO_ERROR_HEAPLOW;
+                       return EMBRYO_PROGRAM_FAIL;
+                    }
+                  PUSH(ep_addr);
+                  free(pr->string);
+               }
+             else if (pr->cell_array)
+               {
+                  int len;
+                  Embryo_Cell ep_addr, *addr;
+
+                  len = pr->cell_array_size;
+                  ep_addr = embryo_data_heap_push(ep, len + 1);
+                  if (ep_addr == EMBRYO_CELL_NONE)
+                    {
+                       ep->error = EMBRYO_ERROR_HEAPLOW;
+                       return EMBRYO_PROGRAM_FAIL;
+                    }
+                  addr = embryo_data_address_get(ep, ep_addr);
+                  if (addr)
+                    memcpy(addr, pr->cell_array,
+                           pr->cell_array_size * sizeof(Embryo_Cell));
+                  else
+                    {
+                       ep->error = EMBRYO_ERROR_HEAPLOW;
+                       return EMBRYO_PROGRAM_FAIL;
+                    }
+                  PUSH(ep_addr);
+                  free(pr->cell_array);
+               }
+             else
+               {
+                  PUSH(pr->cell);
+               }
+          }
+        PUSH(ep->params_size * sizeof(Embryo_Cell));
+        PUSH(0);
+        if (ep->params)
+          {
+             free(ep->params);
+             ep->params = NULL;
+          }
+        ep->params_size = ep->params_alloc = 0;
+     }
+   /* check stack/heap before starting to run */
+   CHKMARGIN();
+
+   /* track recursion depth */
+   ep->run_count++;
+
+   max_run_cycles = ep->max_run_cycles;
+   /* start running */
+   for (cycle_count = 0;;)
+     {
+        if (max_run_cycles > 0)
+          {
+             if (cycle_count >= max_run_cycles)
+               {
+                  TOOLONG(ep);
+               }
+             cycle_count++;
+          }
+        op = (Embryo_Opcode)*cip++;
+        SWITCH(op);
+        CASE(EMBRYO_OP_LOAD_PRI);
+        GETPARAM(offs);
+        pri = *(Embryo_Cell *)(data + (int)offs);
+        BREAK;
+        CASE(EMBRYO_OP_LOAD_ALT);
+        GETPARAM(offs);
+        alt = *(Embryo_Cell *)(data + (int)offs);
+        BREAK;
+        CASE(EMBRYO_OP_LOAD_S_PRI);
+        GETPARAM(offs);
+        pri = *(Embryo_Cell *)(data + (int)frm + (int)offs);
+        BREAK;
+        CASE(EMBRYO_OP_LOAD_S_ALT);
+        GETPARAM(offs);
+        alt = *(Embryo_Cell *)(data + (int)frm + (int)offs);
+        BREAK;
+        CASE(EMBRYO_OP_LREF_PRI);
+        GETPARAM(offs);
+        offs = *(Embryo_Cell *)(data + (int)offs);
+        pri = *(Embryo_Cell *)(data + (int)offs);
+        BREAK;
+        CASE(EMBRYO_OP_LREF_ALT);
+        GETPARAM(offs);
+        offs = *(Embryo_Cell *)(data + (int)offs);
+        alt = *(Embryo_Cell *)(data + (int)offs);
+        BREAK;
+        CASE(EMBRYO_OP_LREF_S_PRI);
+        GETPARAM(offs);
+        offs = *(Embryo_Cell *)(data + (int)frm + (int)offs);
+        pri = *(Embryo_Cell *)(data + (int)offs);
+        BREAK;
+        CASE(EMBRYO_OP_LREF_S_ALT);
+        GETPARAM(offs);
+        offs = *(Embryo_Cell *)(data + (int)frm + (int)offs);
+        alt = *(Embryo_Cell *)(data + (int)offs);
+        BREAK;
+        CASE(EMBRYO_OP_LOAD_I);
+        CHKMEM(pri);
+        pri = *(Embryo_Cell *)(data + (int)pri);
+        BREAK;
+        CASE(EMBRYO_OP_LODB_I);
+        GETPARAM(offs);
+        CHKMEM(pri);
+        switch (offs)
+          {
+           case 1:
+             pri = *(data + (int)pri);
+             break;
+           case 2:
+             pri = *(unsigned short *)(data + (int)pri);
+             break;
+           case 4:
+             pri = *(unsigned int *)(data + (int)pri);
+             break;
+           default:
+             ABORT(ep, EMBRYO_ERROR_INVINSTR);
+             break;
+          }
+        BREAK;
+        CASE(EMBRYO_OP_CONST_PRI);
+        GETPARAM(pri);
+        BREAK;
+        CASE(EMBRYO_OP_CONST_ALT);
+        GETPARAM(alt);
+        BREAK;
+        CASE(EMBRYO_OP_ADDR_PRI);
+        GETPARAM(pri);
+        pri += frm;
+        BREAK;
+        CASE(EMBRYO_OP_ADDR_ALT);
+        GETPARAM(alt);
+        alt += frm;
+        BREAK;
+        CASE(EMBRYO_OP_STOR_PRI);
+        GETPARAM(offs);
+        *(Embryo_Cell *)(data + (int)offs) = pri;
+        BREAK;
+        CASE(EMBRYO_OP_STOR_ALT);
+        GETPARAM(offs);
+        *(Embryo_Cell *)(data + (int)offs) = alt;
+        BREAK;
+        CASE(EMBRYO_OP_STOR_S_PRI);
+        GETPARAM(offs);
+        *(Embryo_Cell *)(data + (int)frm + (int)offs) = pri;
+        BREAK;
+        CASE(EMBRYO_OP_STOR_S_ALT);
+        GETPARAM(offs);
+        *(Embryo_Cell *)(data + (int)frm + (int)offs) = alt;
+        BREAK;
+        CASE(EMBRYO_OP_SREF_PRI);
+        GETPARAM(offs);
+        offs = *(Embryo_Cell *)(data + (int)offs);
+        *(Embryo_Cell *)(data + (int)offs) = pri;
+        BREAK;
+        CASE(EMBRYO_OP_SREF_ALT);
+        GETPARAM(offs);
+        offs = *(Embryo_Cell *)(data + (int)offs);
+        *(Embryo_Cell *)(data + (int)offs) = alt;
+        BREAK;
+        CASE(EMBRYO_OP_SREF_S_PRI);
+        GETPARAM(offs);
+        offs = *(Embryo_Cell *)(data + (int)frm + (int)offs);
+        *(Embryo_Cell *)(data + (int)offs) = pri;
+        BREAK;
+        CASE(EMBRYO_OP_SREF_S_ALT);
+        GETPARAM(offs);
+        offs = *(Embryo_Cell *)(data + (int)frm + (int)offs);
+        *(Embryo_Cell *)(data + (int)offs) = alt;
+        BREAK;
+        CASE(EMBRYO_OP_STOR_I);
+        CHKMEM(alt);
+        *(Embryo_Cell *)(data + (int)alt) = pri;
+        BREAK;
+        CASE(EMBRYO_OP_STRB_I);
+        GETPARAM(offs);
+        CHKMEM(alt);
+        switch (offs)
+          {
+           case 1:
+             *(data + (int)alt) = (unsigned char)pri;
+             break;
+           case 2:
+             *(unsigned short *)(data + (int)alt) = (unsigned short)pri;
+             break;
+           case 4:
+             *(unsigned int *)(data + (int)alt) = (unsigned int)pri;
+             break;
+           default:
+             ABORT(ep, EMBRYO_ERROR_INVINSTR);
+             break;
+          }
+        BREAK;
+        CASE(EMBRYO_OP_LIDX);
+        offs = (pri * sizeof(Embryo_Cell)) + alt;
+        CHKMEM(offs);
+        pri = *(Embryo_Cell *)(data + (int)offs);
+        BREAK;
+        CASE(EMBRYO_OP_LIDX_B);
+        GETPARAM(offs);
+        offs = (pri << (int)offs) + alt;
+        CHKMEM(offs);
+        pri = *(Embryo_Cell *)(data + (int)offs);
+        BREAK;
+        CASE(EMBRYO_OP_IDXADDR);
+        pri = (pri * sizeof(Embryo_Cell)) + alt;
+        BREAK;
+        CASE(EMBRYO_OP_IDXADDR_B);
+        GETPARAM(offs);
+        pri = (pri << (int)offs) + alt;
+        BREAK;
+        CASE(EMBRYO_OP_ALIGN_PRI);
+        GETPARAM(offs);
+#ifdef WORDS_BIGENDIAN
+        if ((size_t)offs < sizeof(Embryo_Cell))
+          pri ^= sizeof(Embryo_Cell) - offs;
+#endif
+        BREAK;
+        CASE(EMBRYO_OP_ALIGN_ALT);
+        GETPARAM(offs);
+#ifdef WORDS_BIGENDIAN
+        if ((size_t)offs < sizeof(Embryo_Cell))
+          alt ^= sizeof(Embryo_Cell) - offs;
+#endif
+        BREAK;
+        CASE(EMBRYO_OP_LCTRL);
+        GETPARAM(offs);
+        switch (offs)
+          {
+           case 0:
+             pri = hdr->cod;
+             break;
+           case 1:
+             pri = hdr->dat;
+             break;
+           case 2:
+             pri = hea;
+             break;
+           case 3:
+             pri = ep->stp;
+             break;
+           case 4:
+             pri = stk;
+             break;
+           case 5:
+             pri = frm;
+             break;
+           case 6:
+             pri = (Embryo_Cell)((unsigned char *)cip - code);
+             break;
+           default:
+             ABORT(ep, EMBRYO_ERROR_INVINSTR);
+             break;
+          }
+        BREAK;
+        CASE(EMBRYO_OP_SCTRL);
+        GETPARAM(offs);
+        switch (offs)
+          {
+           case 0:
+           case 1:
+           case 2:
+             hea = pri;
+             break;
+           case 3:
+             /* cannot change these parameters */
+             break;
+           case 4:
+             stk = pri;
+             break;
+           case 5:
+             frm = pri;
+             break;
+           case 6:
+             cip = (Embryo_Cell *)(code + (int)pri);
+             break;
+           default:
+             ABORT(ep, EMBRYO_ERROR_INVINSTR);
+             break;
+          }
+        BREAK;
+        CASE(EMBRYO_OP_MOVE_PRI);
+        pri = alt;
+        BREAK;
+        CASE(EMBRYO_OP_MOVE_ALT);
+        alt = pri;
+        BREAK;
+        CASE(EMBRYO_OP_XCHG);
+        offs = pri;         /* offs is a temporary variable */
+        pri = alt;
+        alt = offs;
+        BREAK;
+        CASE(EMBRYO_OP_PUSH_PRI);
+        PUSH(pri);
+        BREAK;
+        CASE(EMBRYO_OP_PUSH_ALT);
+        PUSH(alt);
+        BREAK;
+        CASE(EMBRYO_OP_PUSH_C);
+        GETPARAM(offs);
+        PUSH(offs);
+        BREAK;
+        CASE(EMBRYO_OP_PUSH_R);
+        GETPARAM(offs);
+        while (offs--) PUSH(pri);
+        BREAK;
+        CASE(EMBRYO_OP_PUSH);
+        GETPARAM(offs);
+        PUSH(*(Embryo_Cell *)(data + (int)offs));
+        BREAK;
+        CASE(EMBRYO_OP_PUSH_S);
+        GETPARAM(offs);
+        PUSH(*(Embryo_Cell *)(data + (int)frm + (int)offs));
+        BREAK;
+        CASE(EMBRYO_OP_POP_PRI);
+        POP(pri);
+        BREAK;
+        CASE(EMBRYO_OP_POP_ALT);
+        POP(alt);
+        BREAK;
+        CASE(EMBRYO_OP_STACK);
+        GETPARAM(offs);
+        alt = stk;
+        stk += offs;
+        CHKMARGIN();
+        CHKSTACK();
+        BREAK;
+        CASE(EMBRYO_OP_HEAP);
+        GETPARAM(offs);
+        alt = hea;
+        hea += offs;
+        CHKMARGIN();
+        CHKHEAP();
+        BREAK;
+        CASE(EMBRYO_OP_PROC);
+        PUSH(frm);
+        frm = stk;
+        CHKMARGIN();
+        BREAK;
+        CASE(EMBRYO_OP_RET);
+        POP(frm);
+        POP(offs);
+        if ((Embryo_UCell)offs >= codesize)
+          ABORT(ep, EMBRYO_ERROR_MEMACCESS);
+        cip = (Embryo_Cell *)(code + (int)offs);
+        BREAK;
+        CASE(EMBRYO_OP_RETN);
+        POP(frm);
+        POP(offs);
+        if ((Embryo_UCell)offs >= codesize)
+          ABORT(ep, EMBRYO_ERROR_MEMACCESS);
+        cip = (Embryo_Cell *)(code + (int)offs);
+        stk += *(Embryo_Cell *)(data + (int)stk) + sizeof(Embryo_Cell); /* remove parameters from the stack */
+        ep->stk = stk;
+        BREAK;
+        CASE(EMBRYO_OP_CALL);
+        PUSH(((unsigned char *)cip - code) + sizeof(Embryo_Cell));/* skip address */
+        cip = JUMPABS(code, cip); /* jump to the address */
+        BREAK;
+        CASE(EMBRYO_OP_CALL_PRI);
+        PUSH((unsigned char *)cip - code);
+        cip = (Embryo_Cell *)(code + (int)pri);
+        BREAK;
+        CASE(EMBRYO_OP_JUMP);
+        /* since the GETPARAM() macro modifies cip, you cannot
+         * do GETPARAM(cip) directly */
+        cip = JUMPABS(code, cip);
+        BREAK;
+        CASE(EMBRYO_OP_JREL);
+        offs = *cip;
+        cip = (Embryo_Cell *)((unsigned char *)cip + (int)offs + sizeof(Embryo_Cell));
+        BREAK;
+        CASE(EMBRYO_OP_JZER);
+        if (pri == 0)
+          cip = JUMPABS(code, cip);
+        else
+          cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
+        BREAK;
+        CASE(EMBRYO_OP_JNZ);
+        if (pri != 0)
+          cip = JUMPABS(code, cip);
+        else
+          cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
+        BREAK;
+        CASE(EMBRYO_OP_JEQ);
+        if (pri==alt)
+          cip = JUMPABS(code, cip);
+        else
+          cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
+        BREAK;
+        CASE(EMBRYO_OP_JNEQ);
+        if (pri != alt)
+          cip = JUMPABS(code, cip);
+        else
+          cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
+        BREAK;
+        CASE(EMBRYO_OP_JLESS);
+        if ((Embryo_UCell)pri < (Embryo_UCell)alt)
+          cip = JUMPABS(code, cip);
+        else
+          cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
+        BREAK;
+        CASE(EMBRYO_OP_JLEQ);
+        if ((Embryo_UCell)pri <= (Embryo_UCell)alt)
+          cip = JUMPABS(code, cip);
+        else
+          cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
+        BREAK;
+        CASE(EMBRYO_OP_JGRTR);
+        if ((Embryo_UCell)pri > (Embryo_UCell)alt)
+          cip = JUMPABS(code, cip);
+        else
+          cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
+        BREAK;
+        CASE(EMBRYO_OP_JGEQ);
+        if ((Embryo_UCell)pri >= (Embryo_UCell)alt)
+          cip = JUMPABS(code, cip);
+        else
+          cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
+        BREAK;
+        CASE(EMBRYO_OP_JSLESS);
+        if (pri < alt)
+          cip = JUMPABS(code, cip);
+        else
+          cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
+        BREAK;
+        CASE(EMBRYO_OP_JSLEQ);
+        if (pri <= alt)
+          cip = JUMPABS(code, cip);
+        else
+          cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
+        BREAK;
+        CASE(EMBRYO_OP_JSGRTR);
+        if (pri > alt)
+          cip = JUMPABS(code, cip);
+        else
+          cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
+        BREAK;
+        CASE(EMBRYO_OP_JSGEQ);
+        if (pri >= alt)
+          cip = JUMPABS(code, cip);
+        else
+          cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
+        BREAK;
+        CASE(EMBRYO_OP_SHL);
+        pri <<= alt;
+        BREAK;
+        CASE(EMBRYO_OP_SHR);
+        pri = (Embryo_UCell)pri >> (int)alt;
+        BREAK;
+        CASE(EMBRYO_OP_SSHR);
+        pri >>= alt;
+        BREAK;
+        CASE(EMBRYO_OP_SHL_C_PRI);
+        GETPARAM(offs);
+        pri <<= offs;
+        BREAK;
+        CASE(EMBRYO_OP_SHL_C_ALT);
+        GETPARAM(offs);
+        alt <<= offs;
+        BREAK;
+        CASE(EMBRYO_OP_SHR_C_PRI);
+        GETPARAM(offs);
+        pri = (Embryo_UCell)pri >> (int)offs;
+        BREAK;
+        CASE(EMBRYO_OP_SHR_C_ALT);
+        GETPARAM(offs);
+        alt = (Embryo_UCell)alt >> (int)offs;
+        BREAK;
+        CASE(EMBRYO_OP_SMUL);
+        pri *= alt;
+        BREAK;
+        CASE(EMBRYO_OP_SDIV);
+        if (alt == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE);
+        /* divide must always round down; this is a bit
+         * involved to do in a machine-independent way.
+         */
+        offs = ((pri % alt) + alt) % alt; /* true modulus */
+        pri = (pri - offs) / alt;         /* division result */
+        alt = offs;
+        BREAK;
+        CASE(EMBRYO_OP_SDIV_ALT);
+        if (pri == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE);
+        /* divide must always round down; this is a bit
+         * involved to do in a machine-independent way.
+         */
+        offs = ((alt % pri) + pri) % pri; /* true modulus */
+        pri = (alt - offs) / pri;         /* division result */
+        alt = offs;
+        BREAK;
+        CASE(EMBRYO_OP_UMUL);
+        pri = (Embryo_UCell)pri * (Embryo_UCell)alt;
+        BREAK;
+        CASE(EMBRYO_OP_UDIV);
+        if (alt == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE);
+        offs = (Embryo_UCell)pri % (Embryo_UCell)alt; /* temporary storage */
+        pri = (Embryo_UCell)pri / (Embryo_UCell)alt;
+        alt = offs;
+        BREAK;
+        CASE(EMBRYO_OP_UDIV_ALT);
+        if (pri == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE);
+        offs = (Embryo_UCell)alt % (Embryo_UCell)pri; /* temporary storage */
+        pri = (Embryo_UCell)alt / (Embryo_UCell)pri;
+        alt = offs;
+        BREAK;
+        CASE(EMBRYO_OP_ADD);
+        pri += alt;
+        BREAK;
+        CASE(EMBRYO_OP_SUB);
+        pri -= alt;
+        BREAK;
+        CASE(EMBRYO_OP_SUB_ALT);
+        pri = alt - pri;
+        BREAK;
+        CASE(EMBRYO_OP_AND);
+        pri &= alt;
+        BREAK;
+        CASE(EMBRYO_OP_OR);
+        pri |= alt;
+        BREAK;
+        CASE(EMBRYO_OP_XOR);
+        pri ^= alt;
+        BREAK;
+        CASE(EMBRYO_OP_NOT);
+        pri = !pri;
+        BREAK;
+        CASE(EMBRYO_OP_NEG);
+        pri = -pri;
+        BREAK;
+        CASE(EMBRYO_OP_INVERT);
+        pri = ~pri;
+        BREAK;
+        CASE(EMBRYO_OP_ADD_C);
+        GETPARAM(offs);
+        pri += offs;
+        BREAK;
+        CASE(EMBRYO_OP_SMUL_C);
+        GETPARAM(offs);
+        pri *= offs;
+        BREAK;
+        CASE(EMBRYO_OP_ZERO_PRI);
+        pri = 0;
+        BREAK;
+        CASE(EMBRYO_OP_ZERO_ALT);
+        alt = 0;
+        BREAK;
+        CASE(EMBRYO_OP_ZERO);
+        GETPARAM(offs);
+        *(Embryo_Cell *)(data + (int)offs) = 0;
+        BREAK;
+        CASE(EMBRYO_OP_ZERO_S);
+        GETPARAM(offs);
+        *(Embryo_Cell *)(data + (int)frm + (int)offs) = 0;
+        BREAK;
+        CASE(EMBRYO_OP_SIGN_PRI);
+        if ((pri & 0xff) >= 0x80) pri |= ~(Embryo_UCell)0xff;
+        BREAK;
+        CASE(EMBRYO_OP_SIGN_ALT);
+        if ((alt & 0xff) >= 0x80) alt |= ~(Embryo_UCell)0xff;
+        BREAK;
+        CASE(EMBRYO_OP_EQ);
+        pri = (pri == alt) ? 1 : 0;
+        BREAK;
+        CASE(EMBRYO_OP_NEQ);
+        pri = (pri != alt) ? 1 : 0;
+        BREAK;
+        CASE(EMBRYO_OP_LESS);
+        pri = ((Embryo_UCell)pri < (Embryo_UCell)alt) ? 1 : 0;
+        BREAK;
+        CASE(EMBRYO_OP_LEQ);
+        pri = ((Embryo_UCell)pri <= (Embryo_UCell)alt) ? 1 : 0;
+        BREAK;
+        CASE(EMBRYO_OP_GRTR);
+        pri = ((Embryo_UCell)pri > (Embryo_UCell)alt) ? 1 : 0;
+        BREAK;
+        CASE(EMBRYO_OP_GEQ);
+        pri = ((Embryo_UCell)pri >= (Embryo_UCell)alt) ? 1 : 0;
+        BREAK;
+        CASE(EMBRYO_OP_SLESS);
+        pri = (pri < alt) ? 1 : 0;
+        BREAK;
+        CASE(EMBRYO_OP_SLEQ);
+        pri = (pri <= alt) ? 1 : 0;
+        BREAK;
+        CASE(EMBRYO_OP_SGRTR);
+        pri = (pri > alt) ? 1 : 0;
+        BREAK;
+        CASE(EMBRYO_OP_SGEQ);
+        pri = (pri >= alt) ? 1 : 0;
+        BREAK;
+        CASE(EMBRYO_OP_EQ_C_PRI);
+        GETPARAM(offs);
+        pri = (pri == offs) ? 1 : 0;
+        BREAK;
+        CASE(EMBRYO_OP_EQ_C_ALT);
+        GETPARAM(offs);
+        pri = (alt == offs) ? 1 : 0;
+        BREAK;
+        CASE(EMBRYO_OP_INC_PRI);
+        pri++;
+        BREAK;
+        CASE(EMBRYO_OP_INC_ALT);
+        alt++;
+        BREAK;
+        CASE(EMBRYO_OP_INC);
+        GETPARAM(offs);
+        *(Embryo_Cell *)(data + (int)offs) += 1;
+        BREAK;
+        CASE(EMBRYO_OP_INC_S);
+        GETPARAM(offs);
+        *(Embryo_Cell *)(data + (int)frm + (int)offs) += 1;
+        BREAK;
+        CASE(EMBRYO_OP_INC_I);
+        *(Embryo_Cell *)(data + (int)pri) += 1;
+        BREAK;
+        CASE(EMBRYO_OP_DEC_PRI);
+        pri--;
+        BREAK;
+        CASE(EMBRYO_OP_DEC_ALT);
+        alt--;
+        BREAK;
+        CASE(EMBRYO_OP_DEC);
+        GETPARAM(offs);
+        *(Embryo_Cell *)(data + (int)offs) -= 1;
+        BREAK;
+        CASE(EMBRYO_OP_DEC_S);
+        GETPARAM(offs);
+        *(Embryo_Cell *)(data + (int)frm + (int)offs) -= 1;
+        BREAK;
+        CASE(EMBRYO_OP_DEC_I);
+        *(Embryo_Cell *)(data + (int)pri) -= 1;
+        BREAK;
+        CASE(EMBRYO_OP_MOVS);
+        GETPARAM(offs);
+        CHKMEM(pri);
+        CHKMEM(pri + offs);
+        CHKMEM(alt);
+        CHKMEM(alt + offs);
+        memcpy(data+(int)alt, data+(int)pri, (int)offs);
+        BREAK;
+        CASE(EMBRYO_OP_CMPS);
+        GETPARAM(offs);
+        CHKMEM(pri);
+        CHKMEM(pri + offs);
+        CHKMEM(alt);
+        CHKMEM(alt + offs);
+        pri = memcmp(data + (int)alt, data + (int)pri, (int)offs);
+        BREAK;
+        CASE(EMBRYO_OP_FILL);
+        GETPARAM(offs);
+        CHKMEM(alt);
+        CHKMEM(alt + offs);
+        for (i = (int)alt;
+             (size_t)offs >= sizeof(Embryo_Cell);
+             i += sizeof(Embryo_Cell), offs -= sizeof(Embryo_Cell))
+          *(Embryo_Cell *)(data + i) = pri;
+        BREAK;
+        CASE(EMBRYO_OP_HALT);
+        GETPARAM(offs);
+        ep->retval = pri;
+        /* store complete status */
+        ep->frm = frm;
+        ep->stk = stk;
+        ep->hea = hea;
+        ep->pri = pri;
+        ep->alt = alt;
+        ep->cip = (Embryo_Cell)((unsigned char*)cip - code);
+        if (offs == EMBRYO_ERROR_SLEEP)
+          {
+             ep->reset_stk = reset_stk;
+             ep->reset_hea = reset_hea;
+             ep->run_count--;
+             return EMBRYO_PROGRAM_SLEEP;
+          }
+        OK(ep, (int)offs);
+        CASE(EMBRYO_OP_BOUNDS);
+        GETPARAM(offs);
+        if ((Embryo_UCell)pri > (Embryo_UCell)offs)
+          ABORT(ep, EMBRYO_ERROR_BOUNDS);
+        BREAK;
+        CASE(EMBRYO_OP_SYSREQ_PRI);
+        /* save a few registers */
+        ep->cip = (Embryo_Cell)((unsigned char *)cip - code);
+        ep->hea = hea;
+        ep->frm = frm;
+        ep->stk = stk;
+        num = _embryo_native_call(ep, pri, &pri, (Embryo_Cell *)(data + (int)stk));
+        if (num != EMBRYO_ERROR_NONE)
+          {
+             if (num == EMBRYO_ERROR_SLEEP)
+               {
+                  ep->pri = pri;
+                  ep->alt = alt;
+                  ep->reset_stk = reset_stk;
+                  ep->reset_hea = reset_hea;
+                  ep->run_count--;
+                  return EMBRYO_PROGRAM_SLEEP;
+               }
+             ABORT(ep, num);
+          }
+        BREAK;
+        CASE(EMBRYO_OP_SYSREQ_C);
+        GETPARAM(offs);
+        /* save a few registers */
+        ep->cip = (Embryo_Cell)((unsigned char *)cip - code);
+        ep->hea = hea;
+        ep->frm = frm;
+        ep->stk = stk;
+        num = _embryo_native_call(ep, offs, &pri, (Embryo_Cell *)(data + (int)stk));
+        if (num != EMBRYO_ERROR_NONE)
+          {
+             if (num == EMBRYO_ERROR_SLEEP)
+               {
+                  ep->pri = pri;
+                  ep->alt = alt;
+                  ep->reset_stk = reset_stk;
+                  ep->reset_hea = reset_hea;
+                  ep->run_count--;
+                  return EMBRYO_PROGRAM_SLEEP;
+               }
+               {
+                  Embryo_Header    *hdr;
+                  int i, num;
+                  Embryo_Func_Stub *func_entry;
+
+                  hdr = (Embryo_Header *)ep->code;
+                  num = NUMENTRIES(hdr, natives, libraries);
+                  func_entry = GETENTRY(hdr, natives, 0);
+                  for (i = 0; i < num; i++)
+                    {
+                       char *entry_name;
+
+                       entry_name = GETENTRYNAME(hdr, func_entry);
+                       if (i == offs)
+                         printf("EMBRYO: CALL [%i] %s() non-existent!\n", i, entry_name);
+                       func_entry =
+                         (Embryo_Func_Stub *)((unsigned char *)func_entry + hdr->defsize);
+                    }
+               }
+             ABORT(ep, num);
+          }
+        BREAK;
+        CASE(EMBRYO_OP_SYSREQ_D);
+        GETPARAM(offs);
+        /* save a few registers */
+        ep->cip = (Embryo_Cell)((unsigned char *)cip - code);
+        ep->hea = hea;
+        ep->frm = frm;
+        ep->stk = stk;
+        num = _embryo_native_call(ep, offs, &pri, (Embryo_Cell *)(data + (int)stk));
+        if (num != EMBRYO_ERROR_NONE)
+          {
+             if (num == EMBRYO_ERROR_SLEEP)
+               {
+                  ep->pri = pri;
+                  ep->alt = alt;
+                  ep->reset_stk = reset_stk;
+                  ep->reset_hea = reset_hea;
+                  ep->run_count--;
+                  return EMBRYO_PROGRAM_SLEEP;
+               }
+             ABORT(ep, ep->error);
+          }
+        BREAK;
+        CASE(EMBRYO_OP_JUMP_PRI);
+        cip = (Embryo_Cell *)(code + (int)pri);
+        BREAK;
+        CASE(EMBRYO_OP_SWITCH);
+          {
+             Embryo_Cell *cptr;
+
+             /* +1, to skip the "casetbl" opcode */
+             cptr = (Embryo_Cell *)(code + (*cip)) + 1;
+             /* number of records in the case table */
+             num = (int)(*cptr);
+             /* preset to "none-matched" case */
+             cip = (Embryo_Cell *)(code + *(cptr + 1));
+             for (cptr += 2;
+                  (num > 0) && (*cptr != pri);
+                  num--, cptr += 2);
+             /* case found */
+             if (num > 0)
+               cip = (Embryo_Cell *)(code + *(cptr + 1));
+          }
+        BREAK;
+        CASE(EMBRYO_OP_SWAP_PRI);
+        offs = *(Embryo_Cell *)(data + (int)stk);
+        *(Embryo_Cell *)(data + (int)stk) = pri;
+        pri = offs;
+        BREAK;
+        CASE(EMBRYO_OP_SWAP_ALT);
+        offs = *(Embryo_Cell *)(data + (int)stk);
+        *(Embryo_Cell *)(data + (int)stk) = alt;
+        alt = offs;
+        BREAK;
+        CASE(EMBRYO_OP_PUSHADDR);
+        GETPARAM(offs);
+        PUSH(frm + offs);
+        BREAK;
+        CASE(EMBRYO_OP_NOP);
+        BREAK;
+        CASE(EMBRYO_OP_NONE);
+        CASE(EMBRYO_OP_FILE);
+        CASE(EMBRYO_OP_LINE);
+        CASE(EMBRYO_OP_SYMBOL);
+        CASE(EMBRYO_OP_SRANGE);
+        CASE(EMBRYO_OP_CASETBL);
+        CASE(EMBRYO_OP_SYMTAG);
+        BREAK;
+#ifndef EMBRYO_EXEC_JUMPTABLE
+      default:
+        ABORT(ep, EMBRYO_ERROR_INVINSTR);
+#endif
+        SWITCHEND;
+     }
+   ep->max_run_cycles = max_run_cycles;
+   ep->run_count--;
+   ep->hea = hea_start;
+   return EMBRYO_PROGRAM_OK;
+}
+
+EAPI Embryo_Cell
+embryo_program_return_value_get(Embryo_Program *ep)
+{
+   if (!ep) return 0;
+   return ep->retval;
+}
+
+EAPI void
+embryo_program_max_cycle_run_set(Embryo_Program *ep, int max)
+{
+   if (!ep) return;
+   if (max < 0) max = 0;
+   ep->max_run_cycles = max;
+}
+
+EAPI int
+embryo_program_max_cycle_run_get(Embryo_Program *ep)
+{
+   if (!ep) return 0;
+   return ep->max_run_cycles;
+}
+
+
+EAPI int
+embryo_parameter_cell_push(Embryo_Program *ep, Embryo_Cell cell)
+{
+   Embryo_Param *pr;
+
+   ep->params_size++;
+   if (ep->params_size > ep->params_alloc)
+     {
+        ep->params_alloc += 8;
+        pr = realloc(ep->params, ep->params_alloc * sizeof(Embryo_Param));
+        if (!pr) return 0;
+        ep->params = pr;
+     }
+   pr = &(ep->params[ep->params_size - 1]);
+   pr->string = NULL;
+   pr->cell_array = NULL;
+   pr->cell_array_size = 0;
+   pr->cell = 0;
+   pr->cell = cell;
+   return 1;
+}
+
+EAPI int
+embryo_parameter_string_push(Embryo_Program *ep, const char *str)
+{
+   Embryo_Param *pr;
+   char *str_dup;
+
+   if (!str)
+     return embryo_parameter_string_push(ep, "");
+   str_dup = strdup(str);
+   if (!str_dup) return 0;
+   ep->params_size++;
+   if (ep->params_size > ep->params_alloc)
+     {
+        ep->params_alloc += 8;
+        pr = realloc(ep->params, ep->params_alloc * sizeof(Embryo_Param));
+        if (!pr)
+          {
+             free(str_dup);
+             return 0;
+          }
+        ep->params = pr;
+     }
+   pr = &(ep->params[ep->params_size - 1]);
+   pr->string = NULL;
+   pr->cell_array = NULL;
+   pr->cell_array_size = 0;
+   pr->cell = 0;
+   pr->string = str_dup;
+   return 1;
+}
+
+EAPI int
+embryo_parameter_cell_array_push(Embryo_Program *ep, Embryo_Cell *cells, int num)
+{
+   Embryo_Param *pr;
+   Embryo_Cell *cell_array;
+
+   if ((!cells) || (num <= 0))
+     return embryo_parameter_cell_push(ep, 0);
+   cell_array = malloc(num * sizeof(Embryo_Cell));
+   ep->params_size++;
+   if (ep->params_size > ep->params_alloc)
+     {
+        ep->params_alloc += 8;
+        pr = realloc(ep->params, ep->params_alloc * sizeof(Embryo_Param));
+        if (!pr)
+          {
+             free(cell_array);
+             return 0;
+          }
+        ep->params = pr;
+     }
+   pr = &(ep->params[ep->params_size - 1]);
+   pr->string = NULL;
+   pr->cell_array = NULL;
+   pr->cell_array_size = 0;
+   pr->cell = 0;
+   pr->cell_array = cell_array;
+   pr->cell_array_size = num;
+   memcpy(pr->cell_array, cells, num * sizeof(Embryo_Cell));
+   return 1;
+}
diff --git a/libraries/embryo/src/lib/embryo_args.c b/libraries/embryo/src/lib/embryo_args.c
new file mode 100644
index 0000000..0c0089e
--- /dev/null
+++ b/libraries/embryo/src/lib/embryo_args.c
@@ -0,0 +1,128 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#ifdef HAVE_ALLOCA_H
+# include <alloca.h>
+#elif defined __GNUC__
+# define alloca __builtin_alloca
+#elif defined _AIX
+# define alloca __alloca
+#elif defined _MSC_VER
+# include <malloc.h>
+# define alloca _alloca
+#else
+# include <stddef.h>
+# ifdef  __cplusplus
+extern "C"
+# endif
+void *alloca (size_t);
+#endif
+
+#include "Embryo.h"
+#include "embryo_private.h"
+
+#define STRSET(ep, par, str) { \
+   Embryo_Cell *___cptr; \
+   if ((___cptr = embryo_data_address_get(ep, par))) { \
+      embryo_data_string_set(ep, str, ___cptr); \
+   } }
+
+/* exported args api */
+
+static Embryo_Cell
+_embryo_args_numargs(Embryo_Program *ep, Embryo_Cell *params __UNUSED__)
+{
+   Embryo_Header *hdr;
+   unsigned char *data;
+   Embryo_Cell bytes;
+
+   hdr = (Embryo_Header *)ep->base;
+   data = ep->base + (int)hdr->dat;
+   bytes = *(Embryo_Cell *)(data + (int)ep->frm +
+                            (2 * sizeof(Embryo_Cell)));
+   return bytes / sizeof(Embryo_Cell);
+}
+
+static Embryo_Cell
+_embryo_args_getarg(Embryo_Program *ep, Embryo_Cell *params)
+{
+   Embryo_Header *hdr;
+   unsigned char *data;
+   Embryo_Cell val;
+
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   hdr = (Embryo_Header *)ep->base;
+   data = ep->base + (int)hdr->dat;
+   val = *(Embryo_Cell *)(data + (int)ep->frm +
+                          (((int)params[1] + 3) * sizeof(Embryo_Cell)));
+   val += params[2] * sizeof(Embryo_Cell);
+   val = *(Embryo_Cell *)(data + (int)val);
+   return val;
+}
+
+static Embryo_Cell
+_embryo_args_setarg(Embryo_Program *ep, Embryo_Cell *params)
+{
+   Embryo_Header *hdr;
+   unsigned char *data;
+   Embryo_Cell val;
+
+   if (params[0] != (3 * sizeof(Embryo_Cell))) return 0;
+   hdr = (Embryo_Header *)ep->base;
+   data = ep->base + (int)hdr->dat;
+   val = *(Embryo_Cell *)(data + (int)ep->frm +
+                          (((int)params[1] + 3) * sizeof(Embryo_Cell)));
+   val += params[2] * sizeof(Embryo_Cell);
+   if ((val < 0) || ((val >= ep->hea) && (val < ep->stk))) return 0;
+   *(Embryo_Cell *)(data + (int)val) = params[3];
+   return 1;
+}
+
+static Embryo_Cell
+_embryo_args_getsarg(Embryo_Program *ep, Embryo_Cell *params)
+{
+   Embryo_Header *hdr;
+   unsigned char *data;
+   Embryo_Cell base_cell;
+   char *s;
+   int i = 0;
+
+   /* params[1] = arg_no */
+   /* params[2] = buf */
+   /* params[3] = buflen */
+   if (params[0] != (3 * sizeof(Embryo_Cell))) return 0;
+   if (params[3] <= 0) return 0; /* buflen must be > 0 */
+   hdr = (Embryo_Header *)ep->base;
+   data = ep->base + (int)hdr->dat;
+   base_cell = *(Embryo_Cell *)(data + (int)ep->frm +
+                          (((int)params[1] + 3) * sizeof(Embryo_Cell)));
+
+   s = alloca(params[3]);
+
+   while (i < params[3])
+     {
+        int offset = base_cell + (i * sizeof(Embryo_Cell));
+
+        s[i] = *(Embryo_Cell *)(data + offset);
+        if (!s[i++]) break;
+     }
+
+   s[i - 1] = 0;
+   STRSET(ep, params[2], s);
+
+   return i - 1; /* characters written minus terminator */
+}
+
+/* functions used by the rest of embryo */
+
+void
+_embryo_args_init(Embryo_Program *ep)
+{
+   embryo_program_native_call_add(ep, "numargs",  _embryo_args_numargs);
+   embryo_program_native_call_add(ep, "getarg", _embryo_args_getarg);
+   embryo_program_native_call_add(ep, "setarg", _embryo_args_setarg);
+   embryo_program_native_call_add(ep, "getfarg", _embryo_args_getarg);
+   embryo_program_native_call_add(ep, "setfarg", _embryo_args_setarg);
+   embryo_program_native_call_add(ep, "getsarg", _embryo_args_getsarg);
+}
diff --git a/libraries/embryo/src/lib/embryo_float.c b/libraries/embryo/src/lib/embryo_float.c
new file mode 100644
index 0000000..608be9d
--- /dev/null
+++ b/libraries/embryo/src/lib/embryo_float.c
@@ -0,0 +1,331 @@
+/*  Float arithmetic for the Small AMX engine
+ *
+ *  Copyright (c) Artran, Inc. 1999
+ *  Written by Greg Garner (gmg@artran.com)
+ *  Portions Copyright (c) Carsten Haitzler, 2004 <raster@rasterman.com>
+ *
+ *  This software is provided "as-is", without any express or implied warranty.
+ *  In no event will the authors be held liable for any damages arising from
+ *  the use of this software.
+ *
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ *
+ *  1.  The origin of this software must not be misrepresented; you must not
+ *      claim that you wrote the original software. If you use this software in
+ *      a product, an acknowledgment in the product documentation would be
+ *      appreciated but is not required.
+ *  2.  Altered source versions must be plainly marked as such, and must not be
+ *      misrepresented as being the original software.
+ *  3.  This notice may not be removed or altered from any source distribution.
+ */
+
+/* CHANGES -
+ * 2002-08-27: Basic conversion of source from C++ to C by Adam D. Moss
+ *             <adam@gimp.org> <aspirin@icculus.org>
+ * 2003-08-29: Removal of the dynamic memory allocation and replacing two
+ *             type conversion functions by macros, by Thiadmer Riemersma
+ * 2003-09-22: Moved the type conversion macros to AMX.H, and simplifications
+ *             of some routines, by Thiadmer Riemersma
+ * 2003-11-24: A few more native functions (geometry), plus minor modifications,
+ *             mostly to be compatible with dynamically loadable extension
+ *             modules, by Thiadmer Riemersma
+ * 2004-03-20: Cleaned up and reduced size for Embryo, Modified to conform to
+ *             E coding style. Added extra parameter checks.
+ *             Carsten Haitzler, <raster@rasterman.com>
+ */
+
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <math.h>
+
+#include "Embryo.h"
+#include "embryo_private.h"
+
+#define PI  3.1415926535897932384626433832795f
+
+/* internally useful calls */
+
+static float
+_embryo_fp_degrees_to_radians(float angle, int radix)
+{
+   switch (radix)
+     {
+      case 1: /* degrees, sexagesimal system (technically: degrees/minutes/seconds) */
+        return (angle * PI / 180.0f);
+      case 2: /* grades, centesimal system */
+        return (angle * PI / 200.0f);
+      default: /* assume already radian */
+        break;
+     }
+   return angle;
+}
+
+/* exported float api */
+
+static Embryo_Cell
+_embryo_fp(Embryo_Program *ep __UNUSED__, Embryo_Cell *params)
+{
+   /* params[1] = long value to convert to a float */
+   float f;
+
+   if (params[0] != (1 * sizeof(Embryo_Cell))) return 0;
+   f = (float)params[1];
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+static Embryo_Cell
+_embryo_fp_str(Embryo_Program *ep, Embryo_Cell *params)
+{
+   /* params[1] = virtual string address to convert to a float */
+   char buf[64];
+   Embryo_Cell *str;
+   float f;
+   int len;
+
+   if (params[0] != (1 * sizeof(Embryo_Cell))) return 0;
+   str = embryo_data_address_get(ep, params[1]);
+   len = embryo_data_string_length_get(ep, str);
+   if ((len == 0) || (len >= (int)sizeof(buf))) return 0;
+   embryo_data_string_get(ep, str, buf);
+   f = (float)atof(buf);
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+static Embryo_Cell
+_embryo_fp_mul(Embryo_Program *ep __UNUSED__, Embryo_Cell *params)
+{
+   /* params[1] = float operand 1 */
+   /* params[2] = float operand 2 */
+   float f;
+
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   f = EMBRYO_CELL_TO_FLOAT(params[1]) * EMBRYO_CELL_TO_FLOAT(params[2]);
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+static Embryo_Cell
+_embryo_fp_div(Embryo_Program *ep __UNUSED__, Embryo_Cell *params)
+{
+   /* params[1] = float dividend (top) */
+   /* params[2] = float divisor (bottom) */
+   float f;
+
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   f = EMBRYO_CELL_TO_FLOAT(params[1]) / EMBRYO_CELL_TO_FLOAT(params[2]);
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+static Embryo_Cell
+_embryo_fp_add(Embryo_Program *ep __UNUSED__, Embryo_Cell *params)
+{
+   /* params[1] = float operand 1 */
+   /* params[2] = float operand 2 */
+   float f;
+
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   f = EMBRYO_CELL_TO_FLOAT(params[1]) + EMBRYO_CELL_TO_FLOAT(params[2]);
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+static Embryo_Cell
+_embryo_fp_sub(Embryo_Program *ep __UNUSED__, Embryo_Cell *params)
+{
+   /* params[1] = float operand 1 */
+   /* params[2] = float operand 2 */
+   float f;
+
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   f = EMBRYO_CELL_TO_FLOAT(params[1]) - EMBRYO_CELL_TO_FLOAT(params[2]);
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+/* Return fractional part of float */
+static Embryo_Cell
+_embryo_fp_fract(Embryo_Program *ep __UNUSED__, Embryo_Cell *params)
+{
+   /* params[1] = float operand */
+   float f;
+
+   if (params[0] != (1 * sizeof(Embryo_Cell))) return 0;
+   f = EMBRYO_CELL_TO_FLOAT(params[1]);
+   f -= (floorf(f));
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+/* Return integer part of float, rounded */
+static Embryo_Cell
+_embryo_fp_round(Embryo_Program *ep __UNUSED__, Embryo_Cell *params)
+{
+   /* params[1] = float operand */
+   /* params[2] = Type of rounding (cell) */
+   float f;
+
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   f = EMBRYO_CELL_TO_FLOAT(params[1]);
+   switch (params[2])
+     {
+      case 1: /* round downwards (truncate) */
+        f = (floorf(f));
+        break;
+      case 2: /* round upwards */
+        f = (ceilf(f));
+        break;
+      case 3: /* round towards zero */
+        if (f >= 0.0) f = (floorf(f));
+        else          f = (ceilf(f));
+        break;
+      default: /* standard, round to nearest */
+        f = (floorf(f + 0.5));
+        break;
+     }
+    return (Embryo_Cell)f;
+}
+
+static Embryo_Cell
+_embryo_fp_cmp(Embryo_Program *ep __UNUSED__, Embryo_Cell *params)
+{
+   /* params[1] = float operand 1 */
+   /* params[2] = float operand 2 */
+   float f, ff;
+
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   f = EMBRYO_CELL_TO_FLOAT(params[1]);
+   ff = EMBRYO_CELL_TO_FLOAT(params[2]);
+   if (f == ff) return 0;
+   else if (f > ff) return 1;
+   return -1;
+}
+
+static Embryo_Cell
+_embryo_fp_sqroot(Embryo_Program *ep, Embryo_Cell *params)
+{
+   /* params[1] = float operand */
+   float f;
+
+   if (params[0] != (1 * sizeof(Embryo_Cell))) return 0;
+   f = EMBRYO_CELL_TO_FLOAT(params[1]);
+   f = sqrtf(f);
+   if (f < 0)
+     {
+        embryo_program_error_set(ep, EMBRYO_ERROR_DOMAIN);
+        return 0;
+     }
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+static Embryo_Cell
+_embryo_fp_power(Embryo_Program *ep __UNUSED__, Embryo_Cell *params)
+{
+   /* params[1] = float operand 1 */
+   /* params[2] = float operand 2 */
+   float f, ff;
+
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   f = EMBRYO_CELL_TO_FLOAT(params[1]);
+   ff = EMBRYO_CELL_TO_FLOAT(params[2]);
+   f = powf(f, ff);
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+static Embryo_Cell
+_embryo_fp_log(Embryo_Program *ep, Embryo_Cell *params)
+{
+   /* params[1] = float operand 1 (value) */
+   /* params[2] = float operand 2 (base) */
+   float f, ff;
+
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   f = EMBRYO_CELL_TO_FLOAT(params[1]);
+   ff = EMBRYO_CELL_TO_FLOAT(params[2]);
+   if ((f <= 0.0) || (ff <= 0.0))
+     {
+        embryo_program_error_set(ep, EMBRYO_ERROR_DOMAIN);
+        return 0;
+     }
+    if (ff == 10.0) f = log10f(f);
+    else f = (logf(f) / logf(ff));
+    return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+static Embryo_Cell
+_embryo_fp_sin(Embryo_Program *ep __UNUSED__, Embryo_Cell *params)
+{
+   /* params[1] = float operand 1 (angle) */
+   /* params[2] = float operand 2 (radix) */
+   float f;
+
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   f = EMBRYO_CELL_TO_FLOAT(params[1]);
+   f = _embryo_fp_degrees_to_radians(f, params[2]);
+   f = sinf(f);
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+static Embryo_Cell
+_embryo_fp_cos(Embryo_Program *ep __UNUSED__, Embryo_Cell *params)
+{
+   /* params[1] = float operand 1 (angle) */
+   /* params[2] = float operand 2 (radix) */
+   float f;
+
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   f = EMBRYO_CELL_TO_FLOAT(params[1]);
+   f = _embryo_fp_degrees_to_radians(f, params[2]);
+   f = cosf(f);
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+static Embryo_Cell
+_embryo_fp_tan(Embryo_Program *ep __UNUSED__, Embryo_Cell *params)
+{
+   /* params[1] = float operand 1 (angle) */
+   /* params[2] = float operand 2 (radix) */
+   float f;
+
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   f = EMBRYO_CELL_TO_FLOAT(params[1]);
+   f = _embryo_fp_degrees_to_radians(f, params[2]);
+   f = tanf(f);
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+static Embryo_Cell
+_embryo_fp_abs(Embryo_Program *ep __UNUSED__, Embryo_Cell *params)
+{
+   /* params[1] = float operand */
+   float f;
+
+   if (params[0] != (1 * sizeof(Embryo_Cell))) return 0;
+   f = EMBRYO_CELL_TO_FLOAT(params[1]);
+   f = (f >= 0) ? f : -f;
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+/* functions used by the rest of embryo */
+
+void
+_embryo_fp_init(Embryo_Program *ep)
+{
+   embryo_program_native_call_add(ep, "float",     _embryo_fp);
+   embryo_program_native_call_add(ep, "atof",      _embryo_fp_str);
+   embryo_program_native_call_add(ep, "float_mul", _embryo_fp_mul);
+   embryo_program_native_call_add(ep, "float_div", _embryo_fp_div);
+   embryo_program_native_call_add(ep, "float_add", _embryo_fp_add);
+   embryo_program_native_call_add(ep, "float_sub", _embryo_fp_sub);
+   embryo_program_native_call_add(ep, "fract",     _embryo_fp_fract);
+   embryo_program_native_call_add(ep, "round",     _embryo_fp_round);
+   embryo_program_native_call_add(ep, "float_cmp", _embryo_fp_cmp);
+   embryo_program_native_call_add(ep, "sqrt",      _embryo_fp_sqroot);
+   embryo_program_native_call_add(ep, "pow",       _embryo_fp_power);
+   embryo_program_native_call_add(ep, "log",       _embryo_fp_log);
+   embryo_program_native_call_add(ep, "sin",       _embryo_fp_sin);
+   embryo_program_native_call_add(ep, "cos",       _embryo_fp_cos);
+   embryo_program_native_call_add(ep, "tan",       _embryo_fp_tan);
+   embryo_program_native_call_add(ep, "abs",       _embryo_fp_abs);
+}
diff --git a/libraries/embryo/src/lib/embryo_main.c b/libraries/embryo/src/lib/embryo_main.c
new file mode 100644
index 0000000..0b01b11
--- /dev/null
+++ b/libraries/embryo/src/lib/embryo_main.c
@@ -0,0 +1,36 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <time.h>
+
+#include "Embryo.h"
+#include "embryo_private.h"
+
+static Embryo_Version _version = { VMAJ, VMIN, VMIC, VREV };
+EAPI Embryo_Version *embryo_version = &_version;
+
+static int _embryo_init_count = 0;
+
+/*** EXPORTED CALLS ***/
+
+EAPI int
+embryo_init(void)
+{
+   if (++_embryo_init_count != 1)
+     return _embryo_init_count;
+
+   srand(time(NULL));
+
+   return _embryo_init_count;
+}
+
+EAPI int
+embryo_shutdown(void)
+{
+   if (--_embryo_init_count != 0)
+     return _embryo_init_count;
+
+   return _embryo_init_count;
+}
diff --git a/libraries/embryo/src/lib/embryo_private.h b/libraries/embryo/src/lib/embryo_private.h
new file mode 100644
index 0000000..a4205e1
--- /dev/null
+++ b/libraries/embryo/src/lib/embryo_private.h
@@ -0,0 +1,298 @@
+#ifndef _EMBRYO_PRIVATE_H
+#define _EMBRYO_PRIVATE_H
+
+
+#ifdef __GNUC__
+# if __GNUC__ >= 4
+// BROKEN in gcc 4 on amd64
+//#  pragma GCC visibility push(hidden)
+# endif
+#endif
+
+typedef enum _Embryo_Opcode Embryo_Opcode;
+
+enum _Embryo_Opcode
+{
+   EMBRYO_OP_NONE,
+     EMBRYO_OP_LOAD_PRI,
+     EMBRYO_OP_LOAD_ALT,
+     EMBRYO_OP_LOAD_S_PRI,
+     EMBRYO_OP_LOAD_S_ALT,
+     EMBRYO_OP_LREF_PRI,
+     EMBRYO_OP_LREF_ALT,
+     EMBRYO_OP_LREF_S_PRI,
+     EMBRYO_OP_LREF_S_ALT,
+     EMBRYO_OP_LOAD_I,
+     EMBRYO_OP_LODB_I,
+     EMBRYO_OP_CONST_PRI,
+     EMBRYO_OP_CONST_ALT,
+     EMBRYO_OP_ADDR_PRI,
+     EMBRYO_OP_ADDR_ALT,
+     EMBRYO_OP_STOR_PRI,
+     EMBRYO_OP_STOR_ALT,
+     EMBRYO_OP_STOR_S_PRI,
+     EMBRYO_OP_STOR_S_ALT,
+     EMBRYO_OP_SREF_PRI,
+     EMBRYO_OP_SREF_ALT,
+     EMBRYO_OP_SREF_S_PRI,
+     EMBRYO_OP_SREF_S_ALT,
+     EMBRYO_OP_STOR_I,
+     EMBRYO_OP_STRB_I,
+     EMBRYO_OP_LIDX,
+     EMBRYO_OP_LIDX_B,
+     EMBRYO_OP_IDXADDR,
+     EMBRYO_OP_IDXADDR_B,
+     EMBRYO_OP_ALIGN_PRI,
+     EMBRYO_OP_ALIGN_ALT,
+     EMBRYO_OP_LCTRL,
+     EMBRYO_OP_SCTRL,
+     EMBRYO_OP_MOVE_PRI,
+     EMBRYO_OP_MOVE_ALT,
+     EMBRYO_OP_XCHG,
+     EMBRYO_OP_PUSH_PRI,
+     EMBRYO_OP_PUSH_ALT,
+     EMBRYO_OP_PUSH_R,
+     EMBRYO_OP_PUSH_C,
+     EMBRYO_OP_PUSH,
+     EMBRYO_OP_PUSH_S,
+     EMBRYO_OP_POP_PRI,
+     EMBRYO_OP_POP_ALT,
+     EMBRYO_OP_STACK,
+     EMBRYO_OP_HEAP,
+     EMBRYO_OP_PROC,
+     EMBRYO_OP_RET,
+     EMBRYO_OP_RETN,
+     EMBRYO_OP_CALL,
+     EMBRYO_OP_CALL_PRI,
+     EMBRYO_OP_JUMP,
+     EMBRYO_OP_JREL,
+     EMBRYO_OP_JZER,
+     EMBRYO_OP_JNZ,
+     EMBRYO_OP_JEQ,
+     EMBRYO_OP_JNEQ,
+     EMBRYO_OP_JLESS,
+     EMBRYO_OP_JLEQ,
+     EMBRYO_OP_JGRTR,
+     EMBRYO_OP_JGEQ,
+     EMBRYO_OP_JSLESS,
+     EMBRYO_OP_JSLEQ,
+     EMBRYO_OP_JSGRTR,
+     EMBRYO_OP_JSGEQ,
+     EMBRYO_OP_SHL,
+     EMBRYO_OP_SHR,
+     EMBRYO_OP_SSHR,
+     EMBRYO_OP_SHL_C_PRI,
+     EMBRYO_OP_SHL_C_ALT,
+     EMBRYO_OP_SHR_C_PRI,
+     EMBRYO_OP_SHR_C_ALT,
+     EMBRYO_OP_SMUL,
+     EMBRYO_OP_SDIV,
+     EMBRYO_OP_SDIV_ALT,
+     EMBRYO_OP_UMUL,
+     EMBRYO_OP_UDIV,
+     EMBRYO_OP_UDIV_ALT,
+     EMBRYO_OP_ADD,
+     EMBRYO_OP_SUB,
+     EMBRYO_OP_SUB_ALT,
+     EMBRYO_OP_AND,
+     EMBRYO_OP_OR,
+     EMBRYO_OP_XOR,
+     EMBRYO_OP_NOT,
+     EMBRYO_OP_NEG,
+     EMBRYO_OP_INVERT,
+     EMBRYO_OP_ADD_C,
+     EMBRYO_OP_SMUL_C,
+     EMBRYO_OP_ZERO_PRI,
+     EMBRYO_OP_ZERO_ALT,
+     EMBRYO_OP_ZERO,
+     EMBRYO_OP_ZERO_S,
+     EMBRYO_OP_SIGN_PRI,
+     EMBRYO_OP_SIGN_ALT,
+     EMBRYO_OP_EQ,
+     EMBRYO_OP_NEQ,
+     EMBRYO_OP_LESS,
+     EMBRYO_OP_LEQ,
+     EMBRYO_OP_GRTR,
+     EMBRYO_OP_GEQ,
+     EMBRYO_OP_SLESS,
+     EMBRYO_OP_SLEQ,
+     EMBRYO_OP_SGRTR,
+     EMBRYO_OP_SGEQ,
+     EMBRYO_OP_EQ_C_PRI,
+     EMBRYO_OP_EQ_C_ALT,
+     EMBRYO_OP_INC_PRI,
+     EMBRYO_OP_INC_ALT,
+     EMBRYO_OP_INC,
+     EMBRYO_OP_INC_S,
+     EMBRYO_OP_INC_I,
+     EMBRYO_OP_DEC_PRI,
+     EMBRYO_OP_DEC_ALT,
+     EMBRYO_OP_DEC,
+     EMBRYO_OP_DEC_S,
+     EMBRYO_OP_DEC_I,
+     EMBRYO_OP_MOVS,
+     EMBRYO_OP_CMPS,
+     EMBRYO_OP_FILL,
+     EMBRYO_OP_HALT,
+     EMBRYO_OP_BOUNDS,
+     EMBRYO_OP_SYSREQ_PRI,
+     EMBRYO_OP_SYSREQ_C,
+     EMBRYO_OP_FILE,
+     EMBRYO_OP_LINE,
+     EMBRYO_OP_SYMBOL,
+     EMBRYO_OP_SRANGE,
+     EMBRYO_OP_JUMP_PRI,
+     EMBRYO_OP_SWITCH,
+     EMBRYO_OP_CASETBL,
+     EMBRYO_OP_SWAP_PRI,
+     EMBRYO_OP_SWAP_ALT,
+     EMBRYO_OP_PUSHADDR,
+     EMBRYO_OP_NOP,
+     EMBRYO_OP_SYSREQ_D,
+     EMBRYO_OP_SYMTAG,
+     /* ----- */
+     EMBRYO_OP_NUM_OPCODES
+};
+
+#define NUMENTRIES(hdr, field, nextfield) \
+(int)(((hdr)->nextfield - (hdr)->field) / (hdr)->defsize)
+#define GETENTRY(hdr, table, index) \
+(Embryo_Func_Stub *)((unsigned char*)(hdr) + \
+(int)(hdr)->table + index * (hdr)->defsize)
+#ifdef WORDS_BIGENDIAN
+static int __inline __entryswap32(int v)
+{int vv; vv = v; embryo_swap_32((unsigned int *)&vv); return vv;}
+# define GETENTRYNAME(hdr, entry) \
+(((hdr)->defsize == 2 * sizeof(unsigned int)) \
+? (char *)((unsigned char*)(hdr) + \
+__entryswap32(*((unsigned int *)(entry) + 1))) \
+: (entry)->name)
+#else
+# define GETENTRYNAME(hdr, entry) \
+(((hdr)->defsize == 2 * sizeof(unsigned int)) \
+? (char *)((unsigned char*)(hdr) + *((unsigned int *)(entry) + 1)) \
+: (entry)->name)
+#endif
+
+#define CUR_FILE_VERSION    7      /* current file version; also the current Embryo_Program version */
+#define MIN_FILE_VERSION    7      /* lowest supported file format version for the current Embryo_Program version */
+#define MIN_AMX_VERSION     7      /* minimum Embryo_Program version needed to support the current file format */
+#define sEXPMAX             19     /* maximum name length for file version <= 6 */
+#define sNAMEMAX            31     /* maximum name length of symbol name */
+#define EMBRYO_MAGIC        0xf1e0 /* magic byte pattern */
+#define EMBRYO_FLAG_COMPACT 0x04   /* compact encoding */
+#define EMBRYO_FLAG_RELOC   0x8000 /* jump/call addresses relocated */
+#define GETPARAM(v)         (v = *(Embryo_Cell *)cip++)
+#define PUSH(v)             (stk -= sizeof(Embryo_Cell), *(Embryo_Cell *)(data + (int)stk) = v)
+#define POP(v)              (v = *(Embryo_Cell *)(data + (int)stk), stk += sizeof(Embryo_Cell))
+#define ABORT(ep,v)         {(ep)->stk = reset_stk; (ep)->hea = reset_hea; (ep)->run_count--; ep->error = v; (ep)->max_run_cycles = max_run_cycles; return EMBRYO_PROGRAM_FAIL;}
+#define OK(ep,v)            {(ep)->stk = reset_stk; (ep)->hea = reset_hea; (ep)->run_count--; ep->error = v; (ep)->max_run_cycles = max_run_cycles; return EMBRYO_PROGRAM_OK;}
+#define TOOLONG(ep)         {(ep)->pri = pri; (ep)->cip = (Embryo_Cell)((unsigned char *)cip - code); (ep)->alt = alt; (ep)->frm = frm; (ep)->stk = stk; (ep)->hea = hea; (ep)->reset_stk = reset_stk; (ep)->reset_hea = reset_hea; (ep)->run_count--; (ep)->max_run_cycles = max_run_cycles; return EMBRYO_PROGRAM_TOOLONG;}
+#define STKMARGIN           ((Embryo_Cell)(16 * sizeof(Embryo_Cell)))
+#define CHKMARGIN()         if ((hea + STKMARGIN) > stk) {ep->error = EMBRYO_ERROR_STACKERR; return 0;}
+#define CHKSTACK()          if (stk > ep->stp) {ep->run_count--; ep->error = EMBRYO_ERROR_STACKLOW; return 0;}
+#define CHKHEAP()           if (hea < ep->hlw) {ep->run_count--; ep->error = EMBRYO_ERROR_HEAPLOW; return 0;}
+#define CHKMEM(x)           if ((((x) >= hea) && ((x) < stk)) || ((Embryo_UCell)(x) >= (Embryo_UCell)ep->stp)) ABORT(ep, EMBRYO_ERROR_MEMACCESS);
+
+typedef struct _Embryo_Param        Embryo_Param;
+typedef struct _Embryo_Header       Embryo_Header;
+typedef struct _Embryo_Func_Stub    Embryo_Func_Stub;
+
+typedef Embryo_Cell (*Embryo_Native)(Embryo_Program *ep, Embryo_Cell *params);
+
+struct _Embryo_Param
+{
+   char        *string;
+   Embryo_Cell *cell_array;
+   int          cell_array_size;
+   Embryo_Cell  cell;
+};
+
+struct _Embryo_Program
+{
+   unsigned char *base; /* points to the Embryo_Program header ("ephdr") plus the code, optionally also the data */
+   int pushes; /* number of pushes - pops */
+   /* for external functions a few registers must be accessible from the outside */
+   Embryo_Cell cip; /* instruction pointer: relative to base + ephdr->cod */
+   Embryo_Cell frm; /* stack frame base: relative to base + ephdr->dat */
+   Embryo_Cell hea; /* top of the heap: relative to base + ephdr->dat */
+   Embryo_Cell hlw; /* bottom of the heap: relative to base + ephdr->dat */
+   Embryo_Cell stk; /* stack pointer: relative to base + ephdr->dat */
+   Embryo_Cell stp; /* top of the stack: relative to base + ephdr->dat */
+   int flags; /* current status  */
+   /* native functions can raise an error */
+   int error;
+   /* the sleep opcode needs to store the full Embryo_Program status */
+   Embryo_Cell pri;
+   Embryo_Cell alt;
+   Embryo_Cell reset_stk;
+   Embryo_Cell reset_hea;
+   Embryo_Cell *syscall_d; /* relocated value/address for the SYSCALL.D opcode */
+
+   /* extended stuff */
+   Embryo_Native *native_calls;
+   int            native_calls_size;
+   int            native_calls_alloc;
+
+   unsigned char *code;
+   unsigned char  dont_free_code : 1;
+   Embryo_Cell    retval;
+
+   Embryo_Param  *params;
+   int            params_size;
+   int            params_alloc;
+
+   int            run_count;
+
+   int            max_run_cycles;
+
+   void          *data;
+};
+
+#if defined (_MSC_VER) || (defined (__SUNPRO_C) && __SUNPRO_C < 0x5100)
+# pragma pack(1)
+# define EMBRYO_STRUCT_PACKED
+#elif defined (__GNUC__) || (defined (__SUNPRO_C) && __SUNPRO_C >= 0x5100)
+# define EMBRYO_STRUCT_PACKED __attribute__((packed))
+#else
+# define EMBRYO_STRUCT_PACKED
+#endif
+
+struct _Embryo_Func_Stub
+{
+   int  address;
+   char name[sEXPMAX+1];
+} EMBRYO_STRUCT_PACKED;
+
+struct _Embryo_Header
+{
+   unsigned int size; /* size of the "file" */
+   unsigned short magic; /* signature */
+   char file_version; /* file format version */
+   char ep_version; /* required version of the Embryo_Program */
+   short flags;
+   short defsize; /* size of a definition record */
+   int cod; /* initial value of COD - code block */
+   int dat; /* initial value of DAT - data block */
+   int hea; /* initial value of HEA - start of the heap */
+   int stp; /* initial value of STP - stack top */
+   int cip; /* initial value of CIP - the instruction pointer */
+   int publics; /* offset to the "public functions" table */
+   int natives; /* offset to the "native functions" table */
+   int libraries; /* offset to the table of libraries */
+   int pubvars; /* the "public variables" table */
+   int tags; /* the "public tagnames" table */
+   int nametable; /* name table, file version 7 only */
+} EMBRYO_STRUCT_PACKED;
+
+#if defined _MSC_VER || (defined (__SUNPRO_C) && __SUNPRO_C < 0x5100)
+# pragma pack()
+#endif
+
+void _embryo_args_init(Embryo_Program *ep);
+void _embryo_fp_init(Embryo_Program *ep);
+void _embryo_rand_init(Embryo_Program *ep);
+void _embryo_str_init(Embryo_Program *ep);
+void _embryo_time_init(Embryo_Program *ep);
+
+#endif
diff --git a/libraries/embryo/src/lib/embryo_rand.c b/libraries/embryo/src/lib/embryo_rand.c
new file mode 100644
index 0000000..627f7ed
--- /dev/null
+++ b/libraries/embryo/src/lib/embryo_rand.c
@@ -0,0 +1,36 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdlib.h>
+
+#include "Embryo.h"
+#include "embryo_private.h"
+
+/* exported random number api */
+
+static Embryo_Cell
+_embryo_rand_rand(Embryo_Program *ep __UNUSED__, Embryo_Cell *params __UNUSED__)
+{
+   return (Embryo_Cell)(rand() & 0xffff);
+}
+
+static Embryo_Cell
+_embryo_rand_randf(Embryo_Program *ep __UNUSED__, Embryo_Cell *params __UNUSED__)
+{
+   double r;
+   float f;
+
+   r = (double)(rand() & 0xffff) / 65535.0;
+   f = (float)r;
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+/* functions used by the rest of embryo */
+
+void
+_embryo_rand_init(Embryo_Program *ep)
+{
+   embryo_program_native_call_add(ep, "rand",  _embryo_rand_rand);
+   embryo_program_native_call_add(ep, "randf", _embryo_rand_randf);
+}
diff --git a/libraries/embryo/src/lib/embryo_str.c b/libraries/embryo/src/lib/embryo_str.c
new file mode 100644
index 0000000..46a3284
--- /dev/null
+++ b/libraries/embryo/src/lib/embryo_str.c
@@ -0,0 +1,485 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fnmatch.h>
+
+#ifdef HAVE_ALLOCA_H
+# include <alloca.h>
+#elif defined __GNUC__
+# define alloca __builtin_alloca
+#elif defined _AIX
+# define alloca __alloca
+#elif defined _MSC_VER
+# include <malloc.h>
+# define alloca _alloca
+#else
+# include <stddef.h>
+# ifdef  __cplusplus
+extern "C"
+# endif
+void *alloca (size_t);
+#endif
+
+#include "Embryo.h"
+#include "embryo_private.h"
+
+#define STRGET(ep, str, par) { \
+   Embryo_Cell *___cptr; \
+   str = NULL; \
+   if ((___cptr = embryo_data_address_get(ep, par))) { \
+        int ___l; \
+        ___l = embryo_data_string_length_get(ep, ___cptr); \
+        (str) = alloca(___l + 1); \
+        if (str) embryo_data_string_get(ep, ___cptr, str); \
+     } }
+#define STRSET(ep, par, str) { \
+   Embryo_Cell *___cptr; \
+   if ((___cptr = embryo_data_address_get(ep, par))) { \
+      embryo_data_string_set(ep, str, ___cptr); \
+   } }
+
+/* exported string api */
+
+static Embryo_Cell
+_embryo_str_atoi(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1;
+
+   /* params[1] = str */
+   if (params[0] != (1 * sizeof(Embryo_Cell))) return 0;
+   STRGET(ep, s1, params[1]);
+   if (!s1) return 0;
+   return (Embryo_Cell)atoi(s1);
+}
+
+static Embryo_Cell
+_embryo_str_fnmatch(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1, *s2;
+
+   /* params[1] = glob */
+   /* params[2] = str */
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   STRGET(ep, s1, params[1]);
+   STRGET(ep, s2, params[2]);
+   if ((!s1) || (!s2)) return -1;
+   return (Embryo_Cell)fnmatch(s1, s2, 0);
+}
+
+static Embryo_Cell
+_embryo_str_strcmp(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1, *s2;
+
+   /* params[1] = str1 */
+   /* params[2] = str2 */
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return -1;
+   STRGET(ep, s1, params[1]);
+   STRGET(ep, s2, params[2]);
+   if ((!s1) || (!s2)) return -1;
+   return (Embryo_Cell)strcmp(s1, s2);
+}
+
+static Embryo_Cell
+_embryo_str_strncmp(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1, *s2;
+
+   /* params[1] = str1 */
+   /* params[2] = str2 */
+   /* params[3] = n */
+   if (params[0] != (3 * sizeof(Embryo_Cell))) return 0;
+   if (params[3] < 0) params[3] = 0;
+   STRGET(ep, s1, params[1]);
+   STRGET(ep, s2, params[2]);
+   if ((!s1) || (!s2)) return -1;
+   return (Embryo_Cell)strncmp(s1, s2, (size_t)params[3]);
+}
+
+static Embryo_Cell
+_embryo_str_strcpy(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1;
+
+   /* params[1] = dst */
+   /* params[2] = str */
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   STRGET(ep, s1, params[2]);
+   if (!s1) return 0;
+   STRSET(ep, params[1], s1);
+   return 0;
+}
+
+static Embryo_Cell
+_embryo_str_strncpy(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1;
+   int l;
+
+   /* params[1] = dst */
+   /* params[2] = str */
+   /* params[3] = n */
+   if (params[0] != (3 * sizeof(Embryo_Cell))) return 0;
+   if (params[3] < 0) params[3] = 0;
+   STRGET(ep, s1, params[2]);
+   if (!s1) return 0;
+   l = strlen(s1);
+   if (l > params[3]) s1[params[3]] = 0;
+   STRSET(ep, params[1], s1);
+   return 0;
+}
+
+static Embryo_Cell
+_embryo_str_strlen(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1;
+
+   /* params[1] = str */
+   if (params[0] != (1 * sizeof(Embryo_Cell))) return 0;
+   STRGET(ep, s1, params[1]);
+   if (!s1) return 0;
+   return (Embryo_Cell)strlen(s1);
+}
+
+static Embryo_Cell
+_embryo_str_strcat(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1, *s2, *s3;
+
+   /* params[1] = dsr */
+   /* params[2] = str */
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   STRGET(ep, s1, params[1]);
+   STRGET(ep, s2, params[2]);
+   if ((!s1) || (!s2)) return 0;
+   s3 = alloca(strlen(s1) + strlen(s2) + 1);
+   if (!s3) return 0;
+   strcpy(s3, s1);
+   strcat(s3, s2);
+   STRSET(ep, params[1], s3);
+   return 0;
+}
+
+static Embryo_Cell
+_embryo_str_strncat(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1, *s2, *s3;
+   int l1, l2;
+
+   /* params[1] = dst */
+   /* params[2] = str */
+   /* params[3] = n */
+   if (params[0] != (3 * sizeof(Embryo_Cell))) return 0;
+   if (params[3] < 0) params[3] = 0;
+   STRGET(ep, s1, params[1]);
+   STRGET(ep, s2, params[2]);
+   if ((!s1) || (!s2)) return 0;
+   l1 = strlen(s1);
+   l2 = strlen(s2);
+   s3 = alloca(l1 + l2 + 1);
+   if (!s3) return 0;
+   strcpy(s3, s1);
+   strncat(s3, s2, params[3]);
+   if (l2 >= params[3]) s3[l1 + params[3]] = 0;
+   STRSET(ep, params[1], s3);
+   return 0;
+}
+
+static Embryo_Cell
+_embryo_str_strprep(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1, *s2, *s3;
+
+   /* params[1] = dst */
+   /* params[2] = str */
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   STRGET(ep, s1, params[1]);
+   STRGET(ep, s2, params[2]);
+   if ((!s1) || (!s2)) return 0;
+   s3 = alloca(strlen(s1) + strlen(s2) + 1);
+   if (!s3) return 0;
+   strcpy(s3, s2);
+   strcat(s3, s1);
+   STRSET(ep, params[1], s3);
+   return 0;
+}
+
+static Embryo_Cell
+_embryo_str_strnprep(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1, *s2, *s3;
+   int l1, l2;
+
+   /* params[1] = dst */
+   /* params[2] = str */
+   /* params[3] = n */
+   if (params[0] != (3 * sizeof(Embryo_Cell))) return 0;
+   if (params[3] < 0) params[3] = 0;
+   STRGET(ep, s1, params[1]);
+   STRGET(ep, s2, params[2]);
+   if ((!s1) || (!s2)) return 0;
+   l1 = strlen(s1);
+   l2 = strlen(s2);
+   s3 = alloca(l1 + l2 + 1);
+   if (!s3) return 0;
+   strncpy(s3, s2, params[3]);
+   if (params[3] <= l2) s3[params[3]] = 0;
+   strcat(s3, s1);
+   STRSET(ep, params[1], s3);
+   return 0;
+}
+
+static Embryo_Cell
+_embryo_str_strcut(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1, *s2;
+   int l1;
+
+   /* params[1] = dst */
+   /* params[2] = str */
+   /* params[3] = n */
+   /* params[4] = n2 */
+   if (params[0] != (4 * sizeof(Embryo_Cell))) return 0;
+   if (params[3] < 0) params[3] = 0;
+   if (params[4] < params[3]) params[4] = params[3];
+   STRGET(ep, s1, params[2]);
+   if (!s1) return 0;
+   l1 = strlen(s1);
+   if (params[3] >= l1) params[3] = l1;
+   if (params[4] >= l1) params[4] = l1;
+   if (params[4] == params[3])
+     {
+        STRSET(ep, params[1], "");
+        return 0;
+     }
+   s2 = alloca(params[4] - params[3] + 1);
+   strncpy(s2, s1 + params[3], params[4] - params[3]);
+   s2[params[4] - params[3]] = 0;
+   STRSET(ep, params[1], s2);
+   return 0;
+}
+
+static Embryo_Cell
+_embryo_str_snprintf(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1, *s2;
+   int i, o;
+   int inesc = 0;
+   int insub = 0;
+   int p, pnum;
+
+   /* params[1] = buf */
+   /* params[2] = bufsize */
+   /* params[3] = format_string */
+   /* params[4] = first arg ... */
+   if (params[0] < (Embryo_Cell)(3 * sizeof(Embryo_Cell))) return 0;
+   if (params[2] <= 0) return 0;
+   STRGET(ep, s1, params[3]);
+   if (!s1) return -1;
+   s2 = alloca(params[2] + 1);
+   if (!s2) return -1;
+   s2[0] = 0;
+   pnum = (params[0] / sizeof(Embryo_Cell)) - 3;
+   for (p = 0, o = 0, i = 0; (s1[i]) && (o < (params[2] - 1)) && (p < (pnum + 1)); i++)
+     {
+        if ((!inesc) && (!insub))
+          {
+             if      (s1[i] == '\\') inesc = 1;
+             else if (s1[i] == '%')  insub = 1;
+             if ((!inesc) && (!insub))
+               {
+                  s2[o] = s1[i];
+                  o++;
+               }
+          }
+        else
+          {
+             Embryo_Cell *cptr;
+
+             if (inesc)
+               {
+                  switch (s1[i])
+                    {
+                     case 't':
+                       s2[o] = '\t';
+                       o++;
+                       break;
+                     case 'n':
+                       s2[o] = '\n';
+                       o++;
+                       break;
+                     default:
+                       s2[o] = s1[i];
+                       o++;
+                       break;
+                    }
+                  inesc = 0;
+               }
+             if ((insub) && (s1[i] == '%')) pnum++;
+             if ((insub) && (p < pnum))
+               {
+                  switch (s1[i])
+                    {
+                     case '%':
+                       s2[o] = '%';
+                       o++;
+                       break;
+                     case 'c':
+                       cptr = embryo_data_address_get(ep, params[4 + p]);
+                       if (cptr) s2[o] = (char)(*cptr);
+                       p++;
+                       o++;
+                       break;
+                     case 'i':
+                     case 'd':
+                     case 'x':
+                     case 'X':
+                         {
+                            char fmt[10] = "";
+                            char tmp[256] = "";
+                            int l;
+
+                            if      (s1[i] == 'i') strcpy(fmt, "%i");
+                            else if (s1[i] == 'd') strcpy(fmt, "%d");
+                            else if (s1[i] == 'x') strcpy(fmt, "%x");
+                            else if (s1[i] == 'X') strcpy(fmt, "%08x");
+                            cptr = embryo_data_address_get(ep, params[4 + p]);
+                            if (cptr) snprintf(tmp, sizeof(tmp), fmt, (int)(*cptr));
+                            l = strlen(tmp);
+                            if ((o + l) > (params[2] - 1))
+                              {
+                                 l = params[2] - 1 - o;
+                                 if (l < 0) l = 0;
+                                 tmp[l] = 0;
+                              }
+                            strcpy(s2 + o, tmp);
+                            o += l;
+                            p++;
+                         }
+                       break;
+                     case 'f':
+                         {
+                            char tmp[256] = "";
+                            int l;
+
+                            cptr = embryo_data_address_get(ep, params[4 + p]);
+                            if (cptr) snprintf(tmp, sizeof(tmp), "%f", (double)EMBRYO_CELL_TO_FLOAT(*cptr));
+                            l = strlen(tmp);
+                            if ((o + l) > (params[2] - 1))
+                              {
+                                 l = params[2] - 1 - o;
+                                 if (l < 0) l = 0;
+                                 tmp[l] = 0;
+                              }
+                            strcpy(s2 + o, tmp);
+                            o += l;
+                            p++;
+                         }
+                       break;
+                     case 's':
+                         {
+                            char *tmp;
+                            int l;
+
+                            STRGET(ep, tmp, params[4 + p]);
+                            l = strlen(tmp);
+                            if ((o + l) > (params[2] - 1))
+                              {
+                                 l = params[2] - 1 - o;
+                                 if (l < 0) l = 0;
+                                 tmp[l] = 0;
+                              }
+                            strcpy(s2 + o, tmp);
+                            o += l;
+                            p++;
+                         }
+                       break;
+                     default:
+                       break;
+                    }
+                  insub = 0;
+               }
+             else if (insub)
+               insub = 0;
+          }
+     }
+   s2[o] = 0;
+
+   STRSET(ep, params[1], s2);
+   return o;
+}
+
+static Embryo_Cell
+_embryo_str_strstr(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1, *s2, *p;
+
+   /* params[1] = str */
+   /* params[2] = ndl */
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   STRGET(ep, s1, params[1]);
+   STRGET(ep, s2, params[2]);
+   if ((!s1) || (!s2)) return -1;
+   p = strstr(s1, s2);
+   if (!p) return -1;
+   return (Embryo_Cell)(p - s1);
+}
+
+static Embryo_Cell
+_embryo_str_strchr(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1, *s2, *p;
+
+   /* params[1] = str */
+   /* params[2] = ch */
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   STRGET(ep, s1, params[1]);
+   STRGET(ep, s2, params[2]);
+   if ((!s1) || (!s2)) return -1;
+   p = strchr(s1, s2[0]);
+   if (!p) return -1;
+   return (Embryo_Cell)(p - s1);
+}
+
+static Embryo_Cell
+_embryo_str_strrchr(Embryo_Program *ep, Embryo_Cell *params)
+{
+   char *s1, *s2, *p;
+
+   /* params[1] = str */
+   /* params[2] = ch */
+   if (params[0] != (2 * sizeof(Embryo_Cell))) return 0;
+   STRGET(ep, s1, params[1]);
+   STRGET(ep, s2, params[2]);
+   if ((!s1) || (!s2)) return -1;
+   p = strrchr(s1, s2[0]);
+   if (!p) return -1;
+   return (Embryo_Cell)(p - s1);
+}
+
+/* functions used by the rest of embryo */
+
+void
+_embryo_str_init(Embryo_Program *ep)
+{
+   embryo_program_native_call_add(ep, "atoi",     _embryo_str_atoi);
+   embryo_program_native_call_add(ep, "fnmatch",  _embryo_str_fnmatch);
+   embryo_program_native_call_add(ep, "strcmp",   _embryo_str_strcmp);
+   embryo_program_native_call_add(ep, "strncmp",  _embryo_str_strncmp);
+   embryo_program_native_call_add(ep, "strcpy",   _embryo_str_strcpy);
+   embryo_program_native_call_add(ep, "strncpy",  _embryo_str_strncpy);
+   embryo_program_native_call_add(ep, "strlen",   _embryo_str_strlen);
+   embryo_program_native_call_add(ep, "strcat",   _embryo_str_strcat);
+   embryo_program_native_call_add(ep, "strncat",  _embryo_str_strncat);
+   embryo_program_native_call_add(ep, "strprep",  _embryo_str_strprep);
+   embryo_program_native_call_add(ep, "strnprep", _embryo_str_strnprep);
+   embryo_program_native_call_add(ep, "strcut",   _embryo_str_strcut);
+   embryo_program_native_call_add(ep, "snprintf", _embryo_str_snprintf);
+   embryo_program_native_call_add(ep, "strstr",   _embryo_str_strstr);
+   embryo_program_native_call_add(ep, "strchr",   _embryo_str_strchr);
+   embryo_program_native_call_add(ep, "strrchr",  _embryo_str_strrchr);
+}
diff --git a/libraries/embryo/src/lib/embryo_time.c b/libraries/embryo/src/lib/embryo_time.c
new file mode 100644
index 0000000..8392ec3
--- /dev/null
+++ b/libraries/embryo/src/lib/embryo_time.c
@@ -0,0 +1,93 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#ifndef HAVE_GETTIMEOFDAY
+# error "Your platform isn't supported yet"
+#endif
+
+#include <sys/time.h>
+#include <time.h>
+
+#ifdef _MSC_VER
+# include <winsock2.h>
+#endif
+
+#ifdef HAVE_EVIL
+# include <Evil.h>
+#endif
+
+#include "Embryo.h"
+#include "embryo_private.h"
+
+/* exported time api */
+
+static Embryo_Cell
+_embryo_time_seconds(Embryo_Program *ep __UNUSED__, Embryo_Cell *params __UNUSED__)
+{
+   struct timeval      timev;
+   double t;
+   float  f;
+
+   gettimeofday(&timev, NULL);
+   t = (double)(timev.tv_sec - ((timev.tv_sec / (60 * 60 * 24)) * (60 * 60 * 24)))
+     + (((double)timev.tv_usec) / 1000000);
+   f = (float)t;
+   return EMBRYO_FLOAT_TO_CELL(f);
+}
+
+static Embryo_Cell
+_embryo_time_date(Embryo_Program *ep, Embryo_Cell *params)
+{
+   static time_t       last_tzset = 0;
+   struct timeval      timev;
+   struct tm          *tm;
+   time_t              tt;
+
+   if (params[0] != (8 * sizeof(Embryo_Cell))) return 0;
+   gettimeofday(&timev, NULL);
+   tt = (time_t)(timev.tv_sec);
+   if ((tt > (last_tzset + 1)) ||
+       (tt < (last_tzset - 1)))
+     {
+        last_tzset = tt;
+        tzset();
+     }
+   tm = localtime(&tt);
+   if (tm)
+     {
+        Embryo_Cell *cptr;
+        double t;
+        float  f;
+
+        cptr = embryo_data_address_get(ep, params[1]);
+        if (cptr) *cptr = tm->tm_year + 1900;
+        cptr = embryo_data_address_get(ep, params[2]);
+        if (cptr) *cptr = tm->tm_mon + 1;
+        cptr = embryo_data_address_get(ep, params[3]);
+        if (cptr) *cptr = tm->tm_mday;
+        cptr = embryo_data_address_get(ep, params[4]);
+        if (cptr) *cptr = tm->tm_yday;
+        cptr = embryo_data_address_get(ep, params[5]);
+        if (cptr) *cptr = (tm->tm_wday + 6) % 7;
+        cptr = embryo_data_address_get(ep, params[6]);
+        if (cptr) *cptr = tm->tm_hour;
+        cptr = embryo_data_address_get(ep, params[7]);
+        if (cptr) *cptr = tm->tm_min;
+        cptr = embryo_data_address_get(ep, params[8]);
+        t = (double)tm->tm_sec + (((double)timev.tv_usec) / 1000000);
+        f = (float)t;
+        if (cptr) *cptr = EMBRYO_FLOAT_TO_CELL(f);
+
+     }
+   return 0;
+}
+
+/* functions used by the rest of embryo */
+
+void
+_embryo_time_init(Embryo_Program *ep)
+{
+   embryo_program_native_call_add(ep, "seconds", _embryo_time_seconds);
+   embryo_program_native_call_add(ep, "date",    _embryo_time_date);
+}