sproutit-narwhal 0.1.106

data/engines/jsc/src/os-engine.cc

@@ -0,0 +1,210 @@
+#include <narwhal.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+NWObject IO;
+
+FUNCTION(OS_exit)
+{
+    if (ARGC == 0)
+    {
+        exit(0);
+    }
+    else if (ARGC == 1)
+    {
+        ARGN_INT(code, 0);
+        exit(code);
+    }
+    
+    THROW("os.exit() takes 0 or 1 arguments.");
+}
+END
+
+FUNCTION(OS_sleep, ARG_INT(seconds))
+{
+    // TODO: higher resolution sleep?
+    
+    while (seconds > 0)
+        seconds = sleep(seconds);
+    
+    return JS_undefined;
+}
+END
+
+FUNCTION(OS_systemImpl, ARG_UTF8(command))
+{
+    int status = system(command);
+    return JS_int(WEXITSTATUS(status));
+}
+END
+
+typedef struct __PopenPrivate {
+    pid_t   pid;
+} PopenPrivate;
+
+DESTRUCTOR(Popen_finalize)
+{    
+    GET_INTERNAL(PopenPrivate *, data, object);
+    DEBUG("Popen_finalize=[%p]\n", data);
+    if (data) {
+        
+        // call waitpid (not blocking) to avoid zombie processes
+        // TODO: if this finalizer is called before the process exits the process will be a zombie
+        int status;
+        pid_t pid = waitpid(data->pid, &status, WUNTRACED|WNOHANG);
+        
+        free(data);
+    }
+}
+END
+
+JSClassRef Popen_class(JSContextRef _context)
+{
+    static JSClassRef jsClass;
+    if (!jsClass)
+    {
+        JSClassDefinition definition = kJSClassDefinitionEmpty;
+        definition.className = "Popen";
+        definition.finalize = Popen_finalize;
+
+        jsClass = JSClassCreate(&definition);
+    }
+    return jsClass;
+}
+
+JSObjectRef Popen_new(JSContextRef _context, JSValueRef *_exception, pid_t pid)
+{
+    PopenPrivate *data = (PopenPrivate*)malloc(sizeof(PopenPrivate));
+    if (!data) return NULL;
+    
+    data->pid = pid;
+    
+    return JSObjectMake(_context, Popen_class(_context), data);
+}
+
+FUNCTION(Popen_wait)
+{
+    GET_INTERNAL(PopenPrivate*, data, THIS);
+    
+    int status;
+    
+    pid_t pid = waitpid(data->pid, &status, WUNTRACED);
+    if (!pid) {
+        perror("waitpid");
+    }
+    else {
+        if (WIFEXITED(status)) {
+            return JS_int(WEXITSTATUS(status));
+        } else {
+            printf("WIFSIGNALED=%d\n", WIFSIGNALED(status));
+            printf("WIFSTOPPED=%d\n", WIFSTOPPED(status));
+        }
+    }
+    
+    return JS_null;
+}
+END
+
+FUNCTION(OS_popenImpl, ARG_UTF8(command))
+{
+    int outfd[2];
+    int infd[2];
+    int errfd[2];
+    
+    // create pipes for subprocess' stdin, stdout, stderr
+    if (pipe(outfd) < 0) // From where parent is going to read
+        THROW("popen error (pipe): %s", strerror(errno));
+    if (pipe(infd) < 0) // Where the parent is going to write to
+        THROW("popen error (pipe): %s", strerror(errno));
+    if (pipe(errfd) < 0) // Where the parent is going to write to
+        THROW("popen error (pipe): %s", strerror(errno));
+
+    pid_t pid = fork();
+    if(!pid)
+    {
+        // In the forked process:
+
+        // close other end of pipes
+        close(infd[1]);
+        close(outfd[0]);
+        close(errfd[0]);
+        
+        // close existing stdin, stdout, stderr
+        close(STDIN_FILENO);
+        close(STDOUT_FILENO);
+        close(STDERR_FILENO);
+            
+        // set correct endpoints of pipes to stdin, stdout, stderr
+        dup2(infd[0], STDIN_FILENO);
+        dup2(outfd[1], STDOUT_FILENO);
+        dup2(errfd[1], STDERR_FILENO);
+        
+        // close originals
+        close(infd[0]);
+        close(outfd[1]);
+        close(errfd[1]);
+        
+        
+        char *argv[] = {
+            "/bin/sh",
+            "-c",
+            command,
+            NULL
+        };
+    
+        execv(argv[0], argv);
+    }
+    else
+    {
+        // close other end of pipes
+        if (close(infd[0]) < 0)
+            THROW("popen error (close): %s", strerror(errno));
+        if (close(outfd[1]) < 0)
+            THROW("popen error (close): %s", strerror(errno));
+        if (close(errfd[1]) < 0)
+            THROW("popen error (close): %s", strerror(errno));
+            
+        NWObject obj = CALL(Popen_new, pid);
+        
+        ARGS_ARRAY(stdinArgs, JS_int(-1), JS_int(infd[1]));
+        NWObject stdinObj = CALL_AS_CONSTRUCTOR(IO, 2, stdinArgs);
+        HANDLE_EXCEPTION(true, true);
+        SET_VALUE(obj, "stdin", stdinObj);
+        HANDLE_EXCEPTION(true, true);
+        
+        ARGS_ARRAY(stdoutArgs, JS_int(outfd[0]), JS_int(-1));
+        NWObject stdoutObj = CALL_AS_CONSTRUCTOR(IO, 2, stdoutArgs);
+        HANDLE_EXCEPTION(true, true);
+        SET_VALUE(obj, "stdout", stdoutObj);
+        HANDLE_EXCEPTION(true, true);
+        
+        ARGS_ARRAY(stderrArgs, JS_int(errfd[0]), JS_int(-1));
+        NWObject stderrObj = CALL_AS_CONSTRUCTOR(IO, 2, stderrArgs);
+        HANDLE_EXCEPTION(true, true);
+        SET_VALUE(obj, "stderr", stderrObj);
+        HANDLE_EXCEPTION(true, true);
+        
+        SET_VALUE(obj, "wait", JS_fn(Popen_wait));
+        HANDLE_EXCEPTION(true, true);
+        
+        return obj;
+    }
+}
+END
+
+NARWHAL_MODULE(os_engine)
+{
+    EXPORTS("exit", JS_fn(OS_exit));
+    EXPORTS("sleep", JS_fn(OS_sleep));
+    EXPORTS("systemImpl", JS_fn(OS_systemImpl));
+    EXPORTS("popenImpl", JS_fn(OS_popenImpl));
+    
+    require("os-engine.js");
+    
+    NWObject io = require("io");
+    HANDLE_EXCEPTION(true, true);
+    
+    IO = PROTECT_OBJECT(GET_OBJECT(io, "IO"));
+    HANDLE_EXCEPTION(true, true);
+}
+END_NARWHAL_MODULE

