Add from_c() to get a Deno object from ptr.

This is a utility function for CodeCache and other handlers.

BUILD.gn

@@ -78,7 +78,7 @@ rust_test("test_rs") {
   source_root = "src/main.rs"
   extern = main_extern
   deps = [
-    ":deno_bindings",
+    ":libdeno",
   ]
 }
 

src/binding.cc

@@ -288,6 +288,8 @@ void deno_init() {
   v8::V8::Initialize();
 }
 
+void* deno_get_data(Deno* d) { return d->data; }
+
 const char* deno_v8_version() { return v8::V8::GetVersion(); }
 
 // TODO(ry) Remove these when we call deno_reply_start from Rust.

src/binding.rs

@@ -27,6 +27,7 @@ extern "C" {
   pub fn deno_new(data: *const c_void, cb: DenoRecvCb) -> *const DenoC;
   pub fn deno_delete(d: *const DenoC);
   pub fn deno_last_exception(d: *const DenoC) -> *const c_char;
+  pub fn deno_get_data(d: *const DenoC) -> *const c_void;
   pub fn deno_set_response(d: *const DenoC, buf: deno_buf);
   pub fn deno_execute(
     d: *const DenoC,

src/deno.h

@@ -31,6 +31,9 @@ void deno_set_flags(int* argc, char** argv);
 Deno* deno_new(void* data, deno_recv_cb cb);
 void deno_delete(Deno* d);
 
+// Returns the void* data provided in deno_new.
+void* deno_get_data(Deno*);
+
 // Returns false on error.
 // Get error text with deno_last_exception().
 // 0 = fail, 1 = success

src/main.rs

@@ -6,19 +6,15 @@ extern crate msg_rs as msg_generated;
 extern crate url;
 
 use libc::c_int;
+use libc::c_void;
 use std::env;
 use std::ffi::CStr;
 use std::ffi::CString;
 use std::mem;
-use std::ptr;
 
 mod handlers;
 pub use handlers::*;
 mod binding;
-use binding::{
-  deno_delete, deno_execute, deno_handle_msg_from_js, deno_init,
-  deno_last_exception, deno_new, deno_set_flags, DenoC,
-};
 
 // Returns args passed to V8, followed by args passed to JS
 fn parse_core_args(args: Vec<String>) -> (Vec<String>, Vec<String>) {
@@ -71,7 +67,7 @@ fn set_flags(args: Vec<String>) -> Vec<String> {
   let mut c_argc = c_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());
+    binding::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);
@@ -89,14 +85,28 @@ fn set_flags(args: Vec<String>) -> Vec<String> {
 
 type DenoException<'a> = &'a str;
 
-struct Deno {
-  ptr: *const DenoC,
+pub struct Deno {
+  ptr: *const binding::DenoC,
 }
 
+static DENO_INIT: std::sync::Once = std::sync::ONCE_INIT;
+
 impl Deno {
-  fn new() -> Deno {
-    let ptr = unsafe { deno_new(ptr::null(), deno_handle_msg_from_js) };
-    Deno { ptr: ptr }
+  fn new<'a>() -> &'a mut Deno {
+    DENO_INIT.call_once(|| {
+      unsafe { binding::deno_init() };
+    });
+
+    let deno_box = Box::new(Deno {
+      ptr: 0 as *const binding::DenoC,
+    });
+    let deno: &'a mut Deno = Box::leak(deno_box);
+    let external_ptr = deno as *mut _ as *const c_void;
+    let internal_deno_ptr = unsafe {
+      binding::deno_new(external_ptr, binding::deno_handle_msg_from_js)
+    };
+    deno.ptr = internal_deno_ptr;
+    deno
   }
 
   fn execute(
@@ -106,10 +116,11 @@ impl Deno {
   ) -> 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()) };
+    let r = unsafe {
+      binding::deno_execute(self.ptr, filename.as_ptr(), source.as_ptr())
+    };
     if r == 0 {
-      let ptr = unsafe { deno_last_exception(self.ptr) };
+      let ptr = unsafe { binding::deno_last_exception(self.ptr) };
       let cstr = unsafe { CStr::from_ptr(ptr) };
       return Err(cstr.to_str().unwrap());
     }
@@ -119,7 +130,7 @@ impl Deno {
 
 impl Drop for Deno {
   fn drop(&mut self) {
-    unsafe { deno_delete(self.ptr) }
+    unsafe { binding::deno_delete(self.ptr) }
   }
 }
 
@@ -136,6 +147,19 @@ fn test_parse_core_args_2() {
   assert!(js_args == (vec!["deno".to_string()], vec!["--help".to_string()]));
 }
 
+pub fn from_c<'a>(d: *const binding::DenoC) -> &'a mut Deno {
+  let ptr = unsafe { binding::deno_get_data(d) };
+  let deno_ptr = ptr as *mut Deno;
+  let deno_box = unsafe { Box::from_raw(deno_ptr) };
+  Box::leak(deno_box)
+}
+
+#[test]
+fn test_c_to_rust() {
+  let d = Deno::new();
+  let d2 = from_c(d.ptr);
+  assert!(d.ptr == d2.ptr);
+}
 
 static LOGGER: Logger = Logger;
 
@@ -158,8 +182,6 @@ fn main() {
   log::set_logger(&LOGGER).unwrap();
   log::set_max_level(log::LevelFilter::Info);
 
-  unsafe { deno_init() };
-
   let _js_args = set_flags(env::args().collect());
 
   /*
@@ -169,7 +191,7 @@ fn main() {
     println!("version: {}", version);
     */
 
-  let mut d = Deno::new();
+  let d = Deno::new();
 
   d.execute("deno_main.js", "denoMain();")
     .unwrap_or_else(|err| {