|
|
#include <assert.h> |
|
|
#include <bare.h> |
|
|
#include <js.h> |
|
|
#include <stdbool.h> |
|
|
#include <stdint.h> |
|
|
#include <stdlib.h> |
|
|
#include <string.h> |
|
|
#include <utf.h> |
|
|
#include <uv.h> |
|
|
|
|
|
#ifndef _MSC_VER |
|
|
#include <unistd.h> |
|
|
#endif |
|
|
|
|
|
typedef struct { |
|
|
uv_fs_t handle; |
|
|
|
|
|
js_env_t *env; |
|
|
js_ref_t *ctx; |
|
|
js_ref_t *on_response; |
|
|
|
|
|
js_ref_t *data; |
|
|
|
|
|
bool active; |
|
|
bool exiting; |
|
|
|
|
|
js_deferred_teardown_t *teardown; |
|
|
} bare_fs_t; |
|
|
|
|
|
typedef utf8_t bare_fs_path_t[4096 + 1 ]; |
|
|
|
|
|
typedef struct { |
|
|
uv_dir_t *dir; |
|
|
} bare_fs_dir_t; |
|
|
|
|
|
typedef struct { |
|
|
uv_fs_event_t handle; |
|
|
|
|
|
js_env_t *env; |
|
|
js_ref_t *ctx; |
|
|
js_ref_t *on_event; |
|
|
js_ref_t *on_close; |
|
|
|
|
|
js_deferred_teardown_t *teardown; |
|
|
bool closing; |
|
|
bool exiting; |
|
|
} bare_fs_watcher_t; |
|
|
|
|
|
typedef uv_dirent_t bare_fs_dirent_t; |
|
|
|
|
|
static inline void |
|
|
bare_fs__on_finalize(bare_fs_t *req) { |
|
|
int err; |
|
|
|
|
|
js_env_t *env = req->env; |
|
|
|
|
|
js_deferred_teardown_t *teardown = req->teardown; |
|
|
|
|
|
uv_fs_req_cleanup(&req->handle); |
|
|
|
|
|
if (req->data) { |
|
|
err = js_delete_reference(env, req->data); |
|
|
assert(err == 0); |
|
|
|
|
|
req->data = NULL; |
|
|
} |
|
|
|
|
|
err = js_delete_reference(env, req->on_response); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_delete_reference(env, req->ctx); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_finish_deferred_teardown_callback(teardown); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
static void |
|
|
bare_fs__on_teardown(js_deferred_teardown_t *handle, void *data) { |
|
|
int err; |
|
|
|
|
|
bare_fs_t *req = (bare_fs_t *) data; |
|
|
|
|
|
req->exiting = true; |
|
|
|
|
|
err = uv_cancel((uv_req_t *) &req->handle); |
|
|
|
|
|
if (err == 0 || req->active == false) bare_fs__on_finalize(req); |
|
|
} |
|
|
|
|
|
static inline void |
|
|
bare_fs__on_response(uv_fs_t *handle) { |
|
|
int err; |
|
|
|
|
|
bare_fs_t *req = (bare_fs_t *) handle; |
|
|
|
|
|
req->active = false; |
|
|
|
|
|
if (req->exiting) return bare_fs__on_finalize(req); |
|
|
|
|
|
js_env_t *env = req->env; |
|
|
|
|
|
js_handle_scope_t *scope; |
|
|
err = js_open_handle_scope(env, &scope); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *ctx; |
|
|
err = js_get_reference_value(env, req->ctx, &ctx); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *on_response; |
|
|
err = js_get_reference_value(env, req->on_response, &on_response); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *args[2]; |
|
|
|
|
|
if (handle->result < 0) { |
|
|
js_value_t *code; |
|
|
err = js_create_string_utf8(env, (utf8_t *) uv_err_name(handle->result), -1, &code); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *message; |
|
|
err = js_create_string_utf8(env, (utf8_t *) uv_strerror(handle->result), -1, &message); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_error(env, code, message, &args[0]); |
|
|
assert(err == 0); |
|
|
} else { |
|
|
err = js_get_null(env, &args[0]); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
err = js_create_int32(env, handle->result, &args[1]); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_req_cleanup(handle); |
|
|
|
|
|
if (req->data) { |
|
|
err = js_delete_reference(env, req->data); |
|
|
assert(err == 0); |
|
|
|
|
|
req->data = NULL; |
|
|
} |
|
|
|
|
|
js_call_function(env, ctx, on_response, 2, args, NULL); |
|
|
|
|
|
err = js_close_handle_scope(env, scope); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
static void |
|
|
bare_fs__on_stat_response(uv_fs_t *handle) { |
|
|
int err; |
|
|
|
|
|
bare_fs_t *req = (bare_fs_t *) handle; |
|
|
|
|
|
if (req->exiting) return bare_fs__on_response(handle); |
|
|
|
|
|
js_env_t *env = req->env; |
|
|
|
|
|
if (handle->result == 0) { |
|
|
js_handle_scope_t *scope; |
|
|
err = js_open_handle_scope(env, &scope); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *data; |
|
|
err = js_get_reference_value(env, req->data, &data); |
|
|
assert(err == 0); |
|
|
|
|
|
uint32_t i = 0; |
|
|
|
|
|
#define V(property) \ |
|
|
{ \ |
|
|
js_value_t *value; \ |
|
|
err = js_create_int64(env, handle->statbuf.st_##property, &value); \ |
|
|
assert(err == 0); \ |
|
|
err = js_set_element(env, data, i++, value); \ |
|
|
assert(err == 0); \ |
|
|
} |
|
|
|
|
|
V(dev) |
|
|
V(mode) |
|
|
V(nlink) |
|
|
V(uid) |
|
|
V(gid) |
|
|
V(rdev) |
|
|
V(blksize) |
|
|
V(ino) |
|
|
V(size) |
|
|
V(blocks) |
|
|
#undef V |
|
|
|
|
|
#define V(property) \ |
|
|
{ \ |
|
|
uv_timespec_t time = handle->statbuf.st_##property; \ |
|
|
js_value_t *value; \ |
|
|
err = js_create_int64(env, time.tv_sec * 1e3 + time.tv_nsec / 1e6, &value); \ |
|
|
assert(err == 0); \ |
|
|
err = js_set_element(env, data, i++, value); \ |
|
|
assert(err == 0); \ |
|
|
} |
|
|
|
|
|
V(atim) |
|
|
V(mtim) |
|
|
V(ctim) |
|
|
V(birthtim) |
|
|
#undef V |
|
|
|
|
|
err = js_close_handle_scope(env, scope); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
bare_fs__on_response(handle); |
|
|
} |
|
|
|
|
|
static void |
|
|
bare_fs__on_realpath_response(uv_fs_t *handle) { |
|
|
int err; |
|
|
|
|
|
bare_fs_t *req = (bare_fs_t *) handle; |
|
|
|
|
|
if (req->exiting) return bare_fs__on_response(handle); |
|
|
|
|
|
js_env_t *env = req->env; |
|
|
|
|
|
if (handle->result == 0) { |
|
|
js_handle_scope_t *scope; |
|
|
err = js_open_handle_scope(env, &scope); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *data; |
|
|
err = js_get_reference_value(env, req->data, &data); |
|
|
assert(err == 0); |
|
|
|
|
|
char *path; |
|
|
err = js_get_typedarray_info(env, data, NULL, (void **) &path, NULL, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
strncpy(path, handle->ptr, sizeof(bare_fs_path_t)); |
|
|
|
|
|
err = js_close_handle_scope(env, scope); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
bare_fs__on_response(handle); |
|
|
} |
|
|
|
|
|
static void |
|
|
bare_fs__on_readlink_response(uv_fs_t *handle) { |
|
|
int err; |
|
|
|
|
|
bare_fs_t *req = (bare_fs_t *) handle; |
|
|
|
|
|
if (req->exiting) return bare_fs__on_response(handle); |
|
|
|
|
|
js_env_t *env = req->env; |
|
|
|
|
|
if (handle->result == 0) { |
|
|
js_handle_scope_t *scope; |
|
|
err = js_open_handle_scope(env, &scope); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *data; |
|
|
err = js_get_reference_value(env, req->data, &data); |
|
|
assert(err == 0); |
|
|
|
|
|
char *path; |
|
|
err = js_get_typedarray_info(env, data, NULL, (void **) &path, NULL, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
strncpy(path, handle->ptr, sizeof(bare_fs_path_t)); |
|
|
|
|
|
err = js_close_handle_scope(env, scope); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
bare_fs__on_response(handle); |
|
|
} |
|
|
|
|
|
static void |
|
|
bare_fs__on_opendir_response(uv_fs_t *handle) { |
|
|
int err; |
|
|
|
|
|
bare_fs_t *req = (bare_fs_t *) handle; |
|
|
|
|
|
if (req->exiting) return bare_fs__on_response(handle); |
|
|
|
|
|
js_env_t *env = req->env; |
|
|
|
|
|
if (handle->result == 0) { |
|
|
js_handle_scope_t *scope; |
|
|
err = js_open_handle_scope(env, &scope); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *data; |
|
|
err = js_get_reference_value(env, req->data, &data); |
|
|
assert(err == 0); |
|
|
|
|
|
bare_fs_dir_t *dir; |
|
|
err = js_get_typedarray_info(env, data, NULL, (void **) &dir, NULL, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
dir->dir = handle->ptr; |
|
|
|
|
|
err = js_close_handle_scope(env, scope); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
bare_fs__on_response(handle); |
|
|
} |
|
|
|
|
|
static void |
|
|
bare_fs__on_readdir_response(uv_fs_t *handle) { |
|
|
int err; |
|
|
|
|
|
bare_fs_t *req = (bare_fs_t *) handle; |
|
|
|
|
|
if (req->exiting) return bare_fs__on_response(handle); |
|
|
|
|
|
js_env_t *env = req->env; |
|
|
|
|
|
if (handle->result > 0) { |
|
|
js_handle_scope_t *scope; |
|
|
err = js_open_handle_scope(env, &scope); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *data; |
|
|
err = js_get_reference_value(env, req->data, &data); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_dir_t *dir = handle->ptr; |
|
|
|
|
|
for (size_t i = 0, n = handle->result; i < n; i++) { |
|
|
uv_dirent_t *dirent = &dir->dirents[i]; |
|
|
|
|
|
js_value_t *entry; |
|
|
err = js_create_object(env, &entry); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_set_element(env, data, i, entry); |
|
|
assert(err == 0); |
|
|
|
|
|
size_t name_len = strlen(dirent->name); |
|
|
|
|
|
js_value_t *name; |
|
|
void *data; |
|
|
err = js_create_arraybuffer(env, name_len, &data, &name); |
|
|
assert(err == 0); |
|
|
|
|
|
memcpy(data, dirent->name, name_len); |
|
|
|
|
|
err = js_set_named_property(env, entry, "name", name); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *type; |
|
|
err = js_create_uint32(env, dirent->type, &type); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_set_named_property(env, entry, "type", type); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
err = js_close_handle_scope(env, scope); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
bare_fs__on_response(handle); |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_init(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 2; |
|
|
js_value_t *argv[2]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 2); |
|
|
|
|
|
js_value_t *handle; |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_create_arraybuffer(env, sizeof(bare_fs_t), (void **) &req, &handle); |
|
|
assert(err == 0); |
|
|
|
|
|
req->env = env; |
|
|
req->data = NULL; |
|
|
req->active = false; |
|
|
req->exiting = false; |
|
|
|
|
|
err = js_create_reference(env, argv[0], 1, &req->ctx); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_reference(env, argv[1], 1, &req->on_response); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_add_deferred_teardown_callback(env, bare_fs__on_teardown, (void *) req, &req->teardown); |
|
|
assert(err == 0); |
|
|
|
|
|
return handle; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_open(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 4; |
|
|
js_value_t *argv[4]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 4); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[1], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t flags; |
|
|
err = js_get_value_int32(env, argv[2], &flags); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t mode; |
|
|
err = js_get_value_int32(env, argv[3], &mode); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_open(loop, &req->handle, (char *) path, flags, mode, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_open_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[0], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t flags; |
|
|
err = js_get_value_int32(env, argv[1], &flags); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t mode; |
|
|
err = js_get_value_int32(env, argv[2], &mode); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_open(loop, &req, (char *) path, flags, mode, NULL); |
|
|
|
|
|
js_value_t *res = NULL; |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} else { |
|
|
err = js_create_int32(env, req.result, &res); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return res; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_close(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 2; |
|
|
js_value_t *argv[2]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 2); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
uint32_t fd; |
|
|
err = js_get_value_uint32(env, argv[1], &fd); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_close(loop, &req->handle, fd, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_close_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 1; |
|
|
js_value_t *argv[1]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 1); |
|
|
|
|
|
uint32_t fd; |
|
|
err = js_get_value_uint32(env, argv[0], &fd); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_close(loop, &req, fd, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_access(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[1], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t mode; |
|
|
err = js_get_value_int32(env, argv[2], &mode); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_access(loop, &req->handle, (char *) path, mode, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_access_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 2; |
|
|
js_value_t *argv[2]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 2); |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[0], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t mode; |
|
|
err = js_get_value_int32(env, argv[1], &mode); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_access(loop, &req, (char *) path, mode, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_read(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 6; |
|
|
js_value_t *argv[6]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 6); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
uint32_t fd; |
|
|
err = js_get_value_uint32(env, argv[1], &fd); |
|
|
assert(err == 0); |
|
|
|
|
|
uint8_t *data; |
|
|
size_t data_len; |
|
|
err = js_get_typedarray_info(env, argv[2], NULL, (void **) &data, &data_len, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uint32_t offset; |
|
|
err = js_get_value_uint32(env, argv[3], &offset); |
|
|
assert(err == 0); |
|
|
|
|
|
uint32_t len; |
|
|
err = js_get_value_uint32(env, argv[4], &len); |
|
|
assert(err == 0); |
|
|
|
|
|
if (offset >= data_len) len = 0; |
|
|
else if (offset + len >= data_len) len = data_len - offset; |
|
|
|
|
|
int64_t pos; |
|
|
err = js_get_value_int64(env, argv[5], &pos); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_reference(env, argv[2], 1, &req->data); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_buf_t buf = uv_buf_init((void *) (data + offset), len); |
|
|
|
|
|
uv_fs_read(loop, &req->handle, fd, &buf, 1, pos, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_read_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 5; |
|
|
js_value_t *argv[5]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 5); |
|
|
|
|
|
uint32_t fd; |
|
|
err = js_get_value_uint32(env, argv[0], &fd); |
|
|
assert(err == 0); |
|
|
|
|
|
uint8_t *data; |
|
|
size_t data_len; |
|
|
err = js_get_typedarray_info(env, argv[1], NULL, (void **) &data, &data_len, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uint32_t offset; |
|
|
err = js_get_value_uint32(env, argv[2], &offset); |
|
|
assert(err == 0); |
|
|
|
|
|
uint32_t len; |
|
|
err = js_get_value_uint32(env, argv[3], &len); |
|
|
assert(err == 0); |
|
|
|
|
|
if (offset >= data_len) len = 0; |
|
|
else if (offset + len >= data_len) len = data_len - offset; |
|
|
|
|
|
int64_t pos; |
|
|
err = js_get_value_int64(env, argv[4], &pos); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_buf_t buf = uv_buf_init((void *) (data + offset), len); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_read(loop, (uv_fs_t *) &req, fd, &buf, 1, pos, NULL); |
|
|
|
|
|
js_value_t *res; |
|
|
err = js_create_int32(env, req.result, &res); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return res; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_readv(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 4; |
|
|
js_value_t *argv[4]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 4); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
uint32_t fd; |
|
|
err = js_get_value_uint32(env, argv[1], &fd); |
|
|
assert(err == 0); |
|
|
|
|
|
int64_t pos; |
|
|
err = js_get_value_int64(env, argv[3], &pos); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_reference(env, argv[2], 1, &req->data); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *arr = argv[2]; |
|
|
|
|
|
uint32_t bufs_len; |
|
|
err = js_get_array_length(env, arr, &bufs_len); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_buf_t *bufs = malloc(sizeof(uv_buf_t) * bufs_len); |
|
|
|
|
|
js_value_t **elements = malloc(bufs_len * sizeof(js_value_t *)); |
|
|
|
|
|
err = js_get_array_elements(env, arr, elements, bufs_len, 0, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
for (uint32_t i = 0; i < bufs_len; i++) { |
|
|
js_value_t *item = elements[i]; |
|
|
|
|
|
uv_buf_t *buf = &bufs[i]; |
|
|
err = js_get_typedarray_info(env, item, NULL, (void **) &buf->base, (size_t *) &buf->len, NULL, NULL); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_read(loop, &req->handle, fd, bufs, bufs_len, pos, bare_fs__on_response); |
|
|
|
|
|
free(elements); |
|
|
free(bufs); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_write(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 6; |
|
|
js_value_t *argv[6]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 6); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
uint32_t fd; |
|
|
err = js_get_value_uint32(env, argv[1], &fd); |
|
|
assert(err == 0); |
|
|
|
|
|
uint8_t *data; |
|
|
size_t data_len; |
|
|
err = js_get_typedarray_info(env, argv[2], NULL, (void **) &data, &data_len, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uint32_t offset; |
|
|
err = js_get_value_uint32(env, argv[3], &offset); |
|
|
assert(err == 0); |
|
|
|
|
|
uint32_t len; |
|
|
err = js_get_value_uint32(env, argv[4], &len); |
|
|
assert(err == 0); |
|
|
|
|
|
if (offset >= data_len) len = 0; |
|
|
else if (offset + len >= data_len) len = data_len - offset; |
|
|
|
|
|
int64_t pos; |
|
|
err = js_get_value_int64(env, argv[5], &pos); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_reference(env, argv[2], 1, &req->data); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_buf_t buf = uv_buf_init((void *) (data + offset), len); |
|
|
|
|
|
uv_fs_write(loop, &req->handle, fd, &buf, 1, pos, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_write_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 5; |
|
|
js_value_t *argv[5]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 5); |
|
|
|
|
|
uint32_t fd; |
|
|
err = js_get_value_uint32(env, argv[0], &fd); |
|
|
assert(err == 0); |
|
|
|
|
|
uint8_t *data; |
|
|
size_t data_len; |
|
|
err = js_get_typedarray_info(env, argv[1], NULL, (void **) &data, &data_len, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uint32_t offset; |
|
|
err = js_get_value_uint32(env, argv[2], &offset); |
|
|
assert(err == 0); |
|
|
|
|
|
uint32_t len; |
|
|
err = js_get_value_uint32(env, argv[3], &len); |
|
|
assert(err == 0); |
|
|
|
|
|
if (offset >= data_len) len = 0; |
|
|
else if (offset + len >= data_len) len = data_len - offset; |
|
|
|
|
|
int64_t pos; |
|
|
err = js_get_value_int64(env, argv[4], &pos); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_buf_t buf = uv_buf_init((void *) (data + offset), len); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_write(loop, &req, fd, &buf, 1, pos, NULL); |
|
|
|
|
|
js_value_t *res; |
|
|
err = js_create_int32(env, req.result, &res); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return res; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_writev(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 4; |
|
|
js_value_t *argv[4]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 4); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
uint32_t fd; |
|
|
err = js_get_value_uint32(env, argv[1], &fd); |
|
|
assert(err == 0); |
|
|
|
|
|
int64_t pos; |
|
|
err = js_get_value_int64(env, argv[3], &pos); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_reference(env, argv[2], 1, &req->data); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *arr = argv[2]; |
|
|
|
|
|
uint32_t bufs_len; |
|
|
err = js_get_array_length(env, arr, &bufs_len); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_buf_t *bufs = malloc(sizeof(uv_buf_t) * bufs_len); |
|
|
|
|
|
js_value_t **elements = malloc(bufs_len * sizeof(js_value_t *)); |
|
|
|
|
|
err = js_get_array_elements(env, arr, elements, bufs_len, 0, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
for (uint32_t i = 0; i < bufs_len; i++) { |
|
|
js_value_t *item = elements[i]; |
|
|
|
|
|
uv_buf_t *buf = &bufs[i]; |
|
|
err = js_get_typedarray_info(env, item, NULL, (void **) &buf->base, (size_t *) &buf->len, NULL, NULL); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_write(loop, &req->handle, fd, bufs, bufs_len, pos, bare_fs__on_response); |
|
|
|
|
|
free(elements); |
|
|
free(bufs); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_ftruncate(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
uint32_t fd; |
|
|
err = js_get_value_uint32(env, argv[1], &fd); |
|
|
assert(err == 0); |
|
|
|
|
|
int64_t len; |
|
|
err = js_get_value_int64(env, argv[2], &len); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_ftruncate(loop, &req->handle, fd, len, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_ftruncate_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 2; |
|
|
js_value_t *argv[2]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 2); |
|
|
|
|
|
uint32_t fd; |
|
|
err = js_get_value_uint32(env, argv[0], &fd); |
|
|
assert(err == 0); |
|
|
|
|
|
int64_t len; |
|
|
err = js_get_value_int64(env, argv[1], &len); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_ftruncate(loop, &req, fd, len, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_chmod(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[1], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t mode; |
|
|
err = js_get_value_int32(env, argv[2], &mode); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_chmod(loop, &req->handle, (char *) path, mode, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_chmod_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 2; |
|
|
js_value_t *argv[2]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 2); |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[0], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t mode; |
|
|
err = js_get_value_int32(env, argv[1], &mode); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_chmod(loop, &req, (char *) path, mode, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_fchmod(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
uint32_t fd; |
|
|
err = js_get_value_uint32(env, argv[1], &fd); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t mode; |
|
|
err = js_get_value_int32(env, argv[2], &mode); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_fchmod(loop, &req->handle, fd, mode, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_fchmod_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 2; |
|
|
js_value_t *argv[2]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 2); |
|
|
|
|
|
uint32_t fd; |
|
|
err = js_get_value_uint32(env, argv[0], &fd); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t mode; |
|
|
err = js_get_value_int32(env, argv[1], &mode); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_fchmod(loop, &req, fd, mode, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_rename(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_path_t src; |
|
|
err = js_get_value_string_utf8(env, argv[1], src, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
bare_fs_path_t dest; |
|
|
err = js_get_value_string_utf8(env, argv[2], dest, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_rename(loop, &req->handle, (char *) src, (char *) dest, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_rename_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 2; |
|
|
js_value_t *argv[2]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 2); |
|
|
|
|
|
bare_fs_path_t src; |
|
|
err = js_get_value_string_utf8(env, argv[0], src, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
bare_fs_path_t dest; |
|
|
err = js_get_value_string_utf8(env, argv[1], dest, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_rename(loop, &req, (char *) src, (char *) dest, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_copyfile(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 4; |
|
|
js_value_t *argv[4]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 4); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_path_t src; |
|
|
err = js_get_value_string_utf8(env, argv[1], src, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
bare_fs_path_t dest; |
|
|
err = js_get_value_string_utf8(env, argv[2], dest, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t mode; |
|
|
err = js_get_value_int32(env, argv[3], &mode); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_copyfile(loop, &req->handle, (char *) src, (char *) dest, mode, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_copyfile_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_path_t src; |
|
|
err = js_get_value_string_utf8(env, argv[0], src, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
bare_fs_path_t dest; |
|
|
err = js_get_value_string_utf8(env, argv[1], dest, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t mode; |
|
|
err = js_get_value_int32(env, argv[2], &mode); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_copyfile(loop, &req, (char *) src, (char *) dest, mode, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_mkdir(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[1], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t mode; |
|
|
err = js_get_value_int32(env, argv[2], &mode); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_mkdir(loop, &req->handle, (char *) path, mode, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_mkdir_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 2; |
|
|
js_value_t *argv[2]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 2); |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[0], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t mode; |
|
|
err = js_get_value_int32(env, argv[1], &mode); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_mkdir(loop, &req, (char *) path, mode, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_rmdir(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 2; |
|
|
js_value_t *argv[2]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 2); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[1], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_rmdir(loop, &req->handle, (char *) path, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_rmdir_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 1; |
|
|
js_value_t *argv[1]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 1); |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[0], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_rmdir(loop, &req, (char *) path, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_stat(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[1], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_reference(env, argv[2], 1, &req->data); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_stat(loop, &req->handle, (char *) path, bare_fs__on_stat_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_stat_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 1; |
|
|
js_value_t *argv[1]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 1); |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[0], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_stat(loop, &req, (char *) path, NULL); |
|
|
|
|
|
js_value_t *res = NULL; |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} else { |
|
|
err = js_create_array_with_length(env, 14, &res); |
|
|
assert(err == 0); |
|
|
|
|
|
uint32_t i = 0; |
|
|
|
|
|
#define V(property) \ |
|
|
{ \ |
|
|
js_value_t *value; \ |
|
|
err = js_create_int64(env, req.statbuf.st_##property, &value); \ |
|
|
assert(err == 0); \ |
|
|
\ |
|
|
err = js_set_element(env, res, i++, value); \ |
|
|
assert(err == 0); \ |
|
|
} |
|
|
V(dev) |
|
|
V(mode) |
|
|
V(nlink) |
|
|
V(uid) |
|
|
V(gid) |
|
|
V(rdev) |
|
|
V(blksize) |
|
|
V(ino) |
|
|
V(size) |
|
|
V(blocks) |
|
|
#undef V |
|
|
|
|
|
#define V(property) \ |
|
|
{ \ |
|
|
uv_timespec_t time = req.statbuf.st_##property; \ |
|
|
\ |
|
|
js_value_t *value; \ |
|
|
err = js_create_int64(env, time.tv_sec * 1e3 + time.tv_nsec / 1e6, &value); \ |
|
|
assert(err == 0); \ |
|
|
\ |
|
|
err = js_set_element(env, res, i++, value); \ |
|
|
assert(err == 0); \ |
|
|
} |
|
|
V(atim) |
|
|
V(mtim) |
|
|
V(ctim) |
|
|
V(birthtim) |
|
|
#undef V |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return res; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_lstat(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[1], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_reference(env, argv[2], 1, &req->data); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_lstat(loop, &req->handle, (char *) path, bare_fs__on_stat_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_lstat_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 1; |
|
|
js_value_t *argv[1]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 1); |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[0], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_lstat(loop, &req, (char *) path, NULL); |
|
|
|
|
|
js_value_t *res = NULL; |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} else { |
|
|
err = js_create_array_with_length(env, 14, &res); |
|
|
assert(err == 0); |
|
|
|
|
|
uint32_t i = 0; |
|
|
|
|
|
#define V(property) \ |
|
|
{ \ |
|
|
js_value_t *value; \ |
|
|
err = js_create_int64(env, req.statbuf.st_##property, &value); \ |
|
|
assert(err == 0); \ |
|
|
\ |
|
|
err = js_set_element(env, res, i++, value); \ |
|
|
assert(err == 0); \ |
|
|
} |
|
|
V(dev) |
|
|
V(mode) |
|
|
V(nlink) |
|
|
V(uid) |
|
|
V(gid) |
|
|
V(rdev) |
|
|
V(blksize) |
|
|
V(ino) |
|
|
V(size) |
|
|
V(blocks) |
|
|
#undef V |
|
|
|
|
|
#define V(property) \ |
|
|
{ \ |
|
|
uv_timespec_t time = req.statbuf.st_##property; \ |
|
|
\ |
|
|
js_value_t *value; \ |
|
|
err = js_create_int64(env, time.tv_sec * 1e3 + time.tv_nsec / 1e6, &value); \ |
|
|
assert(err == 0); \ |
|
|
\ |
|
|
err = js_set_element(env, res, i++, value); \ |
|
|
assert(err == 0); \ |
|
|
} |
|
|
V(atim) |
|
|
V(mtim) |
|
|
V(ctim) |
|
|
V(birthtim) |
|
|
#undef V |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return res; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_fstat(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
uint32_t fd; |
|
|
err = js_get_value_uint32(env, argv[1], &fd); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_reference(env, argv[2], 1, &req->data); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_fstat(loop, &req->handle, fd, bare_fs__on_stat_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_fstat_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 1; |
|
|
js_value_t *argv[1]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 1); |
|
|
|
|
|
uint32_t fd; |
|
|
err = js_get_value_uint32(env, argv[0], &fd); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_fstat(loop, &req, fd, NULL); |
|
|
|
|
|
js_value_t *res = NULL; |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} else { |
|
|
err = js_create_array_with_length(env, 14, &res); |
|
|
assert(err == 0); |
|
|
|
|
|
uint32_t i = 0; |
|
|
|
|
|
#define V(property) \ |
|
|
{ \ |
|
|
js_value_t *value; \ |
|
|
err = js_create_int64(env, req.statbuf.st_##property, &value); \ |
|
|
assert(err == 0); \ |
|
|
\ |
|
|
err = js_set_element(env, res, i++, value); \ |
|
|
assert(err == 0); \ |
|
|
} |
|
|
V(dev) |
|
|
V(mode) |
|
|
V(nlink) |
|
|
V(uid) |
|
|
V(gid) |
|
|
V(rdev) |
|
|
V(blksize) |
|
|
V(ino) |
|
|
V(size) |
|
|
V(blocks) |
|
|
#undef V |
|
|
|
|
|
#define V(property) \ |
|
|
{ \ |
|
|
uv_timespec_t time = req.statbuf.st_##property; \ |
|
|
\ |
|
|
js_value_t *value; \ |
|
|
err = js_create_int64(env, time.tv_sec * 1e3 + time.tv_nsec / 1e6, &value); \ |
|
|
assert(err == 0); \ |
|
|
\ |
|
|
err = js_set_element(env, res, i++, value); \ |
|
|
assert(err == 0); \ |
|
|
} |
|
|
V(atim) |
|
|
V(mtim) |
|
|
V(ctim) |
|
|
V(birthtim) |
|
|
#undef V |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return res; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_unlink(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 2; |
|
|
js_value_t *argv[2]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 2); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[1], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_unlink(loop, &req->handle, (char *) path, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_unlink_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 1; |
|
|
js_value_t *argv[1]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 1); |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[0], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_unlink(loop, &req, (char *) path, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_realpath(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[1], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_reference(env, argv[2], 1, &req->data); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_realpath(loop, &req->handle, (char *) path, bare_fs__on_realpath_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_realpath_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 2; |
|
|
js_value_t *argv[2]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 2); |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[0], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_realpath(loop, &req, (char *) path, NULL); |
|
|
|
|
|
js_value_t *res = NULL; |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} else { |
|
|
char *path; |
|
|
err = js_get_typedarray_info(env, argv[1], NULL, (void **) &path, NULL, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
strncpy(path, req.ptr, sizeof(bare_fs_path_t)); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return res; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_readlink(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[1], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_reference(env, argv[2], 1, &req->data); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_readlink(loop, &req->handle, (char *) path, bare_fs__on_readlink_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_readlink_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 2; |
|
|
js_value_t *argv[2]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 2); |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[0], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_readlink(loop, &req, (char *) path, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} else { |
|
|
char *path; |
|
|
err = js_get_typedarray_info(env, argv[1], NULL, (void **) &path, NULL, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
strncpy(path, req.ptr, sizeof(bare_fs_path_t)); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_symlink(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 4; |
|
|
js_value_t *argv[4]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 4); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_path_t target; |
|
|
err = js_get_value_string_utf8(env, argv[1], target, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[2], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t flags; |
|
|
err = js_get_value_int32(env, argv[3], &flags); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_symlink(loop, &req->handle, (char *) target, (char *) path, flags, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_symlink_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_path_t target; |
|
|
err = js_get_value_string_utf8(env, argv[0], target, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[1], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
int32_t flags; |
|
|
err = js_get_value_int32(env, argv[2], &flags); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_symlink(loop, &req, (char *) target, (char *) path, flags, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_opendir(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[1], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_reference(env, argv[2], 1, &req->data); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_opendir(loop, &req->handle, (char *) path, bare_fs__on_opendir_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_opendir_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 2; |
|
|
js_value_t *argv[2]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 2); |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[0], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *data = argv[1]; |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_opendir(loop, &req, (char *) path, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} else { |
|
|
bare_fs_dir_t *dir; |
|
|
err = js_get_typedarray_info(env, argv[1], NULL, (void **) &dir, NULL, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
dir->dir = req.ptr; |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_readdir(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 4; |
|
|
js_value_t *argv[4]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 4); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_dir_t *dir; |
|
|
err = js_get_typedarray_info(env, argv[1], NULL, (void **) &dir, NULL, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
bare_fs_dirent_t *dirents; |
|
|
size_t dirents_len; |
|
|
err = js_get_typedarray_info(env, argv[2], NULL, (void **) &dirents, &dirents_len, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_reference(env, argv[3], 1, &req->data); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
dir->dir->dirents = dirents; |
|
|
dir->dir->nentries = dirents_len / sizeof(bare_fs_dirent_t); |
|
|
|
|
|
uv_fs_readdir(loop, &req->handle, dir->dir, bare_fs__on_readdir_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_readdir_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 3; |
|
|
js_value_t *argv[3]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 3); |
|
|
|
|
|
bare_fs_dir_t *dir; |
|
|
err = js_get_typedarray_info(env, argv[0], NULL, (void **) &dir, NULL, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
bare_fs_dirent_t *dirents; |
|
|
size_t dirents_len; |
|
|
err = js_get_typedarray_info(env, argv[1], NULL, (void **) &dirents, &dirents_len, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
dir->dir->dirents = dirents; |
|
|
dir->dir->nentries = dirents_len / sizeof(bare_fs_dirent_t); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_readdir(loop, &req, dir->dir, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} else { |
|
|
uv_dir_t *dir = req.ptr; |
|
|
|
|
|
for (size_t i = 0, n = req.result; i < n; i++) { |
|
|
uv_dirent_t *dirent = &dir->dirents[i]; |
|
|
|
|
|
js_value_t *entry; |
|
|
err = js_create_object(env, &entry); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_set_element(env, argv[2], i, entry); |
|
|
assert(err == 0); |
|
|
|
|
|
size_t name_len = strlen(dirent->name); |
|
|
|
|
|
js_value_t *name; |
|
|
void *data; |
|
|
err = js_create_arraybuffer(env, name_len, &data, &name); |
|
|
assert(err == 0); |
|
|
|
|
|
memcpy(data, dirent->name, name_len); |
|
|
|
|
|
err = js_set_named_property(env, entry, "name", name); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *type; |
|
|
err = js_create_uint32(env, dirent->type, &type); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_set_named_property(env, entry, "type", type); |
|
|
assert(err == 0); |
|
|
} |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_closedir(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 2; |
|
|
js_value_t *argv[2]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 2); |
|
|
|
|
|
bare_fs_t *req; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &req, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
req->active = true; |
|
|
|
|
|
bare_fs_dir_t *dir; |
|
|
err = js_get_typedarray_info(env, argv[1], NULL, (void **) &dir, NULL, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_closedir(loop, &req->handle, dir->dir, bare_fs__on_response); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_closedir_sync(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 1; |
|
|
js_value_t *argv[1]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 1); |
|
|
|
|
|
bare_fs_dir_t *dir; |
|
|
err = js_get_typedarray_info(env, argv[0], NULL, (void **) &dir, NULL, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_fs_t req; |
|
|
uv_fs_closedir(loop, &req, dir->dir, NULL); |
|
|
|
|
|
if (req.result < 0) { |
|
|
err = js_throw_error(env, uv_err_name(req.result), uv_strerror(req.result)); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
uv_fs_req_cleanup(&req); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static void |
|
|
bare_fs__on_watcher_event(uv_fs_event_t *handle, const char *filename, int events, int status) { |
|
|
int err; |
|
|
|
|
|
bare_fs_watcher_t *watcher = (bare_fs_watcher_t *) handle; |
|
|
|
|
|
if (watcher->exiting) return; |
|
|
|
|
|
js_env_t *env = watcher->env; |
|
|
|
|
|
js_handle_scope_t *scope; |
|
|
err = js_open_handle_scope(env, &scope); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *ctx; |
|
|
err = js_get_reference_value(env, watcher->ctx, &ctx); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *on_event; |
|
|
err = js_get_reference_value(env, watcher->on_event, &on_event); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *args[3]; |
|
|
|
|
|
if (status < 0) { |
|
|
js_value_t *code; |
|
|
err = js_create_string_utf8(env, (utf8_t *) uv_err_name(status), -1, &code); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *message; |
|
|
err = js_create_string_utf8(env, (utf8_t *) uv_strerror(status), -1, &message); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_error(env, code, message, &args[0]); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_int32(env, 0, &args[1]); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_get_null(env, &args[2]); |
|
|
assert(err == 0); |
|
|
} else { |
|
|
err = js_get_null(env, &args[0]); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_int32(env, events, &args[1]); |
|
|
assert(err == 0); |
|
|
|
|
|
size_t len = strlen(filename); |
|
|
|
|
|
void *data; |
|
|
err = js_create_arraybuffer(env, len, &data, &args[2]); |
|
|
assert(err == 0); |
|
|
|
|
|
memcpy(data, (void *) filename, len); |
|
|
} |
|
|
|
|
|
js_call_function(env, ctx, on_event, 3, args, NULL); |
|
|
|
|
|
err = js_close_handle_scope(env, scope); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
static void |
|
|
bare_fs__on_watcher_close(uv_handle_t *handle) { |
|
|
int err; |
|
|
|
|
|
bare_fs_watcher_t *watcher = (bare_fs_watcher_t *) handle; |
|
|
|
|
|
js_env_t *env = watcher->env; |
|
|
|
|
|
js_deferred_teardown_t *teardown = watcher->teardown; |
|
|
|
|
|
if (watcher->exiting) { |
|
|
err = js_delete_reference(env, watcher->on_event); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_delete_reference(env, watcher->on_close); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_delete_reference(env, watcher->ctx); |
|
|
assert(err == 0); |
|
|
} else { |
|
|
js_handle_scope_t *scope; |
|
|
err = js_open_handle_scope(env, &scope); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *ctx; |
|
|
err = js_get_reference_value(env, watcher->ctx, &ctx); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *on_close; |
|
|
err = js_get_reference_value(env, watcher->on_close, &on_close); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_delete_reference(env, watcher->on_event); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_delete_reference(env, watcher->on_close); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_delete_reference(env, watcher->ctx); |
|
|
assert(err == 0); |
|
|
|
|
|
js_call_function(env, ctx, on_close, 0, NULL, NULL); |
|
|
|
|
|
err = js_close_handle_scope(env, scope); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
err = js_finish_deferred_teardown_callback(teardown); |
|
|
assert(err == 0); |
|
|
} |
|
|
|
|
|
static void |
|
|
bare_fs__on_watcher_teardown(js_deferred_teardown_t *handle, void *data) { |
|
|
bare_fs_watcher_t *watcher = (bare_fs_watcher_t *) data; |
|
|
|
|
|
watcher->exiting = true; |
|
|
|
|
|
if (watcher->closing) return; |
|
|
|
|
|
uv_close((uv_handle_t *) &watcher->handle, bare_fs__on_watcher_close); |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_watcher_init(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 5; |
|
|
js_value_t *argv[5]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 5); |
|
|
|
|
|
bare_fs_path_t path; |
|
|
err = js_get_value_string_utf8(env, argv[0], path, sizeof(bare_fs_path_t), NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
bool recursive; |
|
|
err = js_get_value_bool(env, argv[1], &recursive); |
|
|
assert(err == 0); |
|
|
|
|
|
js_value_t *result; |
|
|
|
|
|
bare_fs_watcher_t *watcher; |
|
|
err = js_create_arraybuffer(env, sizeof(bare_fs_watcher_t), (void **) &watcher, &result); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_loop_t *loop; |
|
|
err = js_get_env_loop(env, &loop); |
|
|
assert(err == 0); |
|
|
|
|
|
err = uv_fs_event_init(loop, &watcher->handle); |
|
|
|
|
|
if (err < 0) { |
|
|
err = js_throw_error(env, uv_err_name(err), uv_strerror(err)); |
|
|
assert(err == 0); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
err = uv_fs_event_start(&watcher->handle, bare_fs__on_watcher_event, (char *) path, recursive ? UV_FS_EVENT_RECURSIVE : 0); |
|
|
|
|
|
if (err < 0) { |
|
|
err = js_throw_error(env, uv_err_name(err), uv_strerror(err)); |
|
|
assert(err == 0); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
watcher->env = env; |
|
|
watcher->closing = false; |
|
|
watcher->exiting = false; |
|
|
|
|
|
err = js_create_reference(env, argv[2], 1, &watcher->ctx); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_reference(env, argv[3], 1, &watcher->on_event); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_create_reference(env, argv[4], 1, &watcher->on_close); |
|
|
assert(err == 0); |
|
|
|
|
|
err = js_add_deferred_teardown_callback(env, bare_fs__on_watcher_teardown, (void *) watcher, &watcher->teardown); |
|
|
assert(err == 0); |
|
|
|
|
|
return result; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_watcher_close(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 1; |
|
|
js_value_t *argv[1]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 1); |
|
|
|
|
|
bare_fs_watcher_t *watcher; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &watcher, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
err = uv_fs_event_stop(&watcher->handle); |
|
|
assert(err == 0); |
|
|
|
|
|
watcher->closing = true; |
|
|
|
|
|
uv_close((uv_handle_t *) &watcher->handle, bare_fs__on_watcher_close); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_watcher_ref(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 1; |
|
|
js_value_t *argv[1]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 1); |
|
|
|
|
|
bare_fs_watcher_t *watcher; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &watcher, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_ref((uv_handle_t *) &watcher->handle); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_watcher_unref(js_env_t *env, js_callback_info_t *info) { |
|
|
int err; |
|
|
|
|
|
size_t argc = 1; |
|
|
js_value_t *argv[1]; |
|
|
|
|
|
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
assert(argc == 1); |
|
|
|
|
|
bare_fs_watcher_t *watcher; |
|
|
err = js_get_arraybuffer_info(env, argv[0], (void **) &watcher, NULL); |
|
|
assert(err == 0); |
|
|
|
|
|
uv_unref((uv_handle_t *) &watcher->handle); |
|
|
|
|
|
return NULL; |
|
|
} |
|
|
|
|
|
static js_value_t * |
|
|
bare_fs_exports(js_env_t *env, js_value_t *exports) { |
|
|
int err; |
|
|
|
|
|
#define V(name, struct) \ |
|
|
{ \ |
|
|
js_value_t *val; \ |
|
|
err = js_create_uint32(env, sizeof(struct), &val); \ |
|
|
assert(err == 0); \ |
|
|
js_set_named_property(env, exports, name, val); \ |
|
|
assert(err == 0); \ |
|
|
} |
|
|
|
|
|
V("sizeofFSDir", bare_fs_dir_t) |
|
|
V("sizeofFSDirent", bare_fs_dirent_t) |
|
|
V("sizeofFSPath", bare_fs_path_t) |
|
|
#undef V |
|
|
|
|
|
#define V(name, fn) \ |
|
|
{ \ |
|
|
js_value_t *val; \ |
|
|
err = js_create_function(env, name, -1, fn, NULL, &val); \ |
|
|
assert(err == 0); \ |
|
|
err = js_set_named_property(env, exports, name, val); \ |
|
|
assert(err == 0); \ |
|
|
} |
|
|
|
|
|
V("init", bare_fs_init) |
|
|
V("open", bare_fs_open) |
|
|
V("openSync", bare_fs_open_sync) |
|
|
V("close", bare_fs_close) |
|
|
V("closeSync", bare_fs_close_sync) |
|
|
V("access", bare_fs_access) |
|
|
V("accessSync", bare_fs_access_sync) |
|
|
V("read", bare_fs_read) |
|
|
V("readSync", bare_fs_read_sync) |
|
|
V("readv", bare_fs_readv) |
|
|
V("write", bare_fs_write) |
|
|
V("writeSync", bare_fs_write_sync) |
|
|
V("writev", bare_fs_writev) |
|
|
V("ftruncate", bare_fs_ftruncate) |
|
|
V("ftruncateSync", bare_fs_ftruncate_sync) |
|
|
V("chmod", bare_fs_chmod) |
|
|
V("chmodSync", bare_fs_chmod_sync) |
|
|
V("fchmod", bare_fs_fchmod) |
|
|
V("fchmodSync", bare_fs_fchmod_sync) |
|
|
V("rename", bare_fs_rename) |
|
|
V("renameSync", bare_fs_rename_sync) |
|
|
V("copyfile", bare_fs_copyfile) |
|
|
V("copyfileSync", bare_fs_copyfile_sync) |
|
|
V("mkdir", bare_fs_mkdir) |
|
|
V("mkdirSync", bare_fs_mkdir_sync) |
|
|
V("rmdir", bare_fs_rmdir) |
|
|
V("rmdirSync", bare_fs_rmdir_sync) |
|
|
V("stat", bare_fs_stat) |
|
|
V("statSync", bare_fs_stat_sync) |
|
|
V("lstat", bare_fs_lstat) |
|
|
V("lstatSync", bare_fs_lstat_sync) |
|
|
V("fstat", bare_fs_fstat) |
|
|
V("fstatSync", bare_fs_fstat_sync) |
|
|
V("unlink", bare_fs_unlink) |
|
|
V("unlinkSync", bare_fs_unlink_sync) |
|
|
V("realpath", bare_fs_realpath) |
|
|
V("realpathSync", bare_fs_realpath_sync) |
|
|
V("readlink", bare_fs_readlink) |
|
|
V("readlinkSync", bare_fs_readlink_sync) |
|
|
V("symlink", bare_fs_symlink) |
|
|
V("symlinkSync", bare_fs_symlink_sync) |
|
|
V("opendir", bare_fs_opendir) |
|
|
V("opendirSync", bare_fs_opendir_sync) |
|
|
V("readdir", bare_fs_readdir) |
|
|
V("readdirSync", bare_fs_readdir_sync) |
|
|
V("closedir", bare_fs_closedir) |
|
|
V("closedirSync", bare_fs_closedir_sync) |
|
|
V("watcherInit", bare_fs_watcher_init) |
|
|
V("watcherClose", bare_fs_watcher_close) |
|
|
V("watcherRef", bare_fs_watcher_ref) |
|
|
V("watcherUnref", bare_fs_watcher_unref) |
|
|
#undef V |
|
|
|
|
|
#define V(name) \ |
|
|
{ \ |
|
|
js_value_t *val; \ |
|
|
err = js_create_uint32(env, name, &val); \ |
|
|
assert(err == 0); \ |
|
|
err = js_set_named_property(env, exports, #name, val); \ |
|
|
assert(err == 0); \ |
|
|
} |
|
|
|
|
|
V(O_RDWR) |
|
|
V(O_RDONLY) |
|
|
V(O_WRONLY) |
|
|
V(O_CREAT) |
|
|
V(O_TRUNC) |
|
|
V(O_APPEND) |
|
|
|
|
|
#ifdef F_OK |
|
|
V(F_OK) |
|
|
#endif |
|
|
#ifdef R_OK |
|
|
V(R_OK) |
|
|
#endif |
|
|
#ifdef W_OK |
|
|
V(W_OK) |
|
|
#endif |
|
|
#ifdef X_OK |
|
|
V(X_OK) |
|
|
#endif |
|
|
|
|
|
V(S_IFMT) |
|
|
V(S_IFREG) |
|
|
V(S_IFDIR) |
|
|
V(S_IFCHR) |
|
|
V(S_IFLNK) |
|
|
#ifdef S_IFBLK |
|
|
V(S_IFBLK) |
|
|
#endif |
|
|
#ifdef S_IFIFO |
|
|
V(S_IFIFO) |
|
|
#endif |
|
|
#ifdef S_IFSOCK |
|
|
V(S_IFSOCK) |
|
|
#endif |
|
|
|
|
|
#ifdef S_IRUSR |
|
|
V(S_IRUSR) |
|
|
#endif |
|
|
#ifdef S_IWUSR |
|
|
V(S_IWUSR) |
|
|
#endif |
|
|
#ifdef S_IXUSR |
|
|
V(S_IXUSR) |
|
|
#endif |
|
|
#ifdef S_IRGRP |
|
|
V(S_IRGRP) |
|
|
#endif |
|
|
#ifdef S_IWGRP |
|
|
V(S_IWGRP) |
|
|
#endif |
|
|
#ifdef S_IXGRP |
|
|
V(S_IXGRP) |
|
|
#endif |
|
|
#ifdef S_IROTH |
|
|
V(S_IROTH) |
|
|
#endif |
|
|
#ifdef S_IWOTH |
|
|
V(S_IWOTH) |
|
|
#endif |
|
|
#ifdef S_IXOTH |
|
|
V(S_IXOTH) |
|
|
#endif |
|
|
|
|
|
V(UV_DIRENT_UNKNOWN) |
|
|
V(UV_DIRENT_FILE) |
|
|
V(UV_DIRENT_DIR) |
|
|
V(UV_DIRENT_LINK) |
|
|
V(UV_DIRENT_FIFO) |
|
|
V(UV_DIRENT_SOCKET) |
|
|
V(UV_DIRENT_CHAR) |
|
|
V(UV_DIRENT_BLOCK) |
|
|
|
|
|
V(UV_FS_COPYFILE_EXCL) |
|
|
V(UV_FS_COPYFILE_FICLONE) |
|
|
V(UV_FS_COPYFILE_FICLONE_FORCE) |
|
|
V(UV_FS_SYMLINK_DIR) |
|
|
V(UV_FS_SYMLINK_JUNCTION) |
|
|
|
|
|
V(UV_RENAME) |
|
|
V(UV_CHANGE) |
|
|
#undef V |
|
|
|
|
|
return exports; |
|
|
} |
|
|
|
|
|
BARE_MODULE(bare_fs, bare_fs_exports) |
|
|
|
