1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
extern crate libc;
#[macro_use]
extern crate log;
use libc::c_int;
use std::ffi::CStr;
use std::ffi::CString;
use std::ptr;
mod binding;
use binding::{deno_delete, deno_execute, deno_handle_msg_from_js, deno_init, deno_last_exception,
deno_new, deno_set_flags, DenoC};
// Pass the command line arguments to v8.
// Returns a vector of command line arguments that v8 did not understand.
fn set_flags() -> Vec<String> {
// deno_set_flags(int* argc, char** argv) mutates argc and argv to remove
// flags that v8 understands.
// Convert command line arguments to a vector of C strings.
let mut argv = std::env::args()
.map(|arg| CString::new(arg).unwrap().into_bytes_with_nul())
.collect::<Vec<_>>();
// Make a new array, that can be modified by V8::SetFlagsFromCommandLine(),
// containing mutable raw pointers to the individual command line args.
let mut c_argv = argv.iter_mut()
.map(|arg| arg.as_mut_ptr() as *mut i8)
.collect::<Vec<_>>();
// Store the length of the argv array in a local variable. We'll pass a
// pointer to this local variable to deno_set_flags(), which then
// updates its value.
let mut c_argc = argv.len() as c_int;
// Let v8 parse the arguments it recognizes and remove them from c_argv.
unsafe {
deno_set_flags(&mut c_argc, c_argv.as_mut_ptr());
};
// If c_argc was updated we have to change the length of c_argv to match.
c_argv.truncate(c_argc as usize);
// Copy the modified arguments list into a proper rust vec and return it.
c_argv
.iter()
.map(|ptr| unsafe {
let cstr = CStr::from_ptr(*ptr as *const i8);
let slice = cstr.to_str().unwrap();
slice.to_string()
})
.collect::<Vec<_>>()
}
type DenoException<'a> = &'a str;
struct Deno {
ptr: *const DenoC,
}
impl Deno {
fn new() -> Deno {
let ptr = unsafe { deno_new(ptr::null(), deno_handle_msg_from_js) };
Deno { ptr: ptr }
}
fn execute(&mut self, js_filename: &str, js_source: &str) -> Result<(), DenoException> {
let filename = CString::new(js_filename).unwrap();
let source = CString::new(js_source).unwrap();
let r = unsafe { deno_execute(self.ptr, filename.as_ptr(), source.as_ptr()) };
if r == 0 {
let ptr = unsafe { deno_last_exception(self.ptr) };
let cstr = unsafe { CStr::from_ptr(ptr) };
return Err(cstr.to_str().unwrap());
}
Ok(())
}
}
impl Drop for Deno {
fn drop(&mut self) {
unsafe { deno_delete(self.ptr) }
}
}
fn main() {
log::set_max_level(log::LevelFilter::Debug);
unsafe { deno_init() };
set_flags();
/*
let v = unsafe { deno_v8_version() };
let c_str = unsafe { CStr::from_ptr(v) };
let version = c_str.to_str().unwrap();
println!("version: {}", version);
*/
let mut d = Deno::new();
d.execute("deno_main.js", "denoMain();")
.unwrap_or_else(|err| {
error!("{}", err);
std::process::exit(1);
});
}
|
