foster/denoland-deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-12-22 07:14:47 -05:00
Code Issues Packages 1 Wiki Activity

Use 2 space indent.

Browse source 
Apologies for the churn, but my screen is small. rustfmt assumes big
monitors.
This commit is contained in:
Ryan Dahl 2018-07-19 21:14:32 -04:00
parent a7bf154cb8
commit 21c4b8a42d
4 changed files with 254 additions and 248 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

64
src/binding.rs
View file

@ -10,45 +10,45 @@ use libc::uint32_t;
#[repr(C)]
pub struct DenoC {
_unused: [u8; 0],
_unused: [u8; 0],
}
#[repr(C)]
pub struct deno_buf {
alloc_ptr: *mut u8,
alloc_len: usize,
data_ptr: *mut u8,
data_len: usize,
alloc_ptr: *mut u8,
alloc_len: usize,
data_ptr: *mut u8,
data_len: usize,
}
type DenoRecvCb = unsafe extern "C" fn(d: *const DenoC, buf: deno_buf);
extern "C" {
pub fn deno_init();
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_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_set_response(d: *const DenoC, buf: deno_buf);
pub fn deno_execute(
d: *const DenoC,
js_filename: *const c_char,
js_source: *const c_char,
) -> c_int;
pub fn deno_handle_msg_from_js(d: *const DenoC, buf: deno_buf);
pub fn deno_reply_error(
d: *const DenoC,
cmd_id: uint32_t,
msg: *const c_char,
);
pub fn deno_reply_null(d: *const DenoC, cmd_id: uint32_t);
pub fn deno_reply_code_fetch(
d: *const DenoC,
cmd_id: uint32_t,
module_name: *const c_char,
filename: *const c_char,
source_code: *const c_char,
output_code: *const c_char,
);
pub fn deno_init();
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_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_set_response(d: *const DenoC, buf: deno_buf);
pub fn deno_execute(
d: *const DenoC,
js_filename: *const c_char,
js_source: *const c_char,
) -> c_int;
pub fn deno_handle_msg_from_js(d: *const DenoC, buf: deno_buf);
pub fn deno_reply_error(
d: *const DenoC,
cmd_id: uint32_t,
msg: *const c_char,
);
pub fn deno_reply_null(d: *const DenoC, cmd_id: uint32_t);
pub fn deno_reply_code_fetch(
d: *const DenoC,
cmd_id: uint32_t,
module_name: *const c_char,
filename: *const c_char,
source_code: *const c_char,
output_code: *const c_char,
);
}

305
src/handlers.rs
View file

