split up this huge if/else a little more
turns out string interpolation has a rather large cost given all the debug spew.  delaying the interpolation by wrapping it in a closure that we pass to debug.log (which already has support for function args) results in a nice compiler speedup.
finish up the support for things the compiler uses.  the only missing bit wrt node-llvm is the phinode class, which the compiler doesn't use anyway.
put __FILE__:__LINE__ in EJS_NOT_IMPLEMENTED, and add a EJS_NOT_REACHED macro as well
a little makefile cleanup
according to ECMA262 edition 5, the thisArg is passed as-is to Function.prototype.call.  This means that (in this particular case) Boolean.prototype.toString needs to accept and deal with a boolean primitive thisArg
implement String.prototype.split and String.prototype.substr (just like substring, but returns a primitive string)
more atoms for builtin things
1. add ToNumber, which returns an ejsval, and implement ToDouble in terms of that (ToDouble
could really be replaced with a macro).

2. make _ejs_op_typeof return atoms instead of newly allocated primitive strings.

3. implement _ejs_op_strict_neq as !_ejs_op_strict_eq.  same with _ejs_op_neq/_ejs_op_eq.

4. implement _ejs_op_eq in accordance with the spec (ECMA262: 11.9.1 + 11.9.3)
expose the GC through the global GC with a collect() method so we can trigger collections from within the compiled js.  Also
use setjmp to pull the contents of registers onto the stack when we're scanning conservatively.
implement (poorly, but enough for our driver's purposes):
  path.dirname
  path.resolve

  fs.createWriteStream (as well as writeStream.write + writeStream.end)

  child_process.spawn

in ejs, spawn is synchronous, so we use __ejs? in the driver code to run code which
assumes that.
add EJSVAL_IS_REGEXP
stub out RegExp.prototype.toString
wrap all these printfs in a SPEW macro.  turns out one of the printfs was the reason for the crash associated with exception usage.
Array.prototype.forEach passes two args to the supplied closure: the element, as well as its index
switch from separate booleans for writable/configurable/enumerable to bit flags.  also use flags to tell if the value for any of the properties in an EJSPropertyDesc has been set.  this allows us to write the propertydesc handling methods in ejs-object a lot closer to spec.
implement EJSVAL_TO_TAG, _ejs_op_eq needs it
add a String.prototype.slice test
oops, don't collect here
Function.prototype is not enumerable/configurable/writable, but the prototype we supply when creating function objects is configurable/writable