Extensible Embeddable Language

From Wikipedia, the free encyclopedia

Please help improve this article or section by expanding it.
Further information might be found on the talk page or at requests for expansion. (April 2007)

The Extensible Embeddable Language (EEL) is a scripting and programming language, focus on hard real time applications.

EEL uses a C-like syntax with higher level features not existing in the C programming language, which makes it "safe" in most of the environments (i.e. EEL programs should not be able to crash the virtual machine or the host application). EEL is dynamically typed, includes automatic memory management, exception handling and a built-in high level data types.

EEL data-types include strings, dstrings (dynamic strings), vectors (fixed type numeric arrays), arrays (arrays of dynamically typed elements) and tables.

1 Philosophy
2 History
3 Features
- 3.1 Example code
4 Internals
5 Applications
6 External links

[edit] Philosophy

EEL philosophy aims to provide a scripting language that would work in real time systems with 1000+ Hz cycle rates, such as musical synthesizers.

[edit] History

[edit] Features

EEL uses "limbo lists" to keep track of intermediate objects created inside expressions and the like, which greatly simplifies exception handling, and eliminates the need for active reference counting in every single operation.

[edit] Example code

The classic hello world program can be written as follows:

export function main<args>
{
    print("Hello, world!\n");
    return  0;
}

The following is an example of a recursive function:

export function main<args>
{
    print("Recursion test 1:\n");
    
    procedure recurse(arg)
    {
        print("arg = ", arg, "\n");
        if(arg)
             recurse(arg - 1);
    }
    
    recurse(10);
    
    print("Recursion test 2; Mutual Recursion:\n");
    
    procedure mrecurse2(arg);
    
    procedure mrecurse1(arg)
    {
         print("arg = ", arg, "\n");
         if(arg)
              mrecurse2(arg);
         }
    
    procedure mrecurse2(arg)
    {
         mrecurse1(arg - 1);
    };
    
    mrecurse1(10);
    
    print("Recursion test 2; Mutual Recursion with Function Reference:\n");
    
    procedure mrrecurse1(arg, fn)
    {
         print("arg = ", arg, "\n");
         if(arg)
              fn(arg, fn);
         }
    
    local mrr2 = procedure (arg, fn)
    {
         mrrecurse1(arg - 1, fn);
    };
    
    mrrecurse1(10, mrr2);
    
    print(Recursion tests done.\n);
    return 0;
}