data/engines/rhino/bin/narwhal-rhino

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+# get the absolute path of the executable
+SELF_PATH=$(cd -P -- "$(dirname -- "$0")" && pwd -P) && SELF_PATH="$SELF_PATH/$(basename -- "$0")"
+
+# resolve symlinks
+while [ -h "$SELF_PATH" ]; do
+	DIR=$(dirname -- "$SELF_PATH")
+	SYM=$(readlink -- "$SELF_PATH")
+	SELF_PATH=$(cd -- "$DIR" && cd -- $(dirname -- "$SYM") && pwd)/$(basename -- "$SYM")
+done
+
+# NARWHAL_ENGINE_HOME is the 2nd ancestor directory of this shell script
+export NARWHAL_ENGINE_HOME=$(dirname -- "$(dirname -- "$SELF_PATH")")
+
+BOOTSTRAP=$NARWHAL_ENGINE_HOME/bootstrap.js
+
+if [ -z "$NARWHAL_HOME" ]; then
+	export NARWHAL_HOME=$(dirname -- "$(dirname -- "$NARWHAL_ENGINE_HOME")")
+fi
+
+CLASSPATH=$NARWHAL_ENGINE_HOME/jars/jna.jar
+BOOTCLASSPATH=$NARWHAL_ENGINE_HOME/jars/js.jar
+if [ -n "$NARWHAL_CLASSPATH" ]; then
+    CLASSPATH=$NARWHAL_CLASSPATH:$CLASSPATH
+fi
+
+if [ "$(which cygpath 2>/dev/null)" ]; then
+    CLASSPATH=$(cygpath -wp -- "$CLASSPATH")
+    BOOTCLASSPATH=$(cygpath -wp -- "$BOOTCLASSPATH")
+    BOOTSTRAP=$(cygpath -wa -- "$BOOTSTRAP")
+    export NARWHAL_HOME=$(cygpath -wa -- "$NARWHAL_HOME")
+    export NARWHAL_ENGINE_HOME=$(cygpath -wa -- "$NARWHAL_ENGINE_HOME")
+fi
+
+if [ -z "$NARWHAL_JS_VERSION" ]; then
+    NARWHAL_JS_VERSION=170
+fi
+
+if [ -z "$NARWHAL_DEBUGGER" ] || [ "$NARWHAL_DEBUGGER" -eq 0 ]; then
+    JAVA_MAIN=org.mozilla.javascript.tools.shell.Main
+else
+    JAVA_MAIN=org.mozilla.javascript.tools.debugger.Main
+fi
+
+# check the java version number in the most complicated fashion imaginable
+JAVA_VERSION=$(java -version 2>&1 | awk -F '[ ".]+' 'NR==1 {print $3 "." $4}')
+LOWER_VERSION=$( (echo "$JAVA_VERSION"; echo "1.5") | sort -n | head -n 1)
+if [ "$LOWER_VERSION" != "1.5" ]; then
+    echo "Narwhal on Rhino requires Java 1.5 or higher.  You have $JAVA_VERSION."
+    exit
+fi
+
+# drop into shell if there are no additional arguments
+if [ $# -lt 1 ]; then
+    # prefer rlwrap to jline.
+    RLWRAP="$(which rlwrap)"
+    if [ -x "$RLWRAP" ]; then
+        RLWRAP="$RLWRAP -C narwhal -m\\"
+    else
+        RLWRAP=""
+        CLASSPATH="$CLASSPATH:$NARWHAL_ENGINE_HOME/jars/jline.jar"
+    fi
+    $RLWRAP java $NARWHAL_JAVA_ARGUMENTS -cp "$BOOTCLASSPATH:$CLASSPATH" "$JAVA_MAIN" -f "$BOOTSTRAP" -f -
+else
+    java $NARWHAL_JAVA_ARGUMENTS -cp "$BOOTCLASSPATH:$CLASSPATH" "$JAVA_MAIN" -version "$NARWHAL_JS_VERSION" "$BOOTSTRAP" "$0" "$@"
+fi
+

data/engines/rhino/bin/narwhal-rhino.cmd

@@ -0,0 +1,34 @@
+@echo off
+setlocal
+
+:: NARWHAL_ENGINE_HOME is the parent the bin directory
+set NARWHAL_ENGINE_HOME=%~dp0..
+
+set BOOTSTRAP=%NARWHAL_ENGINE_HOME%\bootstrap.js
+
+if "%NARWHAL_HOME%" == "" (
+	set NARWHAL_HOME=%NARWHAL_ENGINE_HOME%\..\..
+)
+
+setlocal ENABLEDELAYEDEXPANSION
+set CLASSPATH=
+for /R "%NARWHAL_ENGINE_HOME%\jars" %%g in (*.jar) do set CLASSPATH=!CLASSPATH!;%%g
+
+if not "%NARWHAL_CLASSPATH%" == "" (
+	set CLASSPATH=%NARWHAL_CLASSPATH%;%CLASSPATH%
+)
+
+if "%NARWHAL_DEBUGGER%" == "" (
+    set JAVA_MAIN=org.mozilla.javascript.tools.shell.Main
+)
+if not "%NARWHAL_DEBUGGER%" == "" (
+    set JAVA_MAIN=org.mozilla.javascript.tools.debugger.Main
+)
+
+
+:: drop into shell if there are no additional arguments
+if "%1" == "" (
+	java -cp "%CLASSPATH%" "%JAVA_MAIN%" -f "%BOOTSTRAP%" -f -
+) else (
+	java -cp "%CLASSPATH%" "%JAVA_MAIN%" "%BOOTSTRAP%" %0 %*
+)

data/engines/rhino/bootstrap.js

@@ -0,0 +1,119 @@
+(function(global, evalGlobal) {
+
+    /*
+        this is a minimal engine-specific thunk for narwhal.js
+        that brings the NARWHAL_PATH environment variable into the global
+        scope using Rhino's special access to Java.
+    */
+
+    var moduleScopingEnabled = false;
+
+    /* this gets used for several fixtures */
+    var context = Packages.org.mozilla.javascript.Context.getCurrentContext();
+    context.getWrapFactory().setJavaPrimitiveWrap(false); 
+
+    // TODO: enable this via a command line switch
+    context.setOptimizationLevel(-1);
+    
+    var prefix = "";
+    if (typeof NARWHAL_HOME != "undefined") {
+        prefix = NARWHAL_HOME;
+        delete NARWHAL_HOME;
+    } else {
+        prefix = String(Packages.java.lang.System.getenv("NARWHAL_HOME") || "");
+    }
+
+    var enginePrefix = "";
+    if (typeof NARWHAL_ENGINE_HOME != "undefined") {
+        enginePrefix = NARWHAL_ENGINE_HOME;
+        delete NARWHAL_ENGINE_HOME;
+    } else {
+        enginePrefix = String(Packages.java.lang.System.getenv("NARWHAL_ENGINE_HOME") || "");
+    }
+
+    var prefixes = [prefix, enginePrefix];
+
+    var isFile = function (path) {
+        try { return new java.io.File(path).isFile(); } catch (e) {}
+        return false;
+    };
+
+    var read = function (path) {
+        var path = new java.io.File(path),
+            stream = new java.io.FileInputStream(path);
+        try {
+            var buffer = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, path.length());
+            stream.read(buffer);
+            return String(new java.lang.String(buffer, "UTF-8"));
+        } finally {
+            stream.close();
+        }
+    };
+    
+    var evaluate = function (text, name, lineNo) {
+        var scope;
+        
+        if (moduleScopingEnabled) {
+            scope = new Object();
+            scope.__parent__ = null;
+            scope.__proto__ = global;
+        } else {
+            scope = global;
+        }
+        
+        return context.compileFunction(
+            scope,
+            "function(require,exports,module,system,print){"+text+"\n// */\n}",
+            name,
+            lineNo,
+            null
+        );
+    };
+
+    delete global.print;
+    var print = function (string) {
+        Packages.java.lang.System.out.println(String(string));
+    };
+
+    var narwhal = context.evaluateReader(
+        global,
+        new Packages.java.io.FileReader(prefix + "/narwhal.js"),
+        "narwhal.js",
+        1,
+        null
+    );
+
+    var debug = +String(Packages.java.lang.System.getenv("NARWHAL_DEBUG"));
+    var verbose = +String(Packages.java.lang.System.getenv("NARWHAL_VERBOSE"));
+    var os = String(Packages.java.lang.System.getProperty("os.name"));
+
+    try {
+        narwhal({
+            global: global,
+            evalGlobal: evalGlobal,
+            engine: 'rhino',
+            engines: ['rhino', 'default'],
+            os: os,
+            print: print,
+            fs: {
+                read: read,
+                isFile: isFile
+            },
+            prefix: prefix,
+            prefixes: prefixes,
+            evaluate: evaluate,
+            debug: debug,
+            verbose: verbose
+        });
+    } catch (e) {
+        print(e);
+        if (e.rhinoException)
+            e.rhinoException.printStackTrace();
+        if (e.javaException)
+            e.javaException.printStackTrace();
+        Packages.java.lang.System.exit(1);
+    }
+        
+})(this, function () {
+    return eval(arguments[0]);
+});

