sproutit-narwhal 0.1.106

data/engines/jsc/narwhal.c

@@ -0,0 +1,29 @@
+#include <narwhal.h>
+
+//#ifdef WEBKIT
+
+JSObjectRef JSObjectMakeArray(JSContextRef _context, size_t argc, const JSValueRef argv[],  JSValueRef* _exception)
+{
+    JSObjectRef Array = GET_OBJECT(JS_GLOBAL, "Array");
+    return CALL_AS_CONSTRUCTOR(Array, argc, argv);
+}
+
+JSObjectRef JSObjectMakeDate(JSContextRef _context, size_t argc, const JSValueRef argv[],  JSValueRef* _exception)
+{
+    JSObjectRef Date = GET_OBJECT(JS_GLOBAL, "Date");
+    return CALL_AS_CONSTRUCTOR(Date, argc, argv);
+}
+
+JSObjectRef JSObjectMakeError(JSContextRef _context, size_t argc, const JSValueRef argv[],  JSValueRef* _exception)
+{
+    JSObjectRef Error = GET_OBJECT(JS_GLOBAL, "Error");
+    return CALL_AS_CONSTRUCTOR(Error, argc, argv);
+}
+
+JSObjectRef JSObjectMakeRegExp(JSContextRef _context, size_t argc, const JSValueRef argv[],  JSValueRef* _exception)
+{
+    JSObjectRef RegExp = GET_OBJECT(JS_GLOBAL, "RegExp");
+    return CALL_AS_CONSTRUCTOR(RegExp, argc, argv);
+}
+
+//#endif

data/engines/jsc/package.json

@@ -0,0 +1,8 @@
+{
+    "name": "narwhal-jsc",
+    "dependencies": ["narwhal"],
+    "engine": "jsc",
+    "author": "Tom Robinson (http://tlrobinson.net/)",
+    "description": "JavaScriptCore engine support for Narwhal",
+    "keywords": ["narwhal", "engine", "jsc", "javascriptcore", "webkit"]
+}

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

