foster/denoland-deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2025-01-22 06:09:25 -05:00
Code Issues Packages 1 Wiki Activity

Rename deno.argv, libdeno::DenoC and deno_set_flags (#796)

Browse source
This commit is contained in:
ztplz 2018-09-22 20:47:44 +08:00 • committed by Ryan Dahl
parent 7a4ad045b1
commit f3684c28e5
10 changed files with 69 additions and 71 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
js/deno.ts
View file

@ -14,4 +14,4 @@ export { ErrorKind, DenoError } from "./errors";
export { libdeno } from "./libdeno"; export { libdeno } from "./libdeno";
export { arch, platform } from "./platform"; export { arch, platform } from "./platform";
export { trace } from "./trace"; export { trace } from "./trace";
export const argv: string[] = []; export const args: string[] = [];

12
js/main.ts
View file

@ -5,7 +5,7 @@ import { assert, log, setLogDebug } from "./util";
import * as os from "./os"; import * as os from "./os";
import { DenoCompiler } from "./compiler"; import { DenoCompiler } from "./compiler";
import { libdeno } from "./libdeno"; import { libdeno } from "./libdeno";
import { argv } from "./deno"; import { args } from "./deno";
import { sendSync, handleAsyncMsgFromRust } from "./dispatch"; import { sendSync, handleAsyncMsgFromRust } from "./dispatch";
function sendStart(): fbs.StartRes { function sendStart(): fbs.StartRes {
@ -39,7 +39,7 @@ export default function denoMain() {
// First we send an empty "Start" message to let the privlaged side know we // First we send an empty "Start" message to let the privlaged side know we
// are ready. The response should be a "StartRes" message containing the CLI // are ready. The response should be a "StartRes" message containing the CLI
// argv and other info. // args and other info.
const startResMsg = sendStart(); const startResMsg = sendStart();
setLogDebug(startResMsg.debugFlag()); setLogDebug(startResMsg.debugFlag());
@ -49,12 +49,12 @@ export default function denoMain() {
// TODO handle shebang. // TODO handle shebang.
for (let i = 1; i < startResMsg.argvLength(); i++) { for (let i = 1; i < startResMsg.argvLength(); i++) {
argv.push(startResMsg.argv(i)); args.push(startResMsg.argv(i));
} }
log("argv", argv); log("args", args);
Object.freeze(argv); Object.freeze(args);
const inputFn = argv[0]; const inputFn = args[0];
if (!inputFn) { if (!inputFn) {
console.log("No input script specified."); console.log("No input script specified.");
os.exit(1); os.exit(1);

2
js/test_util.ts
View file

@ -12,7 +12,7 @@ import * as testing from "./testing/testing.ts";
export { assert, assertEqual } from "./testing/testing.ts"; export { assert, assertEqual } from "./testing/testing.ts";
// testing.setFilter must be run before any tests are defined. // testing.setFilter must be run before any tests are defined.
testing.setFilter(deno.argv[1]); testing.setFilter(deno.args[1]);
interface DenoPermissions { interface DenoPermissions {
write?: boolean; write?: boolean;

2
libdeno/binding.cc
View file

@ -393,7 +393,7 @@ void* deno_get_data(Deno* d) { return d->data; }
const char* deno_v8_version() { return v8::V8::GetVersion(); } const char* deno_v8_version() { return v8::V8::GetVersion(); }
void deno_set_flags(int* argc, char** argv) { void deno_set_v8_flags(int* argc, char** argv) {
v8::V8::SetFlagsFromCommandLine(argc, argv, true); v8::V8::SetFlagsFromCommandLine(argc, argv, true);
} }

2
libdeno/deno.h
View file

@ -26,7 +26,7 @@ typedef void (*deno_recv_cb)(Deno* d, deno_buf buf);
void deno_init(); void deno_init();
const char* deno_v8_version(); const char* deno_v8_version();
void deno_set_flags(int* argc, char** argv); void deno_set_v8_flags(int* argc, char** argv);
Deno* deno_new(void* data, deno_recv_cb cb); Deno* deno_new(void* data, deno_recv_cb cb);
void deno_delete(Deno* d); void deno_delete(Deno* d);

2
libdeno/test.cc
View file

@ -5,6 +5,6 @@
int main(int argc, char** argv) { int main(int argc, char** argv) {
testing::InitGoogleTest(&argc, argv); testing::InitGoogleTest(&argc, argv);
deno_init(); deno_init();
deno_set_flags(&argc, argv); deno_set_v8_flags(&argc, argv);
return RUN_ALL_TESTS(); return RUN_ALL_TESTS();
} }

7
src/flags.rs
View file

@ -189,7 +189,7 @@ fn test_parse_core_args_2() {
// Pass the command line arguments to v8. // Pass the command line arguments to v8.
// Returns a vector of command line arguments that v8 did not understand. // Returns a vector of command line arguments that v8 did not understand.
pub fn v8_set_flags(args: Vec<String>) -> Vec<String> { pub fn v8_set_flags(args: Vec<String>) -> Vec<String> {
// deno_set_flags(int* argc, char** argv) mutates argc and argv to remove // deno_set_v8_flags(int* argc, char** argv) mutates argc and argv to remove
// flags that v8 understands. // flags that v8 understands.
// First parse core args, then converto to a vector of C strings. // First parse core args, then converto to a vector of C strings.
let (argv, rest) = parse_core_args(args); let (argv, rest) = parse_core_args(args);
@ -205,13 +205,12 @@ pub fn v8_set_flags(args: Vec<String>) -> Vec<String> {
.map(|arg| arg.as_mut_ptr() as *mut i8) .map(|arg| arg.as_mut_ptr() as *mut i8)
.collect::<Vec<_>>(); .collect::<Vec<_>>();
// Store the length of the argv array in a local variable. We'll pass a // 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 // pointer to this local variable to deno_set_v8_flags(), which then
// updates its value. // updates its value.
let mut c_argc = c_argv.len() as c_int; let mut c_argc = c_argv.len() as c_int;
// Let v8 parse the arguments it recognizes and remove them from c_argv. // Let v8 parse the arguments it recognizes and remove them from c_argv.
unsafe { unsafe {
// TODO(ry) Rename deno_set_flags to deno_set_v8_flags(). libdeno::deno_set_v8_flags(&mut c_argc, c_argv.as_mut_ptr());
libdeno::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. // If c_argc was updated we have to change the length of c_argv to match.
c_argv.truncate(c_argc as usize); c_argv.truncate(c_argc as usize);

83
src/handlers.rs
View file

@ -10,7 +10,7 @@ use hyper::rt::{Future, Stream};
use hyper::Client; use hyper::Client;
use isolate::from_c; use isolate::from_c;
use libdeno; use libdeno;
use libdeno::{deno_buf, DenoC}; use libdeno::{deno_buf, isolate};
use msg; use msg;
use remove_dir_all::remove_dir_all; use remove_dir_all::remove_dir_all;
use std; use std;
@ -36,9 +36,9 @@ type OpResult = DenoResult<Buf>;
// TODO Ideally we wouldn't have to box the Op being returned. // TODO Ideally we wouldn't have to box the Op being returned.
// The box is just to make it easier to get a prototype refactor working. // The box is just to make it easier to get a prototype refactor working.
type Handler = fn(d: *const DenoC, base: &msg::Base) -> Box<Op>; type Handler = fn(i: *const isolate, base: &msg::Base) -> Box<Op>;
pub extern "C" fn msg_from_js(d: *const DenoC, buf: deno_buf) { pub extern "C" fn msg_from_js(i: *const isolate, buf: deno_buf) {
let bytes = unsafe { std::slice::from_raw_parts(buf.data_ptr, buf.data_len) }; let bytes = unsafe { std::slice::from_raw_parts(buf.data_ptr, buf.data_len) };
let base = msg::get_root_as_base(bytes); let base = msg::get_root_as_base(bytes);
let msg_type = base.msg_type(); let msg_type = base.msg_type();
@ -67,7 +67,7 @@ pub extern "C" fn msg_from_js(d: *const DenoC, buf: deno_buf) {
)), )),
}; };
let future = handler(d, &base); let future = handler(i, &base);
let future = future.or_else(move |err| { let future = future.or_else(move |err| {
// No matter whether we got an Err or Ok, we want a serialized message to // No matter whether we got an Err or Ok, we want a serialized message to
// send back. So transform the DenoError into a deno_buf. // send back. So transform the DenoError into a deno_buf.
@ -84,7 +84,7 @@ pub extern "C" fn msg_from_js(d: *const DenoC, buf: deno_buf) {
)) ))
}); });
let isolate = from_c(d); let isolate = from_c(i);
if base.sync() { if base.sync() {
// Execute future synchronously. // Execute future synchronously.
// println!("sync handler {}", msg::enum_name_any(msg_type)); // println!("sync handler {}", msg::enum_name_any(msg_type));
@ -94,7 +94,7 @@ pub extern "C" fn msg_from_js(d: *const DenoC, buf: deno_buf) {
Some(box_u8) => { Some(box_u8) => {
let buf = deno_buf_from(box_u8); let buf = deno_buf_from(box_u8);
// Set the synchronous response, the value returned from isolate.send(). // Set the synchronous response, the value returned from isolate.send().
unsafe { libdeno::deno_set_response(d, buf) } unsafe { libdeno::deno_set_response(i, buf) }
} }
} }
} else { } else {
@ -118,7 +118,7 @@ pub extern "C" fn msg_from_js(d: *const DenoC, buf: deno_buf) {
} }
}; };
// TODO(ry) make this thread safe. // TODO(ry) make this thread safe.
unsafe { libdeno::deno_send(d, buf) }; unsafe { libdeno::deno_send(i, buf) };
Ok(()) Ok(())
}); });
isolate.rt.spawn(future); isolate.rt.spawn(future);
@ -150,13 +150,13 @@ fn not_implemented() -> DenoError {
)) ))
} }
fn handle_exit(_d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_exit(_i: *const isolate, base: &msg::Base) -> Box<Op> {
let msg = base.msg_as_exit().unwrap(); let msg = base.msg_as_exit().unwrap();
std::process::exit(msg.code()) std::process::exit(msg.code())
} }
fn handle_start(d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_start(i: *const isolate, base: &msg::Base) -> Box<Op> {
let isolate = from_c(d); let isolate = from_c(i);
let mut builder = FlatBufferBuilder::new(); let mut builder = FlatBufferBuilder::new();
let argv = isolate.argv.iter().map(|s| s.as_str()).collect::<Vec<_>>(); let argv = isolate.argv.iter().map(|s| s.as_str()).collect::<Vec<_>>();
@ -211,12 +211,12 @@ fn odd_future(err: DenoError) -> Box<Op> {
} }
// https://github.com/denoland/isolate/blob/golang/os.go#L100-L154 // https://github.com/denoland/isolate/blob/golang/os.go#L100-L154
fn handle_code_fetch(d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_code_fetch(i: *const isolate, base: &msg::Base) -> Box<Op> {
let msg = base.msg_as_code_fetch().unwrap(); let msg = base.msg_as_code_fetch().unwrap();
let cmd_id = base.cmd_id(); let cmd_id = base.cmd_id();
let module_specifier = msg.module_specifier().unwrap(); let module_specifier = msg.module_specifier().unwrap();
let containing_file = msg.containing_file().unwrap(); let containing_file = msg.containing_file().unwrap();
let isolate = from_c(d); let isolate = from_c(i);
assert_eq!( assert_eq!(
isolate.dir.root.join("gen"), isolate.dir.root.join("gen"),
@ -253,24 +253,24 @@ fn handle_code_fetch(d: *const DenoC, base: &msg::Base) -> Box<Op> {
} }
// https://github.com/denoland/isolate/blob/golang/os.go#L156-L169 // https://github.com/denoland/isolate/blob/golang/os.go#L156-L169
fn handle_code_cache(d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_code_cache(i: *const isolate, base: &msg::Base) -> Box<Op> {
let msg = base.msg_as_code_cache().unwrap(); let msg = base.msg_as_code_cache().unwrap();
let filename = msg.filename().unwrap(); let filename = msg.filename().unwrap();
let source_code = msg.source_code().unwrap(); let source_code = msg.source_code().unwrap();
let output_code = msg.output_code().unwrap(); let output_code = msg.output_code().unwrap();
Box::new(futures::future::result(|| -> OpResult { Box::new(futures::future::result(|| -> OpResult {
let isolate = from_c(d); let isolate = from_c(i);
isolate.dir.code_cache(filename, source_code, output_code)?; isolate.dir.code_cache(filename, source_code, output_code)?;
Ok(None) Ok(None)
}())) }()))
} }
fn handle_set_env(d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_set_env(i: *const isolate, base: &msg::Base) -> Box<Op> {
let msg = base.msg_as_set_env().unwrap(); let msg = base.msg_as_set_env().unwrap();
let key = msg.key().unwrap(); let key = msg.key().unwrap();
let value = msg.value().unwrap(); let value = msg.value().unwrap();
let isolate = from_c(d); let isolate = from_c(i);
if !isolate.flags.allow_env { if !isolate.flags.allow_env {
return odd_future(permission_denied()); return odd_future(permission_denied());
} }
@ -279,8 +279,8 @@ fn handle_set_env(d: *const DenoC, base: &msg::Base) -> Box<Op> {
ok_future(None) ok_future(None)
} }
fn handle_env(d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_env(i: *const isolate, base: &msg::Base) -> Box<Op> {
let isolate = from_c(d); let isolate = from_c(i);
let cmd_id = base.cmd_id(); let cmd_id = base.cmd_id();
if !isolate.flags.allow_env { if !isolate.flags.allow_env {
return odd_future(permission_denied()); return odd_future(permission_denied());
@ -320,12 +320,12 @@ fn handle_env(d: *const DenoC, base: &msg::Base) -> Box<Op> {
)) ))
} }
fn handle_fetch_req(d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_fetch_req(i: *const isolate, base: &msg::Base) -> Box<Op> {
let msg = base.msg_as_fetch_req().unwrap(); let msg = base.msg_as_fetch_req().unwrap();
let cmd_id = base.cmd_id(); let cmd_id = base.cmd_id();
let id = msg.id(); let id = msg.id();
let url = msg.url().unwrap(); let url = msg.url().unwrap();
let isolate = from_c(d); let isolate = from_c(i);
if !isolate.flags.allow_net { if !isolate.flags.allow_net {
return odd_future(permission_denied()); return odd_future(permission_denied());
@ -420,7 +420,7 @@ where
(delay_task, cancel_tx) (delay_task, cancel_tx)
} }
fn handle_make_temp_dir(d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_make_temp_dir(i: *const isolate, base: &msg::Base) -> Box<Op> {
let base = Box::new(*base); let base = Box::new(*base);
let msg = base.msg_as_make_temp_dir().unwrap(); let msg = base.msg_as_make_temp_dir().unwrap();
let cmd_id = base.cmd_id(); let cmd_id = base.cmd_id();
@ -428,7 +428,7 @@ fn handle_make_temp_dir(d: *const DenoC, base: &msg::Base) -> Box<Op> {
let prefix = msg.prefix(); let prefix = msg.prefix();
let suffix = msg.suffix(); let suffix = msg.suffix();
let isolate = from_c(d); let isolate = from_c(i);
if !isolate.flags.allow_write { if !isolate.flags.allow_write {
return odd_future(permission_denied()); return odd_future(permission_denied());
} }
@ -459,11 +459,11 @@ fn handle_make_temp_dir(d: *const DenoC, base: &msg::Base) -> Box<Op> {
}())) }()))
} }
fn handle_mkdir(d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_mkdir(i: *const isolate, base: &msg::Base) -> Box<Op> {
let msg = base.msg_as_mkdir().unwrap(); let msg = base.msg_as_mkdir().unwrap();
let mode = msg.mode(); let mode = msg.mode();
let path = msg.path().unwrap(); let path = msg.path().unwrap();
let isolate = from_c(d); let isolate = from_c(i);
if !isolate.flags.allow_write { if !isolate.flags.allow_write {
return odd_future(permission_denied()); return odd_future(permission_denied());
} }
@ -475,11 +475,11 @@ fn handle_mkdir(d: *const DenoC, base: &msg::Base) -> Box<Op> {
}())) }()))
} }
fn handle_remove(d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_remove(i: *const isolate, base: &msg::Base) -> Box<Op> {
let msg = base.msg_as_remove().unwrap(); let msg = base.msg_as_remove().unwrap();
let path = msg.path().unwrap(); let path = msg.path().unwrap();
let recursive = msg.recursive(); let recursive = msg.recursive();
let isolate = from_c(d); let isolate = from_c(i);
if !isolate.flags.allow_write { if !isolate.flags.allow_write {
return odd_future(permission_denied()); return odd_future(permission_denied());
} }
@ -502,7 +502,7 @@ fn handle_remove(d: *const DenoC, base: &msg::Base) -> Box<Op> {
} }
// Prototype https://github.com/denoland/isolate/blob/golang/os.go#L171-L184 // Prototype https://github.com/denoland/isolate/blob/golang/os.go#L171-L184
fn handle_read_file(_d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_read_file(_i: *const isolate, base: &msg::Base) -> Box<Op> {
let msg = base.msg_as_read_file().unwrap(); let msg = base.msg_as_read_file().unwrap();
let cmd_id = base.cmd_id(); let cmd_id = base.cmd_id();
let filename = String::from(msg.filename().unwrap()); let filename = String::from(msg.filename().unwrap());
@ -552,7 +552,7 @@ fn get_mode(_perm: fs::Permissions) -> u32 {
0 0
} }
fn handle_stat(_d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_stat(_i: *const isolate, base: &msg::Base) -> Box<Op> {
let msg = base.msg_as_stat().unwrap(); let msg = base.msg_as_stat().unwrap();
let cmd_id = base.cmd_id(); let cmd_id = base.cmd_id();
let filename = String::from(msg.filename().unwrap()); let filename = String::from(msg.filename().unwrap());
@ -595,13 +595,13 @@ fn handle_stat(_d: *const DenoC, base: &msg::Base) -> Box<Op> {
}())) }()))
} }
fn handle_write_file(d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_write_file(i: *const isolate, base: &msg::Base) -> Box<Op> {
let msg = base.msg_as_write_file().unwrap(); let msg = base.msg_as_write_file().unwrap();
let filename = String::from(msg.filename().unwrap()); let filename = String::from(msg.filename().unwrap());
let data = msg.data().unwrap(); let data = msg.data().unwrap();
let perm = msg.perm(); let perm = msg.perm();
let isolate = from_c(d); let isolate = from_c(i);
if !isolate.flags.allow_write { if !isolate.flags.allow_write {
return odd_future(permission_denied()); return odd_future(permission_denied());
} }
@ -612,25 +612,24 @@ fn handle_write_file(d: *const DenoC, base: &msg::Base) -> Box<Op> {
}())) }()))
} }
// TODO(ry) Use Isolate instead of DenoC as first arg. fn remove_timer(i: *const isolate, timer_id: u32) {
fn remove_timer(d: *const DenoC, timer_id: u32) { let isolate = from_c(i);
let isolate = from_c(d);
isolate.timers.remove(&timer_id); isolate.timers.remove(&timer_id);
} }
// Prototype: https://github.com/ry/isolate/blob/golang/timers.go#L25-L39 // Prototype: https://github.com/ry/isolate/blob/golang/timers.go#L25-L39
fn handle_timer_start(d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_timer_start(i: *const isolate, base: &msg::Base) -> Box<Op> {
debug!("handle_timer_start"); debug!("handle_timer_start");
let msg = base.msg_as_timer_start().unwrap(); let msg = base.msg_as_timer_start().unwrap();
let cmd_id = base.cmd_id(); let cmd_id = base.cmd_id();
let timer_id = msg.id(); let timer_id = msg.id();
let delay = msg.delay(); let delay = msg.delay();
let isolate = from_c(d); let isolate = from_c(i);
let future = { let future = {
let (delay_task, cancel_delay) = set_timeout( let (delay_task, cancel_delay) = set_timeout(
move || { move || {
remove_timer(d, timer_id); remove_timer(i, timer_id);
}, },
delay, delay,
); );
@ -660,15 +659,15 @@ fn handle_timer_start(d: *const DenoC, base: &msg::Base) -> Box<Op> {
} }
// Prototype: https://github.com/ry/isolate/blob/golang/timers.go#L40-L43 // Prototype: https://github.com/ry/isolate/blob/golang/timers.go#L40-L43
fn handle_timer_clear(d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_timer_clear(i: *const isolate, base: &msg::Base) -> Box<Op> {
let msg = base.msg_as_timer_clear().unwrap(); let msg = base.msg_as_timer_clear().unwrap();
debug!("handle_timer_clear"); debug!("handle_timer_clear");
remove_timer(d, msg.id()); remove_timer(i, msg.id());
ok_future(None) ok_future(None)
} }
fn handle_rename(d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_rename(i: *const isolate, base: &msg::Base) -> Box<Op> {
let isolate = from_c(d); let isolate = from_c(i);
if !isolate.flags.allow_write { if !isolate.flags.allow_write {
return odd_future(permission_denied()); return odd_future(permission_denied());
} }
@ -682,8 +681,8 @@ fn handle_rename(d: *const DenoC, base: &msg::Base) -> Box<Op> {
}())) }()))
} }
fn handle_symlink(d: *const DenoC, base: &msg::Base) -> Box<Op> { fn handle_symlink(i: *const isolate, base: &msg::Base) -> Box<Op> {
let deno = from_c(d); let deno = from_c(i);
if !deno.flags.allow_write { if !deno.flags.allow_write {
return odd_future(permission_denied()); return odd_future(permission_denied());
} }

8
src/isolate.rs
View file

@ -14,7 +14,7 @@ use tokio;
type DenoException<'a> = &'a str; type DenoException<'a> = &'a str;
pub struct Isolate { pub struct Isolate {
pub ptr: *const libdeno::DenoC, pub ptr: *const libdeno::isolate,
pub dir: deno_dir::DenoDir, pub dir: deno_dir::DenoDir,
pub rt: tokio::runtime::current_thread::Runtime, pub rt: tokio::runtime::current_thread::Runtime,
pub timers: HashMap<u32, futures::sync::oneshot::Sender<()>>, pub timers: HashMap<u32, futures::sync::oneshot::Sender<()>>,
@ -33,7 +33,7 @@ impl Isolate {
let (flags, argv_rest) = flags::set_flags(argv); let (flags, argv_rest) = flags::set_flags(argv);
let mut deno_box = Box::new(Isolate { let mut deno_box = Box::new(Isolate {
ptr: 0 as *const libdeno::DenoC, ptr: 0 as *const libdeno::isolate,
dir: deno_dir::DenoDir::new(flags.reload, None).unwrap(), dir: deno_dir::DenoDir::new(flags.reload, None).unwrap(),
rt: tokio::runtime::current_thread::Runtime::new().unwrap(), rt: tokio::runtime::current_thread::Runtime::new().unwrap(),
timers: HashMap::new(), timers: HashMap::new(),
@ -76,8 +76,8 @@ impl Drop for Isolate {
} }
} }
pub fn from_c<'a>(d: *const libdeno::DenoC) -> &'a mut Isolate { pub fn from_c<'a>(i: *const libdeno::isolate) -> &'a mut Isolate {
let ptr = unsafe { libdeno::deno_get_data(d) }; let ptr = unsafe { libdeno::deno_get_data(i) };
let ptr = ptr as *mut Isolate; let ptr = ptr as *mut Isolate;
let isolate_box = unsafe { Box::from_raw(ptr) }; let isolate_box = unsafe { Box::from_raw(ptr) };
Box::leak(isolate_box) Box::leak(isolate_box)

20
src/libdeno.rs
View file

@ -6,7 +6,7 @@ use libc::c_int;
use libc::c_void; use libc::c_void;
#[repr(C)] #[repr(C)]
pub struct DenoC { pub struct isolate {
_unused: [u8; 0], _unused: [u8; 0],
} }
@ -19,20 +19,20 @@ pub struct deno_buf {
pub data_len: usize, pub data_len: usize,
} }
type DenoRecvCb = unsafe extern "C" fn(d: *const DenoC, buf: deno_buf); type DenoRecvCb = unsafe extern "C" fn(d: *const isolate, buf: deno_buf);
extern "C" { extern "C" {
pub fn deno_init(); pub fn deno_init();
pub fn deno_v8_version() -> *const c_char; pub fn deno_v8_version() -> *const c_char;
pub fn deno_set_flags(argc: *mut c_int, argv: *mut *mut c_char); pub fn deno_set_v8_flags(argc: *mut c_int, argv: *mut *mut c_char);
pub fn deno_new(data: *const c_void, cb: DenoRecvCb) -> *const DenoC; pub fn deno_new(data: *const c_void, cb: DenoRecvCb) -> *const isolate;
pub fn deno_delete(d: *const DenoC); pub fn deno_delete(i: *const isolate);
pub fn deno_last_exception(d: *const DenoC) -> *const c_char; pub fn deno_last_exception(i: *const isolate) -> *const c_char;
pub fn deno_get_data(d: *const DenoC) -> *const c_void; pub fn deno_get_data(i: *const isolate) -> *const c_void;
pub fn deno_set_response(d: *const DenoC, buf: deno_buf); pub fn deno_set_response(i: *const isolate, buf: deno_buf);
pub fn deno_send(d: *const DenoC, buf: deno_buf); pub fn deno_send(i: *const isolate, buf: deno_buf);
pub fn deno_execute( pub fn deno_execute(
d: *const DenoC, i: *const isolate,
js_filename: *const c_char, js_filename: *const c_char,
js_source: *const c_char, js_source: *const c_char,
) -> c_int; ) -> c_int;