summaryrefslogtreecommitdiff
path: root/cli/napi/js_native_api.rs
diff options
context:
space:
mode:
Diffstat (limited to 'cli/napi/js_native_api.rs')
-rw-r--r--cli/napi/js_native_api.rs850
1 files changed, 548 insertions, 302 deletions
diff --git a/cli/napi/js_native_api.rs b/cli/napi/js_native_api.rs
index c2f3a1122..103a5f06a 100644
--- a/cli/napi/js_native_api.rs
+++ b/cli/napi/js_native_api.rs
@@ -13,30 +13,126 @@ use deno_runtime::deno_napi::function::create_function_template;
use deno_runtime::deno_napi::function::CallbackInfo;
use std::ptr::NonNull;
+#[macro_export]
+macro_rules! check_env {
+ ($env: expr) => {
+ if $env.is_null() {
+ return Err(Error::InvalidArg);
+ }
+ };
+}
+
+#[inline]
+unsafe fn napi_value_unchecked(val: napi_value) -> v8::Local<v8::Value> {
+ transmute::<napi_value, v8::Local<v8::Value>>(val)
+}
+
+#[macro_export]
+macro_rules! return_status_if_false {
+ ($env: expr, $condition: expr, $status: ident) => {
+ if !$condition {
+ return Err(
+ $crate::napi::js_native_api::napi_set_last_error(
+ $env,
+ $status,
+ 0,
+ std::ptr::null_mut(),
+ )
+ .into(),
+ );
+ }
+ };
+}
+
+fn check_new_from_utf8_len<'s>(
+ env: *mut Env,
+ str_: *const c_char,
+ len: usize,
+) -> std::result::Result<v8::Local<'s, v8::String>, Error> {
+ return_status_if_false!(
+ env,
+ (len == NAPI_AUTO_LENGTH) || len <= INT_MAX as _,
+ napi_invalid_arg
+ );
+ return_status_if_false!(env, !str_.is_null(), napi_invalid_arg);
+ let string = if len == NAPI_AUTO_LENGTH {
+ let result = unsafe { std::ffi::CStr::from_ptr(str_ as *const _) }.to_str();
+ return_status_if_false!(env, result.is_ok(), napi_generic_failure);
+ result.unwrap()
+ } else {
+ let string = unsafe { std::slice::from_raw_parts(str_ as *const u8, len) };
+ let result = std::str::from_utf8(string);
+ return_status_if_false!(env, result.is_ok(), napi_generic_failure);
+ result.unwrap()
+ };
+ let result = {
+ let env = unsafe { &mut *env };
+ v8::String::new(&mut env.scope(), string)
+ };
+ return_status_if_false!(env, result.is_some(), napi_generic_failure);
+ Ok(result.unwrap())
+}
+
+#[inline]
+fn check_new_from_utf8<'s>(
+ env: *mut Env,
+ str_: *const c_char,
+) -> std::result::Result<v8::Local<'s, v8::String>, Error> {
+ check_new_from_utf8_len(env, str_, NAPI_AUTO_LENGTH)
+}
+
+#[macro_export]
+macro_rules! status_call {
+ ($call: expr) => {
+ let status = $call;
+ if status != napi_ok {
+ return Err(status.into());
+ }
+ };
+}
+
// Macro to check napi arguments.
// If nullptr, return Err(Error::InvalidArg).
#[macro_export]
macro_rules! check_arg {
- ($ptr: expr) => {
- if $ptr.is_null() {
- return Err(Error::InvalidArg);
- }
+ ($env: expr, $ptr: expr) => {
+ $crate::return_status_if_false!($env, !$ptr.is_null(), napi_invalid_arg);
};
}
macro_rules! check_arg_option {
- ($ptr: expr) => {
- if $ptr.is_none() {
- return Err(Error::InvalidArg);
- }
+ ($env: expr, $opt: expr) => {
+ $crate::return_status_if_false!($env, $opt.is_some(), napi_invalid_arg);
};
}
+fn napi_clear_last_error(env: *mut Env) {
+ let env = unsafe { &mut *env };
+ env.last_error.error_code = napi_ok;
+ env.last_error.engine_error_code = 0;
+ env.last_error.engine_reserved = std::ptr::null_mut();
+ env.last_error.error_message = std::ptr::null_mut();
+}
+
+pub(crate) fn napi_set_last_error(
+ env: *mut Env,
+ error_code: napi_status,
+ engine_error_code: i32,
+ engine_reserved: *mut c_void,
+) -> napi_status {
+ let env = unsafe { &mut *env };
+ env.last_error.error_code = error_code;
+ env.last_error.engine_error_code = engine_error_code;
+ env.last_error.engine_reserved = engine_reserved;
+ error_code
+}
+
/// Returns napi_value that represents a new JavaScript Array.
#[napi_sym::napi_sym]
fn napi_create_array(env: *mut Env, result: *mut napi_value) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, result);
+ let env = unsafe { &mut *env };
*result = v8::Array::new(&mut env.scope(), 0).into();
Ok(())
}
@@ -47,8 +143,9 @@ fn napi_create_array_with_length(
len: i32,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, result);
+ let env = unsafe { &mut *env };
*result = v8::Array::new(&mut env.scope(), len).into();
Ok(())
}
@@ -60,8 +157,9 @@ fn napi_create_arraybuffer(
data: *mut *mut u8,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, result);
+ let env = unsafe { &mut *env };
let value = v8::ArrayBuffer::new(&mut env.scope(), len);
if !data.is_null() {
@@ -78,8 +176,9 @@ fn napi_create_bigint_int64(
value: i64,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, result);
+ let env = unsafe { &mut *env };
*result = v8::BigInt::new_from_i64(&mut env.scope(), value).into();
Ok(())
}
@@ -90,8 +189,9 @@ fn napi_create_bigint_uint64(
value: u64,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, result);
+ let env = unsafe { &mut *env };
*result = v8::BigInt::new_from_u64(&mut env.scope(), value).into();
Ok(())
}
@@ -104,9 +204,10 @@ fn napi_create_bigint_words(
word_count: usize,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(words);
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, words);
+ let env = unsafe { &mut *env };
+ check_arg!(env, result);
if word_count > INT_MAX as _ {
return Err(Error::InvalidArg);
@@ -135,7 +236,8 @@ fn napi_create_buffer(
data: *mut *mut u8,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
let value = v8::ArrayBuffer::new(&mut env.scope(), len);
if !data.is_null() {
*data = get_array_buffer_ptr(value);
@@ -154,7 +256,8 @@ fn napi_create_buffer_copy(
result_data: *mut *mut u8,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
let value = v8::ArrayBuffer::new(&mut env.scope(), len);
let ptr = get_array_buffer_ptr(value);
std::ptr::copy(data, ptr, len);
@@ -173,8 +276,9 @@ fn napi_coerce_to_bool(
value: napi_value,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let coerced = value.to_boolean(&mut env.scope());
let value: v8::Local<v8::Value> = coerced.into();
*result = value.into();
@@ -187,8 +291,9 @@ fn napi_coerce_to_number(
value: napi_value,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let coerced = value
.to_number(&mut env.scope())
.ok_or(Error::NumberExpected)?;
@@ -203,8 +308,9 @@ fn napi_coerce_to_object(
value: napi_value,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let coerced = value.to_object(&mut env.scope()).unwrap();
let value: v8::Local<v8::Value> = coerced.into();
*result = value.into();
@@ -217,8 +323,9 @@ fn napi_coerce_to_string(
value: napi_value,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let coerced = value.to_string(&mut env.scope()).unwrap();
let value: v8::Local<v8::Value> = coerced.into();
*result = value.into();
@@ -233,9 +340,10 @@ fn napi_create_dataview(
byte_offset: usize,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(data);
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, data);
+ let env = unsafe { &mut *env };
+ check_arg!(env, result);
let value = v8::ArrayBuffer::new(&mut env.scope(), len);
if !data.is_null() {
*data = get_array_buffer_ptr(value);
@@ -264,7 +372,8 @@ fn napi_create_date(
time: f64,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
let value: v8::Local<v8::Value> =
v8::Date::new(&mut env.scope(), time).unwrap().into();
*result = value.into();
@@ -277,12 +386,49 @@ fn napi_create_double(
value: f64,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, result);
+ let env = unsafe { &mut *env };
*result = v8::Number::new(&mut env.scope(), value).into();
Ok(())
}
+fn set_error_code(
+ env: *mut Env,
+ error: v8::Local<v8::Value>,
+ code: napi_value,
+ code_cstring: *const c_char,
+) -> Result {
+ if code.is_some() || !code_cstring.is_null() {
+ let err_object: v8::Local<v8::Object> = error.try_into().unwrap();
+
+ let code_value: v8::Local<v8::Value> = if code.is_some() {
+ let mut code_value = unsafe { napi_value_unchecked(code) };
+ return_status_if_false!(
+ env,
+ code_value.is_string(),
+ napi_string_expected
+ );
+ code_value
+ } else {
+ let name = check_new_from_utf8(env, code_cstring)?;
+ name.into()
+ };
+
+ let mut scope = unsafe { &mut *env }.scope();
+ let code_key = v8::String::new(&mut scope, "code").unwrap();
+
+ if err_object
+ .set(&mut scope, code_key.into(), code_value)
+ .is_none()
+ {
+ return Err(napi_generic_failure.into());
+ }
+ }
+
+ Ok(())
+}
+
#[napi_sym::napi_sym]
fn napi_create_error(
env: *mut Env,
@@ -290,15 +436,62 @@ fn napi_create_error(
msg: napi_value,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
-
- let _code = transmute::<napi_value, v8::Local<v8::Value>>(code);
- let msg = transmute::<napi_value, v8::Local<v8::Value>>(msg);
+ check_env!(env);
+ check_arg_option!(env, msg);
+ check_arg!(env, result);
+ let mut message_value = napi_value_unchecked(msg);
+ return_status_if_false!(env, message_value.is_string(), napi_string_expected);
+ let error_obj = v8::Exception::error(
+ &mut unsafe { &mut *env }.scope(),
+ message_value.try_into().unwrap(),
+ );
+ set_error_code(env, error_obj, code, std::ptr::null())?;
+ *result = error_obj.into();
+ napi_clear_last_error(env);
+ Ok(())
+}
- let msg = msg.to_string(&mut env.scope()).unwrap();
- let error = v8::Exception::error(&mut env.scope(), msg);
- *result = error.into();
+#[napi_sym::napi_sym]
+fn napi_create_type_error(
+ env: *mut Env,
+ code: napi_value,
+ msg: napi_value,
+ result: *mut napi_value,
+) -> Result {
+ check_env!(env);
+ check_arg_option!(env, msg);
+ check_arg!(env, result);
+ let mut message_value = napi_value_unchecked(msg);
+ return_status_if_false!(env, message_value.is_string(), napi_string_expected);
+ let error_obj = v8::Exception::type_error(
+ &mut unsafe { &mut *env }.scope(),
+ message_value.try_into().unwrap(),
+ );
+ set_error_code(env, error_obj, code, std::ptr::null())?;
+ *result = error_obj.into();
+ napi_clear_last_error(env);
+ Ok(())
+}
+#[napi_sym::napi_sym]
+fn napi_create_range_error(
+ env: *mut Env,
+ code: napi_value,
+ msg: napi_value,
+ result: *mut napi_value,
+) -> Result {
+ check_env!(env);
+ check_arg_option!(env, msg);
+ check_arg!(env, result);
+ let mut message_value = napi_value_unchecked(msg);
+ return_status_if_false!(env, message_value.is_string(), napi_string_expected);
+ let error_obj = v8::Exception::range_error(
+ &mut unsafe { &mut *env }.scope(),
+ message_value.try_into().unwrap(),
+ );
+ set_error_code(env, error_obj, code, std::ptr::null())?;
+ *result = error_obj.into();
+ napi_clear_last_error(env);
Ok(())
}
@@ -310,7 +503,8 @@ fn napi_create_external(
_finalize_hint: *mut c_void,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
let value: v8::Local<v8::Value> =
v8::External::new(&mut env.scope(), value).into();
// TODO: finalization
@@ -351,7 +545,8 @@ fn napi_create_external_arraybuffer(
finalize_hint: *mut c_void,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
let _slice = std::slice::from_raw_parts(data as *mut u8, byte_length);
// TODO: finalization
let store: UniqueRef<BackingStore> =
@@ -378,7 +573,8 @@ fn napi_create_external_buffer(
_finalize_hint: *mut c_void,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
let slice = if byte_length == -1 {
std::ffi::CStr::from_ptr(data as *const _).to_bytes()
} else {
@@ -400,17 +596,17 @@ fn napi_create_external_buffer(
#[napi_sym::napi_sym]
fn napi_create_function(
- env_ptr: *mut Env,
+ env: *mut Env,
name: *const u8,
length: usize,
cb: napi_callback,
cb_info: napi_callback_info,
result: *mut napi_value,
) -> Result {
- let _: &mut Env = env_ptr.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
- check_arg_option!(cb);
- check_arg!(name);
+ check_env!(env);
+ check_arg!(env, result);
+ check_arg_option!(env, cb);
+ check_arg!(env, name);
if length > INT_MAX as _ {
return Err(Error::InvalidArg);
@@ -424,7 +620,7 @@ fn napi_create_function(
std::str::from_utf8_unchecked(name)
};
- *result = create_function(env_ptr, Some(name), cb, cb_info).into();
+ *result = create_function(env, Some(name), cb, cb_info).into();
Ok(())
}
@@ -434,8 +630,9 @@ fn napi_create_int32(
value: i32,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, result);
+ let env = unsafe { &mut *env };
*result = v8::Integer::new(&mut env.scope(), value).into();
Ok(())
}
@@ -446,8 +643,9 @@ fn napi_create_uint32(
value: u32,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, result);
+ let env = unsafe { &mut *env };
*result = v8::Integer::new_from_unsigned(&mut env.scope(), value).into();
Ok(())
}
@@ -458,15 +656,17 @@ fn napi_create_int64(
value: i64,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, result);
+ let env = unsafe { &mut *env };
*result = v8::Number::new(&mut env.scope(), value as f64).into();
Ok(())
}
#[napi_sym::napi_sym]
fn napi_create_object(env: *mut Env, result: *mut napi_value) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
let object = v8::Object::new(&mut env.scope());
*result = object.into();
Ok(())
@@ -478,7 +678,8 @@ fn napi_create_promise(
deferred: *mut napi_deferred,
promise_out: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
let resolver = v8::PromiseResolver::new(&mut env.scope()).unwrap();
let mut global = v8::Global::new(&mut env.scope(), resolver);
let mut global_ptr = global.into_raw();
@@ -490,35 +691,16 @@ fn napi_create_promise(
}
#[napi_sym::napi_sym]
-fn napi_create_range_error(
- env: *mut Env,
- _code: napi_value,
- msg: napi_value,
- result: *mut napi_value,
-) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
-
- // let code = transmute::<napi_value, v8::Local<v8::Value>>(code);
- let msg = transmute::<napi_value, v8::Local<v8::Value>>(msg);
-
- let msg = msg.to_string(&mut env.scope()).unwrap();
-
- let error = v8::Exception::range_error(&mut env.scope(), msg);
- *result = error.into();
-
- Ok(())
-}
-
-#[napi_sym::napi_sym]
fn napi_create_reference(
env: *mut Env,
value: napi_value,
_initial_refcount: u32,
result: *mut napi_ref,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
let global = v8::Global::new(&mut env.scope(), value);
let mut global_ptr = global.into_raw();
*result = transmute::<NonNull<v8::Value>, napi_ref>(global_ptr);
@@ -532,15 +714,17 @@ fn napi_create_string_latin1(
length: usize,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
if length > 0 {
- check_arg!(string);
- }
- check_arg!(result);
- let safe_len = (length == NAPI_AUTO_LENGTH) || length <= INT_MAX as _;
- if !safe_len {
- return Err(Error::InvalidArg);
+ check_arg!(env, string);
}
+ check_arg!(env, result);
+ return_status_if_false!(
+ env,
+ (length == NAPI_AUTO_LENGTH) || length <= INT_MAX as _,
+ napi_invalid_arg
+ );
let string = if length == NAPI_AUTO_LENGTH {
std::ffi::CStr::from_ptr(string as *const _)
@@ -571,15 +755,17 @@ fn napi_create_string_utf16(
length: usize,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
if length > 0 {
- check_arg!(string);
- }
- check_arg!(result);
- let safe_len = (length == NAPI_AUTO_LENGTH) || length <= INT_MAX as _;
- if !safe_len {
- return Err(Error::InvalidArg);
+ check_arg!(env, string);
}
+ check_arg!(env, result);
+ return_status_if_false!(
+ env,
+ (length == NAPI_AUTO_LENGTH) || length <= INT_MAX as _,
+ napi_invalid_arg
+ );
let string = if length == NAPI_AUTO_LENGTH {
let s = std::ffi::CStr::from_ptr(string as *const _)
@@ -610,15 +796,17 @@ fn napi_create_string_utf8(
length: usize,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
if length > 0 {
- check_arg!(string);
- }
- check_arg!(result);
- let safe_len = (length == NAPI_AUTO_LENGTH) || length <= INT_MAX as _;
- if !safe_len {
- return Err(Error::InvalidArg);
+ check_arg!(env, string);
}
+ check_arg!(env, result);
+ return_status_if_false!(
+ env,
+ (length == NAPI_AUTO_LENGTH) || length <= INT_MAX as _,
+ napi_invalid_arg
+ );
let string = if length == NAPI_AUTO_LENGTH {
std::ffi::CStr::from_ptr(string as *const _)
@@ -640,8 +828,9 @@ fn napi_create_symbol(
description: napi_value,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, result);
+ let env = unsafe { &mut *env };
let scope = &mut env.scope();
let description = description
@@ -655,26 +844,6 @@ fn napi_create_symbol(
}
#[napi_sym::napi_sym]
-fn napi_create_type_error(
- env: *mut Env,
- _code: napi_value,
- msg: napi_value,
- result: *mut napi_value,
-) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
-
- // let code = transmute::<napi_value, v8::Local<v8::Value>>(code);
- let msg = transmute::<napi_value, v8::Local<v8::Value>>(msg);
-
- let msg = msg.to_string(&mut env.scope()).unwrap();
-
- let error = v8::Exception::type_error(&mut env.scope(), msg);
- *result = error.into();
-
- Ok(())
-}
-
-#[napi_sym::napi_sym]
fn napi_create_typedarray(
env: *mut Env,
ty: napi_typedarray_type,
@@ -683,8 +852,9 @@ fn napi_create_typedarray(
byte_offset: usize,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let ab = transmute::<napi_value, v8::Local<v8::Value>>(arraybuffer);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let ab = napi_value_unchecked(arraybuffer);
let ab = v8::Local::<v8::ArrayBuffer>::try_from(ab).unwrap();
let typedarray: v8::Local<v8::Value> = match ty {
napi_uint8_array => {
@@ -760,18 +930,19 @@ fn napi_make_callback(
argv: *const napi_value,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg_option!(recv);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ check_arg_option!(env, recv);
if argc > 0 {
- check_arg!(argv);
+ check_arg!(env, argv);
}
if !async_context.is_null() {
log::info!("napi_make_callback: async_context is not supported");
}
- let recv = transmute::<napi_value, v8::Local<v8::Value>>(recv);
- let func = transmute::<napi_value, v8::Local<v8::Value>>(func);
+ let recv = napi_value_unchecked(recv);
+ let func = napi_value_unchecked(func);
let func = v8::Local::<v8::Function>::try_from(func)
.map_err(|_| Error::FunctionExpected)?;
@@ -788,8 +959,9 @@ fn napi_get_value_bigint_int64(
value: napi_value,
result: *mut i64,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let bigint = value.to_big_int(&mut env.scope()).unwrap();
*result = bigint.i64_value().0;
Ok(())
@@ -801,8 +973,9 @@ fn napi_get_value_bigint_uint64(
value: napi_value,
result: *mut u64,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let bigint = value.to_big_int(&mut env.scope()).unwrap();
*result = bigint.u64_value().0;
Ok(())
@@ -816,9 +989,10 @@ fn napi_get_value_bigint_words(
size: *mut usize,
out_words: *mut u64,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
let bigint = value.to_big_int(&mut env.scope()).unwrap();
let out_words = std::slice::from_raw_parts_mut(out_words, *size);
@@ -839,8 +1013,9 @@ fn napi_get_value_bool(
value: napi_value,
result: *mut bool,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
*result = value.boolean_value(&mut env.scope());
Ok(())
}
@@ -851,8 +1026,10 @@ fn napi_get_value_double(
value: napi_value,
result: *mut f64,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
+ return_status_if_false!(env, value.is_number(), napi_number_expected);
*result = value.number_value(&mut env.scope()).unwrap();
Ok(())
}
@@ -863,7 +1040,7 @@ fn napi_get_value_external(
value: napi_value,
result: *mut *mut c_void,
) -> Result {
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
let ext = v8::Local::<v8::External>::try_from(value).unwrap();
*result = ext.value();
Ok(())
@@ -875,8 +1052,9 @@ fn napi_get_value_int32(
value: napi_value,
result: *mut i32,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
*result = value.int32_value(&mut env.scope()).unwrap();
Ok(())
}
@@ -887,8 +1065,9 @@ fn napi_get_value_int64(
value: napi_value,
result: *mut i64,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
*result = value.integer_value(&mut env.scope()).unwrap();
Ok(())
}
@@ -901,9 +1080,10 @@ fn napi_get_value_string_latin1(
bufsize: usize,
result: *mut usize,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
if !value.is_string() && !value.is_string_object() {
return Err(Error::StringExpected);
@@ -941,9 +1121,10 @@ fn napi_get_value_string_utf8(
bufsize: usize,
result: *mut usize,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
if !value.is_string() && !value.is_string_object() {
return Err(Error::StringExpected);
@@ -982,9 +1163,10 @@ fn napi_get_value_string_utf16(
bufsize: usize,
result: *mut usize,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
if !value.is_string() && !value.is_string_object() {
return Err(Error::StringExpected);
@@ -1020,8 +1202,9 @@ fn napi_get_value_uint32(
value: napi_value,
result: *mut u32,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
*result = value.uint32_value(&mut env.scope()).unwrap();
Ok(())
}
@@ -1046,7 +1229,8 @@ fn napi_adjust_external_memory(
change_in_bytes: i64,
adjusted_value: &mut i64,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
let isolate = &mut *env.isolate_ptr;
*adjusted_value =
isolate.adjust_amount_of_external_allocated_memory(change_in_bytes);
@@ -1062,9 +1246,10 @@ fn napi_call_function(
argv: *const napi_value,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let recv = transmute::<napi_value, v8::Local<v8::Value>>(recv);
- let func = transmute::<napi_value, v8::Local<v8::Value>>(func);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let recv = napi_value_unchecked(recv);
+ let func = napi_value_unchecked(func);
let func = v8::Local::<v8::Function>::try_from(func)
.map_err(|_| Error::FunctionExpected)?;
@@ -1111,11 +1296,11 @@ fn napi_define_class(
result: *mut napi_value,
) -> Result {
let env: &mut Env = env_ptr.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
- check_arg_option!(constructor);
+ check_arg!(env, result);
+ check_arg_option!(env, constructor);
if property_count > 0 {
- check_arg!(properties);
+ check_arg!(env, properties);
}
let name = if length == -1 {
@@ -1276,8 +1461,9 @@ fn napi_delete_element(
index: u32,
result: *mut bool,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let obj = value.to_object(&mut env.scope()).unwrap();
*result = obj.delete_index(&mut env.scope(), index).unwrap_or(false);
Ok(())
@@ -1290,9 +1476,10 @@ fn napi_delete_property(
key: napi_value,
result: *mut bool,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg_option!(key);
- check_arg!(result);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ check_arg_option!(env, key);
+ check_arg!(env, result);
let scope = &mut env.scope();
let object = object
@@ -1315,7 +1502,7 @@ fn napi_delete_reference(env: *mut Env, _nref: napi_ref) -> Result {
#[napi_sym::napi_sym]
fn napi_detach_arraybuffer(_env: *mut Env, value: napi_value) -> Result {
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
let ab = v8::Local::<v8::ArrayBuffer>::try_from(value).unwrap();
ab.detach(None);
Ok(())
@@ -1344,7 +1531,8 @@ fn napi_get_and_clear_last_exception(
env: *mut Env,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
// TODO: just return undefined for now we don't cache
// exceptions in env.
let value: v8::Local<v8::Value> = v8::undefined(&mut env.scope()).into();
@@ -1358,7 +1546,7 @@ fn napi_get_array_length(
value: napi_value,
result: *mut u32,
) -> Result {
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
*result = v8::Local::<v8::Array>::try_from(value).unwrap().length();
Ok(())
}
@@ -1370,7 +1558,7 @@ fn napi_get_arraybuffer_info(
data: *mut *mut u8,
length: *mut usize,
) -> Result {
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
let buf = v8::Local::<v8::ArrayBuffer>::try_from(value).unwrap();
if !data.is_null() {
*data = get_array_buffer_ptr(buf);
@@ -1387,8 +1575,9 @@ fn napi_get_boolean(
value: bool,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, result);
+ let env = unsafe { &mut *env };
*result = v8::Boolean::new(env.isolate(), value).into();
Ok(())
}
@@ -1400,8 +1589,9 @@ fn napi_get_buffer_info(
data: *mut *mut u8,
length: *mut usize,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let buf = v8::Local::<v8::Uint8Array>::try_from(value).unwrap();
let buffer_name = v8::String::new(&mut env.scope(), "buffer").unwrap();
let abuf = v8::Local::<v8::ArrayBuffer>::try_from(
@@ -1427,7 +1617,7 @@ fn napi_get_cb_info(
cb_data: *mut *mut c_void,
) -> Result {
let _: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(cbinfo);
+ check_arg!(env, cbinfo);
let cbinfo: &CallbackInfo = &*(cbinfo as *const CallbackInfo);
let args = &*(cbinfo.args as *const v8::FunctionCallbackArguments);
@@ -1465,8 +1655,9 @@ fn napi_get_dataview_info(
data: *mut *mut u8,
length: *mut usize,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let buf = v8::Local::<v8::DataView>::try_from(value).unwrap();
let buffer_name = v8::String::new(&mut env.scope(), "buffer").unwrap();
let abuf = v8::Local::<v8::ArrayBuffer>::try_from(
@@ -1486,14 +1677,12 @@ fn napi_get_date_value(
value: napi_value,
result: *mut f64,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
-
- if !value.is_date() {
- return Err(Error::DateExpected);
- }
-
+ check_env!(env);
+ let value = napi_value_unchecked(value);
+ return_status_if_false!(env, value.is_date(), napi_date_expected);
+ let env = unsafe { &mut *env };
let date = v8::Local::<v8::Date>::try_from(value).unwrap();
+ // TODO: should be value of
*result = date.number_value(&mut env.scope()).unwrap();
Ok(())
}
@@ -1505,8 +1694,9 @@ fn napi_get_element(
index: u32,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let object = transmute::<napi_value, v8::Local<v8::Value>>(object);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let object = napi_value_unchecked(object);
let array = v8::Local::<v8::Array>::try_from(object).unwrap();
let value: v8::Local<v8::Value> =
array.get_index(&mut env.scope(), index).unwrap();
@@ -1516,7 +1706,8 @@ fn napi_get_element(
#[napi_sym::napi_sym]
fn napi_get_global(env: *mut Env, result: *mut napi_value) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
let context = &mut env.scope().get_current_context();
let global = context.global(&mut env.scope());
@@ -1533,6 +1724,7 @@ fn napi_get_instance_data(env: *mut Env, result: *mut *mut c_void) -> Result {
Ok(())
}
+// TODO(bartlomieju): this function is broken
#[napi_sym::napi_sym]
fn napi_get_last_error_info(
_env: *mut Env,
@@ -1542,7 +1734,7 @@ fn napi_get_last_error_info(
error_message: std::ptr::null(),
engine_reserved: std::ptr::null_mut(),
engine_error_code: 0,
- status_code: napi_ok,
+ error_code: napi_ok,
});
*error_code = Box::into_raw(err_info);
@@ -1556,8 +1748,9 @@ fn napi_get_named_property(
utf8_name: *const c_char,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let object = transmute::<napi_value, v8::Local<v8::Value>>(object);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let object = napi_value_unchecked(object);
let utf8_name = std::ffi::CStr::from_ptr(utf8_name);
let name =
v8::String::new(&mut env.scope(), &utf8_name.to_string_lossy()).unwrap();
@@ -1583,8 +1776,9 @@ fn napi_get_new_target(
#[napi_sym::napi_sym]
fn napi_get_null(env: *mut Env, result: *mut napi_value) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, result);
+ let env = unsafe { &mut *env };
*result = v8::null(env.isolate()).into();
Ok(())
}
@@ -1596,9 +1790,10 @@ fn napi_get_property(
key: napi_value,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
let object = transmute::<napi_value, v8::Local<v8::Object>>(object);
- let key = transmute::<napi_value, v8::Local<v8::Value>>(key);
+ let key = napi_value_unchecked(key);
let value: v8::Local<v8::Value> = object.get(&mut env.scope(), key).unwrap();
*result = value.into();
Ok(())
@@ -1610,8 +1805,9 @@ fn napi_get_property_names(
object: napi_value,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let object = transmute::<napi_value, v8::Local<v8::Value>>(object);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let object = napi_value_unchecked(object);
let array: v8::Local<v8::Array> = object
.to_object(&mut env.scope())
.unwrap()
@@ -1628,8 +1824,9 @@ fn napi_get_prototype(
value: napi_value,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let obj = value.to_object(&mut env.scope()).unwrap();
let proto = obj.get_prototype(&mut env.scope()).unwrap();
*result = proto.into();
@@ -1660,8 +1857,9 @@ fn napi_get_typedarray_info(
arraybuffer: *mut napi_value,
byte_offset: *mut usize,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(typedarray);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(typedarray);
let array = v8::Local::<v8::TypedArray>::try_from(value)
.ok()
.ok_or(Error::InvalidArg)?;
@@ -1711,8 +1909,9 @@ fn napi_get_typedarray_info(
#[napi_sym::napi_sym]
fn napi_get_undefined(env: *mut Env, result: *mut napi_value) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg!(result);
+ check_env!(env);
+ check_arg!(env, result);
+ let env = unsafe { &mut *env };
*result = v8::undefined(env.isolate()).into();
Ok(())
}
@@ -1732,8 +1931,9 @@ fn napi_has_element(
index: u32,
result: *mut bool,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let obj = value.to_object(&mut env.scope()).unwrap();
*result = obj.has_index(&mut env.scope(), index).unwrap_or(false);
Ok(())
@@ -1746,8 +1946,9 @@ fn napi_has_named_property(
key: *const c_char,
result: *mut bool,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let obj = value.to_object(&mut env.scope()).unwrap();
let key = CStr::from_ptr(key).to_str().unwrap();
let key = v8::String::new(&mut env.scope(), key).unwrap();
@@ -1762,9 +1963,10 @@ fn napi_has_own_property(
key: napi_value,
result: *mut bool,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg_option!(key);
- check_arg!(result);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ check_arg_option!(env, key);
+ check_arg!(env, result);
let scope = &mut env.scope();
let object = object
@@ -1791,9 +1993,10 @@ fn napi_has_property(
key: napi_value,
result: *mut bool,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg_option!(key);
- check_arg!(result);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ check_arg_option!(env, key);
+ check_arg!(env, result);
let scope = &mut env.scope();
let object = object
@@ -1814,12 +2017,13 @@ fn napi_instanceof(
constructor: napi_value,
result: *mut bool,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg_option!(constructor);
- check_arg_option!(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ check_arg_option!(env, constructor);
+ check_arg_option!(env, value);
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
- let constructor = transmute::<napi_value, v8::Local<v8::Value>>(constructor);
+ let value = napi_value_unchecked(value);
+ let constructor = napi_value_unchecked(constructor);
let ctor = constructor
.to_object(&mut env.scope())
.ok_or(Error::ObjectExpected)?;
@@ -1842,7 +2046,7 @@ fn napi_is_array(
value: napi_value,
result: *mut bool,
) -> Result {
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
*result = value.is_array();
Ok(())
}
@@ -1853,7 +2057,7 @@ fn napi_is_arraybuffer(
value: napi_value,
result: *mut bool,
) -> Result {
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
*result = value.is_array_buffer();
Ok(())
}
@@ -1864,7 +2068,7 @@ fn napi_is_buffer(
value: napi_value,
result: *mut bool,
) -> Result {
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
// TODO: should we assume Buffer as Uint8Array in Deno?
// or use std/node polyfill?
*result = value.is_typed_array();
@@ -1877,7 +2081,7 @@ fn napi_is_dataview(
value: napi_value,
result: *mut bool,
) -> Result {
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
*result = value.is_data_view();
Ok(())
}
@@ -1888,7 +2092,7 @@ fn napi_is_date(
value: napi_value,
result: *mut bool,
) -> Result {
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
*result = value.is_date();
Ok(())
}
@@ -1899,7 +2103,7 @@ fn napi_is_detached_arraybuffer(
value: napi_value,
result: *mut bool,
) -> Result {
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
let _ab = v8::Local::<v8::ArrayBuffer>::try_from(value).unwrap();
*result = _ab.was_detached();
Ok(())
@@ -1907,13 +2111,20 @@ fn napi_is_detached_arraybuffer(
#[napi_sym::napi_sym]
fn napi_is_error(
- _env: *mut Env,
+ env: *mut Env,
value: napi_value,
result: *mut bool,
) -> Result {
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
- // TODO
- *result = value.is_object();
+ {
+ // TODO(bartlomieju): add `check_env!` macro?
+ let _env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ value.ok_or(Error::InvalidArg)?;
+ check_arg!(env, result);
+
+ let value = napi_value_unchecked(value);
+ *result = value.is_native_error();
+ }
+ napi_clear_last_error(env);
Ok(())
}
@@ -1931,7 +2142,7 @@ fn napi_is_promise(
value: napi_value,
result: *mut bool,
) -> Result {
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
*result = value.is_promise();
Ok(())
}
@@ -1942,7 +2153,7 @@ fn napi_is_typedarray(
value: napi_value,
result: *mut bool,
) -> Result {
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
*result = value.is_typed_array();
Ok(())
}
@@ -1955,8 +2166,9 @@ fn napi_new_instance(
argv: *const napi_value,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let constructor = transmute::<napi_value, v8::Local<v8::Value>>(constructor);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let constructor = napi_value_unchecked(constructor);
let constructor = v8::Local::<v8::Function>::try_from(constructor).unwrap();
let args: &[v8::Local<v8::Value>] =
transmute(std::slice::from_raw_parts(argv, argc));
@@ -2029,7 +2241,8 @@ fn napi_reject_deferred(
deferred: napi_deferred,
error: napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
let deferred_ptr =
NonNull::new_unchecked(deferred as *mut v8::PromiseResolver);
@@ -2042,18 +2255,16 @@ fn napi_reject_deferred(
v8::Local<v8::PromiseResolver>,
>(deferred_ptr);
resolver
- .reject(
- &mut env.scope(),
- transmute::<napi_value, v8::Local<v8::Value>>(error),
- )
+ .reject(&mut env.scope(), napi_value_unchecked(error))
.unwrap();
Ok(())
}
#[napi_sym::napi_sym]
fn napi_remove_wrap(env: *mut Env, value: napi_value) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let obj = value.to_object(&mut env.scope()).unwrap();
let shared = &*(env.shared as *const EnvShared);
let napi_wrap = v8::Local::new(&mut env.scope(), &shared.napi_wrap);
@@ -2067,7 +2278,8 @@ fn napi_resolve_deferred(
deferred: napi_deferred,
result: napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
let deferred_ptr =
NonNull::new_unchecked(deferred as *mut v8::PromiseResolver);
// TODO(@littledivy): Use Global::from_raw instead casting to local.
@@ -2079,10 +2291,7 @@ fn napi_resolve_deferred(
v8::Local<v8::PromiseResolver>,
>(deferred_ptr);
resolver
- .resolve(
- &mut env.scope(),
- transmute::<napi_value, v8::Local<v8::Value>>(result),
- )
+ .resolve(&mut env.scope(), napi_value_unchecked(result))
.unwrap();
Ok(())
}
@@ -2093,10 +2302,13 @@ fn napi_run_script(
script: napi_value,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
- let script = transmute::<napi_value, v8::Local<v8::Value>>(script);
+ let script = napi_value_unchecked(script);
if !script.is_string() {
+ // TODO:
+ // napi_set_last_error
return Err(Error::StringExpected);
}
let script = script.to_string(&mut env.scope()).unwrap();
@@ -2124,10 +2336,11 @@ fn napi_set_element(
index: u32,
value: napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let object = transmute::<napi_value, v8::Local<v8::Value>>(object);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let object = napi_value_unchecked(object);
let array = v8::Local::<v8::Array>::try_from(object).unwrap();
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
array.set_index(&mut env.scope(), index, value).unwrap();
Ok(())
}
@@ -2158,10 +2371,11 @@ fn napi_set_named_property(
name: *const c_char,
value: napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
let name = CStr::from_ptr(name).to_str().unwrap();
let object = transmute::<napi_value, v8::Local<v8::Object>>(object);
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ let value = napi_value_unchecked(value);
let name = v8::String::new(&mut env.scope(), name).unwrap();
object.set(&mut env.scope(), name.into(), value).unwrap();
Ok(())
@@ -2174,9 +2388,10 @@ fn napi_set_property(
key: napi_value,
value: napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg_option!(key);
- check_arg_option!(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ check_arg_option!(env, key);
+ check_arg_option!(env, value);
let scope = &mut env.scope();
let object = object
@@ -2199,8 +2414,8 @@ fn napi_strict_equals(
result: *mut bool,
) -> Result {
let _: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg_option!(lhs);
- check_arg_option!(rhs);
+ check_arg_option!(env, lhs);
+ check_arg_option!(env, rhs);
*result = lhs.unwrap_unchecked().strict_equals(rhs.unwrap_unchecked());
Ok(())
@@ -2208,8 +2423,9 @@ fn napi_strict_equals(
#[napi_sym::napi_sym]
fn napi_throw(env: *mut Env, error: napi_value) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let error = transmute::<napi_value, v8::Local<v8::Value>>(error);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let error = napi_value_unchecked(error);
env.scope().throw_exception(error);
Ok(())
}
@@ -2217,60 +2433,86 @@ fn napi_throw(env: *mut Env, error: napi_value) -> Result {
#[napi_sym::napi_sym]
fn napi_throw_error(
env: *mut Env,
- _code: *const c_char,
+ code: *const c_char,
msg: *const c_char,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ // TODO: add preamble here
- // let code = CStr::from_ptr(code).to_str().unwrap();
- let msg = CStr::from_ptr(msg).to_str().unwrap();
-
- // let code = v8::String::new(&mut env.scope(), code).unwrap();
- let msg = v8::String::new(&mut env.scope(), msg).unwrap();
-
- let error = v8::Exception::error(&mut env.scope(), msg);
- env.scope().throw_exception(error);
+ {
+ check_env!(env);
+ let str_ = check_new_from_utf8(env, msg)?;
+ let error = {
+ let env = unsafe { &mut *env };
+ let scope = &mut env.scope();
+ v8::Exception::error(scope, str_)
+ };
+ set_error_code(
+ env,
+ error,
+ transmute::<*mut (), napi_value>(std::ptr::null_mut()),
+ code,
+ )?;
+
+ unsafe { &mut *env }.scope().throw_exception(error);
+ }
+ napi_clear_last_error(env);
Ok(())
}
#[napi_sym::napi_sym]
fn napi_throw_range_error(
env: *mut Env,
- _code: *const c_char,
+ code: *const c_char,
msg: *const c_char,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
-
- // let code = CStr::from_ptr(code).to_str().unwrap();
- let msg = CStr::from_ptr(msg).to_str().unwrap();
-
- // let code = v8::String::new(&mut env.scope(), code).unwrap();
- let msg = v8::String::new(&mut env.scope(), msg).unwrap();
-
- let error = v8::Exception::range_error(&mut env.scope(), msg);
- env.scope().throw_exception(error);
+ // TODO: add preamble here
+ {
+ check_env!(env);
+ let str_ = check_new_from_utf8(env, msg)?;
+ let error = {
+ let env = unsafe { &mut *env };
+ let scope = &mut env.scope();
+ v8::Exception::range_error(scope, str_)
+ };
+ set_error_code(
+ env,
+ error,
+ transmute::<*mut (), napi_value>(std::ptr::null_mut()),
+ code,
+ )?;
+ unsafe { &mut *env }.scope().throw_exception(error);
+ }
+ napi_clear_last_error(env);
Ok(())
}
#[napi_sym::napi_sym]
fn napi_throw_type_error(
env: *mut Env,
- _code: *const c_char,
+ code: *const c_char,
msg: *const c_char,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
-
- // let code = CStr::from_ptr(code).to_str().unwrap();
- let msg = CStr::from_ptr(msg).to_str().unwrap();
-
- // let code = v8::String::new(&mut env.scope(), code).unwrap();
- let msg = v8::String::new(&mut env.scope(), msg).unwrap();
-
- let error = v8::Exception::type_error(&mut env.scope(), msg);
- env.scope().throw_exception(error);
+ // TODO: add preamble here
+ {
+ check_env!(env);
+ let str_ = check_new_from_utf8(env, msg)?;
+ let error = {
+ let env = unsafe { &mut *env };
+ let scope = &mut env.scope();
+ v8::Exception::type_error(scope, str_)
+ };
+ set_error_code(
+ env,
+ error,
+ transmute::<*mut (), napi_value>(std::ptr::null_mut()),
+ code,
+ )?;
+ unsafe { &mut *env }.scope().throw_exception(error);
+ }
+ napi_clear_last_error(env);
Ok(())
}
@@ -2306,9 +2548,9 @@ fn napi_typeof(
value: napi_value,
result: *mut napi_valuetype,
) -> Result {
- let _: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- check_arg_option!(value);
- check_arg!(result);
+ check_env!(env);
+ check_arg_option!(env, value);
+ check_arg!(env, result);
match get_value_type(value.unwrap()) {
Some(ty) => {
*result = ty;
@@ -2327,8 +2569,9 @@ fn napi_unwrap(
value: napi_value,
result: *mut *mut c_void,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let obj = value.to_object(&mut env.scope()).unwrap();
let shared = &*(env.shared as *const EnvShared);
let napi_wrap = v8::Local::new(&mut env.scope(), &shared.napi_wrap);
@@ -2346,8 +2589,9 @@ fn napi_wrap(
value: napi_value,
native_object: *mut c_void,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
- let value = transmute::<napi_value, v8::Local<v8::Value>>(value);
+ check_env!(env);
+ let env = unsafe { &mut *env };
+ let value = napi_value_unchecked(value);
let obj = value.to_object(&mut env.scope()).unwrap();
let shared = &*(env.shared as *const EnvShared);
let napi_wrap = v8::Local::new(&mut env.scope(), &shared.napi_wrap);
@@ -2362,7 +2606,8 @@ fn node_api_throw_syntax_error(
_code: *const c_char,
msg: *const c_char,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
// let code = CStr::from_ptr(code).to_str().unwrap();
let msg = CStr::from_ptr(msg).to_str().unwrap();
@@ -2383,10 +2628,11 @@ fn node_api_create_syntax_error(
msg: napi_value,
result: *mut napi_value,
) -> Result {
- let env: &mut Env = env.as_mut().ok_or(Error::InvalidArg)?;
+ check_env!(env);
+ let env = unsafe { &mut *env };
- // let code = transmute::<napi_value, v8::Local<v8::Value>>(code);
- let msg = transmute::<napi_value, v8::Local<v8::Value>>(msg);
+ // let code = napi_value_unchecked(code);
+ let msg = napi_value_unchecked(msg);
let msg = msg.to_string(&mut env.scope()).unwrap();
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-27 08:51:51 +0000