diff options
Diffstat (limited to 'src/bindings/eio_js/eio_js.cc')
| -rw-r--r-- | src/bindings/eio_js/eio_js.cc | 1756 |
1 files changed, 1756 insertions, 0 deletions
diff --git a/src/bindings/eio_js/eio_js.cc b/src/bindings/eio_js/eio_js.cc new file mode 100644 index 0000000000..8441247e63 --- /dev/null +++ b/src/bindings/eio_js/eio_js.cc @@ -0,0 +1,1756 @@ +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <Eio_Js.hh> + +namespace efl { namespace eio { namespace js { + +using ::efl::eina::js::compatibility_new; +using ::efl::eina::js::compatibility_return_type; +using ::efl::eina::js::compatibility_callback_info_type; +using ::efl::eina::js::compatibility_return; +using ::efl::eina::js::compatibility_get_pointer_internal_field; +using ::efl::eina::js::compatibility_set_pointer_internal_field; + +namespace { + +Eio_File* extract_eio_file(v8::Local<v8::Object> object) +{ + return compatibility_get_pointer_internal_field<Eio_File*>(object, 0); +} + +v8::Local<v8::Object> wrap_eio_file(Eio_File *file, v8::Isolate *isolate) +{ + using v8::String; + using v8::Boolean; + using v8::ObjectTemplate; + using v8::FunctionTemplate; + + auto obj_tpl = compatibility_new<ObjectTemplate>(isolate); + obj_tpl->SetInternalFieldCount(1); + auto ret = obj_tpl->NewInstance(); + + auto cancel = [](compatibility_callback_info_type info) + -> compatibility_return_type { + if (info.Length() != 0) + return compatibility_return(); + + auto isolate = info.GetIsolate(); + + auto ret = eio_file_cancel(extract_eio_file(info.This())); + return compatibility_return(compatibility_new<Boolean>(isolate, ret), + info); + }; + + auto check = [](compatibility_callback_info_type info) + -> compatibility_return_type { + if (info.Length() != 0) + return compatibility_return(); + + auto isolate = info.GetIsolate(); + + auto ret = eio_file_check(extract_eio_file(info.This())); + return compatibility_return(compatibility_new<Boolean>(isolate, ret), + info); + }; + + ret->Set(compatibility_new<String>(isolate, "cancel"), + compatibility_new<FunctionTemplate>(isolate, cancel) + ->GetFunction()); + ret->Set(compatibility_new<String>(isolate, "check"), + compatibility_new<FunctionTemplate>(isolate, check) + ->GetFunction()); + + compatibility_set_pointer_internal_field(ret, 0, file); + + return ret; +} + +static Eina_File* extract_eina_file(v8::Local<v8::Object> object) +{ + return compatibility_get_pointer_internal_field<Eina_File*>(object, 0); +} + +static v8::Local<v8::Object> wrap_eina_file(Eina_File *file, + v8::Isolate *isolate) +{ + using v8::String; + using v8::ObjectTemplate; + using v8::Object; + using v8::FunctionTemplate; + using v8::WeakCallbackData; + + auto obj_tpl = compatibility_new<ObjectTemplate>(isolate); + obj_tpl->SetInternalFieldCount(1); + auto ret = obj_tpl->NewInstance(); + + /* TODO: + + Eina_File only handle files open in read-only mode. Althought there + aren't many useful functions exposed to a JavaScript binding, the exposed + `file->fd` can be used to expose a few read operations found in + `<cstdio>`. + */ + + auto close = [](compatibility_callback_info_type info) + -> compatibility_return_type { + if (info.Length() != 0) + return compatibility_return(); + + auto o = info.This(); + + auto file = extract_eina_file(o); + if (!file) + return compatibility_return(); + + eina_file_close(file); + compatibility_set_pointer_internal_field<void*>(o, 0, nullptr); + return compatibility_return(); + }; + + ret->Set(compatibility_new<String>(isolate, "close"), + compatibility_new<FunctionTemplate>(isolate, close) + ->GetFunction()); + + compatibility_set_pointer_internal_field(ret, 0, file); + + auto on_gc = [ret]() { + auto file = extract_eina_file(ret); + + if (file) { + eina_file_close(file); + compatibility_set_pointer_internal_field<void*>(ret, 0, nullptr); + } + }; + + efl::eina::js::make_weak(isolate, ret, on_gc); + + return ret; +} + +static Eio_Monitor* extract_monitor(v8::Local<v8::Object> object) +{ + return compatibility_get_pointer_internal_field<Eio_Monitor*>(object, 0); +} + +static v8::Local<v8::Object> wrap_monitor(Eio_Monitor *monitor, + v8::Isolate *isolate) +{ + using v8::String; + using v8::ObjectTemplate; + using v8::FunctionTemplate; + + auto obj_tpl = compatibility_new<ObjectTemplate>(isolate); + obj_tpl->SetInternalFieldCount(1); + auto ret = obj_tpl->NewInstance(); + + auto del = [](compatibility_callback_info_type info) + -> compatibility_return_type { + if (info.Length() != 0) + return compatibility_return(); + + eio_monitor_del(extract_monitor(info.This())); + return compatibility_return(); + }; + + auto path_get = [](compatibility_callback_info_type info) + -> compatibility_return_type { + if (info.Length() != 0) + return compatibility_return(); + + auto ret = eio_monitor_path_get(extract_monitor(info.This())); + return compatibility_return(compatibility_new<String>(info.GetIsolate(), + ret), + info); + }; + + ret->Set(compatibility_new<String>(isolate, "del"), + compatibility_new<FunctionTemplate>(isolate, del)->GetFunction()); + ret->Set(compatibility_new<String>(isolate, "path_get"), + compatibility_new<FunctionTemplate>(isolate, path_get) + ->GetFunction()); + + compatibility_set_pointer_internal_field(ret, 0, monitor); + + return ret; +} + +static Ecore_Event_Handler *extract_event_handler(v8::Local<v8::Object> object) +{ + return compatibility_get_pointer_internal_field<Ecore_Event_Handler*> + (object, 0); +} + +static v8::Local<v8::Object> wrap_event_handler(Ecore_Event_Handler *handler, + v8::Isolate *isolate) +{ + using v8::String; + using v8::ObjectTemplate; + using v8::FunctionTemplate; + using v8::Value; + + auto obj_tpl = compatibility_new<ObjectTemplate>(isolate); + obj_tpl->SetInternalFieldCount(1); + auto ret = obj_tpl->NewInstance(); + + auto del = [](compatibility_callback_info_type info) + -> compatibility_return_type { + if (info.Length() != 0) + return compatibility_return(); + + auto p = ecore_event_handler_del(extract_event_handler(info.This())); + + auto per = static_cast<efl::eina::js::global_ref<Value>*>(p); + per->dispose(); + delete per; + return compatibility_return(); + }; + + ret->Set(compatibility_new<String>(isolate, "del"), + compatibility_new<FunctionTemplate>(isolate, del)->GetFunction()); + + compatibility_set_pointer_internal_field(ret, 0, handler); + + return ret; +} + +static +v8::Local<v8::Object> wrap_eina_file_direct_info(const Eina_File_Direct_Info* + info, + v8::Isolate *isolate) +{ + using v8::Object; + using v8::String; + using v8::Integer; + + auto wrapped_info = compatibility_new<Object>(isolate); + + wrapped_info->Set(compatibility_new<String>(isolate, "path_length"), + compatibility_new<Integer>(isolate, info->path_length)); + wrapped_info->Set(compatibility_new<String>(isolate, "mame_length"), + compatibility_new<Integer>(isolate, info->name_length)); + wrapped_info->Set(compatibility_new<String>(isolate, "name_start"), + compatibility_new<Integer>(isolate, info->name_start)); + wrapped_info->Set(compatibility_new<String>(isolate, "type"), + compatibility_new<Integer>(isolate, info->type)); + wrapped_info->Set(compatibility_new<String>(isolate, "path"), + compatibility_new<String>(isolate, info->path)); + + return wrapped_info; +} + +EAPI +void register_init(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + using v8::FunctionTemplate; + + auto init = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 0) + return compatibility_return(); + + auto isolate = args.GetIsolate(); + auto ret = eio_init(); + return compatibility_return(compatibility_new<Integer>(isolate, ret), + args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, init) + ->GetFunction()); +} + +EAPI +void register_shutdown(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + using v8::FunctionTemplate; + + auto shutdown = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 0) + return compatibility_return(); + + auto isolate = args.GetIsolate(); + auto ret = eio_shutdown(); + return compatibility_return(compatibility_new<Integer>(isolate, ret), + args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, shutdown) + ->GetFunction()); +} + +EAPI +void register_op_file_copy(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, compatibility_new<Integer>(isolate, EIO_FILE_COPY)); +} + +EAPI +void register_op_file_move(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, compatibility_new<Integer>(isolate, EIO_FILE_MOVE)); +} + +EAPI +void register_op_dir_copy(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, compatibility_new<Integer>(isolate, EIO_DIR_COPY)); +} + +EAPI +void register_op_dir_move(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, compatibility_new<Integer>(isolate, EIO_DIR_MOVE)); +} + +EAPI +void register_op_unlink(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, compatibility_new<Integer>(isolate, EIO_UNLINK)); +} + +EAPI +void register_op_file_getpwnam(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, compatibility_new<Integer>(isolate, EIO_FILE_GETPWNAM)); +} + +EAPI +void register_op_file_getgrnam(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, compatibility_new<Integer>(isolate, EIO_FILE_GETGRNAM)); +} + +EAPI +void register_file_open(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + using v8::Value; + using v8::String; + using v8::FunctionTemplate; + using v8::Function; + using v8::Handle; + using std::unique_ptr; + + typedef efl::eina::js::global_ref<Value> persistent_t; + + auto f = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 4 || !args[0]->IsString() || !args[1]->IsBoolean() + || !args[2]->IsFunction() || !args[3]->IsFunction()) + return compatibility_return(); + + auto isolate = args.GetIsolate(); + + auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[2]); + cb_data[0] = persistent_t(isolate, args[2]); + cb_data[1] = persistent_t(isolate, args[3]); + + auto open_cb = [](void *data, Eio_File *handler, Eina_File *file) { + auto persistent = reinterpret_cast<persistent_t*>(data); + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + wrap_eina_file(file, isolate) + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + + delete[] persistent; + }; + auto error_cb = [](void *data, Eio_File *handler, int error) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 1; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + compatibility_new<Integer>(isolate, error) + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + + delete[] (persistent - 1); + }; + + auto ret = eio_file_open(*String::Utf8Value(args[0]), + args[1]->BooleanValue(), open_cb, error_cb, + cb_data.release()); + + return compatibility_return(wrap_eio_file(ret, isolate), args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, f)->GetFunction()); +} + +EAPI +void register_monitor_file_created(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, + compatibility_new<Integer>(isolate, EIO_MONITOR_FILE_CREATED)); +} + +EAPI +void register_monitor_file_deleted(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, + compatibility_new<Integer>(isolate, EIO_MONITOR_FILE_DELETED)); +} + +EAPI +void register_monitor_file_modified(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, + compatibility_new<Integer>(isolate, EIO_MONITOR_FILE_MODIFIED)); +} + +EAPI +void register_monitor_file_closed(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, + compatibility_new<Integer>(isolate, EIO_MONITOR_FILE_CLOSED)); +} + +EAPI +void register_monitor_directory_created(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, + compatibility_new<Integer>(isolate, + EIO_MONITOR_DIRECTORY_CREATED)); +} + +EAPI +void register_monitor_directory_deleted(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, + compatibility_new<Integer>(isolate, + EIO_MONITOR_DIRECTORY_DELETED)); +} + +EAPI +void register_monitor_directory_modified(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, + compatibility_new<Integer>(isolate, + EIO_MONITOR_DIRECTORY_MODIFIED)); +} + +EAPI +void register_monitor_directory_closed(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, + compatibility_new<Integer>(isolate, + EIO_MONITOR_DIRECTORY_CLOSED)); +} + +EAPI +void register_monitor_self_rename(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, + compatibility_new<Integer>(isolate, EIO_MONITOR_SELF_RENAME)); +} + +EAPI +void register_monitor_self_deleted(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, + compatibility_new<Integer>(isolate, EIO_MONITOR_SELF_DELETED)); +} + +EAPI +void register_monitor_error(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + global->Set(name, + compatibility_new<Integer>(isolate, EIO_MONITOR_ERROR)); +} + +EAPI +void register_monitor_add(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::String; + using v8::Integer; + using v8::FunctionTemplate; + using v8::Handle; + using v8::Value; + using v8::Function; + + auto f = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 1 || !args[0]->IsString()) + return compatibility_return(); + + auto isolate = args.GetIsolate(); + auto ret = eio_monitor_add(*String::Utf8Value(args[0])); + return compatibility_return(wrap_monitor(ret, isolate), args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, f)->GetFunction()); +} + +template<int &wanted_event> +static +void register_monitor_event_handler_add(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::Integer; + using v8::String; + using v8::Value; + using v8::Object; + using v8::Function; + using v8::Handle; + using v8::Local; + using v8::FunctionTemplate; + + auto f = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 1 || !args[0]->IsFunction()) + return compatibility_return(); + + auto isolate = args.GetIsolate(); + + auto p = new efl::eina::js::global_ref<Value>(isolate, args[0]); + + auto cb = [](void *d, int type, void *event) -> Eina_Bool { + auto p = reinterpret_cast<efl::eina::js::global_ref<Value>*>(d); + auto e = reinterpret_cast<Eio_Monitor_Event*>(event); + + auto isolate = v8::Isolate::GetCurrent(); + + auto o = p->handle(); + auto wrapped_event = compatibility_new<Object>(isolate); + + wrapped_event->Set(compatibility_new<String>(isolate, "monitor"), + wrap_monitor(e->monitor, isolate)); + wrapped_event->Set(compatibility_new<String>(isolate, "filename"), + compatibility_new<String>(isolate, e->filename)); + + Handle<Value> args[2]{ + compatibility_new<Integer>(isolate, type), + wrapped_event + }; + + auto ret = Function::Cast(*o)->Call(o->ToObject(), 2, args); + auto bret = ret->IsBoolean() && ret->BooleanValue(); + + return bret ? EINA_TRUE : EINA_FALSE; + }; + + auto ret = ecore_event_handler_add(wanted_event, cb, p); + return compatibility_return(wrap_event_handler(ret, isolate), args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, f)->GetFunction()); +} + +EAPI +void +register_event_monitor_file_created_handler_add(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + return register_monitor_event_handler_add<EIO_MONITOR_FILE_CREATED> + (isolate, global, name); +} + +EAPI +void +register_event_monitor_file_deleted_handler_add(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + return register_monitor_event_handler_add<EIO_MONITOR_FILE_DELETED> + (isolate, global, name); +} + +EAPI +void +register_event_monitor_file_modified_handler_add(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + return register_monitor_event_handler_add<EIO_MONITOR_FILE_MODIFIED> + (isolate, global, name); +} + +EAPI +void +register_event_monitor_file_closed_handler_add(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + return register_monitor_event_handler_add<EIO_MONITOR_FILE_CLOSED> + (isolate, global, name); +} + +EAPI +void register_event_monitor_directory_created_handler_add +(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + return register_monitor_event_handler_add<EIO_MONITOR_DIRECTORY_CREATED> + (isolate, global, name); +} + +EAPI +void register_event_monitor_directory_deleted_handler_add +(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + return register_monitor_event_handler_add<EIO_MONITOR_DIRECTORY_DELETED> + (isolate, global, name); +} + +EAPI +void register_event_monitor_directory_modified_handler_add +(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + return register_monitor_event_handler_add<EIO_MONITOR_DIRECTORY_MODIFIED> + (isolate, global, name); +} + +EAPI +void register_event_monitor_directory_closed_handler_add +(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + return register_monitor_event_handler_add<EIO_MONITOR_DIRECTORY_CLOSED> + (isolate, global, name); +} + +EAPI +void +register_event_monitor_self_rename_handler_add(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + return register_monitor_event_handler_add<EIO_MONITOR_SELF_RENAME> + (isolate, global, name); +} + +EAPI +void +register_event_monitor_self_deleted_handler_add(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + return register_monitor_event_handler_add<EIO_MONITOR_SELF_DELETED> + (isolate, global, name); +} + +EAPI +void +register_event_monitor_error_handler_add(v8::Isolate *isolate, + v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + return register_monitor_event_handler_add<EIO_MONITOR_ERROR> + (isolate, global, name); +} + +EAPI +void register_file_ls(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::String; + using v8::Integer; + using v8::FunctionTemplate; + using v8::Handle; + using v8::Value; + using v8::Function; + using std::unique_ptr; + + typedef efl::eina::js::global_ref<Value> persistent_t; + + auto f = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 5 || !args[0]->IsString() || !args[1]->IsFunction() + || !args[2]->IsFunction() || !args[3]->IsFunction() + || !args[4]->IsFunction()) { + return compatibility_return(); + } + + auto isolate = args.GetIsolate(); + + auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[4]); + cb_data[0] = persistent_t(isolate, args[1]); + cb_data[1] = persistent_t(isolate, args[2]); + cb_data[2] = persistent_t(isolate, args[3]); + cb_data[3] = persistent_t(isolate, args[4]); + + auto filter_cb = [](void *data, Eio_File *handler, const char *file) + -> Eina_Bool { + auto persistent = reinterpret_cast<persistent_t*>(data); + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + compatibility_new<String>(isolate, file) + }; + + auto ret = Function::Cast(*o)->Call(o->ToObject(), 2, args); + auto bret = ret->IsBoolean() && ret->BooleanValue(); + return bret ? EINA_TRUE : EINA_FALSE; + }; + auto main_cb = [](void *data, Eio_File *handler, const char *file) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 1; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + compatibility_new<String>(isolate, file) + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + }; + auto done_cb = [](void *data, Eio_File *handler) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 2; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args = wrap_eio_file(handler, isolate); + + Function::Cast(*o)->Call(o->ToObject(), 1, &args); + + delete[] (persistent - 2); + }; + auto error_cb = [](void *data, Eio_File *handler, int error) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 3; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + compatibility_new<Integer>(isolate, error) + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + + delete[] (persistent - 3); + }; + + auto ret = eio_file_ls(*String::Utf8Value(args[0]), filter_cb, main_cb, + done_cb, error_cb, cb_data.release()); + return compatibility_return(wrap_eio_file(ret, isolate), args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, f)->GetFunction()); +} + +EAPI +void register_file_chmod(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::String; + using v8::Integer; + using v8::FunctionTemplate; + using v8::Handle; + using v8::Value; + using v8::Function; + using std::unique_ptr; + + typedef efl::eina::js::global_ref<Value> persistent_t; + + auto f = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 4 || !args[0]->IsString() || !args[1]->IsNumber() + || !args[2]->IsFunction() || !args[3]->IsFunction()) { + return compatibility_return(); + } + + auto isolate = args.GetIsolate(); + + auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[2]); + cb_data[0] = persistent_t(isolate, args[2]); + cb_data[1] = persistent_t(isolate, args[3]); + auto done_cb = [](void *data, Eio_File *handler) { + auto persistent = reinterpret_cast<persistent_t*>(data); + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args = wrap_eio_file(handler, isolate); + + Function::Cast(*o)->Call(o->ToObject(), 1, &args); + + delete[] persistent; + }; + auto error_cb = [](void *data, Eio_File *handler, int error) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 1; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + compatibility_new<Integer>(isolate, error) + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + + delete[] (persistent - 1); + }; + + auto ret = eio_file_chmod(*String::Utf8Value(args[0]), + args[1]->IntegerValue(), done_cb, error_cb, + cb_data.release()); + return compatibility_return(wrap_eio_file(ret, isolate), args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, f)->GetFunction()); +} + +EAPI +void register_file_chown(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::String; + using v8::Integer; + using v8::FunctionTemplate; + using v8::Handle; + using v8::Value; + using v8::Function; + using std::unique_ptr; + + typedef efl::eina::js::global_ref<Value> persistent_t; + + auto f = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 5 || !args[0]->IsString() || !args[1]->IsString() + || !args[2]->IsString() || !args[3]->IsFunction() + || !args[4]->IsFunction()) { + return compatibility_return(); + } + + auto isolate = args.GetIsolate(); + + auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[2]); + cb_data[0] = persistent_t(isolate, args[3]); + cb_data[1] = persistent_t(isolate, args[4]); + auto done_cb = [](void *data, Eio_File *handler) { + auto persistent = reinterpret_cast<persistent_t*>(data); + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args = wrap_eio_file(handler, isolate); + + Function::Cast(*o)->Call(o->ToObject(), 1, &args); + + delete[] persistent; + }; + auto error_cb = [](void *data, Eio_File *handler, int error) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 1; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + compatibility_new<Integer>(isolate, error) + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + + delete[] (persistent - 1); + }; + + auto ret = eio_file_chown(*String::Utf8Value(args[0]), + *String::Utf8Value(args[1]), + *String::Utf8Value(args[2]), done_cb, + error_cb, + cb_data.release()); + return compatibility_return(wrap_eio_file(ret, isolate), args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, f)->GetFunction()); +} + +EAPI +void register_file_unlink(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::String; + using v8::Integer; + using v8::FunctionTemplate; + using v8::Handle; + using v8::Value; + using v8::Function; + using std::unique_ptr; + + typedef efl::eina::js::global_ref<Value> persistent_t; + + auto f = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 3 || !args[0]->IsString() || !args[1]->IsFunction() + || !args[2]->IsFunction()) { + return compatibility_return(); + } + + auto isolate = args.GetIsolate(); + + auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[2]); + cb_data[0] = persistent_t(isolate, args[1]); + cb_data[1] = persistent_t(isolate, args[2]); + auto done_cb = [](void *data, Eio_File *handler) { + auto persistent = reinterpret_cast<persistent_t*>(data); + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args = wrap_eio_file(handler, isolate); + + Function::Cast(*o)->Call(o->ToObject(), 1, &args); + + delete[] persistent; + }; + auto error_cb = [](void *data, Eio_File *handler, int error) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 1; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + compatibility_new<Integer>(isolate, error) + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + + delete[] (persistent - 1); + }; + + auto ret = eio_file_unlink(*String::Utf8Value(args[0]), done_cb, + error_cb, cb_data.release()); + return compatibility_return(wrap_eio_file(ret, isolate), args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, f)->GetFunction()); +} + +EAPI +void register_file_mkdir(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::String; + using v8::Integer; + using v8::FunctionTemplate; + using v8::Handle; + using v8::Value; + using v8::Function; + using std::unique_ptr; + + typedef efl::eina::js::global_ref<Value> persistent_t; + + auto f = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 4 || !args[0]->IsString() || !args[1]->IsNumber() + || !args[2]->IsString() || !args[3]->IsFunction()) { + return compatibility_return(); + } + + auto isolate = args.GetIsolate(); + + auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[2]); + cb_data[0] = persistent_t(isolate, args[2]); + cb_data[1] = persistent_t(isolate, args[3]); + auto done_cb = [](void *data, Eio_File *handler) { + auto persistent = reinterpret_cast<persistent_t*>(data); + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args = wrap_eio_file(handler, isolate); + + Function::Cast(*o)->Call(o->ToObject(), 1, &args); + + delete[] persistent; + }; + auto error_cb = [](void *data, Eio_File *handler, int error) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 1; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + compatibility_new<Integer>(isolate, error) + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + + delete[] (persistent - 1); + }; + + auto ret = eio_file_mkdir(*String::Utf8Value(args[0]), + args[1]->IntegerValue(), done_cb, error_cb, + cb_data.release()); + return compatibility_return(wrap_eio_file(ret, isolate), args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, f)->GetFunction()); +} + +EAPI +void register_file_move(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::String; + using v8::Integer; + using v8::Number; + using v8::Object; + using v8::FunctionTemplate; + using v8::Handle; + using v8::Value; + using v8::Function; + using std::unique_ptr; + + typedef efl::eina::js::global_ref<Value> persistent_t; + + auto f = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 5 || !args[0]->IsString() || !args[1]->IsString() + || !args[2]->IsFunction() || !args[3]->IsFunction() + || !args[4]->IsFunction()) { + return compatibility_return(); + } + + auto isolate = args.GetIsolate(); + + auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[3]); + cb_data[0] = persistent_t(isolate, args[2]); + cb_data[1] = persistent_t(isolate, args[3]); + cb_data[2] = persistent_t(isolate, args[4]); + auto progress_cb = [](void *data, Eio_File *handler, + const Eio_Progress *info) { + auto persistent = reinterpret_cast<persistent_t*>(data); + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + auto wrapped_info = compatibility_new<Object>(isolate); + + wrapped_info->Set(compatibility_new<String>(isolate, "op"), + compatibility_new<Integer>(isolate, info->op)); + wrapped_info->Set(compatibility_new<String>(isolate, "current"), + compatibility_new<Integer>(isolate, + info->current)); + wrapped_info->Set(compatibility_new<String>(isolate, "max"), + compatibility_new<Integer>(isolate, info->max)); + wrapped_info->Set(compatibility_new<String>(isolate, "percent"), + compatibility_new<Number>(isolate, + info->percent)); + wrapped_info->Set(compatibility_new<String>(isolate, "source"), + compatibility_new<String>(isolate, info->source)); + wrapped_info->Set(compatibility_new<String>(isolate, "dest"), + compatibility_new<String>(isolate, info->dest)); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + wrapped_info + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + }; + auto done_cb = [](void *data, Eio_File *handler) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 1; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args = wrap_eio_file(handler, isolate); + + Function::Cast(*o)->Call(o->ToObject(), 1, &args); + + delete[] (persistent - 1); + }; + auto error_cb = [](void *data, Eio_File *handler, int error) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 2; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + compatibility_new<Integer>(isolate, error) + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + + delete[] (persistent - 2); + }; + + auto ret = eio_file_move(*String::Utf8Value(args[0]), + *String::Utf8Value(args[1]), + progress_cb, done_cb, error_cb, + cb_data.release()); + return compatibility_return(wrap_eio_file(ret, isolate), args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, f)->GetFunction()); +} + +EAPI +void register_file_copy(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::String; + using v8::Integer; + using v8::Number; + using v8::Object; + using v8::FunctionTemplate; + using v8::Handle; + using v8::Value; + using v8::Function; + using std::unique_ptr; + + typedef efl::eina::js::global_ref<Value> persistent_t; + + auto f = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 5 || !args[0]->IsString() || !args[1]->IsString() + || !args[2]->IsFunction() || !args[3]->IsFunction() + || !args[4]->IsFunction()) { + return compatibility_return(); + } + + auto isolate = args.GetIsolate(); + + auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[3]); + cb_data[0] = persistent_t(isolate, args[2]); + cb_data[1] = persistent_t(isolate, args[3]); + cb_data[2] = persistent_t(isolate, args[4]); + auto progress_cb = [](void *data, Eio_File *handler, + const Eio_Progress *info) { + auto persistent = reinterpret_cast<persistent_t*>(data); + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + auto wrapped_info = compatibility_new<Object>(isolate); + + wrapped_info->Set(compatibility_new<String>(isolate, "op"), + compatibility_new<Integer>(isolate, info->op)); + wrapped_info->Set(compatibility_new<String>(isolate, "current"), + compatibility_new<Integer>(isolate, + info->current)); + wrapped_info->Set(compatibility_new<String>(isolate, "max"), + compatibility_new<Integer>(isolate, info->max)); + wrapped_info->Set(compatibility_new<String>(isolate, "percent"), + compatibility_new<Number>(isolate, + info->percent)); + wrapped_info->Set(compatibility_new<String>(isolate, "source"), + compatibility_new<String>(isolate, info->source)); + wrapped_info->Set(compatibility_new<String>(isolate, "dest"), + compatibility_new<String>(isolate, info->dest)); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + wrapped_info + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + }; + auto done_cb = [](void *data, Eio_File *handler) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 1; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args = wrap_eio_file(handler, isolate); + + Function::Cast(*o)->Call(o->ToObject(), 1, &args); + + delete[] (persistent - 1); + }; + auto error_cb = [](void *data, Eio_File *handler, int error) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 2; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + compatibility_new<Integer>(isolate, error) + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + + delete[] (persistent - 2); + }; + + auto ret = eio_file_copy(*String::Utf8Value(args[0]), + *String::Utf8Value(args[1]), + progress_cb, done_cb, error_cb, + cb_data.release()); + return compatibility_return(wrap_eio_file(ret, isolate), args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, f)->GetFunction()); +} + +EAPI +void register_dir_move(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::String; + using v8::Integer; + using v8::Number; + using v8::Object; + using v8::FunctionTemplate; + using v8::Handle; + using v8::Value; + using v8::Function; + using std::unique_ptr; + + typedef efl::eina::js::global_ref<Value> persistent_t; + + auto f = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 6 || !args[0]->IsString() || !args[1]->IsString() + || !args[2]->IsFunction() || !args[3]->IsFunction() + || !args[4]->IsFunction() || !args[5]->IsFunction()) { + return compatibility_return(); + } + + auto isolate = args.GetIsolate(); + + auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[4]); + cb_data[0] = persistent_t(isolate, args[2]); + cb_data[1] = persistent_t(isolate, args[3]); + cb_data[2] = persistent_t(isolate, args[4]); + cb_data[3] = persistent_t(isolate, args[5]); + auto filter_cb = [](void *data, Eio_File *handler, + const Eina_File_Direct_Info *info) -> Eina_Bool { + auto persistent = reinterpret_cast<persistent_t*>(data); + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + wrap_eina_file_direct_info(info, isolate) + }; + + auto ret = Function::Cast(*o)->Call(o->ToObject(), 2, args); + auto bret = ret->IsBoolean() && ret->BooleanValue(); + return bret ? EINA_TRUE : EINA_FALSE; + }; + auto progress_cb = [](void *data, Eio_File *handler, + const Eio_Progress *info) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 1; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + auto wrapped_info = compatibility_new<Object>(isolate); + + wrapped_info->Set(compatibility_new<String>(isolate, "op"), + compatibility_new<Integer>(isolate, info->op)); + wrapped_info->Set(compatibility_new<String>(isolate, "current"), + compatibility_new<Integer>(isolate, + info->current)); + wrapped_info->Set(compatibility_new<String>(isolate, "max"), + compatibility_new<Integer>(isolate, info->max)); + wrapped_info->Set(compatibility_new<String>(isolate, "percent"), + compatibility_new<Number>(isolate, + info->percent)); + wrapped_info->Set(compatibility_new<String>(isolate, "source"), + compatibility_new<String>(isolate, info->source)); + wrapped_info->Set(compatibility_new<String>(isolate, "dest"), + compatibility_new<String>(isolate, info->dest)); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + wrapped_info + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + }; + auto done_cb = [](void *data, Eio_File *handler) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 2; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args = wrap_eio_file(handler, isolate); + + Function::Cast(*o)->Call(o->ToObject(), 1, &args); + + delete[] (persistent - 2); + }; + auto error_cb = [](void *data, Eio_File *handler, int error) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 3; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + compatibility_new<Integer>(isolate, error) + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + + delete[] (persistent - 3); + }; + + auto ret = eio_dir_move(*String::Utf8Value(args[0]), + *String::Utf8Value(args[1]), filter_cb, + progress_cb, done_cb, error_cb, + cb_data.release()); + return compatibility_return(wrap_eio_file(ret, isolate), args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, f)->GetFunction()); +} + +EAPI +void register_dir_copy(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::String; + using v8::Integer; + using v8::Number; + using v8::Object; + using v8::FunctionTemplate; + using v8::Handle; + using v8::Value; + using v8::Function; + using std::unique_ptr; + + typedef efl::eina::js::global_ref<Value> persistent_t; + + auto f = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 6 || !args[0]->IsString() || !args[1]->IsString() + || !args[2]->IsFunction() || !args[3]->IsFunction() + || !args[4]->IsFunction() || !args[5]->IsFunction()) { + return compatibility_return(); + } + + auto isolate = args.GetIsolate(); + + auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[4]); + cb_data[0] = persistent_t(isolate, args[2]); + cb_data[1] = persistent_t(isolate, args[3]); + cb_data[2] = persistent_t(isolate, args[4]); + cb_data[3] = persistent_t(isolate, args[5]); + auto filter_cb = [](void *data, Eio_File *handler, + const Eina_File_Direct_Info *info) -> Eina_Bool { + auto persistent = reinterpret_cast<persistent_t*>(data); + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + wrap_eina_file_direct_info(info, isolate) + }; + + auto ret = Function::Cast(*o)->Call(o->ToObject(), 2, args); + auto bret = ret->IsBoolean() && ret->BooleanValue(); + return bret ? EINA_TRUE : EINA_FALSE; + }; + auto progress_cb = [](void *data, Eio_File *handler, + const Eio_Progress *info) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 1; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + auto wrapped_info = compatibility_new<Object>(isolate); + + wrapped_info->Set(compatibility_new<String>(isolate, "op"), + compatibility_new<Integer>(isolate, info->op)); + wrapped_info->Set(compatibility_new<String>(isolate, "current"), + compatibility_new<Integer>(isolate, + info->current)); + wrapped_info->Set(compatibility_new<String>(isolate, "max"), + compatibility_new<Integer>(isolate, info->max)); + wrapped_info->Set(compatibility_new<String>(isolate, "percent"), + compatibility_new<Number>(isolate, + info->percent)); + wrapped_info->Set(compatibility_new<String>(isolate, "source"), + compatibility_new<String>(isolate, info->source)); + wrapped_info->Set(compatibility_new<String>(isolate, "dest"), + compatibility_new<String>(isolate, info->dest)); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + wrapped_info + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + }; + auto done_cb = [](void *data, Eio_File *handler) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 2; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args = wrap_eio_file(handler, isolate); + + Function::Cast(*o)->Call(o->ToObject(), 1, &args); + + delete[] (persistent - 2); + }; + auto error_cb = [](void *data, Eio_File *handler, int error) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 3; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + compatibility_new<Integer>(isolate, error) + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + + delete[] (persistent - 3); + }; + + auto ret = eio_dir_copy(*String::Utf8Value(args[0]), + *String::Utf8Value(args[1]), filter_cb, + progress_cb, done_cb, error_cb, + cb_data.release()); + return compatibility_return(wrap_eio_file(ret, isolate), args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, f)->GetFunction()); +} + +EAPI +void register_dir_unlink(v8::Isolate *isolate, v8::Handle<v8::Object> global, + v8::Handle<v8::String> name) +{ + using v8::String; + using v8::Integer; + using v8::Number; + using v8::Object; + using v8::FunctionTemplate; + using v8::Handle; + using v8::Value; + using v8::Function; + using std::unique_ptr; + + typedef efl::eina::js::global_ref<Value> persistent_t; + + auto f = [](compatibility_callback_info_type args) + -> compatibility_return_type { + if (args.Length() != 5 || !args[0]->IsString() || !args[1]->IsFunction() + || !args[2]->IsFunction() || !args[3]->IsFunction() + || !args[4]->IsFunction()) { + return compatibility_return(); + } + + auto isolate = args.GetIsolate(); + + auto cb_data = unique_ptr<persistent_t[]>(new persistent_t[4]); + cb_data[0] = persistent_t(isolate, args[1]); + cb_data[1] = persistent_t(isolate, args[2]); + cb_data[2] = persistent_t(isolate, args[3]); + cb_data[3] = persistent_t(isolate, args[4]); + auto filter_cb = [](void *data, Eio_File *handler, + const Eina_File_Direct_Info *info) -> Eina_Bool { + auto persistent = reinterpret_cast<persistent_t*>(data); + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + wrap_eina_file_direct_info(info, isolate) + }; + + auto ret = Function::Cast(*o)->Call(o->ToObject(), 2, args); + auto bret = ret->IsBoolean() && ret->BooleanValue(); + return bret ? EINA_TRUE : EINA_FALSE; + }; + auto progress_cb = [](void *data, Eio_File *handler, + const Eio_Progress *info) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 1; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + auto wrapped_info = compatibility_new<Object>(isolate); + + wrapped_info->Set(compatibility_new<String>(isolate, "op"), + compatibility_new<Integer>(isolate, info->op)); + wrapped_info->Set(compatibility_new<String>(isolate, "current"), + compatibility_new<Integer>(isolate, + info->current)); + wrapped_info->Set(compatibility_new<String>(isolate, "max"), + compatibility_new<Integer>(isolate, info->max)); + wrapped_info->Set(compatibility_new<String>(isolate, "percent"), + compatibility_new<Number>(isolate, + info->percent)); + wrapped_info->Set(compatibility_new<String>(isolate, "source"), + compatibility_new<String>(isolate, info->source)); + wrapped_info->Set(compatibility_new<String>(isolate, "dest"), + compatibility_new<String>(isolate, info->dest)); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + wrapped_info + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + }; + auto done_cb = [](void *data, Eio_File *handler) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 2; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args = wrap_eio_file(handler, isolate); + + Function::Cast(*o)->Call(o->ToObject(), 1, &args); + + delete[] (persistent - 2); + }; + auto error_cb = [](void *data, Eio_File *handler, int error) { + auto persistent = reinterpret_cast<persistent_t*>(data) + 3; + auto o = persistent->handle(); + + auto isolate = v8::Isolate::GetCurrent(); + + Handle<Value> args[2] = { + wrap_eio_file(handler, isolate), + compatibility_new<Integer>(isolate, error) + }; + + Function::Cast(*o)->Call(o->ToObject(), 2, args); + + delete[] (persistent - 3); + }; + + auto ret = eio_dir_unlink(*String::Utf8Value(args[0]), filter_cb, + progress_cb, done_cb, error_cb, + cb_data.release()); + return compatibility_return(wrap_eio_file(ret, isolate), args); + }; + + global->Set(name, + compatibility_new<FunctionTemplate>(isolate, f)->GetFunction()); +} + +} + +EAPI +void register_eio(v8::Isolate* isolate, v8::Handle<v8::Object> exports) +{ + using v8::String; + register_init(isolate, exports, + compatibility_new<String>(isolate, "eio_init")); + register_shutdown(isolate, exports, + compatibility_new<String>(isolate, "eio_shutdown")); + register_op_file_copy(isolate, exports, + compatibility_new<String>(isolate, "EIO_FILE_COPY")); + register_op_file_move(isolate, exports, + compatibility_new<String>(isolate, "EIO_FILE_MOVE")); + register_op_dir_copy(isolate, exports, + compatibility_new<String>(isolate, "EIO_DIR_COPY")); + register_op_dir_move(isolate, exports, + compatibility_new<String>(isolate, "EIO_DIR_MOVE")); + register_op_unlink(isolate, exports, + compatibility_new<String>(isolate, "EIO_LINK")); + register_op_file_getpwnam(isolate, exports, + compatibility_new<String>(isolate, + "EIO_FILE_GETPWNAM")); + register_op_file_getgrnam(isolate, exports, + compatibility_new<String>(isolate, + "EIO_FILE_GETGRNAM")); + register_file_open(isolate, exports, + compatibility_new<String>(isolate, "eio_file_open")); + register_monitor_file_created(isolate, exports, + compatibility_new<String>(isolate, + "EIO_MONITOR_FILE" + "_CREATED")); + register_monitor_file_deleted(isolate, exports, + compatibility_new<String>(isolate, + "EIO_MONITOR_FILE" + "_DELETED")); + register_monitor_file_modified(isolate, exports, + compatibility_new<String>(isolate, + "EIO_MONITOR_FILE" + "_MODIFIED")); + register_monitor_file_closed(isolate, exports, + compatibility_new<String>(isolate, + "EIO_MONITOR_FILE" + "_CLOSED")); + register_monitor_directory_created(isolate, exports, + compatibility_new<String> + (isolate, + "EIO_MONITOR_DIRECTORY_CREATED")); + register_monitor_directory_deleted(isolate, exports, + compatibility_new<String> + (isolate, + "EIO_MONITOR_DIRECTORY_DELETED")); + register_monitor_directory_modified(isolate, exports, + compatibility_new<String> + (isolate, + "EIO_MONITOR_DIRECTORY_MODIFIED")); + register_monitor_directory_closed(isolate, exports, + compatibility_new<String> + (isolate, "EIO_MONITOR_DIRECTORY_CLOSED")); + register_monitor_self_rename(isolate, exports, + compatibility_new<String> + (isolate, "EIO_MONITOR_SELF_RENAME")); + register_monitor_self_deleted(isolate, exports, + compatibility_new<String> + (isolate, "EIO_MONITOR_SELF_DELETED")); + register_monitor_error(isolate, exports, + compatibility_new<String>(isolate, + "EIO_MONITOR_ERROR")); + register_monitor_add(isolate, exports, + compatibility_new<String>(isolate, "eio_monitor_add")); + register_event_monitor_file_created_handler_add + (isolate, exports, + compatibility_new<String>(isolate, + "eio_event_monitor_file_created_handler_add")); + register_event_monitor_file_deleted_handler_add + (isolate, exports, + compatibility_new<String>(isolate, + "eio_event_monitor_file_deleted_handler_add")); + register_event_monitor_file_modified_handler_add + (isolate, exports, + compatibility_new<String> + (isolate, "eio_event_monitor_file_modified_handler_add")); + register_event_monitor_file_closed_handler_add + (isolate, exports, + compatibility_new<String>(isolate, + "eio_event_monitor_file_closed_handler_add")); + register_event_monitor_directory_created_handler_add + (isolate, exports, + compatibility_new<String> + (isolate, "eio_event_monitor_directory_created_handler_add")); + register_event_monitor_directory_deleted_handler_add + (isolate, exports, + compatibility_new<String> + (isolate, "eio_event_monitor_directory_deleted_handler_add")); + register_event_monitor_directory_modified_handler_add + (isolate, exports, + compatibility_new<String> + (isolate, "eio_event_monitor_directory_modified_handler_add")); + register_event_monitor_directory_closed_handler_add + (isolate, exports, + compatibility_new<String> + (isolate, "eio_event_monitor_directory_closed_handler_add")); + register_event_monitor_self_rename_handler_add + (isolate, exports, + compatibility_new<String>(isolate, + "eio_event_monitor_self_rename_handler_add")); + register_event_monitor_self_deleted_handler_add + (isolate, exports, + compatibility_new<String>(isolate, + "eio_event_monitor_self_deleted_handler_add")); + register_event_monitor_error_handler_add + (isolate, exports, + compatibility_new<String>(isolate, + "eio_event_monitor_error_handler_add")); + register_file_ls(isolate, exports, + compatibility_new<String>(isolate, "eio_file_ls")); + register_file_chmod(isolate, exports, + compatibility_new<String>(isolate, "eio_file_chmod")); + register_file_chown(isolate, exports, + compatibility_new<String>(isolate, "eio_file_chown")); + register_file_unlink(isolate, exports, + compatibility_new<String>(isolate, "eio_file_unlink")); + register_file_mkdir(isolate, exports, + compatibility_new<String>(isolate, "eio_file_mkdir")); + register_file_move(isolate, exports, + compatibility_new<String>(isolate, "eio_file_move")); + register_file_copy(isolate, exports, + compatibility_new<String>(isolate, "eio_file_copy")); + register_dir_move(isolate, exports, + compatibility_new<String>(isolate, "eio_dir_move")); + register_dir_copy(isolate, exports, + compatibility_new<String>(isolate, "eio_dir_copy")); + register_dir_unlink(isolate, exports, + compatibility_new<String>(isolate, "eio_dir_unlink")); +} + +} } } // namespace efl { namespace eio { namespace js { |