diff --git a/Cargo.toml b/Cargo.toml index 5fd4b52..4da26e7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,18 +1,7 @@ -[package] -name = "node-api" -version = "0.1.0" -authors = ["Jupp Müller "] - -[lib] -crate-type = ["lib"] - -[dependencies] -node-api-sys = {path = "./node-api-sys"} -futures = "0.1" - [workspace] members = [ "examples/hello-world", + "node-api", "node-api-sys", "tests", -] \ No newline at end of file +] diff --git a/examples/hello-world/Cargo.toml b/examples/hello-world/Cargo.toml index 30e6382..9d20fab 100644 --- a/examples/hello-world/Cargo.toml +++ b/examples/hello-world/Cargo.toml @@ -7,4 +7,4 @@ authors = ["Jupp Müller "] crate-type = ["cdylib"] [dependencies] -node-api = { path = "../.." } +node-api = { path = "../../node-api" } diff --git a/examples/hello-world/npm-debug.log b/examples/hello-world/npm-debug.log new file mode 100644 index 0000000..2b93449 --- /dev/null +++ b/examples/hello-world/npm-debug.log @@ -0,0 +1,49 @@ +0 info it worked if it ends with ok +1 verbose cli [ '/usr/local/bin/node', '/usr/local/bin/npm', 'start' ] +2 info using npm@3.10.10 +3 info using node@v6.11.0 +4 verbose run-script [ 'prestart', 'start', 'poststart' ] +5 info lifecycle hello-world@1.0.0~prestart: hello-world@1.0.0 +6 verbose lifecycle hello-world@1.0.0~prestart: unsafe-perm in lifecycle true +7 verbose lifecycle hello-world@1.0.0~prestart: PATH: /usr/local/lib/node_modules/npm/bin/node-gyp-bin:/Users/hendrik/code/rust/node-api/examples/hello-world/node_modules/.bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/X11/bin:/Library/TeX/texbin:/Applications/Wireshark.app/Contents/MacOS:/Users/hendrik/.cargo/bin:/Users/hendrik/.go/bin +8 verbose lifecycle hello-world@1.0.0~prestart: CWD: /Users/hendrik/code/rust/node-api/examples/hello-world +9 silly lifecycle hello-world@1.0.0~prestart: Args: [ '-c', 'npm install' ] +10 silly lifecycle hello-world@1.0.0~prestart: Returned: code: 0 signal: null +11 info lifecycle hello-world@1.0.0~start: hello-world@1.0.0 +12 verbose lifecycle hello-world@1.0.0~start: unsafe-perm in lifecycle true +13 verbose lifecycle hello-world@1.0.0~start: PATH: /usr/local/lib/node_modules/npm/bin/node-gyp-bin:/Users/hendrik/code/rust/node-api/examples/hello-world/node_modules/.bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/X11/bin:/Library/TeX/texbin:/Applications/Wireshark.app/Contents/MacOS:/Users/hendrik/.cargo/bin:/Users/hendrik/.go/bin +14 verbose lifecycle hello-world@1.0.0~start: CWD: /Users/hendrik/code/rust/node-api/examples/hello-world +15 silly lifecycle hello-world@1.0.0~start: Args: [ '-c', 'node --napi-modules index.js' ] +16 silly lifecycle hello-world@1.0.0~start: Returned: code: 9 signal: null +17 info lifecycle hello-world@1.0.0~start: Failed to exec start script +18 verbose stack Error: hello-world@1.0.0 start: `node --napi-modules index.js` +18 verbose stack Exit status 9 +18 verbose stack at EventEmitter. (/usr/local/lib/node_modules/npm/lib/utils/lifecycle.js:255:16) +18 verbose stack at emitTwo (events.js:106:13) +18 verbose stack at EventEmitter.emit (events.js:191:7) +18 verbose stack at ChildProcess. (/usr/local/lib/node_modules/npm/lib/utils/spawn.js:40:14) +18 verbose stack at emitTwo (events.js:106:13) +18 verbose stack at ChildProcess.emit (events.js:191:7) +18 verbose stack at maybeClose (internal/child_process.js:891:16) +18 verbose stack at Process.ChildProcess._handle.onexit (internal/child_process.js:226:5) +19 verbose pkgid hello-world@1.0.0 +20 verbose cwd /Users/hendrik/code/rust/node-api/examples/hello-world +21 error Darwin 16.6.0 +22 error argv "/usr/local/bin/node" "/usr/local/bin/npm" "start" +23 error node v6.11.0 +24 error npm v3.10.10 +25 error code ELIFECYCLE +26 error hello-world@1.0.0 start: `node --napi-modules index.js` +26 error Exit status 9 +27 error Failed at the hello-world@1.0.0 start script 'node --napi-modules index.js'. +27 error Make sure you have the latest version of node.js and npm installed. +27 error If you do, this is most likely a problem with the hello-world package, +27 error not with npm itself. +27 error Tell the author that this fails on your system: +27 error node --napi-modules index.js +27 error You can get information on how to open an issue for this project with: +27 error npm bugs hello-world +27 error Or if that isn't available, you can get their info via: +27 error npm owner ls hello-world +27 error There is likely additional logging output above. +28 verbose exit [ 1, true ] diff --git a/examples/hello-world/package.json b/examples/hello-world/package.json index 1018bde..30f6068 100644 --- a/examples/hello-world/package.json +++ b/examples/hello-world/package.json @@ -8,8 +8,8 @@ "license": "MIT", "scripts": { "preinstall": "cargo build", - "postinstall": "mkdir -p node-api && (cp ./target/debug/libhello_world.dylib node-api/index.node || cp ./target/debug/libhello_world.so node-api/index.node || cp ./target/debug/libhello_world.dll node-api/index.node)", + "postinstall": "mkdir -p node-api && (cp ../../target/debug/libhello_world.dylib node-api/index.node || cp ../../target/debug/libhello_world.so node-api/index.node || cp ../../target/debug/libhello_world.dll node-api/index.node)", "prestart": "npm install", - "start": "node --napi-modules index.js" + "start": "node index.js" } } diff --git a/examples/hello-world/src/lib.rs b/examples/hello-world/src/lib.rs index 19d9af8..245ae23 100755 --- a/examples/hello-world/src/lib.rs +++ b/examples/hello-world/src/lib.rs @@ -9,7 +9,7 @@ use node_api::{create_function, set_named_property, create_object}; use node_api::error::*; #[no_mangle] -pub extern "C" fn register(env: NapiEnv, exports: NapiValue, _module: NapiValue, _priv: *mut std::os::raw::c_void) { +pub extern "C" fn register(env: NapiEnv, exports: NapiValue) -> NapiValue { let function = create_function(env, "foo", |_: NapiEnv, _: NapiValue, ()| { HelloReturn { foo: "hello".to_string(), @@ -18,6 +18,8 @@ pub extern "C" fn register(env: NapiEnv, exports: NapiValue, _module: NapiValue, }) .expect("error creating function"); set_named_property(env, exports, "hello", function).expect("error attaching function"); + + exports } struct HelloArgs {} @@ -29,7 +31,7 @@ impl FromNapiValues for HelloArgs { struct HelloReturn { pub foo: String, - pub bar: u64, + pub bar: i64, } impl IntoNapiValue for HelloReturn { diff --git a/node-api-sys/.gitignore b/node-api-sys/.gitignore index 4308d82..7fed360 100644 --- a/node-api-sys/.gitignore +++ b/node-api-sys/.gitignore @@ -1,3 +1,5 @@ target/ **/*.rs.bk Cargo.lock +node_api.h +node_api_types.h diff --git a/node-api-sys/README.md b/node-api-sys/README.md new file mode 100644 index 0000000..5e34e07 --- /dev/null +++ b/node-api-sys/README.md @@ -0,0 +1,21 @@ +# Node-API-sys + +This crate contains the bindings to the N-API. +These are generated from [node_api.h](https://github.com/nodejs/node/blob/master/src/node_api.h) [using](https://rust-lang-nursery.github.io/rust-bindgen/) [bindgen](https://github.com/rust-lang-nursery/rust-bindgen). + +## Updating the bindings + +Run [build.sh](build.sh) to get the latest version of the headers from master and run bindgen on them. +Manually remove a bunch of system constants :( +Manually change the following: + +```rust +pub type napi_env = *mut napi_env__; +// to +pub type napi_env = u64; + +// and +pub type napi_value = *mut napi_value__; +// to +pub type napi_value = u64; +``` diff --git a/node-api-sys/build.sh b/node-api-sys/build.sh new file mode 100755 index 0000000..b1cf5e5 --- /dev/null +++ b/node-api-sys/build.sh @@ -0,0 +1,10 @@ +#!/bin/bash + +# curl -O "https://raw.githubusercontent.com/nodejs/node/master/src/node_api.h" +# curl -O "https://raw.githubusercontent.com/nodejs/node/master/src/node_api_types.h" + +# nodejs 8.7.0 +curl -O "https://raw.githubusercontent.com/nodejs/node/dc4f1b981a888a2f39219d384b6d3eb593203383/src/node_api.h" +curl -O "https://raw.githubusercontent.com/nodejs/node/dc4f1b981a888a2f39219d384b6d3eb593203383/src/node_api_types.h" + +bindgen node_api.h > src/lib.rs diff --git a/node-api-sys/src/lib.rs b/node-api-sys/src/lib.rs index 830500e..5bafaad 100755 --- a/node-api-sys/src/lib.rs +++ b/node-api-sys/src/lib.rs @@ -1,20 +1,22 @@ +#![allow(non_camel_case_types)] /* automatically generated by rust-bindgen */ -pub type intmax_t = ::std::os::raw::c_long; -pub type uintmax_t = ::std::os::raw::c_ulong; pub type char16_t = u16; +pub const NAPI_MODULE_VERSION: ::std::os::raw::c_uint = 1; +pub const NAPI_AUTO_LENGTH: ::std::os::raw::c_int = -1; + #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct napi_env__ { _unused: [u8; 0], } -pub type napi_env = u64; +pub type napi_env = usize; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct napi_value__ { _unused: [u8; 0], } -pub type napi_value = u64; +pub type napi_value = usize; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct napi_ref__ { @@ -41,10 +43,22 @@ pub struct napi_callback_info__ { pub type napi_callback_info = *mut napi_callback_info__; #[repr(C)] #[derive(Debug, Copy, Clone)] +pub struct napi_async_context__ { + _unused: [u8; 0], +} +pub type napi_async_context = *mut napi_async_context__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] pub struct napi_async_work__ { _unused: [u8; 0], } pub type napi_async_work = *mut napi_async_work__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct napi_deferred__ { + _unused: [u8; 0], +} +pub type napi_deferred = *mut napi_deferred__; #[repr(u32)] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum napi_property_attributes { @@ -95,7 +109,7 @@ pub enum napi_status { napi_generic_failure = 9, napi_pending_exception = 10, napi_cancelled = 11, - napi_status_last = 12, + napi_escape_called_twice = 12, } pub type napi_callback = ::std::option::Option Self { *self } } +#[repr(C)] +#[derive(Debug, Copy)] +pub struct napi_node_version { + pub major: u32, + pub minor: u32, + pub patch: u32, + pub release: *const ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_napi_node_version() { + assert_eq!(::std::mem::size_of::() , 24usize , concat ! + ( "Size of: " , stringify ! ( napi_node_version ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat + ! ( "Alignment of " , stringify ! ( napi_node_version ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_node_version ) ) . major as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_node_version ) , + "::" , stringify ! ( major ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_node_version ) ) . minor as * const + _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_node_version ) , + "::" , stringify ! ( minor ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_node_version ) ) . patch as * const + _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_node_version ) , + "::" , stringify ! ( patch ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_node_version ) ) . release as * + const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_node_version ) , + "::" , stringify ! ( release ) )); +} +impl Clone for napi_node_version { + fn clone(&self) -> Self { *self } +} pub type napi_addon_register_func = ::std::option::Option; + exports: napi_value) + -> napi_value>; #[repr(C)] #[derive(Debug, Copy)] pub struct napi_module { @@ -289,7 +339,6 @@ fn bindgen_test_layout_napi_module() { impl Clone for napi_module { fn clone(&self) -> Self { *self } } - extern "C" { pub fn napi_module_register(mod_: *mut napi_module); } @@ -299,6 +348,12 @@ extern "C" { *mut *const napi_extended_error_info) -> napi_status; } +extern "C" { + pub fn napi_fatal_error(location: *const ::std::os::raw::c_char, + location_len: usize, + message: *const ::std::os::raw::c_char, + message_len: usize); +} extern "C" { pub fn napi_get_undefined(env: napi_env, result: *mut napi_value) -> napi_status; @@ -329,9 +384,21 @@ extern "C" { -> napi_status; } extern "C" { - pub fn napi_create_number(env: napi_env, value: f64, + pub fn napi_create_double(env: napi_env, value: f64, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_create_int32(env: napi_env, value: i32, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_create_uint32(env: napi_env, value: u32, result: *mut napi_value) -> napi_status; } +extern "C" { + pub fn napi_create_int64(env: napi_env, value: i64, + result: *mut napi_value) -> napi_status; +} extern "C" { pub fn napi_create_string_latin1(env: napi_env, str: *const ::std::os::raw::c_char, @@ -356,21 +423,23 @@ extern "C" { extern "C" { pub fn napi_create_function(env: napi_env, utf8name: *const ::std::os::raw::c_char, - cb: napi_callback, + length: usize, cb: napi_callback, data: *mut ::std::os::raw::c_void, result: *mut napi_value) -> napi_status; } extern "C" { - pub fn napi_create_error(env: napi_env, msg: napi_value, + pub fn napi_create_error(env: napi_env, code: napi_value, msg: napi_value, result: *mut napi_value) -> napi_status; } extern "C" { - pub fn napi_create_type_error(env: napi_env, msg: napi_value, - result: *mut napi_value) -> napi_status; + pub fn napi_create_type_error(env: napi_env, code: napi_value, + msg: napi_value, result: *mut napi_value) + -> napi_status; } extern "C" { - pub fn napi_create_range_error(env: napi_env, msg: napi_value, - result: *mut napi_value) -> napi_status; + pub fn napi_create_range_error(env: napi_env, code: napi_value, + msg: napi_value, result: *mut napi_value) + -> napi_status; } extern "C" { pub fn napi_typeof(env: napi_env, value: napi_value, @@ -452,6 +521,16 @@ extern "C" { key: napi_value, result: *mut napi_value) -> napi_status; } +extern "C" { + pub fn napi_delete_property(env: napi_env, object: napi_value, + key: napi_value, result: *mut bool) + -> napi_status; +} +extern "C" { + pub fn napi_has_own_property(env: napi_env, object: napi_value, + key: napi_value, result: *mut bool) + -> napi_status; +} extern "C" { pub fn napi_set_named_property(env: napi_env, object: napi_value, utf8name: *const ::std::os::raw::c_char, @@ -479,6 +558,10 @@ extern "C" { pub fn napi_get_element(env: napi_env, object: napi_value, index: u32, result: *mut napi_value) -> napi_status; } +extern "C" { + pub fn napi_delete_element(env: napi_env, object: napi_value, index: u32, + result: *mut bool) -> napi_status; +} extern "C" { pub fn napi_define_properties(env: napi_env, object: napi_value, property_count: usize, @@ -513,12 +596,6 @@ extern "C" { constructor: napi_value, result: *mut bool) -> napi_status; } -extern "C" { - pub fn napi_make_callback(env: napi_env, recv: napi_value, - func: napi_value, argc: usize, - argv: *const napi_value, - result: *mut napi_value) -> napi_status; -} extern "C" { pub fn napi_get_cb_info(env: napi_env, cbinfo: napi_callback_info, argc: *mut usize, argv: *mut napi_value, @@ -527,13 +604,13 @@ extern "C" { -> napi_status; } extern "C" { - pub fn napi_is_construct_call(env: napi_env, cbinfo: napi_callback_info, - result: *mut bool) -> napi_status; + pub fn napi_get_new_target(env: napi_env, cbinfo: napi_callback_info, + result: *mut napi_value) -> napi_status; } extern "C" { pub fn napi_define_class(env: napi_env, utf8name: *const ::std::os::raw::c_char, - constructor: napi_callback, + length: usize, constructor: napi_callback, data: *mut ::std::os::raw::c_void, property_count: usize, properties: *const napi_property_descriptor, @@ -551,6 +628,11 @@ extern "C" { result: *mut *mut ::std::os::raw::c_void) -> napi_status; } +extern "C" { + pub fn napi_remove_wrap(env: napi_env, js_object: napi_value, + result: *mut *mut ::std::os::raw::c_void) + -> napi_status; +} extern "C" { pub fn napi_create_external(env: napi_env, data: *mut ::std::os::raw::c_void, @@ -615,16 +697,20 @@ extern "C" { pub fn napi_throw(env: napi_env, error: napi_value) -> napi_status; } extern "C" { - pub fn napi_throw_error(env: napi_env, msg: *const ::std::os::raw::c_char) + pub fn napi_throw_error(env: napi_env, + code: *const ::std::os::raw::c_char, + msg: *const ::std::os::raw::c_char) -> napi_status; } extern "C" { pub fn napi_throw_type_error(env: napi_env, + code: *const ::std::os::raw::c_char, msg: *const ::std::os::raw::c_char) -> napi_status; } extern "C" { pub fn napi_throw_range_error(env: napi_env, + code: *const ::std::os::raw::c_char, msg: *const ::std::os::raw::c_char) -> napi_status; } @@ -715,7 +801,24 @@ extern "C" { byte_offset: *mut usize) -> napi_status; } extern "C" { - pub fn napi_create_async_work(env: napi_env, + pub fn napi_create_dataview(env: napi_env, length: usize, + arraybuffer: napi_value, byte_offset: usize, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_is_dataview(env: napi_env, value: napi_value, + result: *mut bool) -> napi_status; +} +extern "C" { + pub fn napi_get_dataview_info(env: napi_env, dataview: napi_value, + bytelength: *mut usize, + data: *mut *mut ::std::os::raw::c_void, + arraybuffer: *mut napi_value, + byte_offset: *mut usize) -> napi_status; +} +extern "C" { + pub fn napi_create_async_work(env: napi_env, async_resource: napi_value, + async_resource_name: napi_value, execute: napi_async_execute_callback, complete: napi_async_complete_callback, data: *mut ::std::os::raw::c_void, @@ -734,6 +837,57 @@ extern "C" { pub fn napi_cancel_async_work(env: napi_env, work: napi_async_work) -> napi_status; } +extern "C" { + pub fn napi_async_init(env: napi_env, async_resource: napi_value, + async_resource_name: napi_value, + result: *mut napi_async_context) -> napi_status; +} +extern "C" { + pub fn napi_async_destroy(env: napi_env, + async_context: napi_async_context) + -> napi_status; +} +extern "C" { + pub fn napi_make_callback(env: napi_env, + async_context: napi_async_context, + recv: napi_value, func: napi_value, argc: usize, + argv: *const napi_value, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_get_version(env: napi_env, result: *mut u32) -> napi_status; +} +extern "C" { + pub fn napi_get_node_version(env: napi_env, + version: *mut *const napi_node_version) + -> napi_status; +} +extern "C" { + pub fn napi_create_promise(env: napi_env, deferred: *mut napi_deferred, + promise: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_resolve_deferred(env: napi_env, deferred: napi_deferred, + resolution: napi_value) -> napi_status; +} +extern "C" { + pub fn napi_reject_deferred(env: napi_env, deferred: napi_deferred, + rejection: napi_value) -> napi_status; +} +extern "C" { + pub fn napi_is_promise(env: napi_env, promise: napi_value, + is_promise: *mut bool) -> napi_status; +} +extern "C" { + pub fn napi_adjust_external_memory(env: napi_env, change_in_bytes: i64, + adjusted_value: *mut i64) + -> napi_status; +} +extern "C" { + pub fn napi_run_script(env: napi_env, script: napi_value, + result: *mut napi_value) -> napi_status; +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; #[repr(C)] #[derive(Debug, Copy)] pub struct __va_list_tag { @@ -772,4 +926,3 @@ fn bindgen_test_layout___va_list_tag() { impl Clone for __va_list_tag { fn clone(&self) -> Self { *self } } -pub type __builtin_va_list = [__va_list_tag; 1usize]; diff --git a/node-api-sys/src/new_lib.rs b/node-api-sys/src/new_lib.rs new file mode 100644 index 0000000..830ff28 --- /dev/null +++ b/node-api-sys/src/new_lib.rs @@ -0,0 +1,928 @@ +#![allow(non_camel_case_types)] +/* automatically generated by rust-bindgen */ + +pub type char16_t = u16; +pub const NAPI_MODULE_VERSION: ::std::os::raw::c_uint = 1; +pub const NAPI_AUTO_LENGTH: ::std::os::raw::c_int = -1; + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct napi_env__ { + _unused: [u8; 0], +} +pub type napi_env = *mut napi_env__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct napi_value__ { + _unused: [u8; 0], +} +pub type napi_value = *mut napi_value__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct napi_ref__ { + _unused: [u8; 0], +} +pub type napi_ref = *mut napi_ref__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct napi_handle_scope__ { + _unused: [u8; 0], +} +pub type napi_handle_scope = *mut napi_handle_scope__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct napi_escapable_handle_scope__ { + _unused: [u8; 0], +} +pub type napi_escapable_handle_scope = *mut napi_escapable_handle_scope__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct napi_callback_info__ { + _unused: [u8; 0], +} +pub type napi_callback_info = *mut napi_callback_info__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct napi_async_context__ { + _unused: [u8; 0], +} +pub type napi_async_context = *mut napi_async_context__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct napi_async_work__ { + _unused: [u8; 0], +} +pub type napi_async_work = *mut napi_async_work__; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct napi_deferred__ { + _unused: [u8; 0], +} +pub type napi_deferred = *mut napi_deferred__; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum napi_property_attributes { + napi_default = 0, + napi_writable = 1, + napi_enumerable = 2, + napi_configurable = 4, + napi_static = 1024, +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum napi_valuetype { + napi_undefined = 0, + napi_null = 1, + napi_boolean = 2, + napi_number = 3, + napi_string = 4, + napi_symbol = 5, + napi_object = 6, + napi_function = 7, + napi_external = 8, +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum napi_typedarray_type { + napi_int8_array = 0, + napi_uint8_array = 1, + napi_uint8_clamped_array = 2, + napi_int16_array = 3, + napi_uint16_array = 4, + napi_int32_array = 5, + napi_uint32_array = 6, + napi_float32_array = 7, + napi_float64_array = 8, +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum napi_status { + napi_ok = 0, + napi_invalid_arg = 1, + napi_object_expected = 2, + napi_string_expected = 3, + napi_name_expected = 4, + napi_function_expected = 5, + napi_number_expected = 6, + napi_boolean_expected = 7, + napi_array_expected = 8, + napi_generic_failure = 9, + napi_pending_exception = 10, + napi_cancelled = 11, + napi_escape_called_twice = 12, +} +pub type napi_callback = + ::std::option::Option napi_value>; +pub type napi_finalize = + ::std::option::Option; +pub type napi_async_execute_callback = + ::std::option::Option; +pub type napi_async_complete_callback = + ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct napi_property_descriptor { + pub utf8name: *const ::std::os::raw::c_char, + pub name: napi_value, + pub method: napi_callback, + pub getter: napi_callback, + pub setter: napi_callback, + pub value: napi_value, + pub attributes: napi_property_attributes, + pub data: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_napi_property_descriptor() { + assert_eq!(::std::mem::size_of::() , 64usize , + concat ! ( + "Size of: " , stringify ! ( napi_property_descriptor ) )); + assert_eq! (::std::mem::align_of::() , 8usize , + concat ! ( + "Alignment of " , stringify ! ( napi_property_descriptor ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_property_descriptor ) ) . utf8name + as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + napi_property_descriptor ) , "::" , stringify ! ( utf8name ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_property_descriptor ) ) . name as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + napi_property_descriptor ) , "::" , stringify ! ( name ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_property_descriptor ) ) . method as + * const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( + napi_property_descriptor ) , "::" , stringify ! ( method ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_property_descriptor ) ) . getter as + * const _ as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( + napi_property_descriptor ) , "::" , stringify ! ( getter ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_property_descriptor ) ) . setter as + * const _ as usize } , 32usize , concat ! ( + "Alignment of field: " , stringify ! ( + napi_property_descriptor ) , "::" , stringify ! ( setter ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_property_descriptor ) ) . value as * + const _ as usize } , 40usize , concat ! ( + "Alignment of field: " , stringify ! ( + napi_property_descriptor ) , "::" , stringify ! ( value ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_property_descriptor ) ) . attributes + as * const _ as usize } , 48usize , concat ! ( + "Alignment of field: " , stringify ! ( + napi_property_descriptor ) , "::" , stringify ! ( attributes ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_property_descriptor ) ) . data as * + const _ as usize } , 56usize , concat ! ( + "Alignment of field: " , stringify ! ( + napi_property_descriptor ) , "::" , stringify ! ( data ) )); +} +impl Clone for napi_property_descriptor { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct napi_extended_error_info { + pub error_message: *const ::std::os::raw::c_char, + pub engine_reserved: *mut ::std::os::raw::c_void, + pub engine_error_code: u32, + pub error_code: napi_status, +} +#[test] +fn bindgen_test_layout_napi_extended_error_info() { + assert_eq!(::std::mem::size_of::() , 24usize , + concat ! ( + "Size of: " , stringify ! ( napi_extended_error_info ) )); + assert_eq! (::std::mem::align_of::() , 8usize , + concat ! ( + "Alignment of " , stringify ! ( napi_extended_error_info ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_extended_error_info ) ) . + error_message as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + napi_extended_error_info ) , "::" , stringify ! ( + error_message ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_extended_error_info ) ) . + engine_reserved as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + napi_extended_error_info ) , "::" , stringify ! ( + engine_reserved ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_extended_error_info ) ) . + engine_error_code as * const _ as usize } , 16usize , concat ! + ( + "Alignment of field: " , stringify ! ( + napi_extended_error_info ) , "::" , stringify ! ( + engine_error_code ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_extended_error_info ) ) . error_code + as * const _ as usize } , 20usize , concat ! ( + "Alignment of field: " , stringify ! ( + napi_extended_error_info ) , "::" , stringify ! ( error_code ) + )); +} +impl Clone for napi_extended_error_info { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct napi_node_version { + pub major: u32, + pub minor: u32, + pub patch: u32, + pub release: *const ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_napi_node_version() { + assert_eq!(::std::mem::size_of::() , 24usize , concat ! + ( "Size of: " , stringify ! ( napi_node_version ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat + ! ( "Alignment of " , stringify ! ( napi_node_version ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_node_version ) ) . major as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_node_version ) , + "::" , stringify ! ( major ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_node_version ) ) . minor as * const + _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_node_version ) , + "::" , stringify ! ( minor ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_node_version ) ) . patch as * const + _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_node_version ) , + "::" , stringify ! ( patch ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_node_version ) ) . release as * + const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_node_version ) , + "::" , stringify ! ( release ) )); +} +impl Clone for napi_node_version { + fn clone(&self) -> Self { *self } +} +pub type napi_addon_register_func = + ::std::option::Option napi_value>; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct napi_module { + pub nm_version: ::std::os::raw::c_int, + pub nm_flags: ::std::os::raw::c_uint, + pub nm_filename: *const ::std::os::raw::c_char, + pub nm_register_func: napi_addon_register_func, + pub nm_modname: *const ::std::os::raw::c_char, + pub nm_priv: *mut ::std::os::raw::c_void, + pub reserved: [*mut ::std::os::raw::c_void; 4usize], +} +#[test] +fn bindgen_test_layout_napi_module() { + assert_eq!(::std::mem::size_of::() , 72usize , concat ! ( + "Size of: " , stringify ! ( napi_module ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( napi_module ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_module ) ) . nm_version as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_module ) , "::" , + stringify ! ( nm_version ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_module ) ) . nm_flags as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_module ) , "::" , + stringify ! ( nm_flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_module ) ) . nm_filename as * const + _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_module ) , "::" , + stringify ! ( nm_filename ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_module ) ) . nm_register_func as * + const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_module ) , "::" , + stringify ! ( nm_register_func ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_module ) ) . nm_modname as * const _ + as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_module ) , "::" , + stringify ! ( nm_modname ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_module ) ) . nm_priv as * const _ as + usize } , 32usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_module ) , "::" , + stringify ! ( nm_priv ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const napi_module ) ) . reserved as * const _ + as usize } , 40usize , concat ! ( + "Alignment of field: " , stringify ! ( napi_module ) , "::" , + stringify ! ( reserved ) )); +} +impl Clone for napi_module { + fn clone(&self) -> Self { *self } +} +extern "C" { + pub fn napi_module_register(mod_: *mut napi_module); +} +extern "C" { + pub fn napi_get_last_error_info(env: napi_env, + result: + *mut *const napi_extended_error_info) + -> napi_status; +} +extern "C" { + pub fn napi_fatal_error(location: *const ::std::os::raw::c_char, + location_len: usize, + message: *const ::std::os::raw::c_char, + message_len: usize); +} +extern "C" { + pub fn napi_get_undefined(env: napi_env, result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_get_null(env: napi_env, result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_get_global(env: napi_env, result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_get_boolean(env: napi_env, value: bool, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_create_object(env: napi_env, result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_create_array(env: napi_env, result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_create_array_with_length(env: napi_env, length: usize, + result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_create_double(env: napi_env, value: f64, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_create_int32(env: napi_env, value: i32, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_create_uint32(env: napi_env, value: u32, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_create_int64(env: napi_env, value: i64, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_create_string_latin1(env: napi_env, + str: *const ::std::os::raw::c_char, + length: usize, result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_create_string_utf8(env: napi_env, + str: *const ::std::os::raw::c_char, + length: usize, result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_create_string_utf16(env: napi_env, str: *const char16_t, + length: usize, result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_create_symbol(env: napi_env, description: napi_value, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_create_function(env: napi_env, + utf8name: *const ::std::os::raw::c_char, + length: usize, cb: napi_callback, + data: *mut ::std::os::raw::c_void, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_create_error(env: napi_env, code: napi_value, msg: napi_value, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_create_type_error(env: napi_env, code: napi_value, + msg: napi_value, result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_create_range_error(env: napi_env, code: napi_value, + msg: napi_value, result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_typeof(env: napi_env, value: napi_value, + result: *mut napi_valuetype) -> napi_status; +} +extern "C" { + pub fn napi_get_value_double(env: napi_env, value: napi_value, + result: *mut f64) -> napi_status; +} +extern "C" { + pub fn napi_get_value_int32(env: napi_env, value: napi_value, + result: *mut i32) -> napi_status; +} +extern "C" { + pub fn napi_get_value_uint32(env: napi_env, value: napi_value, + result: *mut u32) -> napi_status; +} +extern "C" { + pub fn napi_get_value_int64(env: napi_env, value: napi_value, + result: *mut i64) -> napi_status; +} +extern "C" { + pub fn napi_get_value_bool(env: napi_env, value: napi_value, + result: *mut bool) -> napi_status; +} +extern "C" { + pub fn napi_get_value_string_latin1(env: napi_env, value: napi_value, + buf: *mut ::std::os::raw::c_char, + bufsize: usize, result: *mut usize) + -> napi_status; +} +extern "C" { + pub fn napi_get_value_string_utf8(env: napi_env, value: napi_value, + buf: *mut ::std::os::raw::c_char, + bufsize: usize, result: *mut usize) + -> napi_status; +} +extern "C" { + pub fn napi_get_value_string_utf16(env: napi_env, value: napi_value, + buf: *mut char16_t, bufsize: usize, + result: *mut usize) -> napi_status; +} +extern "C" { + pub fn napi_coerce_to_bool(env: napi_env, value: napi_value, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_coerce_to_number(env: napi_env, value: napi_value, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_coerce_to_object(env: napi_env, value: napi_value, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_coerce_to_string(env: napi_env, value: napi_value, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_get_prototype(env: napi_env, object: napi_value, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_get_property_names(env: napi_env, object: napi_value, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_set_property(env: napi_env, object: napi_value, + key: napi_value, value: napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_has_property(env: napi_env, object: napi_value, + key: napi_value, result: *mut bool) + -> napi_status; +} +extern "C" { + pub fn napi_get_property(env: napi_env, object: napi_value, + key: napi_value, result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_delete_property(env: napi_env, object: napi_value, + key: napi_value, result: *mut bool) + -> napi_status; +} +extern "C" { + pub fn napi_has_own_property(env: napi_env, object: napi_value, + key: napi_value, result: *mut bool) + -> napi_status; +} +extern "C" { + pub fn napi_set_named_property(env: napi_env, object: napi_value, + utf8name: *const ::std::os::raw::c_char, + value: napi_value) -> napi_status; +} +extern "C" { + pub fn napi_has_named_property(env: napi_env, object: napi_value, + utf8name: *const ::std::os::raw::c_char, + result: *mut bool) -> napi_status; +} +extern "C" { + pub fn napi_get_named_property(env: napi_env, object: napi_value, + utf8name: *const ::std::os::raw::c_char, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_set_element(env: napi_env, object: napi_value, index: u32, + value: napi_value) -> napi_status; +} +extern "C" { + pub fn napi_has_element(env: napi_env, object: napi_value, index: u32, + result: *mut bool) -> napi_status; +} +extern "C" { + pub fn napi_get_element(env: napi_env, object: napi_value, index: u32, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_delete_element(env: napi_env, object: napi_value, index: u32, + result: *mut bool) -> napi_status; +} +extern "C" { + pub fn napi_define_properties(env: napi_env, object: napi_value, + property_count: usize, + properties: *const napi_property_descriptor) + -> napi_status; +} +extern "C" { + pub fn napi_is_array(env: napi_env, value: napi_value, result: *mut bool) + -> napi_status; +} +extern "C" { + pub fn napi_get_array_length(env: napi_env, value: napi_value, + result: *mut u32) -> napi_status; +} +extern "C" { + pub fn napi_strict_equals(env: napi_env, lhs: napi_value, rhs: napi_value, + result: *mut bool) -> napi_status; +} +extern "C" { + pub fn napi_call_function(env: napi_env, recv: napi_value, + func: napi_value, argc: usize, + argv: *const napi_value, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_new_instance(env: napi_env, constructor: napi_value, + argc: usize, argv: *const napi_value, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_instanceof(env: napi_env, object: napi_value, + constructor: napi_value, result: *mut bool) + -> napi_status; +} +extern "C" { + pub fn napi_get_cb_info(env: napi_env, cbinfo: napi_callback_info, + argc: *mut usize, argv: *mut napi_value, + this_arg: *mut napi_value, + data: *mut *mut ::std::os::raw::c_void) + -> napi_status; +} +extern "C" { + pub fn napi_get_new_target(env: napi_env, cbinfo: napi_callback_info, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_define_class(env: napi_env, + utf8name: *const ::std::os::raw::c_char, + length: usize, constructor: napi_callback, + data: *mut ::std::os::raw::c_void, + property_count: usize, + properties: *const napi_property_descriptor, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_wrap(env: napi_env, js_object: napi_value, + native_object: *mut ::std::os::raw::c_void, + finalize_cb: napi_finalize, + finalize_hint: *mut ::std::os::raw::c_void, + result: *mut napi_ref) -> napi_status; +} +extern "C" { + pub fn napi_unwrap(env: napi_env, js_object: napi_value, + result: *mut *mut ::std::os::raw::c_void) + -> napi_status; +} +extern "C" { + pub fn napi_remove_wrap(env: napi_env, js_object: napi_value, + result: *mut *mut ::std::os::raw::c_void) + -> napi_status; +} +extern "C" { + pub fn napi_create_external(env: napi_env, + data: *mut ::std::os::raw::c_void, + finalize_cb: napi_finalize, + finalize_hint: *mut ::std::os::raw::c_void, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_get_value_external(env: napi_env, value: napi_value, + result: *mut *mut ::std::os::raw::c_void) + -> napi_status; +} +extern "C" { + pub fn napi_create_reference(env: napi_env, value: napi_value, + initial_refcount: u32, result: *mut napi_ref) + -> napi_status; +} +extern "C" { + pub fn napi_delete_reference(env: napi_env, ref_: napi_ref) + -> napi_status; +} +extern "C" { + pub fn napi_reference_ref(env: napi_env, ref_: napi_ref, result: *mut u32) + -> napi_status; +} +extern "C" { + pub fn napi_reference_unref(env: napi_env, ref_: napi_ref, + result: *mut u32) -> napi_status; +} +extern "C" { + pub fn napi_get_reference_value(env: napi_env, ref_: napi_ref, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_open_handle_scope(env: napi_env, + result: *mut napi_handle_scope) + -> napi_status; +} +extern "C" { + pub fn napi_close_handle_scope(env: napi_env, scope: napi_handle_scope) + -> napi_status; +} +extern "C" { + pub fn napi_open_escapable_handle_scope(env: napi_env, + result: + *mut napi_escapable_handle_scope) + -> napi_status; +} +extern "C" { + pub fn napi_close_escapable_handle_scope(env: napi_env, + scope: + napi_escapable_handle_scope) + -> napi_status; +} +extern "C" { + pub fn napi_escape_handle(env: napi_env, + scope: napi_escapable_handle_scope, + escapee: napi_value, result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_throw(env: napi_env, error: napi_value) -> napi_status; +} +extern "C" { + pub fn napi_throw_error(env: napi_env, + code: *const ::std::os::raw::c_char, + msg: *const ::std::os::raw::c_char) + -> napi_status; +} +extern "C" { + pub fn napi_throw_type_error(env: napi_env, + code: *const ::std::os::raw::c_char, + msg: *const ::std::os::raw::c_char) + -> napi_status; +} +extern "C" { + pub fn napi_throw_range_error(env: napi_env, + code: *const ::std::os::raw::c_char, + msg: *const ::std::os::raw::c_char) + -> napi_status; +} +extern "C" { + pub fn napi_is_error(env: napi_env, value: napi_value, result: *mut bool) + -> napi_status; +} +extern "C" { + pub fn napi_is_exception_pending(env: napi_env, result: *mut bool) + -> napi_status; +} +extern "C" { + pub fn napi_get_and_clear_last_exception(env: napi_env, + result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_create_buffer(env: napi_env, length: usize, + data: *mut *mut ::std::os::raw::c_void, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_create_external_buffer(env: napi_env, length: usize, + data: *mut ::std::os::raw::c_void, + finalize_cb: napi_finalize, + finalize_hint: + *mut ::std::os::raw::c_void, + result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_create_buffer_copy(env: napi_env, length: usize, + data: *const ::std::os::raw::c_void, + result_data: + *mut *mut ::std::os::raw::c_void, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_is_buffer(env: napi_env, value: napi_value, result: *mut bool) + -> napi_status; +} +extern "C" { + pub fn napi_get_buffer_info(env: napi_env, value: napi_value, + data: *mut *mut ::std::os::raw::c_void, + length: *mut usize) -> napi_status; +} +extern "C" { + pub fn napi_is_arraybuffer(env: napi_env, value: napi_value, + result: *mut bool) -> napi_status; +} +extern "C" { + pub fn napi_create_arraybuffer(env: napi_env, byte_length: usize, + data: *mut *mut ::std::os::raw::c_void, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_create_external_arraybuffer(env: napi_env, + external_data: + *mut ::std::os::raw::c_void, + byte_length: usize, + finalize_cb: napi_finalize, + finalize_hint: + *mut ::std::os::raw::c_void, + result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_get_arraybuffer_info(env: napi_env, arraybuffer: napi_value, + data: *mut *mut ::std::os::raw::c_void, + byte_length: *mut usize) -> napi_status; +} +extern "C" { + pub fn napi_is_typedarray(env: napi_env, value: napi_value, + result: *mut bool) -> napi_status; +} +extern "C" { + pub fn napi_create_typedarray(env: napi_env, type_: napi_typedarray_type, + length: usize, arraybuffer: napi_value, + byte_offset: usize, result: *mut napi_value) + -> napi_status; +} +extern "C" { + pub fn napi_get_typedarray_info(env: napi_env, typedarray: napi_value, + type_: *mut napi_typedarray_type, + length: *mut usize, + data: *mut *mut ::std::os::raw::c_void, + arraybuffer: *mut napi_value, + byte_offset: *mut usize) -> napi_status; +} +extern "C" { + pub fn napi_create_dataview(env: napi_env, length: usize, + arraybuffer: napi_value, byte_offset: usize, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_is_dataview(env: napi_env, value: napi_value, + result: *mut bool) -> napi_status; +} +extern "C" { + pub fn napi_get_dataview_info(env: napi_env, dataview: napi_value, + bytelength: *mut usize, + data: *mut *mut ::std::os::raw::c_void, + arraybuffer: *mut napi_value, + byte_offset: *mut usize) -> napi_status; +} +extern "C" { + pub fn napi_create_async_work(env: napi_env, async_resource: napi_value, + async_resource_name: napi_value, + execute: napi_async_execute_callback, + complete: napi_async_complete_callback, + data: *mut ::std::os::raw::c_void, + result: *mut napi_async_work) + -> napi_status; +} +extern "C" { + pub fn napi_delete_async_work(env: napi_env, work: napi_async_work) + -> napi_status; +} +extern "C" { + pub fn napi_queue_async_work(env: napi_env, work: napi_async_work) + -> napi_status; +} +extern "C" { + pub fn napi_cancel_async_work(env: napi_env, work: napi_async_work) + -> napi_status; +} +extern "C" { + pub fn napi_async_init(env: napi_env, async_resource: napi_value, + async_resource_name: napi_value, + result: *mut napi_async_context) -> napi_status; +} +extern "C" { + pub fn napi_async_destroy(env: napi_env, + async_context: napi_async_context) + -> napi_status; +} +extern "C" { + pub fn napi_make_callback(env: napi_env, + async_context: napi_async_context, + recv: napi_value, func: napi_value, argc: usize, + argv: *const napi_value, + result: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_get_version(env: napi_env, result: *mut u32) -> napi_status; +} +extern "C" { + pub fn napi_get_node_version(env: napi_env, + version: *mut *const napi_node_version) + -> napi_status; +} +extern "C" { + pub fn napi_create_promise(env: napi_env, deferred: *mut napi_deferred, + promise: *mut napi_value) -> napi_status; +} +extern "C" { + pub fn napi_resolve_deferred(env: napi_env, deferred: napi_deferred, + resolution: napi_value) -> napi_status; +} +extern "C" { + pub fn napi_reject_deferred(env: napi_env, deferred: napi_deferred, + rejection: napi_value) -> napi_status; +} +extern "C" { + pub fn napi_is_promise(env: napi_env, promise: napi_value, + is_promise: *mut bool) -> napi_status; +} +extern "C" { + pub fn napi_adjust_external_memory(env: napi_env, change_in_bytes: i64, + adjusted_value: *mut i64) + -> napi_status; +} +extern "C" { + pub fn napi_run_script(env: napi_env, script: napi_value, + result: *mut napi_value) -> napi_status; +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!(::std::mem::size_of::<__va_list_tag>() , 24usize , concat ! ( + "Size of: " , stringify ! ( __va_list_tag ) )); + assert_eq! (::std::mem::align_of::<__va_list_tag>() , 8usize , concat ! ( + "Alignment of " , stringify ! ( __va_list_tag ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const __va_list_tag ) ) . gp_offset as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( __va_list_tag ) , "::" + , stringify ! ( gp_offset ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const __va_list_tag ) ) . fp_offset as * const + _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( __va_list_tag ) , "::" + , stringify ! ( fp_offset ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const __va_list_tag ) ) . overflow_arg_area as + * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( __va_list_tag ) , "::" + , stringify ! ( overflow_arg_area ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const __va_list_tag ) ) . reg_save_area as * + const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( __va_list_tag ) , "::" + , stringify ! ( reg_save_area ) )); +} +impl Clone for __va_list_tag { + fn clone(&self) -> Self { *self } +} diff --git a/node-api/Cargo.toml b/node-api/Cargo.toml new file mode 100644 index 0000000..b01c246 --- /dev/null +++ b/node-api/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "node-api" +version = "0.1.0" +authors = ["Jupp Müller "] + +[lib] +crate-type = ["lib"] + +[dependencies] +node-api-sys = {path = "../node-api-sys"} +futures = "0.1" + diff --git a/src/error.rs b/node-api/src/error.rs similarity index 97% rename from src/error.rs rename to node-api/src/error.rs index 20ac2e7..2a453b9 100644 --- a/src/error.rs +++ b/node-api/src/error.rs @@ -75,7 +75,6 @@ impl From for NapiErrorType { napi_status::napi_generic_failure => NapiErrorType::GenericFailure, napi_status::napi_pending_exception => NapiErrorType::PendingException, napi_status::napi_cancelled => NapiErrorType::Cancelled, - napi_status::napi_status_last => NapiErrorType::StatusLast, _ => NapiErrorType::GenericFailure, } } diff --git a/src/futures.rs b/node-api/src/futures.rs similarity index 100% rename from src/futures.rs rename to node-api/src/futures.rs diff --git a/src/lib.rs b/node-api/src/lib.rs similarity index 61% rename from src/lib.rs rename to node-api/src/lib.rs index 0f3af0d..4c6bae8 100755 --- a/src/lib.rs +++ b/node-api/src/lib.rs @@ -23,22 +23,20 @@ extern "C" {} #[cfg_attr(target_os = "macos", link_section = "__DATA,__mod_init_func")] #[cfg_attr(target_os = "windows", link_section = ".CRT$XCU")] pub static REGISTER_FOO: extern "C" fn() = { - extern "C" fn __load_napi_module() { - node_api::module_register(node_api::NapiModule { - version: NAPI_MODULE_VERSION, - flags: 0, - filename: $module.to_string(), - register_func: Some($register_func), - modname: $module.to_string(), - }) + extern "C" + fn __load_napi_module() { + let napi_mod = node_api::NapiModule { + version: NAPI_MODULE_VERSION, + flags: 0, + filename: $module.to_string(), + register_func: Some($register_func), + modname: $module.to_string(), + }; + node_api::module_register(napi_mod) .expect("error registering module"); - } + } __load_napi_module }; + }} -#[cfg(test)] -mod tests { - #[test] - fn it_works() {} -} diff --git a/src/napi.rs b/node-api/src/napi.rs similarity index 98% rename from src/napi.rs rename to node-api/src/napi.rs index fc68427..a07fe7e 100644 --- a/src/napi.rs +++ b/node-api/src/napi.rs @@ -149,13 +149,23 @@ pub fn array_with_length(env: NapiEnv, size: usize) -> Result { } } -pub fn create_number(env: NapiEnv, value: f64) -> Result { +macro_rules! create_number { + ($name:ident, $sys_name:ident, $value_type:ty) => { +pub fn $name(env: NapiEnv, value: $value_type) -> Result { unsafe { let mut napi_val: NapiValue = mem::uninitialized(); - let status = napi_create_number(env, value, &mut napi_val); + let status = $sys_name(env, value, &mut napi_val); napi_either(env, status, napi_val) } } + }; +} + +create_number!(create_double, napi_create_double, f64); +create_number!(create_i32, napi_create_int32, i32); +create_number!(create_u32, napi_create_uint32, u32); +create_number!(create_i64, napi_create_int64, i64); + pub fn create_string_utf8(env: NapiEnv, val: T) -> Result where T: AsRef @@ -215,6 +225,7 @@ pub fn create_function(env: NapiEnv, utf8name: &str, f: F) -> Result), user_data, &mut napi_val) diff --git a/src/napi_futures.rs b/node-api/src/napi_futures.rs similarity index 100% rename from src/napi_futures.rs rename to node-api/src/napi_futures.rs diff --git a/src/napi_value.rs b/node-api/src/napi_value.rs similarity index 83% rename from src/napi_value.rs rename to node-api/src/napi_value.rs index d05b789..05cb0b8 100644 --- a/src/napi_value.rs +++ b/node-api/src/napi_value.rs @@ -28,11 +28,11 @@ macro_rules! impl_from_napi_values { } } -impl_from_napi_values!(String, NapiValueType::String, napi::get_value_string_utf8); -impl_from_napi_values!(i64, NapiValueType::Number, napi::get_value_int64); -impl_from_napi_values!(u64, NapiValueType::Number, get_value_uint64); -impl_from_napi_values!(bool, NapiValueType::Boolean, napi::get_value_bool); -impl_from_napi_values!(f64, NapiValueType::Number, napi::get_value_double); +impl_from_napi_values!(String, NapiValueType::String, napi::get_value_string_utf8); +impl_from_napi_values!(i64, NapiValueType::Number, napi::get_value_int64); +impl_from_napi_values!(u64, NapiValueType::Number, get_value_uint64); +impl_from_napi_values!(bool, NapiValueType::Boolean, napi::get_value_bool); +impl_from_napi_values!(f64, NapiValueType::Number, napi::get_value_double); fn get_value_uint64(env: napi::NapiEnv, value: napi::NapiValue) -> Result { @@ -117,18 +117,17 @@ impl<'a> IntoNapiValue for &'a str { } } -impl_into_napi_values!(u8, |env, s| napi::create_number(env, s as f64)); -impl_into_napi_values!(u16, |env, s| napi::create_number(env, s as f64)); -impl_into_napi_values!(u32, |env, s| napi::create_number(env, s as f64)); -impl_into_napi_values!(u64, |env, s| napi::create_number(env, s as f64)); +impl_into_napi_values!(u8, |env, s| napi::create_u32(env, s as u32)); +impl_into_napi_values!(u16, |env, s| napi::create_u32(env, s as u32)); +impl_into_napi_values!(u32, |env, s| napi::create_u32(env, s as u32)); -impl_into_napi_values!(i8, |env, s| napi::create_number(env, s as f64)); -impl_into_napi_values!(i16, |env, s| napi::create_number(env, s as f64)); -impl_into_napi_values!(i32, |env, s| napi::create_number(env, s as f64)); -impl_into_napi_values!(i64, |env, s| napi::create_number(env, s as f64)); +impl_into_napi_values!(i8, |env, s| napi::create_i64(env, s as i64)); +impl_into_napi_values!(i16, |env, s| napi::create_i64(env, s as i64)); +impl_into_napi_values!(i32, |env, s| napi::create_i64(env, s as i64)); +impl_into_napi_values!(i64, |env, s| napi::create_i64(env, s as i64)); -impl_into_napi_values!(f32, |env, s| napi::create_number(env, s as f64)); -impl_into_napi_values!(f64, |env, s| napi::create_number(env, s as f64)); +impl_into_napi_values!(f32, |env, s| napi::create_double(env, s as f64)); +impl_into_napi_values!(f64, |env, s| napi::create_double(env, s)); impl_into_napi_values!(bool, napi::get_boolean); @@ -180,7 +179,7 @@ impl IntoNapiValue for future::BoxFuture Ok(val) => (then_args.on_fulfilled)(env, this, val), Err(err) => (then_args.on_rejected)(env, this, err) } - future::result::<(),()>(Ok(())).boxed() + Box::new(future::result::<(),()>(Ok(()))) }).boxed().wait().unwrap(); })?; napi::set_named_property(env, obj, "then", then)?; diff --git a/tests/Cargo.toml b/tests/Cargo.toml index 2c2e8ff..593665b 100644 --- a/tests/Cargo.toml +++ b/tests/Cargo.toml @@ -9,6 +9,6 @@ name = "tests" crate-type = ["cdylib"] [dependencies] -node-api = {path = ".."} +node-api = {path = "../node-api"} futures = "0.1.13" tokio-core = "0.1" diff --git a/tests/package-lock.json b/tests/package-lock.json index 501d2c7..a3bda61 100644 --- a/tests/package-lock.json +++ b/tests/package-lock.json @@ -2,6 +2,7 @@ "name": "tests", "version": "1.0.0", "lockfileVersion": 1, + "requires": true, "dependencies": { "assertion-error": { "version": "1.0.2", @@ -16,7 +17,11 @@ "brace-expansion": { "version": "1.1.7", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.7.tgz", - "integrity": "sha1-Pv/DxQ4ABTH7cg6v+A8K6O8jz1k=" + "integrity": "sha1-Pv/DxQ4ABTH7cg6v+A8K6O8jz1k=", + "requires": { + "balanced-match": "0.4.2", + "concat-map": "0.0.1" + } }, "browser-stdout": { "version": "1.3.0", @@ -26,12 +31,20 @@ "chai": { "version": "3.5.0", "resolved": "https://registry.npmjs.org/chai/-/chai-3.5.0.tgz", - "integrity": "sha1-TQJjewZ/6Vi9v906QOxW/vc3Mkc=" + "integrity": "sha1-TQJjewZ/6Vi9v906QOxW/vc3Mkc=", + "requires": { + "assertion-error": "1.0.2", + "deep-eql": "0.1.3", + "type-detect": "1.0.0" + } }, "commander": { "version": "2.9.0", "resolved": "https://registry.npmjs.org/commander/-/commander-2.9.0.tgz", - "integrity": "sha1-nJkJQXbhIkDLItbFFGCYQA/g99Q=" + "integrity": "sha1-nJkJQXbhIkDLItbFFGCYQA/g99Q=", + "requires": { + "graceful-readlink": "1.0.1" + } }, "concat-map": { "version": "0.0.1", @@ -41,12 +54,18 @@ "debug": { "version": "2.6.0", "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.0.tgz", - "integrity": "sha1-vFlryr52F/Edn6FTYe3tVgi4SZs=" + "integrity": "sha1-vFlryr52F/Edn6FTYe3tVgi4SZs=", + "requires": { + "ms": "0.7.2" + } }, "deep-eql": { "version": "0.1.3", "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-0.1.3.tgz", "integrity": "sha1-71WKyrjeJSBs1xOQbXTlaTDrafI=", + "requires": { + "type-detect": "0.1.1" + }, "dependencies": { "type-detect": { "version": "0.1.1", @@ -73,7 +92,15 @@ "glob": { "version": "7.1.1", "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.1.tgz", - "integrity": "sha1-gFIR3wT6rxxjo2ADBs31reULLsg=" + "integrity": "sha1-gFIR3wT6rxxjo2ADBs31reULLsg=", + "requires": { + "fs.realpath": "1.0.0", + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" + } }, "graceful-readlink": { "version": "1.0.1", @@ -93,7 +120,11 @@ "inflight": { "version": "1.0.6", "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", - "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=" + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "requires": { + "once": "1.4.0", + "wrappy": "1.0.2" + } }, "inherits": { "version": "2.0.3", @@ -108,7 +139,11 @@ "lodash._baseassign": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/lodash._baseassign/-/lodash._baseassign-3.2.0.tgz", - "integrity": "sha1-jDigmVAPIVrQnlnxci/QxSv+Ck4=" + "integrity": "sha1-jDigmVAPIVrQnlnxci/QxSv+Ck4=", + "requires": { + "lodash._basecopy": "3.0.1", + "lodash.keys": "3.1.2" + } }, "lodash._basecopy": { "version": "3.0.1", @@ -133,7 +168,12 @@ "lodash.create": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/lodash.create/-/lodash.create-3.1.1.tgz", - "integrity": "sha1-1/KEnw29p+BGgruM1yqwIkYd6+c=" + "integrity": "sha1-1/KEnw29p+BGgruM1yqwIkYd6+c=", + "requires": { + "lodash._baseassign": "3.2.0", + "lodash._basecreate": "3.0.3", + "lodash._isiterateecall": "3.0.9" + } }, "lodash.isarguments": { "version": "3.1.0", @@ -148,12 +188,20 @@ "lodash.keys": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/lodash.keys/-/lodash.keys-3.1.2.tgz", - "integrity": "sha1-TbwEcrFWvlCgsoaFXRvQsMZWCYo=" + "integrity": "sha1-TbwEcrFWvlCgsoaFXRvQsMZWCYo=", + "requires": { + "lodash._getnative": "3.9.1", + "lodash.isarguments": "3.1.0", + "lodash.isarray": "3.0.4" + } }, "minimatch": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", - "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==" + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "requires": { + "brace-expansion": "1.1.7" + } }, "minimist": { "version": "0.0.8", @@ -163,10 +211,26 @@ "mkdirp": { "version": "0.5.1", "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", - "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=" + "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", + "requires": { + "minimist": "0.0.8" + } }, "mocha": { - "version": "github:jupp0r/mocha#63f0cc03240e9b9235b7f7cd899389fd7fdc9f90" + "version": "github:jupp0r/mocha#63f0cc03240e9b9235b7f7cd899389fd7fdc9f90", + "requires": { + "browser-stdout": "1.3.0", + "commander": "2.9.0", + "debug": "2.6.0", + "diff": "3.2.0", + "escape-string-regexp": "1.0.5", + "glob": "7.1.1", + "growl": "1.9.2", + "json3": "3.3.2", + "lodash.create": "3.1.1", + "mkdirp": "0.5.1", + "supports-color": "3.1.2" + } }, "ms": { "version": "0.7.2", @@ -176,7 +240,10 @@ "once": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", - "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=" + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "requires": { + "wrappy": "1.0.2" + } }, "path-is-absolute": { "version": "1.0.1", @@ -186,7 +253,10 @@ "supports-color": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-3.1.2.tgz", - "integrity": "sha1-cqJiiU2dQIuVbKBf83su2KbiotU=" + "integrity": "sha1-cqJiiU2dQIuVbKBf83su2KbiotU=", + "requires": { + "has-flag": "1.0.0" + } }, "type-detect": { "version": "1.0.0", diff --git a/tests/src/lib.rs b/tests/src/lib.rs index 5490c8b..a8f6d6b 100755 --- a/tests/src/lib.rs +++ b/tests/src/lib.rs @@ -6,8 +6,13 @@ extern crate tokio_core; use node_api::{NapiEnv, NapiValue, FromNapiValues, IntoNapiValue}; use node_api::error::*; -use node_api::{create_function, get_named_property, set_named_property, create_object, - create_external}; +use node_api::{ + create_function, + get_named_property, + set_named_property, + create_object, + create_external +}; use futures::future; use futures::Future; @@ -17,27 +22,25 @@ use tokio_core::reactor::Core; napi_module!("tests", register); #[no_mangle] -pub extern "C" fn register(env: NapiEnv, - exports: NapiValue, - module: NapiValue, - _priv: *mut std::os::raw::c_void) { - // create_and_attach_event_loop(env, module); +pub unsafe extern "C" fn register(env: NapiEnv, exports: NapiValue) -> usize { + // create_and_attach_event_loop(env, exports); - register_test(env, "returns_objects", exports, &returns_objects); - register_test(env, "returns_strings", exports, &returns_strings); - register_test(env, "returns_numbers", exports, &returns_numbers); - register_test(env, "returns_booleans", exports, &returns_booleans); - register_test(env, "returns_arrays", exports, &returns_arrays); + register_test(env, "returns_objects", &returns_objects); + register_test(env, "returns_strings", &returns_strings); + register_test(env, "returns_numbers", &returns_numbers); + register_test(env, "returns_booleans", &returns_booleans); + register_test(env, "returns_arrays", &returns_arrays); - register_test(env, "receives_objects", exports, &receives_objects); - register_test(env, "receives_strings", exports, &receives_strings); - register_test(env, "receives_booleans", exports, &receives_booleans); - register_test(env, "receives_f64", exports, &receives_f64); - register_test(env, "receives_u64", exports, &receives_u64); - register_test(env, "receives_i64", exports, &receives_i64); - register_test(env, "receives_arrays", exports, &receives_arrays); + register_test(env, "receives_objects", &receives_objects); + register_test(env, "receives_strings", &receives_strings); + register_test(env, "receives_booleans", &receives_booleans); + register_test(env, "receives_f64", &receives_f64); + register_test(env, "receives_i64", &receives_i64); + register_test(env, "receives_arrays", &receives_arrays); - register_test(env, "returns_promises", exports, &returns_promises); + register_test(env, "returns_promises", &returns_promises); + + exports } // fn create_and_attach_event_loop(env: NapiEnv, module: NapiValue) { @@ -45,12 +48,13 @@ pub extern "C" fn register(env: NapiEnv, // let core_js = node_api::create_external(env, core).unwrap(); //} -fn register_test(env: NapiEnv, name: &str, exports: NapiValue, f: F) +fn register_test(env: NapiEnv, name: &str, f: F) where F: Fn(NapiEnv, NapiValue, A) -> R, A: FromNapiValues, R: IntoNapiValue { let test = create_function(env, name, f).unwrap(); + let exports = create_object(env).unwrap(); set_named_property(env, exports, name, test).unwrap(); } @@ -65,7 +69,7 @@ fn returns_objects(_: NapiEnv, _: NapiValue, _: ()) -> Object { #[derive(Debug)] struct Object { pub foo: String, - pub bar: u64, + pub bar: i64, } impl IntoNapiValue for Object { @@ -124,8 +128,8 @@ fn returns_strings(_: NapiEnv, _: NapiValue, _: ()) -> String { "returned_string".to_string() } -fn returns_numbers(_: NapiEnv, _: NapiValue, _: ()) -> u64 { - 42 +fn returns_numbers(_: NapiEnv, _: NapiValue, _: ()) -> f64 { + 42.1337 } fn returns_booleans(_: NapiEnv, _: NapiValue, _: ()) -> bool { @@ -152,10 +156,6 @@ fn receives_f64(_: NapiEnv, _: NapiValue, arg: f64) -> f64 { arg } -fn receives_u64(_: NapiEnv, _: NapiValue, arg: u64) -> u64 { - arg -} - fn receives_i64(_: NapiEnv, _: NapiValue, arg: i64) -> i64 { arg }