@@ -0,0 +1,290 @@
+#include <narwhal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <iconv.h>
+#include <errno.h>
+
+#include <binary-engine.h>
+
+DESTRUCTOR(Bytes_finalize)
+{    
+    GET_INTERNAL(BytesPrivate *, data, object);
+    DEBUG("freeing bytes=[%p]\n", data);
+    if (data) {
+        if (data->buffer)
+            free(data->buffer);
+        data->buffer = NULL;
+        free(data);
+    }
+}
+END
+
+#ifdef NARWHAL_JSC
+
+JSClassRef Bytes_class(JSContextRef _context)
+{
+    static JSClassRef jsClass;
+    if (!jsClass)
+    {
+        JSClassDefinition definition = kJSClassDefinitionEmpty;
+        definition.finalize = Bytes_finalize;
+
+        jsClass = JSClassCreate(&definition);
+    }
+    return jsClass;
+}
+
+JSObjectRef Bytes_new(JSContextRef _context, JSValueRef *_exception, char* buffer, int length)
+{
+    BytesPrivate *data = (BytesPrivate*)malloc(sizeof(BytesPrivate));
+    if (!data) return NULL;
+    
+    data->length = length;
+    data->buffer = buffer;
+    
+    return JSObjectMake(_context, Bytes_class(_context), data);
+}
+
+#elif NARWHAL_V8
+
+OBJECT(Bytes_new, 2, char* buffer, size_t length)
+{
+    BytesPrivate *data = (BytesPrivate*)malloc(sizeof(BytesPrivate));
+    
+    data->length = length;
+    data->buffer = buffer;
+    
+    SET_INTERNAL(self, data);
+    
+    Persistent<Object> _weak_handle = Persistent<Object>::New(self);
+    _weak_handle.MakeWeak(NULL, &Bytes_finalize);
+
+    return self;
+}
+END
+
+#endif
+
+FUNCTION(B_ALLOC, ARG_INT(length))
+{
+    char *buffer = (char*)calloc(length, sizeof(char));
+    if (!buffer)
+        THROW("B_ALLOC: Couldn't alloc buffer");
+
+    return CALL(Bytes_new, buffer, length);
+}
+END
+
+FUNCTION(B_LENGTH, ARG_OBJ(bytes))
+{
+    GET_INTERNAL(BytesPrivate*, byte_data, bytes);
+    return JS_int(byte_data->length);
+}
+END
+
+FUNCTION(B_FILL, ARG_OBJ(bytes), ARG_INT(from), ARG_INT(to), ARG_INT(value))
+{
+    GET_INTERNAL(BytesPrivate*, byte_data, bytes);
+
+    if (!byte_data->buffer)
+        THROW("B_FILL: NULL buffer");
+
+    if (from > to || from < 0 || to >= byte_data->length)
+        THROW("B_FILL: tried to fill beyond bounds");
+
+    memset(byte_data->buffer + from, value, to - from);
+
+    return JS_undefined;
+}
+END
+
+FUNCTION(B_COPY, ARG_OBJ(src), ARG_INT(srcOffset), ARG_OBJ(dst), ARG_INT(dstOffset), ARG_INT(length))
+{
+    GET_INTERNAL(BytesPrivate*, src_data, src);
+    GET_INTERNAL(BytesPrivate*, dst_data, dst);
+
+    if (srcOffset + length > src_data->length || dstOffset + length > dst_data->length)
+        THROW("B_COPY: tried to copy beyond bounds");
+
+    memcpy(dst_data->buffer + dstOffset, src_data->buffer + srcOffset, length);
+
+    return JS_undefined;
+}
+END
+
+FUNCTION(B_GET, ARG_OBJ(bytes), ARG_INT(index))
+{
+    GET_INTERNAL(BytesPrivate*, bytes_data, bytes);
+
+    if (index >= bytes_data->length)
+        THROW("B_GET: tried get beyond bounds");
+
+    unsigned char b = bytes_data->buffer[index];
+
+    return JS_int((int)b);
+}
+END
+
+FUNCTION(B_SET, ARG_OBJ(bytes), ARG_INT(index), ARG_INT(value))
+{
+    GET_INTERNAL(BytesPrivate*, bytes_data, bytes);
+
+    if (index >= bytes_data->length) 
+        THROW("B_SET: tried set beyond bounds");
+    if (value < 0 || value >= 256)
+        THROW("B_SET: tried to set out of byte range");
+
+    bytes_data->buffer[index] = (unsigned char)value;
+
+    return JS_undefined;
+}
+END
+
+FUNCTION(B_DECODE_DEFAULT, ARG_OBJ(bytes), ARG_INT(offset), ARG_INT(length))
+{
+    GET_INTERNAL(BytesPrivate*, bytes_data, bytes);
+    return JS_str_utf8((char *)(bytes_data->buffer + offset), length);
+}
+END
+
+FUNCTION(B_ENCODE_DEFAULT, ARG_UTF8(string))
+{
+    int length = strlen(string);
+
+    char* buffer = (char*)calloc(length, sizeof(char));
+    if (!buffer)
+        THROW("B_ENCODE_DEFAULT: Couldn't alloc buffer");
+
+    memcpy(buffer, string, length);
+
+    return CALL(Bytes_new, buffer, length);
+}
+END
+
+int transcode(char *src, size_t srcLength, char **dstOut, size_t *dstLengthOut, const char *srcCodec, const char *dstCodec)
+{
+    /*
+    printf("src=%p srcLength=%d srcCodec=%s dstCodec=%s\n", src, srcLength, srcCodec, dstCodec);
+    for (size_t i = 0; i < srcLength; i++)
+        printf("%02x ",(unsigned char)src[i]);
+    printf("\n");
+    //*/
+    
+    int dst_length = srcLength*10; // FIXME!!!!!!
+    char *dst = (char*)calloc(dst_length, 1);
+    if (!dst) {
+        perror("transcode");
+        return 0;
+    }
+
+    iconv_t cd = iconv_open(dstCodec, srcCodec);
+    if (cd == (iconv_t)-1) {
+        perror("transcode");
+        return 0;
+    }
+
+    char *src_buf = src, *dst_buf = dst;
+    size_t src_bytes_left = (size_t)srcLength, dst_bytes_left = (size_t)dst_length, converted=0;
+
+    while (dst_bytes_left > 0)
+    {
+        if (src_bytes_left == 0)
+            break;
+        if ((converted = iconv(cd, &src_buf, &src_bytes_left, &dst_buf, &dst_bytes_left)) == (size_t)-1)
+        {
+            if (errno != EINVAL)
+            {
+                perror("transcode");
+                return 0;
+            }
+        }
+    }
+
+    if (dst_bytes_left >= sizeof (wchar_t))
+        *((wchar_t *) dst_buf) = L'\0';
+
+    if (iconv_close(cd)) {
+        perror("transcode");
+        return 0;
+    }
+
+    if (src_bytes_left > 0) {
+        perror("transcode");
+        return 0;
+    }
+
+    *dstOut = dst;
+    *dstLengthOut = (dst_length - dst_bytes_left);
+
+    return 1;
+}
+
+FUNCTION(B_DECODE, ARG_OBJ(bytes), ARG_INT(offset), ARG_INT(srcLength), ARG_UTF8(codec))
+{
+    GET_INTERNAL(BytesPrivate*, src_data, bytes);
+
+    char *dst;
+    size_t dstLength;
+
+    if (!transcode((char *)(src_data->buffer + offset), srcLength, &dst, &dstLength, codec, UTF_16_ENCODING))
+        THROW("B_DECODE: iconv error");
+
+    NWString string = JS_str_utf16(dst, dstLength);
+    free(dst);
+
+    return string;
+}
+END
+
+FUNCTION(B_ENCODE, ARG_STR(string), ARG_UTF8(codec))
+{
+    char *src, *dst;
+    size_t srcLength, dstLength;
+    
+    if (!GET_UTF16(string, &src, &srcLength))
+        THROW("BLAHHHHH");
+
+    if (!transcode(src, srcLength, &dst, &dstLength, UTF_16_ENCODING, codec))
+        THROW("B_ENCODE: iconv error");
+    
+    free(src);
+
+    return CALL(Bytes_new, dst, dstLength);
+}
+END
+
+FUNCTION(B_TRANSCODE, ARG_OBJ(srcBytes), ARG_INT(srcOffset), ARG_INT(srcLength), ARG_UTF8(srcCodec), ARG_UTF8(dstCodec))
+{
+    GET_INTERNAL(BytesPrivate*, src_data, srcBytes);
+
+    char *dst;
+    size_t dstLength;
+
+    char *src = (char *)(src_data->buffer + srcOffset);
+    if (!transcode(src, srcLength, &dst, &dstLength, srcCodec, dstCodec))
+        THROW("B_TRANSCODE: iconv error");
+
+    return CALL(Bytes_new, dst, dstLength);
+}
+END
+
+NARWHAL_MODULE(binary_engine)
+{
+    EXPORTS("B_LENGTH", JS_fn(B_LENGTH));
+    EXPORTS("B_ALLOC", JS_fn(B_ALLOC));
+    EXPORTS("B_FILL", JS_fn(B_FILL));
+    EXPORTS("B_COPY", JS_fn(B_COPY));
+    EXPORTS("B_GET", JS_fn(B_GET));
+    EXPORTS("B_SET", JS_fn(B_SET));
+
+    EXPORTS("B_DECODE", JS_fn(B_DECODE));
+    EXPORTS("B_ENCODE", JS_fn(B_ENCODE));
+
+    EXPORTS("B_DECODE_DEFAULT", JS_fn(B_DECODE_DEFAULT));
+    EXPORTS("B_ENCODE_DEFAULT", JS_fn(B_ENCODE_DEFAULT));
+
+    EXPORTS("B_TRANSCODE", JS_fn(B_TRANSCODE));
+
+    EXPORTS("DEFAULT_CODEC", JS_str_utf8("UTF-8", strlen("UTF-8")));
+}
+END_NARWHAL_MODULE

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

