use libc::c_char;
use libc::c_int;
use std::ffi::CStr;
use std::ffi::CString;
use std::sync::Mutex;
use std::vec::Vec;
use crate::platform::Platform;
use crate::support::UniqueRef;
extern "C" {
fn v8__V8__SetFlagsFromCommandLine(argc: *mut c_int, argv: *mut *mut c_char);
fn v8__V8__GetVersion() -> *const c_char;
fn v8__V8__InitializePlatform(platform: *mut Platform);
fn v8__V8__Initialize();
fn v8__V8__Dispose() -> bool;
fn v8__V8__ShutdownPlatform();
}
#[derive(Debug, Eq, PartialEq)]
enum GlobalState {
Uninitialized,
PlatformInitialized,
Initialized,
Disposed,
PlatformShutdown,
}
use GlobalState::*;
lazy_static! {
static ref GLOBAL_STATE: Mutex<GlobalState> =
Mutex::new(GlobalState::Uninitialized);
}
pub fn assert_initialized() {
let global_state_guard = GLOBAL_STATE.lock().unwrap();
assert_eq!(*global_state_guard, Initialized);
}
pub fn set_flags_from_command_line(args: Vec<String>) -> 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 c_char)
.collect::<Vec<_>>();
let mut c_argv_len = c_argv.len() as c_int;
unsafe {
v8__V8__SetFlagsFromCommandLine(&mut c_argv_len, c_argv.as_mut_ptr())
};
c_argv.truncate(c_argv_len as usize);
c_argv
.iter()
.map(|ptr| unsafe {
let cstr = CStr::from_ptr(*ptr as *const c_char);
let slice = cstr.to_str().unwrap();
slice.to_string()
})
.collect()
}
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: UniqueRef<Platform>) {
let mut global_state_guard = GLOBAL_STATE.lock().unwrap();
assert_eq!(*global_state_guard, Uninitialized);
unsafe { v8__V8__InitializePlatform(platform.into_raw()) };
*global_state_guard = PlatformInitialized;
}
pub fn initialize() {
let mut global_state_guard = GLOBAL_STATE.lock().unwrap();
assert_eq!(*global_state_guard, PlatformInitialized);
unsafe { v8__V8__Initialize() };
*global_state_guard = Initialized;
}
pub unsafe fn dispose() -> bool {
let mut global_state_guard = GLOBAL_STATE.lock().unwrap();
assert_eq!(*global_state_guard, Initialized);
assert_eq!(v8__V8__Dispose(), true);
*global_state_guard = Disposed;
true
}
pub fn shutdown_platform() {
let mut global_state_guard = GLOBAL_STATE.lock().unwrap();
assert_eq!(*global_state_guard, Disposed);
unsafe { v8__V8__ShutdownPlatform() };
*global_state_guard = PlatformShutdown;
}