summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--cli/cli_behavior.rs16
-rw-r--r--cli/compiler.rs6
-rw-r--r--cli/isolate.rs13
-rw-r--r--cli/main.rs5
-rw-r--r--cli/ops.rs2
-rw-r--r--cli/startup_data.rs21
-rw-r--r--cli/workers.rs15
-rw-r--r--core/http_bench.rs19
-rw-r--r--core/isolate.rs70
-rw-r--r--core/libdeno.rs60
-rw-r--r--core/libdeno/api.cc10
-rw-r--r--core/libdeno/deno.h28
-rw-r--r--core/libdeno/internal.h1
-rw-r--r--core/libdeno/libdeno_test.cc14
-rw-r--r--core/libdeno/modules_test.cc8
-rw-r--r--core/libdeno/snapshot_creator.cc8
-rw-r--r--core/libdeno/test.cc2
-rw-r--r--core/libdeno/test.h3
18 files changed, 181 insertions, 120 deletions
diff --git a/cli/cli_behavior.rs b/cli/cli_behavior.rs
index 05f2cf006..860ec76ec 100644
--- a/cli/cli_behavior.rs
+++ b/cli/cli_behavior.rs
@@ -4,24 +4,16 @@ use crate::ops;
use deno::deno_buf;
use deno::Behavior;
use deno::Op;
-use deno::StartupData;
use std::sync::Arc;
/// Implements deno::Behavior for the main Deno command-line.
pub struct CliBehavior {
- startup_data: Option<StartupData>,
pub state: Arc<IsolateState>,
}
impl CliBehavior {
- pub fn new(
- startup_data: Option<StartupData>,
- state: Arc<IsolateState>,
- ) -> Self {
- Self {
- startup_data,
- state,
- }
+ pub fn new(state: Arc<IsolateState>) -> Self {
+ Self { state }
}
}
@@ -38,10 +30,6 @@ impl IsolateStateContainer for CliBehavior {
}
impl Behavior for CliBehavior {
- fn startup_data(&mut self) -> Option<StartupData> {
- self.startup_data.take()
- }
-
fn dispatch(
&mut self,
control: &[u8],
diff --git a/cli/compiler.rs b/cli/compiler.rs
index 3bf230bc3..e4d76c44c 100644
--- a/cli/compiler.rs
+++ b/cli/compiler.rs
@@ -17,7 +17,6 @@ use deno::Behavior;
use deno::Buf;
use deno::JSError;
use deno::Op;
-use deno::StartupData;
use futures::future::*;
use futures::sync::oneshot;
use futures::Future;
@@ -70,10 +69,6 @@ impl IsolateStateContainer for &CompilerBehavior {
}
impl Behavior for CompilerBehavior {
- fn startup_data(&mut self) -> Option<StartupData> {
- Some(startup_data::compiler_isolate_init())
- }
-
fn dispatch(
&mut self,
control: &[u8],
@@ -148,6 +143,7 @@ fn lazy_start(parent_state: Arc<IsolateState>) -> ResourceId {
cell
.get_or_insert_with(|| {
let worker_result = workers::spawn(
+ startup_data::compiler_isolate_init(),
CompilerBehavior::new(
parent_state.flags.clone(),
parent_state.argv.clone(),
diff --git a/cli/isolate.rs b/cli/isolate.rs
index 1d7201074..2e6d69d87 100644
--- a/cli/isolate.rs
+++ b/cli/isolate.rs
@@ -13,6 +13,7 @@ use deno;
use deno::deno_mod;
use deno::Behavior;
use deno::JSError;
+use deno::StartupData;
use futures::future::Either;
use futures::Async;
use futures::Future;
@@ -32,10 +33,10 @@ pub struct Isolate<B: Behavior> {
}
impl<B: DenoBehavior> Isolate<B> {
- pub fn new(behavior: B) -> Isolate<B> {
+ pub fn new(startup_data: StartupData, behavior: B) -> Isolate<B> {
let state = behavior.state().clone();
Self {
- inner: CoreIsolate::new(behavior),
+ inner: CoreIsolate::new(startup_data, behavior),
state,
}
}
@@ -270,8 +271,8 @@ mod tests {
let state = Arc::new(IsolateState::new(flags, rest_argv, None, false));
let state_ = state.clone();
tokio_util::run(lazy(move || {
- let cli = CliBehavior::new(None, state.clone());
- let mut isolate = Isolate::new(cli);
+ let cli = CliBehavior::new(state.clone());
+ let mut isolate = Isolate::new(StartupData::None, cli);
if let Err(err) = isolate.execute_mod(&filename, false) {
eprintln!("execute_mod err {:?}", err);
}
@@ -293,8 +294,8 @@ mod tests {
let state = Arc::new(IsolateState::new(flags, rest_argv, None, false));
let state_ = state.clone();
tokio_util::run(lazy(move || {
- let cli = CliBehavior::new(None, state.clone());
- let mut isolate = Isolate::new(cli);
+ let cli = CliBehavior::new(state.clone());
+ let mut isolate = Isolate::new(StartupData::None, cli);
if let Err(err) = isolate.execute_mod(&filename, false) {
eprintln!("execute_mod err {:?}", err);
}
diff --git a/cli/main.rs b/cli/main.rs
index 4d0ceab5a..bda4f7b8f 100644
--- a/cli/main.rs
+++ b/cli/main.rs
@@ -107,9 +107,8 @@ fn main() {
let state = Arc::new(IsolateState::new(flags, rest_argv, None, false));
let state_ = state.clone();
- let startup_data = startup_data::deno_isolate_init();
- let cli = CliBehavior::new(Some(startup_data), state_);
- let mut isolate = Isolate::new(cli);
+ let cli = CliBehavior::new(state_);
+ let mut isolate = Isolate::new(startup_data::deno_isolate_init(), cli);
let main_future = lazy(move || {
// Setup runtime.
diff --git a/cli/ops.rs b/cli/ops.rs
index 889061651..a0169d6ab 100644
--- a/cli/ops.rs
+++ b/cli/ops.rs
@@ -15,6 +15,7 @@ use crate::resolve_addr::resolve_addr;
use crate::resources;
use crate::resources::table_entries;
use crate::resources::Resource;
+use crate::startup_data;
use crate::tokio_util;
use crate::tokio_write;
use crate::version;
@@ -1865,6 +1866,7 @@ fn op_create_worker(
parent_state.argv.clone(),
);
match workers::spawn(
+ startup_data::deno_isolate_init(),
behavior,
&format!("USER-WORKER-{}", specifier),
workers::WorkerInit::Module(specifier.to_string()),
diff --git a/cli/startup_data.rs b/cli/startup_data.rs
index 61891ced4..1a77915e9 100644
--- a/cli/startup_data.rs
+++ b/cli/startup_data.rs
@@ -1,8 +1,7 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-use deno::deno_buf;
use deno::{Script, StartupData};
-pub fn deno_isolate_init() -> StartupData {
+pub fn deno_isolate_init() -> StartupData<'static> {
if cfg!(feature = "no-snapshot-init") {
debug!("Deno isolate init without snapshots.");
#[cfg(not(feature = "check-only"))]
@@ -12,8 +11,8 @@ pub fn deno_isolate_init() -> StartupData {
let source_bytes = vec![];
StartupData::Script(Script {
- filename: "gen/cli/bundle/main.js".to_string(),
- source: std::str::from_utf8(&source_bytes[..]).unwrap().to_string(),
+ filename: "gen/cli/bundle/main.js",
+ source: std::str::from_utf8(&source_bytes[..]).unwrap(),
})
} else {
debug!("Deno isolate init with snapshots.");
@@ -23,13 +22,11 @@ pub fn deno_isolate_init() -> StartupData {
#[cfg(any(feature = "check-only", feature = "no-snapshot-init"))]
let data = vec![];
- unsafe {
- StartupData::Snapshot(deno_buf::from_raw_parts(data.as_ptr(), data.len()))
- }
+ StartupData::Snapshot(data)
}
}
-pub fn compiler_isolate_init() -> StartupData {
+pub fn compiler_isolate_init() -> StartupData<'static> {
if cfg!(feature = "no-snapshot-init") {
debug!("Compiler isolate init without snapshots.");
#[cfg(not(feature = "check-only"))]
@@ -41,8 +38,8 @@ pub fn compiler_isolate_init() -> StartupData {
let source_bytes = vec![];
StartupData::Script(Script {
- filename: "gen/cli/bundle/compiler.js".to_string(),
- source: std::str::from_utf8(&source_bytes[..]).unwrap().to_string(),
+ filename: "gen/cli/bundle/compiler.js",
+ source: std::str::from_utf8(&source_bytes[..]).unwrap(),
})
} else {
debug!("Deno isolate init with snapshots.");
@@ -54,8 +51,6 @@ pub fn compiler_isolate_init() -> StartupData {
#[cfg(any(feature = "check-only", feature = "no-snapshot-init"))]
let data = vec![];
- unsafe {
- StartupData::Snapshot(deno_buf::from_raw_parts(data.as_ptr(), data.len()))
- }
+ StartupData::Snapshot(data)
}
}
diff --git a/cli/workers.rs b/cli/workers.rs
index 02126f1e2..7c39a5d2e 100644
--- a/cli/workers.rs
+++ b/cli/workers.rs
@@ -7,7 +7,6 @@ use crate::isolate_state::IsolateStateContainer;
use crate::isolate_state::WorkerChannels;
use crate::ops;
use crate::resources;
-use crate::startup_data;
use deno::deno_buf;
use deno::Behavior;
use deno::Buf;
@@ -44,10 +43,6 @@ impl IsolateStateContainer for &UserWorkerBehavior {
}
impl Behavior for UserWorkerBehavior {
- fn startup_data(&mut self) -> Option<StartupData> {
- Some(startup_data::deno_isolate_init())
- }
-
fn dispatch(
&mut self,
control: &[u8],
@@ -83,7 +78,7 @@ pub struct Worker<B: WorkerBehavior> {
}
impl<B: WorkerBehavior> Worker<B> {
- pub fn new(mut behavior: B) -> Self {
+ pub fn new(startup_data: StartupData, mut behavior: B) -> Self {
let (worker_in_tx, worker_in_rx) = mpsc::channel::<Buf>(1);
let (worker_out_tx, worker_out_rx) = mpsc::channel::<Buf>(1);
@@ -92,7 +87,7 @@ impl<B: WorkerBehavior> Worker<B> {
behavior.set_internal_channels(internal_channels);
- let isolate = Isolate::new(behavior);
+ let isolate = Isolate::new(startup_data, behavior);
Worker {
isolate,
@@ -129,12 +124,13 @@ pub enum WorkerInit {
}
pub fn spawn<B: WorkerBehavior + 'static>(
+ startup_data: StartupData,
behavior: B,
worker_debug_name: &str,
init: WorkerInit,
) -> Result<Worker<B>, RustOrJsError> {
let state = behavior.state().clone();
- let mut worker = Worker::new(behavior);
+ let mut worker = Worker::new(startup_data, behavior);
worker
.execute(&format!("denoMain('{}')", worker_debug_name))
@@ -172,6 +168,7 @@ mod tests {
use crate::compiler::CompilerBehavior;
use crate::isolate_state::IsolateState;
use crate::js_errors::JSErrorColor;
+ use crate::startup_data;
use crate::tokio_util;
use futures::future::lazy;
use std::thread;
@@ -180,6 +177,7 @@ mod tests {
fn test_spawn() {
tokio_util::init(|| {
let worker_result = spawn(
+ startup_data::compiler_isolate_init(),
CompilerBehavior::new(
IsolateState::mock().flags.clone(),
IsolateState::mock().argv.clone(),
@@ -242,6 +240,7 @@ mod tests {
fn removed_from_resource_table_on_close() {
tokio_util::init(|| {
let worker_result = spawn(
+ startup_data::compiler_isolate_init(),
CompilerBehavior::new(
IsolateState::mock().flags.clone(),
IsolateState::mock().argv.clone(),
diff --git a/core/http_bench.rs b/core/http_bench.rs
index 37965510f..fced92bf8 100644
--- a/core/http_bench.rs
+++ b/core/http_bench.rs
@@ -99,15 +99,6 @@ pub type HttpBenchOp = dyn Future<Item = i32, Error = std::io::Error> + Send;
struct HttpBench();
impl Behavior for HttpBench {
- fn startup_data(&mut self) -> Option<StartupData> {
- let js_source = include_str!("http_bench.js");
-
- Some(StartupData::Script(Script {
- source: js_source.to_string(),
- filename: "http_bench.js".to_string(),
- }))
- }
-
fn dispatch(
&mut self,
control: &[u8],
@@ -168,7 +159,15 @@ fn main() {
// TODO currently isolate.execute() must be run inside tokio, hence the
// lazy(). It would be nice to not have that contraint. Probably requires
// using v8::MicrotasksPolicy::kExplicit
- let isolate = deno::Isolate::new(HttpBench());
+
+ let js_source = include_str!("http_bench.js");
+
+ let startup_data = StartupData::Script(Script {
+ source: js_source,
+ filename: "http_bench.js",
+ });
+
+ let isolate = deno::Isolate::new(startup_data, HttpBench());
isolate.then(|r| {
js_check(r);
diff --git a/core/isolate.rs b/core/isolate.rs
index a722f5a3c..88f42be0e 100644
--- a/core/isolate.rs
+++ b/core/isolate.rs
@@ -8,6 +8,8 @@ use crate::js_errors::JSError;
use crate::libdeno;
use crate::libdeno::deno_buf;
use crate::libdeno::deno_mod;
+use crate::libdeno::Snapshot1;
+use crate::libdeno::Snapshot2;
use crate::shared_queue::SharedQueue;
use crate::shared_queue::RECOMMENDED_SIZE;
use futures::Async;
@@ -16,6 +18,7 @@ use futures::Poll;
use libc::c_void;
use std::ffi::CStr;
use std::ffi::CString;
+use std::ptr::null;
use std::sync::{Arc, Mutex, Once, ONCE_INIT};
pub type Buf = Box<[u8]>;
@@ -48,26 +51,24 @@ impl Future for PendingOp {
}
/// Stores a script used to initalize a Isolate
-pub struct Script {
- pub source: String,
- pub filename: String,
+pub struct Script<'a> {
+ pub source: &'a str,
+ pub filename: &'a str,
}
/// Represents data used to initialize isolate at startup
/// either a binary snapshot or a javascript source file
/// in the form of the StartupScript struct.
-pub enum StartupData {
- Script(Script),
- Snapshot(deno_buf),
+pub enum StartupData<'a> {
+ Script(Script<'a>),
+ Snapshot(&'a [u8]),
+ None,
}
/// Defines the behavior of an Isolate.
+// TODO(ry) Now that Behavior only has the dispatch method, it should be renamed
+// to Dispatcher.
pub trait Behavior {
- /// Allow for a behavior to define the snapshot or script used at
- /// startup to initalize the isolate. Called exactly once when an
- /// Isolate is created.
- fn startup_data(&mut self) -> Option<StartupData>;
-
/// Called whenever Deno.core.dispatch() is called in JavaScript. zero_copy_buf
/// corresponds to the second argument of Deno.core.dispatch().
fn dispatch(
@@ -109,7 +110,9 @@ impl<B: Behavior> Drop for Isolate<B> {
static DENO_INIT: Once = ONCE_INIT;
impl<B: Behavior> Isolate<B> {
- pub fn new(mut behavior: B) -> Self {
+ /// startup_data defines the snapshot or script used at startup to initalize
+ /// the isolate.
+ pub fn new(startup_data: StartupData, behavior: B) -> Self {
DENO_INIT.call_once(|| {
unsafe { libdeno::deno_init() };
});
@@ -118,16 +121,16 @@ impl<B: Behavior> Isolate<B> {
let needs_init = true;
// Seperate into Option values for eatch startup type
- let (startup_snapshot, startup_script) = match behavior.startup_data() {
- Some(StartupData::Snapshot(d)) => (Some(d), None),
- Some(StartupData::Script(d)) => (None, Some(d)),
- None => (None, None),
+ let (startup_snapshot, startup_script) = match startup_data {
+ StartupData::Snapshot(d) => (Some(d), None),
+ StartupData::Script(d) => (None, Some(d)),
+ StartupData::None => (None, None),
};
let config = libdeno::deno_config {
will_snapshot: 0,
load_snapshot: match startup_snapshot {
- Some(s) => s,
- None => libdeno::deno_buf::empty(),
+ Some(s) => Snapshot2::from(s),
+ None => Snapshot2::empty(),
},
shared: shared.as_deno_buf(),
recv_cb: Self::pre_dispatch,
@@ -146,9 +149,7 @@ impl<B: Behavior> Isolate<B> {
// If we want to use execute this has to happen here sadly.
if let Some(s) = startup_script {
- core_isolate
- .execute(s.filename.as_str(), s.source.as_str())
- .unwrap()
+ core_isolate.execute(s.filename, s.source).unwrap()
};
core_isolate
@@ -329,6 +330,18 @@ impl<B: Behavior> Isolate<B> {
}
out
}
+
+ pub fn snapshot_new(&self) -> Result<Snapshot1, JSError> {
+ let snapshot = unsafe { libdeno::deno_snapshot_new(self.libdeno_isolate) };
+ if let Some(js_error) = self.last_exception() {
+ assert_eq!(snapshot.data_ptr, null());
+ assert_eq!(snapshot.data_len, 0);
+ return Err(js_error);
+ }
+ assert_ne!(snapshot.data_ptr, null());
+ assert_ne!(snapshot.data_len, 0);
+ Ok(snapshot)
+ }
}
/// Called during mod_instantiate() to resolve imports.
@@ -546,10 +559,13 @@ pub mod tests {
impl TestBehavior {
pub fn setup(mode: TestBehaviorMode) -> Isolate<Self> {
- let mut isolate = Isolate::new(TestBehavior {
- dispatch_count: 0,
- mode,
- });
+ let mut isolate = Isolate::new(
+ StartupData::None,
+ TestBehavior {
+ dispatch_count: 0,
+ mode,
+ },
+ );
js_check(isolate.execute(
"setup.js",
r#"
@@ -566,10 +582,6 @@ pub mod tests {
}
impl Behavior for TestBehavior {
- fn startup_data(&mut self) -> Option<StartupData> {
- None
- }
-
fn dispatch(
&mut self,
control: &[u8],
diff --git a/core/libdeno.rs b/core/libdeno.rs
index 1a80330de..e6445f299 100644
--- a/core/libdeno.rs
+++ b/core/libdeno.rs
@@ -4,6 +4,7 @@ use libc::c_char;
use libc::c_int;
use libc::c_void;
use libc::size_t;
+use std::marker::PhantomData;
use std::ops::{Deref, DerefMut};
use std::ptr::null;
@@ -108,6 +109,56 @@ impl AsMut<[u8]> for deno_buf {
}
}
+#[repr(C)]
+pub struct deno_snapshot<'a> {
+ pub data_ptr: *const u8,
+ pub data_len: usize,
+ _marker: PhantomData<&'a [u8]>,
+}
+
+/// `deno_snapshot` can not clone, and there is no interior mutability.
+/// This type satisfies Send bound.
+unsafe impl Send for deno_snapshot<'_> {}
+
+// TODO(ry) Snapshot1 and Snapshot2 are not very good names and need to be
+// reconsidered. The entire snapshotting interface is still under construction.
+
+/// The type returned from deno_snapshot_new. Needs to be dropped.
+pub type Snapshot1<'a> = deno_snapshot<'a>;
+
+// TODO Does this make sense?
+impl Drop for Snapshot1<'_> {
+ fn drop(&mut self) {
+ unsafe { deno_snapshot_delete(self) }
+ }
+}
+
+/// The type created from slice. Used for loading.
+pub type Snapshot2<'a> = deno_snapshot<'a>;
+
+/// Converts Rust &Buf to libdeno `deno_buf`.
+impl<'a> From<&'a [u8]> for Snapshot2<'a> {
+ #[inline]
+ fn from(x: &'a [u8]) -> Self {
+ Self {
+ data_ptr: x.as_ref().as_ptr(),
+ data_len: x.len(),
+ _marker: PhantomData,
+ }
+ }
+}
+
+impl Snapshot2<'_> {
+ #[inline]
+ pub fn empty() -> Self {
+ Self {
+ data_ptr: null(),
+ data_len: 0,
+ _marker: PhantomData,
+ }
+ }
+}
+
#[allow(non_camel_case_types)]
type deno_recv_cb = unsafe extern "C" fn(
user_data: *mut c_void,
@@ -126,9 +177,9 @@ type deno_resolve_cb = unsafe extern "C" fn(
) -> deno_mod;
#[repr(C)]
-pub struct deno_config {
+pub struct deno_config<'a> {
pub will_snapshot: c_int,
- pub load_snapshot: deno_buf,
+ pub load_snapshot: Snapshot2<'a>,
pub shared: deno_buf,
pub recv_cb: deno_recv_cb,
}
@@ -214,4 +265,9 @@ extern "C" {
user_data: *const c_void,
id: deno_mod,
);
+
+ pub fn deno_snapshot_new(i: *const isolate) -> Snapshot1<'static>;
+
+ #[allow(dead_code)]
+ pub fn deno_snapshot_delete(s: &mut deno_snapshot);
}
diff --git a/core/libdeno/api.cc b/core/libdeno/api.cc
index fa1fe92f9..ad9c2a574 100644
--- a/core/libdeno/api.cc
+++ b/core/libdeno/api.cc
@@ -93,7 +93,7 @@ void deno_unlock(Deno* d_) {
d->locker_ = nullptr;
}
-deno_buf deno_get_snapshot(Deno* d_) {
+deno_snapshot deno_snapshot_new(Deno* d_) {
auto* d = unwrap(d_);
CHECK_NOT_NULL(d->snapshot_creator_);
d->ClearModules();
@@ -101,8 +101,12 @@ deno_buf deno_get_snapshot(Deno* d_) {
auto blob = d->snapshot_creator_->CreateBlob(
v8::SnapshotCreator::FunctionCodeHandling::kKeep);
- return {nullptr, 0, reinterpret_cast<uint8_t*>(const_cast<char*>(blob.data)),
- blob.raw_size, 0};
+ return {reinterpret_cast<uint8_t*>(const_cast<char*>(blob.data)),
+ blob.raw_size};
+}
+
+void deno_snapshot_delete(deno_snapshot snapshot) {
+ delete[] snapshot.data_ptr;
}
static std::unique_ptr<v8::Platform> platform;
diff --git a/core/libdeno/deno.h b/core/libdeno/deno.h
index f3902985e..8054090ed 100644
--- a/core/libdeno/deno.h
+++ b/core/libdeno/deno.h
@@ -18,6 +18,11 @@ typedef struct {
size_t zero_copy_id; // 0 = normal, 1 = must call deno_zero_copy_release.
} deno_buf;
+typedef struct {
+ uint8_t* data_ptr;
+ size_t data_len;
+} deno_snapshot;
+
typedef struct deno_s Deno;
// A callback to receive a message from a libdeno.send() javascript call.
@@ -31,22 +36,27 @@ const char* deno_v8_version();
void deno_set_v8_flags(int* argc, char** argv);
typedef struct {
- int will_snapshot; // Default 0. If calling deno_get_snapshot 1.
- deno_buf load_snapshot; // Optionally: A deno_buf from deno_get_snapshot.
- deno_buf shared; // Shared buffer to be mapped to libdeno.shared
- deno_recv_cb recv_cb; // Maps to libdeno.send() calls.
+ int will_snapshot; // Default 0. If calling deno_snapshot_new 1.
+ deno_snapshot load_snapshot; // A startup snapshot to use.
+ deno_buf shared; // Shared buffer to be mapped to libdeno.shared
+ deno_recv_cb recv_cb; // Maps to libdeno.send() calls.
} deno_config;
// Create a new deno isolate.
-// Warning: If config.will_snapshot is set, deno_get_snapshot() must be called
+// Warning: If config.will_snapshot is set, deno_snapshot_new() must be called
// or an error will result.
Deno* deno_new(deno_config config);
+void deno_delete(Deno* d);
-// Generate a snapshot. The resulting buf can be used with deno_new.
-// The caller must free the returned data by calling delete[] buf.data_ptr.
-deno_buf deno_get_snapshot(Deno* d);
+// Generate a snapshot. The resulting buf can be used in as the load_snapshot
+// member in deno_confg.
+// When calling this function, the caller must have created the isolate "d" with
+// "will_snapshot" set to 1.
+// The caller must free the returned data with deno_snapshot_delete().
+deno_snapshot deno_snapshot_new(Deno* d);
-void deno_delete(Deno* d);
+// Only for use with data returned from deno_snapshot_new.
+void deno_snapshot_delete(deno_snapshot);
void deno_lock(Deno* d);
void deno_unlock(Deno* d);
diff --git a/core/libdeno/internal.h b/core/libdeno/internal.h
index 71cf731b6..ce8c63c56 100644
--- a/core/libdeno/internal.h
+++ b/core/libdeno/internal.h
@@ -169,6 +169,7 @@ static intptr_t external_references[] = {
0};
static const deno_buf empty_buf = {nullptr, 0, nullptr, 0, 0};
+static const deno_snapshot empty_snapshot = {nullptr, 0};
Deno* NewFromSnapshot(void* user_data, deno_recv_cb cb);
diff --git a/core/libdeno/libdeno_test.cc b/core/libdeno/libdeno_test.cc
index 8949e7f4a..7b936cc32 100644
--- a/core/libdeno/libdeno_test.cc
+++ b/core/libdeno/libdeno_test.cc
@@ -10,10 +10,10 @@ TEST(LibDenoTest, InitializesCorrectly) {
}
TEST(LibDenoTest, Snapshotter) {
- Deno* d1 = deno_new(deno_config{1, empty, empty, nullptr});
+ Deno* d1 = deno_new(deno_config{1, empty_snapshot, empty, nullptr});
deno_execute(d1, nullptr, "a.js", "a = 1 + 2");
EXPECT_EQ(nullptr, deno_last_exception(d1));
- deno_buf test_snapshot = deno_get_snapshot(d1);
+ deno_snapshot test_snapshot = deno_snapshot_new(d1);
deno_delete(d1);
Deno* d2 = deno_new(deno_config{0, test_snapshot, empty, nullptr});
@@ -21,7 +21,7 @@ TEST(LibDenoTest, Snapshotter) {
EXPECT_EQ(nullptr, deno_last_exception(d2));
deno_delete(d2);
- delete[] test_snapshot.data_ptr;
+ deno_snapshot_delete(test_snapshot);
}
TEST(LibDenoTest, CanCallFunction) {
@@ -249,7 +249,7 @@ TEST(LibDenoTest, CheckPromiseErrors) {
}
TEST(LibDenoTest, LastException) {
- Deno* d = deno_new(deno_config{0, empty, empty, nullptr});
+ Deno* d = deno_new(deno_config{0, empty_snapshot, empty, nullptr});
EXPECT_EQ(deno_last_exception(d), nullptr);
deno_execute(d, nullptr, "a.js", "\n\nthrow Error('boo');\n\n");
EXPECT_STREQ(deno_last_exception(d),
@@ -264,7 +264,7 @@ TEST(LibDenoTest, LastException) {
}
TEST(LibDenoTest, EncodeErrorBug) {
- Deno* d = deno_new(deno_config{0, empty, empty, nullptr});
+ Deno* d = deno_new(deno_config{0, empty_snapshot, empty, nullptr});
EXPECT_EQ(deno_last_exception(d), nullptr);
deno_execute(d, nullptr, "a.js", "eval('a')");
EXPECT_STREQ(
@@ -293,7 +293,7 @@ TEST(LibDenoTest, Shared) {
}
TEST(LibDenoTest, Utf8Bug) {
- Deno* d = deno_new(deno_config{0, empty, empty, nullptr});
+ Deno* d = deno_new(deno_config{0, empty_snapshot, empty, nullptr});
// The following is a valid UTF-8 javascript which just defines a string
// literal. We had a bug where libdeno would choke on this.
deno_execute(d, nullptr, "a.js", "x = \"\xEF\xBF\xBD\"");
@@ -318,7 +318,7 @@ TEST(LibDenoTest, LibDenoEvalContextError) {
TEST(LibDenoTest, SharedAtomics) {
int32_t s[] = {0, 1, 2};
deno_buf shared = {nullptr, 0, reinterpret_cast<uint8_t*>(s), sizeof s, 0};
- Deno* d = deno_new(deno_config{0, empty, shared, nullptr});
+ Deno* d = deno_new(deno_config{0, empty_snapshot, shared, nullptr});
deno_execute(d, nullptr, "a.js",
"Atomics.add(new Int32Array(Deno.core.shared), 0, 1)");
EXPECT_EQ(nullptr, deno_last_exception(d));
diff --git a/core/libdeno/modules_test.cc b/core/libdeno/modules_test.cc
index 9f9228430..0eaa9e8eb 100644
--- a/core/libdeno/modules_test.cc
+++ b/core/libdeno/modules_test.cc
@@ -13,7 +13,7 @@ void recv_cb(void* user_data, deno_buf buf, deno_buf zero_copy_buf) {
TEST(ModulesTest, Resolution) {
exec_count = 0; // Reset
- Deno* d = deno_new(deno_config{0, empty, empty, recv_cb});
+ Deno* d = deno_new(deno_config{0, empty_snapshot, empty, recv_cb});
EXPECT_EQ(0, exec_count);
static deno_mod a = deno_mod_new(d, true, "a.js",
@@ -66,7 +66,7 @@ TEST(ModulesTest, Resolution) {
TEST(ModulesTest, ResolutionError) {
exec_count = 0; // Reset
- Deno* d = deno_new(deno_config{0, empty, empty, recv_cb});
+ Deno* d = deno_new(deno_config{0, empty_snapshot, empty, recv_cb});
EXPECT_EQ(0, exec_count);
static deno_mod a = deno_mod_new(d, true, "a.js",
@@ -99,7 +99,7 @@ TEST(ModulesTest, ResolutionError) {
TEST(ModulesTest, ImportMetaUrl) {
exec_count = 0; // Reset
- Deno* d = deno_new(deno_config{0, empty, empty, recv_cb});
+ Deno* d = deno_new(deno_config{0, empty_snapshot, empty, recv_cb});
EXPECT_EQ(0, exec_count);
static deno_mod a =
@@ -119,7 +119,7 @@ TEST(ModulesTest, ImportMetaUrl) {
}
TEST(ModulesTest, ImportMetaMain) {
- Deno* d = deno_new(deno_config{0, empty, empty, recv_cb});
+ Deno* d = deno_new(deno_config{0, empty_snapshot, empty, recv_cb});
const char* throw_not_main_src = "if (!import.meta.main) throw 'err'";
static deno_mod throw_not_main =
diff --git a/core/libdeno/snapshot_creator.cc b/core/libdeno/snapshot_creator.cc
index 19098392d..081bd1156 100644
--- a/core/libdeno/snapshot_creator.cc
+++ b/core/libdeno/snapshot_creator.cc
@@ -8,8 +8,6 @@
#include "third_party/v8/include/v8.h"
#include "third_party/v8/src/base/logging.h"
-namespace deno {} // namespace deno
-
int main(int argc, char** argv) {
const char* snapshot_out_bin = argv[1];
const char* js_fn = argv[2];
@@ -23,7 +21,7 @@ int main(int argc, char** argv) {
CHECK(deno::ReadFileToString(js_fn, &js_source));
deno_init();
- deno_config config = {1, deno::empty_buf, deno::empty_buf, nullptr};
+ deno_config config = {1, deno::empty_snapshot, deno::empty_buf, nullptr};
Deno* d = deno_new(config);
deno_execute(d, nullptr, js_fn, js_source.c_str());
@@ -34,13 +32,13 @@ int main(int argc, char** argv) {
return 1;
}
- auto snapshot = deno_get_snapshot(d);
+ auto snapshot = deno_snapshot_new(d);
std::ofstream file_(snapshot_out_bin, std::ios::binary);
file_.write(reinterpret_cast<char*>(snapshot.data_ptr), snapshot.data_len);
file_.close();
- delete[] snapshot.data_ptr;
+ deno_snapshot_delete(snapshot);
deno_delete(d);
return file_.bad();
diff --git a/core/libdeno/test.cc b/core/libdeno/test.cc
index 1340fe8c3..3d022c904 100644
--- a/core/libdeno/test.cc
+++ b/core/libdeno/test.cc
@@ -3,7 +3,7 @@
#include <string>
#include "file_util.h"
-deno_buf snapshot = {nullptr, 0, nullptr, 0, 0};
+deno_snapshot snapshot = {nullptr, 0};
int main(int argc, char** argv) {
// Locate the snapshot.
diff --git a/core/libdeno/test.h b/core/libdeno/test.h
index 2f7c32384..dd5dc99b2 100644
--- a/core/libdeno/test.h
+++ b/core/libdeno/test.h
@@ -5,7 +5,8 @@
#include "deno.h"
#include "testing/gtest/include/gtest/gtest.h"
-extern deno_buf snapshot; // Loaded in libdeno/test.cc
+extern deno_snapshot snapshot; // Loaded in libdeno/test.cc
const deno_buf empty = {nullptr, 0, nullptr, 0, 0};
+const deno_snapshot empty_snapshot = {nullptr, 0};
#endif // TEST_H_
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-27 14:44:20 +0000