svrg.net feed en http://svrg.net/rss.xml activities from svrg.net Fri, 30 Apr 2010 21:13:42 CEST Fri, 30 Apr 2010 21:13:42 CEST CL-Javascript 0.10.05 Fri, 30 Apr 2010 21:13:33 CEST http://svrg.net/CL-Javascript%200.10.05.html http://svrg.net/CL-Javascript%200.10.05.html CL-Javascript 0.10.05

With version 0.10.05 we announce the first public release of CL-Javascript, translator from Javascript to Common Lisp.

Project overview

The main idea behind the project was to provide a way to extend CL applications (or libraries) with a standard and widely accepted scripting language. Javascript seemed to be ideal for such a purpose since the language is popular, quite small and its semantics are not that far from Lisp's.

Rather than writing an interpreter, CL-Javascript converts Javascript to CL, which is then compiled as any other Lisp program. With such an approach most of the runtime overhead is eliminated – although the function-calling protocol and runtime dispatching still make Javascript programs slower compared to pure CL.

CL-Javascript is licensed under the MIT Public License.

The official project page is at http://github.com/akapav/js

Implementation

For parsing, CL-Javascript uses Marijn Haverbeke's excellent parse-js library, which generates AST in a form of s-expression which perfectly suits its needs. This AST is preprocessed (lexical scope analysis, local function reordering, keywords changed to symbols from the JS package, and some syntactic forms reduced) so that the resulting form is a valid and executable CL expression in which every node is further macroexpanded. On top of that there is a reader macro layer which allows embedding parts of Javascript directly into Lisp code.

The rest of the system contains support for the JS runtime -- including object hash tables, functions, operators, as well as an implementation (currently incomplete) of the JS standard library.

Usage

Since there is no documentation (yet), here are a few examples how to use CL-Javascript. It is important to mention that while all system symbols are interned in the JS package, symbols generated during program execution are interned in the JS-USER package.

At the moment, there are several ways to execute JS code from within Lisp.

!eval macro

Probably the easiest way to invoke JS code from CL is using the js::!eval macro. The following example just prints hello world and returns its result (UNDEFINED in this example) back to Lisp. 

(!eval "print('hello world!');")

Reader macros

Reader macros are designed to embed JS code directly into CL. Code between #{javascript} and . will be compiled and inserted in-place.

In the following example an anonymous JS function is generated and returned to Lisp, where it can be used directly. 

(defun sum-to (n)
  (js::js-funcall
#{javascript}
    (function(n) {
      var sum = 0;
      for(var i = 0; i < n; sum += i++);
      return sum;
    })
.
  n))

Note that unless you are in the JS-USER package you should write #{js::javascript} instead.

Loading external files

To load and execute external JS programs one should use the js::js-load-file function which accepts a filename as its only argument. 

(js-load-file "hello.js")

Interning to JS-USER

At the moment, all properties of [object Global] are interned into the JS-USER package, so they are directly visible form CL. If some of those properties are function definitions then a defun wrapper is also generated. The drawback to such an approach is that JS properties are case- sensitive, while most CL implementations use an uppercase symbol case policy. 

#{javascript}
var one = 1
function adder(n)
{
   return function(m) {return n+m;}
}
.

(js::js-funcall (adder one) 2) ;=> 3

Callbacks

this part will probably be changed soon

At the moment the only way to implement callback functions to CL is to use the js-function macro.

Example from stdlib.lisp: 

(setf (prop *global* "print")                               ;add 'print' property to global object
      (js-function (arg)                                    ;define js callable function 
        (if (undefined? arg) (format t "~%")                ;underlying lisp code
            (format t "~A~%" (js-funcall string.ctor arg)))))

There are also plans to allow direct embedding of Common Lisp code in Javascript (the opposite of the #{javascript} reader macro), but such a change would require some additional modifications to Javascript's syntax.

Project status

Although most of the ECMA-262 standard is implemented, the project is still under heavy development. Known missing features are: bitwise operators, RegExp and Date classes, as well as some Number formatting methods. Error reporting still needs significant improvement; additionally, optimizations to operator dispatching would increase the overall performance of generated code.

The project is developed in SBCL, but since no SBCL specific extensions are used, it should be easy portable to any other Common Lisp implementation.

Versioning

CL-Javascript uses a hybrid versioning schema - the first number indicates development stage (0 means no stable release yet), and decimal numbers indicate release date. In general, the schema for minor releases is [0,1,..].yy.mm, while stable releases use [1,2,..].00.00.

]]>