use once_cell::sync::Lazy;
use std::ffi::CStr;
use std::ffi::CString;
use std::sync::Mutex;
use std::vec::Vec;
use crate::platform::Platform;
use crate::support::char;
use crate::support::int;
use crate::support::SharedRef;
use crate::support::UnitType;
extern "C" {
fn v8__V8__SetFlagsFromCommandLine(
argc: *mut int,
argv: *mut *mut char,
usage: *const char,
);
fn v8__V8__SetFlagsFromString(flags: *const u8, length: usize);
fn v8__V8__SetEntropySource(callback: EntropySource);
fn v8__V8__GetVersion() -> *const char;
fn v8__V8__InitializePlatform(platform: *mut Platform);
fn v8__V8__Initialize();
fn v8__V8__Dispose() -> bool;
fn v8__V8__DisposePlatform();
}
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct EntropySource(RawEntropySource);
pub trait IntoEntropySource:
UnitType + Into<EntropySource> + FnOnce(&mut [u8]) -> bool
{
}
impl<F> IntoEntropySource for F where
F: UnitType + Into<EntropySource> + FnOnce(&mut [u8]) -> bool
{
}
type RawEntropySource = extern "C" fn(*mut u8, usize) -> bool;
impl<F> From<F> for EntropySource
where
F: UnitType + FnOnce(&mut [u8]) -> bool,
{
fn from(_: F) -> Self {
#[inline(always)]
extern "C" fn adapter<F: IntoEntropySource>(
buffer: *mut u8,
length: usize,
) -> bool {
let buffer = unsafe { std::slice::from_raw_parts_mut(buffer, length) };
(F::get())(buffer)
}
Self(adapter::<F>)
}
}
#[derive(Debug)]
enum GlobalState {
Uninitialized,
PlatformInitialized(SharedRef<Platform>),
Initialized(SharedRef<Platform>),
Disposed(#[allow(dead_code)] SharedRef<Platform>),
PlatformShutdown,
}
use GlobalState::*;
static GLOBAL_STATE: Lazy<Mutex<GlobalState>> =
Lazy::new(|| Mutex::new(Uninitialized));
pub fn assert_initialized() {
let global_state_guard = GLOBAL_STATE.lock().unwrap();
match *global_state_guard {
Initialized(_) => {}
_ => panic!("Invalid global state"),
};
}
pub fn set_flags_from_command_line(args: Vec<String>) -> Vec<String> {
set_flags_from_command_line_with_usage(args, None)
}
pub fn set_flags_from_command_line_with_usage(
args: Vec<String>,
usage: Option<&str>,
) -> Vec<String> {
let mut raw_argv = args
.iter()
.map(|arg| CString::new(arg.as_str()).unwrap().into_bytes_with_nul())
.collect::<Vec<_>>();
let mut c_argv = raw_argv
.iter_mut()
.map(|arg| arg.as_mut_ptr() as *mut char)
.collect::<Vec<_>>();
let mut c_argv_len = c_argv.len() as int;
let c_usage = match usage {
Some(str) => CString::new(str).unwrap().into_raw() as *const char,
None => std::ptr::null(),
};
unsafe {
v8__V8__SetFlagsFromCommandLine(
&mut c_argv_len,
c_argv.as_mut_ptr(),
c_usage,
);
};
c_argv.truncate(c_argv_len as usize);
c_argv
.iter()
.map(|ptr| unsafe {
let cstr = CStr::from_ptr(*ptr as *const char);
let slice = cstr.to_str().unwrap();
slice.to_string()
})
.collect()
}
pub fn set_flags_from_string(flags: &str) {
unsafe {
v8__V8__SetFlagsFromString(flags.as_ptr(), flags.len());
}
}
pub fn set_entropy_source(
callback: impl UnitType + Into<EntropySource> + FnOnce(&mut [u8]) -> bool,
) {
unsafe { v8__V8__SetEntropySource(callback.into()) };
}
pub fn get_version() -> &'static str {
let version = unsafe { v8__V8__GetVersion() };
let c_str = unsafe { CStr::from_ptr(version) };
c_str.to_str().unwrap()
}
pub fn initialize_platform(platform: SharedRef<Platform>) {
let mut global_state_guard = GLOBAL_STATE.lock().unwrap();
*global_state_guard = match *global_state_guard {
Uninitialized => PlatformInitialized(platform.clone()),
_ => panic!("Invalid global state"),
};
{
unsafe {
v8__V8__InitializePlatform(&*platform as *const Platform as *mut _)
};
}
}
pub fn initialize() {
let mut global_state_guard = GLOBAL_STATE.lock().unwrap();
*global_state_guard = match *global_state_guard {
PlatformInitialized(ref platform) => Initialized(platform.clone()),
_ => panic!("Invalid global state"),
};
unsafe { v8__V8__Initialize() }
}
pub fn get_current_platform() -> SharedRef<Platform> {
let global_state_guard = GLOBAL_STATE.lock().unwrap();
match *global_state_guard {
Initialized(ref platform) => platform.clone(),
_ => panic!("Invalid global state"),
}
}
pub unsafe fn dispose() -> bool {
let mut global_state_guard = GLOBAL_STATE.lock().unwrap();
*global_state_guard = match *global_state_guard {
Initialized(ref platform) => Disposed(platform.clone()),
_ => panic!("Invalid global state"),
};
assert!(v8__V8__Dispose());
true
}
pub fn dispose_platform() {
let mut global_state_guard = GLOBAL_STATE.lock().unwrap();
*global_state_guard = match *global_state_guard {
Disposed(_) => {
unsafe { v8__V8__DisposePlatform() };
PlatformShutdown
}
_ => panic!("Invalid global state"),
};
}