@ -22,125 +22,131 @@ const ASSET_PREFIX: &str = "/$asset$/";
#[test]
fn test_url() {
let issue_list_url = Url::parse("https://github.com/rust-lang").unwrap();
assert!(issue_list_url.scheme() == "https");
let issue_list_url = Url::parse("https://github.com/rust-lang").unwrap();
assert!(issue_list_url.scheme() == "https");
}
fn string_from_ptr(ptr: *const c_char) -> String {
let cstr = unsafe { CStr::from_ptr(ptr as *const i8) };
String::from(cstr.to_str().unwrap())
let cstr = unsafe { CStr::from_ptr(ptr as *const i8) };
String::from(cstr.to_str().unwrap())
}
fn as_cstring(s: &String) -> CString {
CString::new(s.as_str()).unwrap()
CString::new(s.as_str()).unwrap()
}
// Prototype: https://github.com/ry/deno/blob/golang/os.go#L56-L68
#[allow(dead_code)]
fn src_file_to_url<P: AsRef<Path>>(filename: P) -> String {
assert!(SRC_DIR.len() > 0, "SRC_DIR shouldn't be empty");
assert!(SRC_DIR.len() > 0, "SRC_DIR shouldn't be empty");
let filename = filename.as_ref().to_path_buf();
let src = (SRC_DIR.as_ref() as &Path).to_path_buf();
let filename = filename.as_ref().to_path_buf();
let src = (SRC_DIR.as_ref() as &Path).to_path_buf();
if filename.starts_with(&src) {
let rest = filename.strip_prefix(&src).unwrap();
"http://".to_string() + rest.to_str().unwrap()
} else {
String::from(filename.to_str().unwrap())
}
if filename.starts_with(&src) {
let rest = filename.strip_prefix(&src).unwrap();
"http://".to_string() + rest.to_str().unwrap()
} else {
String::from(filename.to_str().unwrap())
}
}
#[test]
fn test_src_file_to_url() {
assert_eq!("hello", src_file_to_url("hello"));
assert_eq!("/hello", src_file_to_url("/hello"));
let x = SRC_DIR.to_string() + "hello";
assert_eq!("http://hello", src_file_to_url(&x));
let x = SRC_DIR.to_string() + "/hello";
assert_eq!("http://hello", src_file_to_url(&x));
assert_eq!("hello", src_file_to_url("hello"));
assert_eq!("/hello", src_file_to_url("/hello"));
let x = SRC_DIR.to_string() + "hello";
assert_eq!("http://hello", src_file_to_url(&x));
let x = SRC_DIR.to_string() + "/hello";
assert_eq!("http://hello", src_file_to_url(&x));
}
// Prototype: https://github.com/ry/deno/blob/golang/os.go#L70-L98
// Returns (module name, local filename)
fn resolve_module(
module_specifier: &String,
containing_file: &String,
module_specifier: &String,
containing_file: &String,
) -> Result<(String, String), url::ParseError> {
info!(
"resolve_module before module_specifier {} containing_file {}",
module_specifier, containing_file
);
info!(
"resolve_module before module_specifier {} containing_file {}",
module_specifier, containing_file
);
//let module_specifier = src_file_to_url(module_specifier);
//let containing_file = src_file_to_url(containing_file);
//let base_url = Url::parse(&containing_file)?;
//let module_specifier = src_file_to_url(module_specifier);
//let containing_file = src_file_to_url(containing_file);
//let base_url = Url::parse(&containing_file)?;
let j: Url = if containing_file.as_str().ends_with("/") {
let base = Url::from_directory_path(&containing_file).unwrap();
base.join(module_specifier)?
} else if containing_file == "." {
Url::from_file_path(module_specifier).unwrap()
} else {
let base = Url::from_file_path(&containing_file).unwrap();
base.join(module_specifier)?
};
let j: Url = if containing_file.as_str().ends_with("/") {
let base = Url::from_directory_path(&containing_file).unwrap();
base.join(module_specifier)?
} else if containing_file == "." {
Url::from_file_path(module_specifier).unwrap()
} else {
let base = Url::from_file_path(&containing_file).unwrap();
base.join(module_specifier)?
};
let mut p = j.to_file_path()
.unwrap()
.into_os_string()
.into_string()
.unwrap();
let mut p = j.to_file_path()
.unwrap()
.into_os_string()
.into_string()
.unwrap();
if cfg!(target_os = "windows") {
// On windows, replace backward slashes to forward slashes.
// TODO(piscisaureus): This may not me be right, I just did it to make
// the tests pass.
p = p.replace("\\", "/");
}
if cfg!(target_os = "windows") {
// On windows, replace backward slashes to forward slashes.
// TODO(piscisaureus): This may not me be right, I just did it to make
// the tests pass.
p = p.replace("\\", "/");
}
let module_name = p.to_string();
let filename = p.to_string();
let module_name = p.to_string();
let filename = p.to_string();
Ok((module_name, filename))
Ok((module_name, filename))
}
// https://github.com/ry/deno/blob/golang/os_test.go#L16-L87
#[test]
fn test_resolve_module() {
// The `add_root` macro prepends "C:" to a string if on windows; on posix
// systems it returns the input string untouched. This is necessary because
// `Url::from_file_path()` fails if the input path isn't an absolute path.
macro_rules! add_root {
($path:expr) => {
if cfg!(target_os = "windows") {
concat!("C:", $path)
} else {
$path
}
};
}
// The `add_root` macro prepends "C:" to a string if on windows; on posix
// systems it returns the input string untouched. This is necessary because
// `Url::from_file_path()` fails if the input path isn't an absolute path.
macro_rules! add_root {
($path:expr) => {
if cfg!(target_os = "windows") {
concat!("C:", $path)
} else {
$path
}
};
}
let test_cases = [
(
"./subdir/print_hello.ts",
add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/006_url_imports.ts"),
add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/subdir/print_hello.ts"),
add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/subdir/print_hello.ts"),
),
(
"testdata/001_hello.js",
add_root!("/Users/rld/go/src/github.com/ry/deno/"),
add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/001_hello.js"),
add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/001_hello.js"),
),
(
add_root!("/Users/rld/src/deno/hello.js"),
".",
add_root!("/Users/rld/src/deno/hello.js"),
add_root!("/Users/rld/src/deno/hello.js"),
),
/*
let test_cases = [
(
"./subdir/print_hello.ts",
add_root!(
"/Users/rld/go/src/github.com/ry/deno/testdata/006_url_imports.ts"
),
add_root!(
"/Users/rld/go/src/github.com/ry/deno/testdata/subdir/print_hello.ts"
),
add_root!(
"/Users/rld/go/src/github.com/ry/deno/testdata/subdir/print_hello.ts"
),
),
(
"testdata/001_hello.js",
add_root!("/Users/rld/go/src/github.com/ry/deno/"),
add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/001_hello.js"),
add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/001_hello.js"),
),
(
add_root!("/Users/rld/src/deno/hello.js"),
".",
add_root!("/Users/rld/src/deno/hello.js"),
add_root!("/Users/rld/src/deno/hello.js"),
),
/*
(
"http://localhost:4545/testdata/subdir/print_hello.ts",
add_root!("/Users/rld/go/src/github.com/ry/deno/testdata/006_url_imports.ts"),
@ -160,88 +166,87 @@ fn test_resolve_module() {
path.Join(SrcDir, "unpkg.com/liltest@0.0.5/util"),
),
*/
];
for &test in test_cases.iter() {
let module_specifier = String::from(test.0);
let containing_file = String::from(test.1);
let (module_name, filename) =
resolve_module(&module_specifier, &containing_file).unwrap();
assert_eq!(module_name, test.2);
assert_eq!(filename, test.3);
}
];
for &test in test_cases.iter() {
let module_specifier = String::from(test.0);
let containing_file = String::from(test.1);
let (module_name, filename) =
resolve_module(&module_specifier, &containing_file).unwrap();
assert_eq!(module_name, test.2);
assert_eq!(filename, test.3);
}
}
// https://github.com/ry/deno/blob/golang/os.go#L100-L154
#[no_mangle]
pub extern "C" fn handle_code_fetch(
d: *const DenoC,
cmd_id: u32,
module_specifier_: *const c_char,
containing_file_: *const c_char,
d: *const DenoC,
cmd_id: u32,
module_specifier_: *const c_char,
containing_file_: *const c_char,
) {
let module_specifier = string_from_ptr(module_specifier_);
let containing_file = string_from_ptr(containing_file_);
let module_specifier = string_from_ptr(module_specifier_);
let containing_file = string_from_ptr(containing_file_);
let result = resolve_module(&module_specifier, &containing_file);
if result.is_err() {
let err = result.unwrap_err();
let errmsg =
format!("{} {} {}", err, module_specifier, containing_file);
let errmsg_c = as_cstring(&errmsg);
unsafe { deno_reply_error(d, cmd_id, errmsg_c.as_ptr()) };
return;
}
let (module_name, filename) = result.unwrap();
let result = resolve_module(&module_specifier, &containing_file);
if result.is_err() {
let err = result.unwrap_err();
let errmsg = format!("{} {} {}", err, module_specifier, containing_file);
let errmsg_c = as_cstring(&errmsg);
unsafe { deno_reply_error(d, cmd_id, errmsg_c.as_ptr()) };
return;
}
let (module_name, filename) = result.unwrap();
let mut source_code = String::new();
let mut source_code = String::new();
debug!(
debug!(
"code_fetch. module_name = {} module_specifier = {} containing_file = {} filename = {}",
module_name, module_specifier, containing_file, filename
);
if is_remote(&module_name) {
unimplemented!();
} else if module_name.starts_with(ASSET_PREFIX) {
assert!(false, "Asset resolution should be done in JS, not Rust.");
} else {
assert!(
module_name == filename,
"if a module isn't remote, it should have the same filename"
);
let result = File::open(&filename);
if result.is_err() {
let err = result.unwrap_err();
let errmsg = format!("{} {}", err, filename);
let errmsg_c = as_cstring(&errmsg);
unsafe { deno_reply_error(d, cmd_id, errmsg_c.as_ptr()) };
return;
}
let mut f = result.unwrap();
let result = f.read_to_string(&mut source_code);
if result.is_err() {
let err = result.unwrap_err();
let errmsg = format!("{} {}", err, filename);
let errmsg_c = as_cstring(&errmsg);
unsafe { deno_reply_error(d, cmd_id, errmsg_c.as_ptr()) };
return;
}
if is_remote(&module_name) {
unimplemented!();
} else if module_name.starts_with(ASSET_PREFIX) {
assert!(false, "Asset resolution should be done in JS, not Rust.");
} else {
assert!(
module_name == filename,
"if a module isn't remote, it should have the same filename"
);
let result = File::open(&filename);
if result.is_err() {
let err = result.unwrap_err();
let errmsg = format!("{} {}", err, filename);
let errmsg_c = as_cstring(&errmsg);
unsafe { deno_reply_error(d, cmd_id, errmsg_c.as_ptr()) };
return;
}
let output_code = String::new(); //load_output_code_cache(filename, source_code);
unsafe {
deno_reply_code_fetch(
d,
cmd_id,
as_cstring(&module_name).as_ptr(),
as_cstring(&filename).as_ptr(),
as_cstring(&source_code).as_ptr(),
as_cstring(&output_code).as_ptr(),
)
let mut f = result.unwrap();
let result = f.read_to_string(&mut source_code);
if result.is_err() {
let err = result.unwrap_err();
let errmsg = format!("{} {}", err, filename);
let errmsg_c = as_cstring(&errmsg);
unsafe { deno_reply_error(d, cmd_id, errmsg_c.as_ptr()) };
return;
}
}
let output_code = String::new(); //load_output_code_cache(filename, source_code);
unsafe {
deno_reply_code_fetch(
d,
cmd_id,
as_cstring(&module_name).as_ptr(),
as_cstring(&filename).as_ptr(),
as_cstring(&source_code).as_ptr(),
as_cstring(&output_code).as_ptr(),
)
}
}
fn is_remote(_module_name: &String) -> bool {
false
false
}

132
src/main.rs
View file

@ -9,101 +9,101 @@ 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,
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<_>>()
// 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,
ptr: *const DenoC,
}
impl Deno {
fn new() -> Deno {
let ptr = unsafe { deno_new(ptr::null(), deno_handle_msg_from_js) };
Deno { ptr: ptr }
}
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(())
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 drop(&mut self) {
unsafe { deno_delete(self.ptr) }
}
}
fn main() {
log::set_max_level(log::LevelFilter::Debug);
log::set_max_level(log::LevelFilter::Debug);
unsafe { deno_init() };
unsafe { deno_init() };
set_flags();
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();
let mut d = Deno::new();
d.execute("deno_main.js", "denoMain();")
.unwrap_or_else(|err| {
error!("{}", err);
std::process::exit(1);
});
d.execute("deno_main.js", "denoMain();")
.unwrap_or_else(|err| {
error!("{}", err);
std::process::exit(1);
});
}

1
tools/rustfmt.toml
View file

@ -1 +1,2 @@
max_width = 80
tab_spaces = 2