data/engines/rhino/lib/binary-engine.js

@@ -0,0 +1,83 @@
+exports.B_LENGTH = function(bytes) {
+    return bytes.length;
+}
+
+exports.B_ALLOC = function(length) {
+    return Packages.java.lang.reflect.Array.newInstance(Packages.java.lang.Byte.TYPE, length);
+}
+
+exports.B_FILL = function(bytes, length, offset, value) {
+    Packages.java.util.Arrays.fill(bytes, length, offset, value);
+}
+
+exports.B_COPY = function(src, srcOffset, dst, dstOffset, length) {
+    Packages.java.lang.System.arraycopy(src, srcOffset, dst, dstOffset, length);
+}
+
+exports.B_GET = function(bytes, index) {
+    return (bytes[index] >>> 0) & 0xFF;
+}   
+
+exports.B_SET = function(bytes, index, value) {
+    return bytes[index] = ((value & 0x80) ? -1 - (value ^ 0xFF) : value);
+}
+
+exports.B_DECODE = function(bytes, offset, length, codec) {
+    return String(new Packages.java.lang.String(bytes, offset, length, codec));
+}
+
+exports.B_DECODE_DEFAULT = function(bytes, offset, length) {
+    return String(new Packages.java.lang.String(bytes, offset, length));
+}
+
+exports.B_ENCODE = function(string, codec) {
+    return new Packages.java.lang.String(string).getBytes(codec);
+}
+
+exports.B_ENCODE_DEFAULT = function(string) {
+    return new Packages.java.lang.String(string).getBytes();
+}
+
+exports.B_TRANSCODE = function(bytes, offset, length, sourceCodec, targetCodec) {
+    return new Packages.java.lang.String(bytes, offset, length, sourceCodec).getBytes(targetCodec);
+}
+
+function wrapper(that) {
+    var obj = new JavaAdapter(
+        Packages.org.mozilla.javascript.ScriptableObject,
+        Packages.org.mozilla.javascript.Wrapper,
+        {
+            get : function(index, start) {
+                if (typeof index === "number")
+                    return that.get(index);
+            
+                return that[index];
+            },
+            has : function(index, start) {
+                if (typeof index === "number")
+                    return index < that._length;
+            
+                return (that[index] !== undefined)
+            },
+            put : function(index, start, value) {
+                if (typeof index === "number")
+                    that.set(index, value);
+                else
+                    that[index] = value;
+            },
+            unwrap : function() {
+                var bytes = Packages.java.lang.reflect.Array.newInstance(Packages.java.lang.Byte.TYPE, that._length);
+                Packages.java.lang.System.arraycopy(that._bytes, that._offset, bytes, 0, that._length);
+                return bytes;
+            }
+        }
+    );
+
+    obj.__proto__ = that;
+    
+    return obj;
+}
+
+// FIXME: disabling these because it broke several tests. figure out why.
+//exports.ByteStringWrapper = wrapper;
+//exports.ByteArrayWrapper = wrapper;