sproutit-narwhal 0.1.106

data/engines/jsc/lib/file-engine.js

@@ -0,0 +1,31 @@
+var file = require("file");
+
+exports.mkdirs = function(path) {
+    var components = file.Path(path).split();
+    for (var i = 0; i < components.length; i++) {
+        var dir = file.join.apply(null, components.slice(0, i+1));
+        if (!file.isDirectory(dir))
+            file.mkdir(dir);
+    }
+};
+
+exports.touch = function (path, mtime) {
+    if (mtime === undefined || mtime === null)
+        mtime = new Date();
+        
+    if (!file.exists(path))
+        file.write(path, "");
+        
+    return file.touchImpl(path, mtime.getTime());
+};
+
+exports.rename = function(source, target) {
+    source = file.path(source);
+    target = source.resolve(target);
+    
+    return file.renameImpl(source, target);
+};
+
+exports.canonical = function(path) {
+    return file.normal(file.canonicalImpl(path));
+};

data/engines/jsc/lib/http.js

@@ -0,0 +1 @@
+system.stderr.print("Warning: http module not yet implemented for narwhal-jsc.");

data/engines/jsc/lib/io-engine.js

@@ -0,0 +1,202 @@
+var exports = require("io-engine"),
+    ByteString = require("binary").ByteString,
+    binary_engine = require("binary-engine"),
+    B_ALLOC = binary_engine.B_ALLOC,
+    B_COPY = binary_engine.B_COPY;
+
+exports.IO.prototype.copy = function (output, mode, options) {
+    while (true) {
+        var buffer = this.read(null);
+        if (!buffer.length)
+            break;
+        output.write(buffer);
+    }
+    output.flush();
+    return this;
+};
+
+var ByteIO = exports.ByteIO = function(binary) {
+    this.buffer = [];
+    this.length = 0;
+    
+    if (binary) this.write(binary);
+}
+
+ByteIO.prototype.toByteString = function() {
+    var result = this.read();
+
+    // replace the buffer with the collapsed ByteString
+    this.buffer = [result];
+    this.length = result.length;
+
+    return result;
+}
+
+ByteIO.prototype.decodeToString = function(charset) {
+    return charset ? 
+        this.toByteString().decodeToString(charset) :
+        this.toByteString().decodeToString();
+}
+
+ByteIO.prototype.read = function(length) {
+    if (typeof length !== "number") length = this.length;
+    
+    if (length <= 0)
+        return new ByteString();
+    
+    var bytes = B_ALLOC(length),
+        position = 0;
+    
+    while (position < length && this.length > 0) {
+        var segment = this.buffer[0];
+        
+        var len = Math.min(segment._length, length - position);
+
+        B_COPY(segment._bytes, segment._offset, bytes, position, len);
+        
+        position += len;
+        this.length -= len;
+        
+        if (len < segment._length) {
+            this.buffer[0] = segment.slice(len);
+        } else {
+            this.buffer.shift();
+        }
+    }
+    
+    return new ByteString(bytes, 0, position);
+}
+
+ByteIO.prototype.write = function(object) {
+    var segment = object.toByteString();
+    
+    this.buffer.push(segment);
+    this.length += segment.length;
+    
+    return this;
+}
+
+ByteIO.prototype.flush = function() {
+    return this;
+}
+
+ByteIO.prototype.close = function() {
+}
+
+var TextIOWrapper = exports.TextIOWrapper = function (raw, mode, lineBuffering, buffering, charset, options) {
+    if (mode.update) {
+        return new exports.TextIOStream(raw, lineBuffering, buffering, charset, options);
+    } else if (mode.write || mode.append) {
+        return new exports.TextOutputStream(raw, lineBuffering, buffering, charset, options);
+    } else if (mode.read) {
+        return new exports.TextInputStream(raw, lineBuffering, buffering, charset, options);
+    } else {
+        throw new Error("file must be opened for read, write, or append mode.");
+    }
+};
+
+
+var TextInputStream = exports.TextInputStream;
+
+TextInputStream.prototype.readLine = TextInputStream.prototype.readLine || function () {
+    var buffer = [],
+        last;
+    
+    do {
+        last = this.read(1);
+        buffer.push(last);
+    } while (last !== "\n" && last !== "");
+    
+    return buffer.join("");
+};
+
+TextInputStream.prototype.next = TextInputStream.prototype.next || function () {
+    var line = this.readLine().slice(0, -1);
+    if (!line.length)
+        throw StopIteration;
+    return line;
+};
+
+TextInputStream.prototype.iterator = TextInputStream.prototype.iterator || function () {
+    return this;
+};
+
+TextInputStream.prototype.forEach = TextInputStream.prototype.forEach || function (block, context) {
+    var line;
+    while (true) {
+        try {
+            line = this.next();
+        } catch (exception) {
+            break;
+        }
+        block.call(context, line);
+    }
+};
+
+TextInputStream.prototype.input = TextInputStream.prototype.input || function () {
+    throw "NYI";
+};
+
+TextInputStream.prototype.readLines = TextInputStream.prototype.readLines || function () {
+    var lines = [];
+    do {
+        var line = this.readLine();
+        if (line.length)
+            lines.push(line);
+    } while (line.length);
+    return lines;
+};
+
+TextInputStream.prototype.readInto = TextInputStream.prototype.readInto || function (buffer) {
+    throw "NYI";
+};
+
+TextInputStream.prototype.copy = TextInputStream.prototype.copy || function (output, mode, options) {
+    do {
+        var line = this.readLine();
+        output.write(line).flush();
+    } while (line.length);
+    return this;
+};
+
+TextInputStream.prototype.close = TextInputStream.prototype.close || function () {
+    this.raw.close();
+};
+
+
+var TextOutputStream = exports.TextOutputStream = function (raw, lineBuffering, buffering, charset, options) {
+    this.raw = raw;
+    this.charset = charset;
+}
+
+TextOutputStream.prototype.write = function (str) {
+    this.raw.write(str.toByteString(this.charset));
+    return this;
+};
+
+TextOutputStream.prototype.writeLine = function (line) {
+    this.write(line + "\n"); // todo recordSeparator
+    return this;
+};
+
+TextOutputStream.prototype.writeLines = function (lines) {
+    lines.forEach(this.writeLine, this);
+    return this;
+};
+
+TextOutputStream.prototype.print = function () {
+    this.write(Array.prototype.join.call(arguments, " ") + "\n");
+    this.flush();
+    // todo recordSeparator, fieldSeparator
+    return this;
+};
+
+TextOutputStream.prototype.flush = function () {
+    this.raw.flush();
+    return this;
+};
+
+TextOutputStream.prototype.close = function () {
+    this.raw.close();
+    return this;
+};

