use std::convert::TryInto;
use std::mem::MaybeUninit;
use std::ptr::null;
use crate::support::int;
use crate::support::MapFnFrom;
use crate::support::MapFnTo;
use crate::support::MaybeBool;
use crate::support::ToCFn;
use crate::support::UnitType;
use crate::Context;
use crate::HandleScope;
use crate::Local;
use crate::Module;
use crate::String;
use crate::Value;
#[cfg(not(target_os = "windows"))]
pub type ResolveCallback<'a> = extern "C" fn(
Local<'a, Context>,
Local<'a, String>,
Local<'a, Module>,
) -> *const Module;
#[cfg(target_os = "windows")]
pub type ResolveCallback<'a> = extern "C" fn(
*mut *const Module,
Local<'a, Context>,
Local<'a, String>,
Local<'a, Module>,
) -> *mut *const Module;
impl<'a, F> MapFnFrom<F> for ResolveCallback<'a>
where
F: UnitType
+ Fn(
Local<'a, Context>,
Local<'a, String>,
Local<'a, Module>,
) -> Option<Local<'a, Module>>,
{
#[cfg(not(target_os = "windows"))]
fn mapping() -> Self {
let f = |context, specifier, referrer| {
(F::get())(context, specifier, referrer)
.map(|r| -> *const Module { &*r })
.unwrap_or(null())
};
f.to_c_fn()
}
#[cfg(target_os = "windows")]
fn mapping() -> Self {
let f = |ret_ptr, context, specifier, referrer| {
let r = (F::get())(context, specifier, referrer)
.map(|r| -> *const Module { &*r })
.unwrap_or(null());
unsafe { std::ptr::write(ret_ptr, r) }; ret_ptr };
f.to_c_fn()
}
}
extern "C" {
fn v8__Module__GetStatus(this: *const Module) -> ModuleStatus;
fn v8__Module__GetException(this: *const Module) -> *const Value;
fn v8__Module__GetModuleRequestsLength(this: *const Module) -> int;
fn v8__Module__GetModuleRequest(this: *const Module, i: int)
-> *const String;
fn v8__Module__GetModuleRequestLocation(
this: *const Module,
i: int,
out: *mut MaybeUninit<Location>,
) -> Location;
fn v8__Module__GetModuleNamespace(this: *const Module) -> *const Value;
fn v8__Module__GetIdentityHash(this: *const Module) -> int;
fn v8__Module__InstantiateModule(
this: *const Module,
context: *const Context,
cb: ResolveCallback,
) -> MaybeBool;
fn v8__Module__Evaluate(
this: *const Module,
context: *const Context,
) -> *const Value;
fn v8__Location__GetLineNumber(this: *const Location) -> int;
fn v8__Location__GetColumnNumber(this: *const Location) -> int;
}
#[repr(C)]
pub struct Location([usize; 1]);
impl Location {
pub fn get_line_number(&self) -> int {
unsafe { v8__Location__GetLineNumber(self) }
}
pub fn get_column_number(&self) -> int {
unsafe { v8__Location__GetColumnNumber(self) }
}
}
#[derive(Debug, PartialEq)]
#[repr(C)]
pub enum ModuleStatus {
Uninstantiated,
Instantiating,
Instantiated,
Evaluating,
Evaluated,
Errored,
}
impl Module {
pub fn get_status(&self) -> ModuleStatus {
unsafe { v8__Module__GetStatus(self) }
}
pub fn get_exception(&self) -> Local<Value> {
unsafe { Local::from_raw(v8__Module__GetException(self)) }.unwrap()
}
pub fn get_module_requests_length(&self) -> usize {
unsafe { v8__Module__GetModuleRequestsLength(self) }
.try_into()
.unwrap()
}
pub fn get_module_request(&self, i: usize) -> Local<String> {
unsafe {
Local::from_raw(v8__Module__GetModuleRequest(self, i.try_into().unwrap()))
}
.unwrap()
}
pub fn get_module_request_location(&self, i: usize) -> Location {
let mut out = MaybeUninit::<Location>::uninit();
unsafe {
v8__Module__GetModuleRequestLocation(
self,
i.try_into().unwrap(),
&mut out,
);
out.assume_init()
}
}
pub fn get_identity_hash(&self) -> int {
unsafe { v8__Module__GetIdentityHash(self) }
}
pub fn get_module_namespace(&self) -> Local<Value> {
unsafe { Local::from_raw(v8__Module__GetModuleNamespace(self)).unwrap() }
}
#[must_use]
pub fn instantiate_module<'a>(
&self,
scope: &mut HandleScope,
callback: impl MapFnTo<ResolveCallback<'a>>,
) -> Option<bool> {
unsafe {
v8__Module__InstantiateModule(
self,
&*scope.get_current_context(),
callback.map_fn_to(),
)
}
.into()
}
#[must_use]
pub fn evaluate<'s>(
&self,
scope: &mut HandleScope<'s>,
) -> Option<Local<'s, Value>> {
unsafe {
scope
.cast_local(|sd| v8__Module__Evaluate(&*self, sd.get_current_context()))
}
}
}