embed.pod - Parrot embedding system


    #include "parrot/embed.h"

    int main(int argc, char *argv[]) {
        Parrot_Interp interp;
        Parrot_PackFile pf;
        char * bcfile = "program.pbc";

        argc--; argv++; /* skip the program name */


        if(PARROT_JIT_CAPABLE) {
            Parrot_set_run_core(interp, PARROT_JIT_CORE);  /* activate JIT */

        pf = Parrot_readbc(interp, bcfile);
        Parrot_loadbc(interp, pf);

        /* argc and argv as seen by the bytecode file */
        Parrot_runcode(interp, argc, argv);


        return 0;





Parrot's embedding system is designed with one guiding principle in mind: encapsulation. Users of Parrot shouldn't have to know what the insides of a Parrot_Interp structure look like or how to load a packfile. They should just know a few functions and constants. The embedding system is designed to do just that.

Data Structures ^


This typedef represents (a pointer to) an actual Parrot interpreter.


This structure represents (a pointer to) a 'packfile'--a Parrot bytecode file.


An interpreter flag.


The value passed in with an interpreter flag. Unused at the moment--just pass in NULL.





Various Parrot internal types; most are chosen at Configure time.

Constants ^

interpreter core setting is done by a call of Parrot_set_run_core() like:

  Parrot_set_run_core(interp, PARROT_JIT_CORE);

See /include/parrot/interpreter.h for a list of available cores beside PARROT_PREDEREF_CORE, PARROT_JIT_CORE.


This flag turns on predereferencing. Parrot will transform many offsets in the opcode stream to absolute pointers.


This flag turns on just-in-time compilation. Parrot will convert the bytecode file into native machine code and run it, usually resulting in substantial speedup.

Interpreter flags setting is done by a call of Parrot_set_flag() like>:

    Parrot_set_flag(interp, PARROT_TRACE_FLAG, NULL);

See /include/parrot/interpreter.h for an up to date list.


This flag turns on debugging mode. Debugging mode basically means that Parrot's core prints out diagnostic messages. This flag does not take any parameters.


This flag turns on opcode tracing. Parrot will print out each opcode and the parameters passed to it as it is called. This flag does not take any parameters.


This flag turns on bounds checking. Parrot will make sure that all addresses returned by an opcode function are within the boundaries of the bytecode block. This flag does not take any parameters.


This flag turns on profiling. Parrot will print out a list of each opcode called, the number of times it was called, the average time it took to run, and the total time it took over the life of the program. This flag does not take any parameters.


This flags control the threading behavior. With PARROT_THR_TYPE_1, threads runs without sharing variables and do not communicate, With PARROT_THR_TYPE_2, threads shares no variables and communicate by sending messages. With PARROT_THR_TYPE_3, threads share variables. See t/pmc/threads.t for examples.

Other constants:


This constant contains a string representation of Parrot's version number.


This constant contains the first part of Parrot's version number.


This constant contains the second part of Parrot's version number.


This constant contains the third part of Parrot's version number.


This constant contains the date that Configure was run to generate config.h.


This constant is true if Parrot supports JIT on this platform, false otherwise.


This constant contains a string representation of the Parrot JIT's name for the current architecture.


This constant contains the name of your processor (as the JIT sees it).


This constant contains the name of your operating system (as the JIT sees it).

Functions ^

Parrot_Interp Parrot_new(Parrot_Interp parent)

Allocates and returns a new Parrot interpreter. parent is NULL for the main interpreter that will be destroyed last.

void Parrot_setflags(Parrot_Interp, Parrot_Interp_flag, Parrot_Interp_flag_val)

Sets a flag in the Parrot interpreter.

Parrot_PackFile Parrot_readbc(Parrot_Interp, char *filename)

Reads in a bytecode file and returns a packfile structure for it.

void Parrot_loadbc(Parrot_Interp, Parrot_PackFile)

Loads a packfile into a Parrot interpreter.

void Parrot_runcode(Parrot_Interp, int argc, char *argv[])

Runs the bytecode associated with a Parrot interpreter. argc and argv are the parameters the bytecode should receive.

void Parrot_destroy(Parrot_Interp)

Deallocates all memory associated with a Parrot interpreter.

XXX At the moment, it just leaks most of it.


Note: This section is aimed at you if you are writing an application external to parrot which links against an installed parrot library.

Your application will need to include the appropriate header files and link against parrot and its dependencies.

Since the location of these files can vary from platform to platform, and build to build, a general method is provided to find out the necessary flags to use.

pkg-config is a helper tool, now common on many platforms, which many packages have adopted to provide the necessary compiler and linker flags required to build against a library. parrot will install a file called parrot.pc which can be queried using pkg-config.

To start with, let's find out what version of parrot is installed by running pkg-config with the --modversion flag. If this command fails with an error, skip to the bottom of this section.

  pkg-config --modversion parrot

To find out the necessary -I flags, use --cflags

  pkg-config --cflags parrot

and to find the necessary -L and -l flags, use --libs

  pkg-config --libs parrot

Where both compiling and linking are performed in one step, both sets of flags can be queries with

  pkg-config --cflags --libs parrot

The pkg-config command can be incorporated with a compile as shown here.

  cc src/disassemble.c `pkg-config --cflags --libs parrot`

Most applications will probably choose to run pkg-config as part of a configure script, so if you are using autoconf you could use a test such as this.

                    [AC_DEFINE([HAVE_PARROT], 1, [define if have parrot])])

If parrot has been installed system-wide, then any of the previous lines should have returned the relevant flags. If it is not installed in one of the standard places that pkg-config looks, then you will get an error message.

  pkg-config --libs parrot
  Package parrot was not found in the pkg-config search path.
  Perhaps you should add the directory containing `parrot.pc'
  to the PKG_CONFIG_PATH environment variable
  No package 'parrot' found

As stated in the error message, an environment variable can be used to make pkg-config look in more locations.

  export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig

The last part of the variable will almost certainly be .../lib/pkgconfig. This variable will have to be set in your login scripts if you need it to be available in future.


embed.c and embed.h for the implementation.

src/test_main.c for Parrot's use of the embedding system. A pkg-config page