Embedded JavaScript™

JavaScript is an interpreted, object oriented language suitable for embedding in applications and devices. Best known as the scripting language for browsers, JavaScript is general purpose language that can also be used for web server scripting and many other embedded scripting needs. Embedded JavaScript is used by Embedded Server Pages to allow access to HTTP variables and to retrieve dynamic data for presentation to the client's browser.

JavaScript was originally developed by Netscape but has subsequently been standardized as ECMAScript. The ECMA-262 standard describes JavaScript 1.5 which is the basis for Embedded JavaScript.

JavaScript is syntactically similar to C or C++. JavaScript expresssions and statements such as if/else, for, +, -, &&, || are almost identical to C. However, JavaScript is an untyped language that will automatically convert data from one type to another as expressions and statements require. This makes it much more like Perl than a strongly typed language. JavaScript also has objects and methods and resembles Java and C++ in this regard and it supports associative arrays like Pearl or TCL. Thus, JavaScript is a nice blend of some of the best features of C, C++, Java and Perl.

JavaScript is best when it is used for scripting. It was not designed for large-scale application development. For that purpose, strongly typed languages are a better choice.

This JavaScript documentation includes sections on:

• Language Syntax
• Objects and Arrays
• Expressions and Operators
• JavaScript Statements
• Standard Globals
• Extending JavaScript

For more information about JavaScript, we recommend the excellent book on JavaScript by David Flanagan, JavaScript the Definitive Guide by O'Reilly, ISBN: 0-596-00048-0, 2002.

JavaScript Quick Example

So what does JavaScript actually look like? The following code fragment demonstrates the syntax and some of the features of JavaScript:

/*
 *  Can use either C or C++ style comments
 */
function justForDemo(start, end)        // Arguments do not have types
{
    var i, j;                                // Declare variables with var
    var objects = new Array(10);     // Create an array with ten elements

    for (i = start; i < 10; i++) {   // Classic for loop
        objects[i] = new Object();     // Store a new object
    }

    for (o in objects) {            // Iterate over all the objects
        // Can do something here to each object
    }
    return "Hello World";
}

justForDemo(0, 10);                    // Invoke the function

Embedded JavaScript Overview

Embedded JavaScript (EJS) was created as a subset of ECMAScript as specified in the ECMA-262 specification. The ECMA specification defines a complete and extensive language of which Embedded Javascript implements a well defined subset focussed on the needs of the embedded market.

The complete ECMA-262 specification has many features that are not essential for embedded use and the resultant memory footprint for the complete spec (typically > 500K) is too large for many embedded applications. Embedded JavaScript in contrast, requires approximately ~50K of code and 20K of RAM to execute depending on the size of the program.

Design Goals

The design goals for EJS were, to develop a useful and powerful subset of the JavaScript language, while minimizing the system resources required in which to execute. Redundant language features were eliminated and unnecessary features were ommitted. An architecture and implementation was then chosen for EJS to prioritize small memory size above fast execution speed. For example: a recursive descent parser was selected over a table driven parser as it requires considerably less memory.

Recursive Descent Parser

Embedded JavaScript uses a compact, recursive descent parser. This is a one-pass, parse and execute interpreter. Compared to two-pass interpreters that create in-memory representations of the script to execute, the one-pass, recursive descent parser has greatly reduced memory requirements. It is somewhat slower than two-pass interpreters that use Just-in-time compilation technologies.

Multiple Instances

EJS supports multiple independent instances at run-time. Embedded Server Pages uses this feature to allow multiple HTTP requests to execute concurrently.

Garbage Collection

Unlike C and C++ where objects are explicitly destroyed, JavaScript uses an automatic mechanism called Garbage Collectionto reclaim unused memory when objects are no longer used.

Because Embedded JavaScript may be used in embedded real-time systems, determinism in the garbage collection was an important design goal. However, the traditional JavaScript mark and sweep algorithms exhibit decidedly non-deterministic behavior. Consequently, a modified reference counting approach was chosen. This approach is very efficient and uses little CPU or memory to implement, but it can be temporarily miss reclaiming objects that have cyclical references. This is normally not a problem when implemented in systems like Embedded Server Pages that use smaller scripts that run for short durations.

Data Types

Embedded JavaScript borrows from some of the proposed JavaScript 2.0 features to provide a rich suite of types. 32-bit and 64-bit integers are provided along with floating point, boolean and string primitive types. EJS can also be configured when building from source code to select the default numeric type.

Extensible

The Embedded JavaScript capabilities may be extended by publishing new JavaScript functions. JavaScript functions may be created via the ESP C API. See the Programmers Reference for more details.

Quick Language Overview

Embedded JavaScript implements the following standard JavaScript elements:

• Case sensitivity, white space, optional semicolons, C and C++ style comments
• Identifiers
• Data types including numbers, booleans, strings with quoted backslash characters
• Expressions / operators (< <= == != > >= + - / % << >> ++ -- && || !)
  
• If/else statement
  
• for and for/in
• Functions and return statement
  
• Objects and new statement
• Arrays and associative arrays
  

The following language elements are not implemented:

• Exceptions including try, catch and throw
  
• Labeled statements including: break, continue
  
• Control flow statements including: switch, while, do, export, import, with
• Regular expressions
• The operators === !== <<< >>>
  
• The prefix ++ and -- operators
• Function, array and object literals
• Standard object methods: toLocaleString, hasOwnProperty, propertyIsEnumerable, isPrototypeOf,
  
• Standard array methods: length, join, sort, reverse, slice, splice, push, pop, unshift, shift, toLocaleString
• Number and Date classes
• Object class prototypes and class methods

Other differences in Embedded JavaScript from the ECMAScript standard are listed below. All these differences were deliberate design decisions made in support of the design goals.

• Strings are stored in ASCII not UNICODE.
• Number types are integers by default instead of floating point. This is changable as a build time configuration option.