@@ -0,0 +1,405 @@
+#include <narwhal.h>
+
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <utime.h>
+
+#define PATH_OR_DOT(path) (path[0] == '\0' ? "." : path)
+
+NWObject io;
+
+FUNCTION(F_cwd)
+{
+    ARG_COUNT(0);
+    
+    char *cwd = getcwd(NULL, 0);
+    if (!cwd)
+        THROW("Couldn't get cwd.");
+        
+    NWValue cwdValue = JS_str_utf8(cwd, strlen(cwd));
+    free(cwd);
+    
+    return cwdValue;
+}
+END
+
+FUNCTION(F_canonicalImpl, ARG_UTF8_CAST(path))
+{
+    ARG_COUNT(1);
+    
+    // FIXME: http://insanecoding.blogspot.com/2007/11/pathmax-simply-isnt.html
+    char resolved_name[PATH_MAX];
+
+    char *canon = realpath(PATH_OR_DOT(path), resolved_name);
+    if (!canon)
+        return JS_str_utf8(path, strlen(path));
+
+    return JS_str_utf8(canon, strlen(canon));
+}
+END
+
+FUNCTION(F_mtime, ARG_UTF8_CAST(path))
+{
+    ARG_COUNT(1);
+    
+	struct stat stat_info;
+    int ret = stat(PATH_OR_DOT(path), &stat_info);
+    if (ret < 0)
+        THROW("mtime: %s", strerror(errno));
+    
+    long long timestamp = ((long long)(stat_info.st_mtime)) * 1000;
+
+    return JS_date(timestamp);
+}
+END
+
+FUNCTION(F_size, ARG_UTF8_CAST(path))
+{
+    ARG_COUNT(1);
+    
+	struct stat stat_info;
+    int ret = stat(PATH_OR_DOT(path), &stat_info);
+    
+    return JS_int(stat_info.st_size);
+}
+END
+
+FUNCTION(F_stat, ARG_UTF8_CAST(path))
+{
+    ARG_COUNT(1);
+
+	struct stat stat_info;
+    int ret = stat(PATH_OR_DOT(path), &stat_info);
+    
+    return JS_undefined;
+}
+END
+
+FUNCTION(F_exists, ARG_UTF8_CAST(path))
+{
+    ARG_COUNT(1);
+
+	struct stat stat_info;
+    int ret = stat(PATH_OR_DOT(path), &stat_info);
+    
+    return JS_bool(ret != -1);
+}
+END
+
+FUNCTION(F_linkExists, ARG_UTF8_CAST(path))
+{
+    ARG_COUNT(1);
+
+	struct stat stat_info;
+    int ret = stat(PATH_OR_DOT(path), &stat_info);
+
+    return JS_bool(ret != -1 && (S_ISREG(stat_info.st_mode) || S_ISLNK(stat_info.st_mode)));
+}
+END
+
+FUNCTION(F_isDirectory, ARG_UTF8_CAST(path))
+{
+    ARG_COUNT(1);
+
+	struct stat stat_info;
+    int ret = stat(PATH_OR_DOT(path), &stat_info);
+
+    return JS_bool(ret != -1 && S_ISDIR(stat_info.st_mode));
+}
+END
+    
+FUNCTION(F_isFile, ARG_UTF8_CAST(path))
+{
+    ARG_COUNT(1);
+
+	struct stat stat_info;
+    int ret = stat(PATH_OR_DOT(path), &stat_info);
+
+    return JS_bool(ret != -1 && S_ISREG(stat_info.st_mode));
+}
+END
+
+FUNCTION(F_isLink, ARG_UTF8_CAST(path))
+{
+    ARG_COUNT(1);
+
+	struct stat stat_info;
+    int ret = lstat(PATH_OR_DOT(path), &stat_info);
+
+    return JS_bool(ret != -1 && S_ISLNK(stat_info.st_mode));
+}
+END
+
+FUNCTION(F_isReadable, ARG_UTF8_CAST(path))
+{
+    ARG_COUNT(1);
+    
+    return JS_bool(access(PATH_OR_DOT(path), R_OK) == 0);
+}
+END
+
+FUNCTION(F_isWritable, ARG_UTF8_CAST(path))
+{
+    ARG_COUNT(1);
+    
+    return JS_bool(access(PATH_OR_DOT(path), W_OK) == 0);
+}
+END
+
+FUNCTION(F_chmod, ARG_UTF8_CAST(path), ARG_INT(mode))
+{
+    ARG_COUNT(2);
+    
+    if (chmod(PATH_OR_DOT(path), mode) < 0)
+        THROW("failed to chmod %s", path);
+    
+    return JS_undefined;
+}
+END
+
+FUNCTION(F_chown, ARG_UTF8_CAST(path), ARG_UTF8_CAST(owner), ARG_UTF8_CAST(group))
+{
+    ARG_COUNT(3);
+    
+    THROW("NYI chown");
+    
+    return JS_undefined;
+}
+END
+
+FUNCTION(F_link, ARG_UTF8_CAST(source), ARG_UTF8_CAST(target))
+{
+    ARG_COUNT(1);
+    
+    THROW("NYI link");
+
+    return JS_undefined;
+}
+END
+
+FUNCTION(F_symlink, ARG_UTF8_CAST(source), ARG_UTF8_CAST(target))
+{
+    ARG_COUNT(2);
+    
+    if (symlink(PATH_OR_DOT(source), PATH_OR_DOT(target)) < 0)
+        THROW("failed to symlink %s to %s", source, target);
+
+    return JS_undefined;
+}
+END
+
+FUNCTION(F_renameImpl, ARG_UTF8_CAST(source), ARG_UTF8_CAST(target))
+{
+    ARG_COUNT(2);
+
+    if (rename(PATH_OR_DOT(source), PATH_OR_DOT(target)) < 0)
+        THROW("failed to rename %s to %s", source, target);
+
+    return JS_undefined;
+}
+END
+
+//FUNCTION(F_move, ARG_UTF8_CAST(source), ARG_UTF8_CAST(target))
+//{
+//    ARG_COUNT(2);
+//
+//    THROW("NYI move");
+//
+//    return JS_undefined;
+//}
+//END
+    
+FUNCTION(F_remove, ARG_UTF8_CAST(path))
+{
+    ARG_COUNT(1);
+    
+    if (unlink(PATH_OR_DOT(path)) < 0)
+        THROW("failed to delete %s: %s", path, strerror(errno));
+
+    return JS_undefined;
+}
+END
+
+FUNCTION(F_mkdir, ARG_UTF8_CAST(path))
+{
+    ARG_COUNT(1);
+    
+    if (mkdir(PATH_OR_DOT(path), 0777) < 0) {
+        // TODO: Should this fail
+        THROW("failed to make directory %s: %s", path, strerror(errno));
+    }
+
+    return JS_undefined;
+}
+END
+
+//FUNCTION(F_mkdirs, ARG_UTF8_CAST(path))
+//{
+//    ARG_COUNT(1);
+//
+//    THROW("NYI mkdirs");
+//
+//    return JS_undefined;
+//}
+//END
+
+FUNCTION(F_rmdir, ARG_UTF8_CAST(path))
+{
+    ARG_COUNT(1);
+
+    if (rmdir(PATH_OR_DOT(path)) < 0)
+        THROW("failed to remove the directory %s: %s", path, strerror(errno));
+
+    return JS_undefined;
+}
+END
+    
+FUNCTION(F_list, ARG_UTF8_CAST(path))
+{
+    DIR *dp;
+    struct dirent *dirp;
+
+    if((dp  = opendir(PATH_OR_DOT(path))) == NULL) {
+        THROW("%s", strerror(errno));
+    }
+
+    NWObject array = JS_array(0, NULL);
+
+    int index = 0;
+    while ((dirp = readdir(dp)) != NULL) {
+        if (strcmp(".", dirp->d_name) && strcmp("..", dirp->d_name))
+            SET_VALUE_AT_INDEX(array, index++, JS_str_utf8(dirp->d_name, dirp->d_namlen));
+    }
+    closedir(dp);
+
+    return array;
+}
+END
+
+FUNCTION(F_touchImpl, ARG_UTF8_CAST(path), ARG_DOUBLE(mtime))
+{
+    ARG_COUNT(2);
+
+    struct utimbuf times;
+    times.actime = (time_t)(mtime/1000.0);
+    times.modtime = (time_t)(mtime/1000.0);
+    
+    if (utime(PATH_OR_DOT(path), &times) < 0)
+        THROW("unable to set mtime of %s: %s", path, strerror(errno));
+
+    return JS_undefined;
+}
+END
+
+FUNCTION(F_FileIO, ARG_UTF8_CAST(path))
+{
+    NWObject IO = GET_OBJECT(io, "IO");
+    NWObject mode_fn = GET_OBJECT(Exports, "mode");
+    
+    ARGS_ARRAY(argv, ARGV(1));
+    NWObject modeObject = TO_OBJECT(CALL_AS_FUNCTION(mode_fn, JS_GLOBAL, 1, argv));
+    
+    int readFlag = GET_BOOL(modeObject, "read");
+    int writeFlag = GET_BOOL(modeObject, "write");
+    int appendFlag = GET_BOOL(modeObject, "append");
+    int updateFlag = GET_BOOL(modeObject, "update");
+    
+    DEBUG("path=%s readFlag=%d writeFlag=%d readFlag=%d readFlag=%d\n", path, readFlag, writeFlag, appendFlag, updateFlag);
+    
+    int oflag = 0;
+    
+    if (readFlag && writeFlag)
+        oflag = oflag | O_RDWR;
+    else if (writeFlag)
+        oflag = oflag | O_WRONLY;
+    else if (readFlag)
+        oflag = oflag | O_RDONLY;
+        
+    if (appendFlag)
+        oflag = oflag | O_APPEND;
+    // if (!updateFlag)
+    //     oflag = oflag | O_TRUNC;
+    
+    if (updateFlag) {
+        THROW("Updating IO not yet implemented.");
+    } else if (writeFlag || appendFlag) {
+        oflag = oflag | O_CREAT;
+        if (!(oflag & O_APPEND))
+            oflag = oflag | O_TRUNC;
+
+        int fd = open(path, oflag, 0644);
+        DEBUG("fd=%d\n", fd);
+        if (fd < 0)
+            THROW("%s", strerror(errno));
+
+        ARGS_ARRAY(argv, JS_int(-1), JS_int(fd));
+        return TO_OBJECT(CALL_AS_CONSTRUCTOR(IO, 2, argv));
+    } else if (readFlag) {
+
+        int fd = open(path, oflag);
+        DEBUG("fd=%d\n", fd);
+        if (fd < 0)
+            THROW("%s", strerror(errno));
+
+        ARGS_ARRAY(argv, JS_int(fd), JS_int(-1));
+        return CALL_AS_CONSTRUCTOR(IO, 2, argv);
+    } else {
+        THROW("Files must be opened either for read, write, or update mode.");
+    }
+    
+    return JS_undefined;
+}
+END
+
+
+NARWHAL_MODULE(file_engine)
+{
+    Exports = PROTECT_OBJECT(require("./file"));
+    io = PROTECT_OBJECT(require("io"));
+    
+    EXPORTS("FileIO", JS_fn(F_FileIO));
+    
+    EXPORTS("cwd", JS_fn(F_cwd));
+    //EXPORTS("canonical", JS_fn(F_canonical));
+    EXPORTS("canonicalImpl", JS_fn(F_canonicalImpl));
+    EXPORTS("mtime", JS_fn(F_mtime));
+    EXPORTS("size", JS_fn(F_size));
+    EXPORTS("stat", JS_fn(F_stat));
+    EXPORTS("exists", JS_fn(F_exists));
+    EXPORTS("linkExists", JS_fn(F_linkExists));
+    EXPORTS("isDirectory", JS_fn(F_isDirectory));
+    EXPORTS("isFile", JS_fn(F_isFile));
+    EXPORTS("isLink", JS_fn(F_isLink));
+    EXPORTS("isReadable", JS_fn(F_isReadable));
+    EXPORTS("isWritable", JS_fn(F_isWritable));
+    EXPORTS("chmod", JS_fn(F_chmod));
+    EXPORTS("chown", JS_fn(F_chown));
+    EXPORTS("link", JS_fn(F_link));
+    EXPORTS("symlink", JS_fn(F_symlink));
+    //EXPORTS("rename", JS_fn(F_rename));
+    //EXPORTS("move", JS_fn(F_rename));
+    EXPORTS("renameImpl", JS_fn(F_renameImpl));
+    //EXPORTS("move", JS_fn(F_move));
+    EXPORTS("remove", JS_fn(F_remove));
+    EXPORTS("mkdir", JS_fn(F_mkdir));
+    //EXPORTS("mkdirs", JS_fn(F_mkdirs));
+    EXPORTS("rmdir", JS_fn(F_rmdir));
+    EXPORTS("listImpl", JS_fn(F_list));
+    //EXPORTS("list", JS_fn(F_list));
+    EXPORTS("touchImpl", JS_fn(F_touchImpl));
+    //EXPORTS("touch", JS_fn(F_touch));
+    
+    NWObject file_engine_js = require("file-engine.js");
+    EXPORTS("mkdirs", GET_VALUE(file_engine_js, "mkdirs"));
+    EXPORTS("touch", GET_VALUE(file_engine_js, "touch"));
+    EXPORTS("rename", GET_VALUE(file_engine_js, "rename"));
+    EXPORTS("move", GET_VALUE(file_engine_js, "rename"));
+    EXPORTS("canonical", GET_VALUE(file_engine_js, "canonical"));
+}
+END_NARWHAL_MODULE