data/engines/jsc/lib/os-engine.js

@@ -0,0 +1,25 @@
+var exports = require("os-engine");
+
+var io = require("io");
+
+exports.system = function (command) {
+    if (Array.isArray(command)) {
+        command = command.map(require("os").enquote).join(" ");
+    }
+    
+    return exports.systemImpl(command);
+};
+
+exports.popen = function (command) {
+    if (Array.isArray(command)) {
+        command = command.map(require("os").enquote).join(" ");
+    }
+    
+    var result = exports.popenImpl(command);
+    
+    result.stdin = new io.TextOutputStream(result.stdin);
+    result.stdout = new io.TextInputStream(result.stdout);
+    result.stderr = new io.TextInputStream(result.stderr);
+    
+    return result;
+};

data/engines/jsc/lib/system.js

@@ -0,0 +1,18 @@
+
+var io = require("./io");
+
+exports.stdin  = new io.TextInputStream(new io.IO(io.STDIN_FILENO, -1));
+exports.stdout = new io.TextOutputStream(new io.IO(-1, io.STDOUT_FILENO));
+exports.stderr = new io.TextOutputStream(new io.IO(-1, io.STDERR_FILENO));
+
+exports.args = ARGS;
+delete ARGS;
+
+exports.env = ENV;
+delete ENV;
+
+exports.fs = require('./file');
+
+// default logger
+var Logger = require("logger").Logger;
+exports.log = new Logger(exports.stdout);

data/engines/jsc/lib/zip.js

@@ -0,0 +1 @@
+system.stderr.print("Warning: zip module not yet implemented for narwhal-jsc.");

data/engines/jsc/narwhal-jsc.c

