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:
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.