@@ -0,0 +1,273 @@
+#define NOTRACE
+
+#include <JavaScriptCore/JavaScriptCore.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <readline/readline.h>
+#include <readline/history.h>
+
+#include <narwhal.h>
+
+#include <dlfcn.h>
+
+#ifdef JSCOCOA
+#import <JSCocoa/JSCocoa.h>
+#endif
+
+#ifdef WEBKIT
+#import <Foundation/Foundation.h>
+#import <WebKit/WebKit.h>
+#endif
+
+NarwhalContext narwhal_context;
+
+// Reads a file into a v8 string.
+JSStringRef ReadFile(const char* name) {
+    FILE* file = fopen(name, "rb");
+    if (file == NULL) return NULL;
+
+    fseek(file, 0, SEEK_END);
+    int size = ftell(file);
+    rewind(file);
+
+    char *chars = (char*)malloc(sizeof(char) * (size + 1));
+    int i;
+    for (i = 0; i < size;) {
+        int read = fread(&chars[i], 1, size - i, file);
+        i += read;
+    }
+    chars[size] = '\0';
+    fclose(file);
+    JSStringRef result = JSStringCreateWithUTF8CString(chars);
+    free(chars);
+    return result;
+}
+
+FUNCTION(NW_print)
+{
+    size_t i;
+    for (i = 0; i < ARGC; i++) {
+        JS_Print(ARGV(i));
+        if (_exception)
+            return NULL;
+    }
+        
+    return JS_undefined;
+}
+END
+
+FUNCTION(NW_read, ARG_UTF8(path))
+{
+    ARG_COUNT(1);
+
+    JSStringRef contents = ReadFile(path);
+
+    if (contents) {
+        JSValueRef result = JSValueMakeString(_context, contents);
+        JSStringRelease(contents);
+        
+        if (result)
+            return result;
+    }
+    
+    *_exception = JSValueMakeStringWithUTF8CString(_context, "read() error occurred");
+    
+    return JS_undefined;
+}
+END
+
+FUNCTION(NW_isFile, ARG_UTF8(path))
+{
+    ARG_COUNT(1);
+
+    struct stat stat_info;
+    int ret = stat(path, &stat_info);
+
+    return JS_bool(ret != -1 && S_ISREG(stat_info.st_mode));
+}
+END
+
+typedef JSObjectCallAsFunctionCallback factory_t;
+typedef const char *(*getModuleName_t)(NarwhalContext *);
+
+FUNCTION(NW_requireNative, ARG_UTF8(topId), ARG_UTF8(path))
+{
+    ARG_COUNT(2)
+    
+    DEBUG("RequireNative: topId=[%s] path=[%s] \n", topId, path);
+    
+    void *handle = dlopen(path, RTLD_LOCAL | RTLD_LAZY);
+    if (handle == NULL) {
+        printf("dlopen error: %s\n", dlerror());
+        return JS_null;
+    }
+    
+    getModuleName_t narwhalModuleInit = (getModuleName_t)dlsym(handle, "narwhalModuleInit");
+    if (narwhalModuleInit == NULL) {
+        fprintf(stderr, "dlsym (getModuleName) error: %s\n", dlerror());
+        return JS_null;
+    }
+    
+    const char *moduleName = narwhalModuleInit(&narwhal_context);
+    
+    factory_t func = (factory_t)dlsym(handle, moduleName);
+    if (func == NULL) {
+        fprintf(stderr, "dlsym (%s) error: %s\n", moduleName, dlerror());
+        return JS_null;
+    }
+    
+    return JS_fn(func);
+}
+END
+
+JSObjectRef envpToObject(JSGlobalContextRef _context, JSValueRef *_exception, char *envp[])
+{
+    JSObjectRef ENV = JSObjectMake(_context, NULL, NULL);
+    
+    char *key, *value;
+    while (key = *(envp++)) {
+        value = strchr(key, '=') + 1;
+        *(value - 1) = '\0';
+        
+        SET_VALUE(ENV, key, JS_str_utf8(value, strlen(value)));
+        HANDLE_EXCEPTION(true, true);
+        
+        *(value - 1) = '=';
+    }
+    
+    return ENV;
+}
+
+JSObjectRef argvToArray(JSGlobalContextRef _context, JSValueRef *_exception, int argc, char *argv[])
+{
+    JSValueRef arguments[argc];
+    
+    int i;
+    for (i = 0; i < argc; i++)
+        arguments[i] = JSValueMakeStringWithUTF8CString(_context, argv[i]);
+    
+    JSObjectRef ARGS = JSObjectMakeArray(_context, argc, arguments, _exception);
+    HANDLE_EXCEPTION(true, true);
+    
+    return ARGS;
+}
+
+// The read-eval-execute loop of the shell.
+void* RunShell(JSContextRef _context) {
+    printf("Narwhal version %s, JavaScriptCore engine\n", NARWHAL_VERSION);
+    while (true)
+    {
+#ifdef JSCOCOA
+        NSAutoreleasePool *pool = [NSAutoreleasePool new];
+#endif
+        char *str = readline("> ");
+        if (str && *str)
+            add_history(str);
+        
+        if (!str)
+            break;
+        
+        JSStringRef source = JSStringCreateWithUTF8CString(str);
+        free(str);
+        
+        LOCK();
+        
+        JSValueRef exception = NULL;
+        JSValueRef *_exception = &exception;
+        if (JSCheckScriptSyntax(_context, source, 0, 0, _exception) && !(*_exception))
+        {
+            JSValueRef value = JSEvaluateScript(_context, source, 0, 0, 0, _exception);
+            HANDLE_EXCEPTION(true, false);
+            
+            if (value && !JSValueIsUndefined(_context, value)) {
+                JS_Print(value);
+                HANDLE_EXCEPTION(true, false);
+            }
+        }
+        else
+        {
+            HANDLE_EXCEPTION(true, false);
+        }
+        
+        JSStringRelease(source);
+        
+        UNLOCK();
+        
+#ifdef JSCOCOA
+        [pool drain];
+#endif
+    }
+    printf("\n");
+}
+
+JSValueRef narwhal(JSGlobalContextRef _context, JSValueRef *_exception, int argc, char *argv[], char *envp[])
+{
+    pthread_mutex_t	_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+    narwhal_context.context = _context;
+    narwhal_context.mutex = &_mutex;
+    
+    LOCK();
+
+    JSObjectRef global = JS_GLOBAL;
+
+    SET_VALUE(global, "print",          JS_fn(NW_print));
+    SET_VALUE(global, "isFile",         JS_fn(NW_isFile));
+    SET_VALUE(global, "read",           JS_fn(NW_read));
+    SET_VALUE(global, "requireNative",  JS_fn(NW_requireNative));
+    SET_VALUE(global, "ARGS",           CALL(argvToArray, argc, argv));
+    SET_VALUE(global, "ENV",            CALL(envpToObject, envp));
+    
+    // Load bootstrap.js
+    char *NARWHAL_ENGINE_HOME = getenv("NARWHAL_ENGINE_HOME");
+    char *bootstrapPathRelative = "/bootstrap.js";
+    char bootstrapPathFull[strlen(NARWHAL_ENGINE_HOME) + strlen(bootstrapPathRelative) + 1];
+    snprintf(bootstrapPathFull, sizeof(bootstrapPathFull), "%s%s", NARWHAL_ENGINE_HOME, bootstrapPathRelative);
+    
+    JSStringRef bootstrapSource = ReadFile(bootstrapPathFull);
+    if (!bootstrapSource) {
+        THROW("Error reading bootstrap.js\n");
+    }
+    
+    JSEvaluateScript(_context, bootstrapSource, 0, 0, 0, _exception);
+    JSStringRelease(bootstrapSource);
+    
+    UNLOCK();
+    
+    if (!*_exception && argc <= 1)
+        RunShell(_context);
+}
+
+int main(int argc, char *argv[], char *envp[])
+{
+    #ifdef WEBKIT
+        NSAutoreleasePool *pool = [NSAutoreleasePool new];
+        WebView * webView = [[WebView alloc] init];
+        JSGlobalContextRef _context = [[webView mainFrame] globalContext];
+    #elif defined(JSCOCOA)
+        NSAutoreleasePool *pool = [NSAutoreleasePool new];
+        JSCocoaController *jsc = [JSCocoa new];
+        JSGlobalContextRef _context = [jsc ctx];
+    #else
+        JSGlobalContextRef _context = JSGlobalContextCreate(NULL);
+    #endif
+    
+    JSValueRef exception = NULL;
+    JSValueRef *_exception = &exception;
+        
+    CALL(narwhal, argc, argv, envp);
+    
+    int code = 0;
+    if (*_exception) {
+        code = 1;
+        JS_Print(*_exception);
+    }
+    
+    #ifdef WEBKIT
+        [pool drain];
+    #elif defined(JSCOCOA)
+        [pool drain];
+    #endif
+    
+    return code;
+}