foster/denoland-deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-11-24 15:19:26 -05:00
Code Issues Packages 1 Wiki Activity

namespace reorg: libdeno and DenoCore to Deno.core (#1998)

Browse source
This commit is contained in:
Kitson Kelly 2019-03-26 23:22:07 +11:00 committed by Ryan Dahl
parent ed2977d3c0
commit c43cfedeba
26 changed files with 178 additions and 146 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
BUILD.gn
View file

@ -82,7 +82,6 @@ ts_sources = [
"js/globals.ts",
"js/headers.ts",
"js/io.ts",
"js/libdeno.ts",
"js/lib.web_assembly.d.ts",
"js/location.ts",
"js/main.ts",

6
cli/ops.rs
View file

@ -69,9 +69,9 @@ fn empty_buf() -> Buf {
}
/// Processes raw messages from JavaScript.
/// This functions invoked every time libdeno.send() is called.
/// control corresponds to the first argument of libdeno.send().
/// data corresponds to the second argument of libdeno.send().
/// This functions invoked every time Deno.core.dispatch() is called.
/// control corresponds to the first argument of Deno.core.dispatch().
/// data corresponds to the second argument of Deno.core.dispatch().
pub fn dispatch_all(
sc: &IsolateStateContainer,
control: &[u8],

25
core/core.d.ts vendored Normal file
View file

@ -0,0 +1,25 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
// This file contains APIs that are introduced into the global namespace by
// Deno core. These are not intended to be used directly by runtime users of
// Deno and therefore do not flow through to the runtime type library.
declare interface MessageCallback {
(msg: Uint8Array): void;
}
declare interface DenoCore {
dispatch(
control: Uint8Array,
zeroCopy?: ArrayBufferView | null
): Uint8Array | null;
setAsyncHandler(cb: MessageCallback): void;
sharedQueue: {
head(): number;
numRecords(): number;
size(): number;
push(buf: Uint8Array): boolean;
reset(): void;
shift(): Uint8Array | null;
};
}

12
core/http_bench.js
View file

@ -42,7 +42,7 @@ function send(promiseId, opId, arg, zeroCopy = null) {
scratch32[1] = opId;
scratch32[2] = arg;
scratch32[3] = -1;
return DenoCore.dispatch(scratchBytes, zeroCopy);
return Deno.core.dispatch(scratchBytes, zeroCopy);
}
/** Returns Promise<number> */
@ -123,17 +123,17 @@ async function serve(rid) {
}
async function main() {
DenoCore.setAsyncHandler(handleAsyncMsgFromRust);
Deno.core.setAsyncHandler(handleAsyncMsgFromRust);
libdeno.print("http_bench.js start\n");
Deno.core.print("http_bench.js start\n");
const listenerRid = listen();
libdeno.print(`listening http://127.0.0.1:4544/ rid = ${listenerRid}\n`);
Deno.core.print(`listening http://127.0.0.1:4544/ rid = ${listenerRid}\n`);
while (true) {
const rid = await accept(listenerRid);
// libdeno.print(`accepted ${rid}`);
// Deno.core.print(`accepted ${rid}`);
if (rid < 0) {
libdeno.print(`accept error ${rid}`);
Deno.core.print(`accept error ${rid}`);
return;
}
serve(rid);

68
core/isolate.rs
View file

@ -63,8 +63,8 @@ pub trait Behavior {
/// Isolate is created.
fn startup_data(&mut self) -> Option<StartupData>;
/// Called whenever libdeno.send() is called in JavaScript. zero_copy_buf
/// corresponds to the second argument of libdeno.send().
/// Called whenever Deno.core.send() is called in JavaScript. zero_copy_buf
/// corresponds to the second argument of Deno.core.send().
fn dispatch(
&mut self,
control: &[u8],
@ -77,7 +77,7 @@ pub trait Behavior {
/// Tokio. The Isolate future complete when there is an error or when all
/// pending ops have completed.
///
/// Ops are created in JavaScript by calling libdeno.send(), and in Rust by
/// Ops are created in JavaScript by calling Deno.core.send(), and in Rust by
/// implementing Behavior::dispatch. An Op corresponds exactly to a Promise in
/// JavaScript.
pub struct Isolate<B: Behavior> {
@ -125,7 +125,7 @@ impl<B: Behavior> Isolate<B> {
None => libdeno::deno_buf::empty(),
},
shared: shared.as_deno_buf(),
recv_cb: Self::pre_dispatch,
recv_cb: Self::predispatch,
};
let libdeno_isolate = unsafe { libdeno::deno_new(config) };
@ -157,7 +157,7 @@ impl<B: Behavior> Isolate<B> {
}
}
/// Executes a bit of built-in JavaScript to provide Deno._sharedQueue.
/// Executes a bit of built-in JavaScript to provide Deno.sharedQueue.
pub fn shared_init(&mut self) {
if self.needs_init {
self.needs_init = false;
@ -167,7 +167,7 @@ impl<B: Behavior> Isolate<B> {
}
}
extern "C" fn pre_dispatch(
extern "C" fn predispatch(
user_data: *mut c_void,
control_argv0: deno_buf,
zero_copy_buf: deno_buf,
@ -178,12 +178,12 @@ impl<B: Behavior> Isolate<B> {
let control_shared = isolate.shared.shift();
let (is_sync, op) = if control_argv0.len() > 0 {
// The user called libdeno.send(control)
// The user called Deno.core.send(control)
isolate
.behavior
.dispatch(control_argv0.as_ref(), zero_copy_buf)
} else if let Some(c) = control_shared {
// The user called Deno._sharedQueue.push(control)
// The user called Deno.sharedQueue.push(control)
isolate.behavior.dispatch(&c, zero_copy_buf)
} else {
// The sharedQueue is empty. The shouldn't happen usually, but it's also
@ -199,7 +199,7 @@ impl<B: Behavior> Isolate<B> {
if is_sync {
let res_record = op.wait().unwrap();
// For sync messages, we always return the response via libdeno.send's
// For sync messages, we always return the response via Deno.core.send's
// return value.
// TODO(ry) check that if JSError thrown during respond(), that it will be
// picked up.
@ -614,15 +614,15 @@ mod tests {
}
#[test]
fn test_dispatch() {
fn testdispatch() {
let mut isolate = TestBehavior::setup(TestBehaviorMode::AsyncImmediate);
js_check(isolate.execute(
"filename.js",
r#"
let control = new Uint8Array([42]);
libdeno.send(control);
Deno.core.send(control);
async function main() {
libdeno.send(control);
Deno.core.send(control);
}
main();
"#,
@ -641,7 +641,7 @@ mod tests {
import { b } from 'b.js'
if (b() != 'b') throw Error();
let control = new Uint8Array([42]);
libdeno.send(control);
Deno.core.send(control);
"#,
).unwrap();
assert_eq!(isolate.behavior.dispatch_count, 0);
@ -685,7 +685,7 @@ mod tests {
"setup2.js",
r#"
let nrecv = 0;
DenoCore.setAsyncHandler((buf) => {
Deno.core.setAsyncHandler((buf) => {
nrecv++;
});
"#,
@ -696,7 +696,7 @@ mod tests {
r#"
assert(nrecv == 0);
let control = new Uint8Array([42]);
libdeno.send(control);
Deno.core.send(control);
assert(nrecv == 0);
"#,
));
@ -707,7 +707,7 @@ mod tests {
"check2.js",
r#"
assert(nrecv == 1);
libdeno.send(control);
Deno.core.send(control);
assert(nrecv == 1);
"#,
));
@ -727,7 +727,7 @@ mod tests {
"setup2.js",
r#"
let nrecv = 0;
DenoCore.setAsyncHandler((buf) => {
Deno.core.setAsyncHandler((buf) => {
assert(buf.byteLength === 1);
assert(buf[0] === 43);
nrecv++;
@ -740,12 +740,12 @@ mod tests {
"send1.js",
r#"
let control = new Uint8Array([42]);
DenoCore.shared.push(control);
libdeno.send();
Deno.core.sharedQueue.push(control);
Deno.core.send();
assert(nrecv === 0);
DenoCore.shared.push(control);
libdeno.send();
Deno.core.sharedQueue.push(control);
Deno.core.send();
assert(nrecv === 0);
"#,
));
@ -832,10 +832,10 @@ mod tests {
"overflow_req_sync.js",
r#"
let asyncRecv = 0;
DenoCore.setAsyncHandler((buf) => { asyncRecv++ });
Deno.core.setAsyncHandler((buf) => { asyncRecv++ });
// Large message that will overflow the shared space.
let control = new Uint8Array(100 * 1024 * 1024);
let response = DenoCore.dispatch(control);
let response = Deno.core.dispatch(control);
assert(response instanceof Uint8Array);
assert(response.length == 1);
assert(response[0] == 43);
@ -854,10 +854,10 @@ mod tests {
"overflow_res_sync.js",
r#"
let asyncRecv = 0;
DenoCore.setAsyncHandler((buf) => { asyncRecv++ });
Deno.core.setAsyncHandler((buf) => { asyncRecv++ });
// Large message that will overflow the shared space.
let control = new Uint8Array([42]);
let response = DenoCore.dispatch(control);
let response = Deno.core.dispatch(control);
assert(response instanceof Uint8Array);
assert(response.length == 100 * 1024 * 1024);
assert(response[0] == 99);
@ -874,14 +874,14 @@ mod tests {
"overflow_req_async.js",
r#"
let asyncRecv = 0;
DenoCore.setAsyncHandler((buf) => {
Deno.core.setAsyncHandler((buf) => {
assert(buf.byteLength === 1);
assert(buf[0] === 43);
asyncRecv++;
});
// Large message that will overflow the shared space.
let control = new Uint8Array(100 * 1024 * 1024);
let response = DenoCore.dispatch(control);
let response = Deno.core.dispatch(control);
// Async messages always have null response.
assert(response == null);
assert(asyncRecv == 0);
@ -901,14 +901,14 @@ mod tests {
"overflow_res_async.js",
r#"
let asyncRecv = 0;
DenoCore.setAsyncHandler((buf) => {
Deno.core.setAsyncHandler((buf) => {
assert(buf.byteLength === 100 * 1024 * 1024);
assert(buf[0] === 4);
asyncRecv++;
});
// Large message that will overflow the shared space.
let control = new Uint8Array([42]);
let response = DenoCore.dispatch(control);
let response = Deno.core.dispatch(control);
assert(response == null);
assert(asyncRecv == 0);
"#,
@ -919,27 +919,27 @@ mod tests {
}
#[test]
fn overflow_res_multiple_dispatch_async() {
fn overflow_res_multipledispatch_async() {
// TODO(ry) This test is quite slow due to memcpy-ing 100MB into JS. We
// should optimize this.
let mut isolate = TestBehavior::setup(TestBehaviorMode::OverflowResAsync);
js_check(isolate.execute(
"overflow_res_multiple_dispatch_async.js",
"overflow_res_multipledispatch_async.js",
r#"
let asyncRecv = 0;
DenoCore.setAsyncHandler((buf) => {
Deno.core.setAsyncHandler((buf) => {
assert(buf.byteLength === 100 * 1024 * 1024);
assert(buf[0] === 4);
asyncRecv++;
});
// Large message that will overflow the shared space.
let control = new Uint8Array([42]);
let response = DenoCore.dispatch(control);
let response = Deno.core.dispatch(control);
assert(response == null);
assert(asyncRecv == 0);
// Dispatch another message to verify that pending ops
// are done even if shared space overflows
DenoCore.dispatch(control);
Deno.core.dispatch(control);
"#,
));
assert_eq!(isolate.behavior.dispatch_count, 2);

35
core/shared_queue.js
View file

@ -1,5 +1,8 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
(window => {
const GLOBAL_NAMESPACE = "Deno";
const CORE_NAMESPACE = "core";
const MAX_RECORDS = 100;
const INDEX_NUM_RECORDS = 0;
const INDEX_NUM_SHIFTED_OFF = 1;
@ -8,8 +11,11 @@
const INDEX_RECORDS = 3 + MAX_RECORDS;
const HEAD_INIT = 4 * INDEX_RECORDS;
let sharedBytes = null;
let shared32 = null;
const Deno = window[GLOBAL_NAMESPACE];
const core = Deno[CORE_NAMESPACE];
let sharedBytes;
let shared32;
function assert(cond) {
if (!cond) {
@ -92,10 +98,12 @@
reset();
}
assert(off != null);
assert(end != null);
return sharedBytes.subarray(off, end);
}
let asyncHandler = null;
let asyncHandler;
function setAsyncHandler(cb) {
assert(asyncHandler == null);
asyncHandler = cb;
@ -117,23 +125,22 @@
assert(shared32 == null);
sharedBytes = new Uint8Array(shared);
shared32 = new Int32Array(shared);
// Callers should not call libdeno.recv, use setAsyncHandler.
libdeno.recv(handleAsyncMsgFromRust);
// Callers should not call Deno.core.recv, use setAsyncHandler.
window.Deno.core.recv(handleAsyncMsgFromRust);
}
function dispatch(control, zeroCopy = null) {
// First try to push control to shared.
const success = push(control);
// If successful, don't use first argument of libdeno.send.
// If successful, don't use first argument of core.send.
const arg0 = success ? null : control;
return libdeno.send(arg0, zeroCopy);
return window.Deno.core.send(arg0, zeroCopy);
}
assert(!window["DenoCore"]);
window["DenoCore"] = {
const denoCore = {
setAsyncHandler,
dispatch,
shared: {
sharedQueue: {
head,
numRecords,
size,
@ -143,5 +150,9 @@
}
};
init(libdeno.shared);
})(this);
assert(window[GLOBAL_NAMESPACE] != null);
assert(window[GLOBAL_NAMESPACE][CORE_NAMESPACE] != null);
Object.assign(core, denoCore);
init(Deno.core.shared);
})(globalThis);

4
core/shared_queue_test.js
View file

@ -7,7 +7,7 @@ function assert(cond) {
}
function main() {
const q = DenoCore.shared;
const q = Deno.core.sharedQueue;
let h = q.head();
assert(h > 0);
@ -56,7 +56,7 @@ function main() {
assert(q.numRecords() == 0);
assert(q.size() == 0);
libdeno.print("shared_queue_test.js ok\n");
Deno.core.print("shared_queue_test.js ok\n");
}
main();

4
js/compiler.ts
View file

@ -4,7 +4,7 @@ import * as msg from "gen/msg_generated";
import { window } from "./window";
import { assetSourceCode } from "./assets";
import { Console } from "./console";
import { libdeno } from "./libdeno";
import { core } from "./core";
import * as os from "./os";
import { TextDecoder, TextEncoder } from "./text_encoding";
import { clearTimer, setTimeout } from "./timers";
@ -16,7 +16,7 @@ const ASSETS = "$asset$";
const LIB_RUNTIME = `${ASSETS}/lib.deno_runtime.d.ts`;
// An instance of console
const console = new Console(libdeno.print);
const console = new Console(core.print);
/** The location that a module is being loaded from. This could be a directory,
* like `.`, or it could be a module specifier like

4
js/console.ts
View file

@ -5,7 +5,7 @@ import { TextEncoder } from "./text_encoding";
import { File, stdout } from "./files";
import { cliTable } from "./console_table";
import { formatError } from "./format_error";
import { libdeno } from "./libdeno";
import { core } from "./core";
type ConsoleContext = Set<unknown>;
type ConsoleOptions = Partial<{
@ -323,7 +323,7 @@ function createObjectString(
...args: [ConsoleContext, number, number]
): string {
if (value instanceof Error) {
const errorJSON = libdeno.errorToJSON(value);
const errorJSON = core.errorToJSON(value);
return formatError(errorJSON);
} else if (Array.isArray(value)) {
return createArrayString(value, ...args);

11
js/core.ts
View file

@ -1,13 +1,4 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { window } from "./window";
type MessageCallback = (msg: Uint8Array) => void;
// Declared in core/shared_queue.js.
interface DenoCore {
setAsyncHandler(cb: MessageCallback): void;
dispatch(control: Uint8Array, zeroCopy?: Uint8Array): null | Uint8Array;
}
// TODO(ry) Rename to Deno.core.shared and Deno.core.setAsyncHandler.
export const DenoCore = window.DenoCore as DenoCore;
export const core = window.Deno.core as DenoCore;

6
js/deno.ts
View file

@ -49,7 +49,6 @@ export { statSync, lstatSync, stat, lstat } from "./stat";
export { symlinkSync, symlink } from "./symlink";
export { writeFileSync, writeFile, WriteFileOptions } from "./write_file";
export { ErrorKind, DenoError } from "./errors";
export { libdeno } from "./libdeno";
export {
permissions,
revokePermission,
@ -67,6 +66,11 @@ export { build, platform, OperatingSystem, Arch } from "./build";
export { version } from "./version";
export const args: string[] = [];
// These are internal Deno APIs. We are marking them as internal so they do not
// appear in the runtime type library.
/** @internal */
export { core } from "./core";
// TODO Don't expose Console nor stringifyArgs.
/** @internal */
export { Console, stringifyArgs } from "./console";

4
js/dispatch.ts
View file

@ -1,5 +1,5 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { window } from "./window";
import { core } from "./core";
import * as flatbuffers from "./flatbuffers";
import * as msg from "gen/msg_generated";
import * as errors from "./errors";
@ -39,7 +39,7 @@ function sendInternal(
builder.finish(msg.Base.endBase(builder));
const control = builder.asUint8Array();
const response = window.DenoCore.dispatch(control, zeroCopy);
const response = core.dispatch(control, zeroCopy);
builder.inUse = false;
return [cmdId, response];

4
js/event.ts
View file

@ -21,7 +21,7 @@ export class EventInit implements domTypes.EventInit {
export class Event implements domTypes.Event {
// Each event has the following associated flags
private _canceledFlag = false;
private _dispatchedFlag = false;
private dispatchedFlag = false;
private _initializedFlag = false;
private _inPassiveListenerFlag = false;
private _stopImmediatePropagationFlag = false;
@ -76,7 +76,7 @@ export class Event implements domTypes.Event {
}
get dispatched(): boolean {
return this._dispatchedFlag;
return this.dispatchedFlag;
}
get eventPhase(): number {

2
js/flatbuffers.ts
View file

@ -17,7 +17,7 @@ globalBuilder.inUse = false;
// This is a wrapper around the real Builder .
// The purpose is to reuse a single ArrayBuffer for every message.
// We can do this because the "control" messages sent to the privileged
// side are guaranteed to be used during the call to libdeno.send().
// side are guaranteed to be used during the call to Deno.core.send().
export function createBuilder(): Builder {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const gb = globalBuilder as any;

5
js/globals.ts
View file

@ -27,7 +27,7 @@ import * as performanceUtil from "./performance";
// These imports are not exposed and therefore are fine to just import the
// symbols required.
import { libdeno } from "./libdeno";
import { core } from "./core";
// During the build process, augmentations to the variable `window` in this
// file are tracked and created as part of default library that is built into
@ -43,7 +43,6 @@ window.window = window;
// This is the Deno namespace, it is handled differently from other window
// properties when building the runtime type library, as the whole module
// is flattened into a single namespace.
window.Deno = deno;
Object.freeze(window.Deno);
@ -53,7 +52,7 @@ window.btoa = textEncoding.btoa;
window.fetch = fetchTypes.fetch;
window.clearTimeout = timers.clearTimer;
window.clearInterval = timers.clearTimer;
window.console = new consoleTypes.Console(libdeno.print);
window.console = new consoleTypes.Console(core.print);
window.setTimeout = timers.setTimeout;
window.setInterval = timers.setInterval;
window.location = (undefined as unknown) as domTypes.Location;

11
js/os.ts
View file

@ -1,6 +1,6 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import * as msg from "gen/msg_generated";
import { window } from "./window";
import { core } from "./core";
import { handleAsyncMsgFromRust, sendSync } from "./dispatch";
import * as flatbuffers from "./flatbuffers";
import { TextDecoder } from "./text_encoding";
@ -16,12 +16,7 @@ export let noColor: boolean;
/** Path to the current deno process's executable file. */
export let execPath: string;
/** @internal */
export function setGlobals(
pid_: number,
noColor_: boolean,
execPath_: string
): void {
function setGlobals(pid_: number, noColor_: boolean, execPath_: string): void {
assert(!pid);
pid = pid_;
noColor = noColor_;
@ -169,7 +164,7 @@ function sendStart(): msg.StartRes {
// the runtime and the compiler environments.
// @internal
export function start(source?: string): msg.StartRes {
window.DenoCore.setAsyncHandler(handleAsyncMsgFromRust);
core.setAsyncHandler(handleAsyncMsgFromRust);
// First we send an empty `Start` message to let the privileged side know we
// are ready. The response should be a `StartRes` message containing the CLI

10
js/repl.ts
View file

@ -6,7 +6,7 @@ import { close } from "./files";
import * as dispatch from "./dispatch";
import { exit } from "./os";
import { window } from "./window";
import { libdeno } from "./libdeno";
import { core } from "./core";
import { formatError } from "./format_error";
const helpMsg = [
@ -90,7 +90,7 @@ function isRecoverableError(e: Error): boolean {
// Returns true if code is consumed (no error/irrecoverable error).
// Returns false if error is recoverable
function evaluate(code: string): boolean {
const [result, errInfo] = libdeno.evalContext(code);
const [result, errInfo] = core.evalContext(code);
if (!errInfo) {
console.log(result);
} else if (errInfo.isCompileError && isRecoverableError(errInfo.thrown)) {
@ -99,7 +99,7 @@ function evaluate(code: string): boolean {
} else {
if (errInfo.isNativeError) {
const formattedError = formatError(
libdeno.errorToJSON(errInfo.thrown as Error)
core.errorToJSON(errInfo.thrown as Error)
);
console.error(formattedError);
} else {
@ -140,7 +140,7 @@ export async function replLoop(): Promise<void> {
if (err.message !== "Interrupted") {
// e.g. this happens when we have deno.close(3).
// We want to display the problem.
const formattedError = formatError(libdeno.errorToJSON(err));
const formattedError = formatError(core.errorToJSON(err));
console.error(formattedError);
}
// Quit REPL anyways.
@ -162,7 +162,7 @@ export async function replLoop(): Promise<void> {
} else {
// e.g. this happens when we have deno.close(3).
// We want to display the problem.
const formattedError = formatError(libdeno.errorToJSON(err));
const formattedError = formatError(core.errorToJSON(err));
console.error(formattedError);
quitRepl(1);
}

2
libdeno/api.cc
View file

@ -177,7 +177,7 @@ void deno_respond(Deno* d_, void* user_data, deno_buf buf) {
auto recv_ = d->recv_.Get(d->isolate_);
if (recv_.IsEmpty()) {
d->last_exception_ = "libdeno.recv_ has not been called.";
d->last_exception_ = "Deno.core.recv has not been called.";
return;
}

19
libdeno/binding.cc
View file

@ -232,7 +232,7 @@ void Recv(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::HandleScope handle_scope(isolate);
if (!d->recv_.IsEmpty()) {
isolate->ThrowException(v8_str("libdeno.recv_ already called."));
isolate->ThrowException(v8_str("Deno.core.recv already called."));
return;
}
@ -485,33 +485,36 @@ void InitializeContext(v8::Isolate* isolate, v8::Local<v8::Context> context) {
auto global = context->Global();
auto deno_val = v8::Object::New(isolate);
CHECK(global->Set(context, deno::v8_str("libdeno"), deno_val).FromJust());
CHECK(global->Set(context, deno::v8_str("Deno"), deno_val).FromJust());
auto core_val = v8::Object::New(isolate);
CHECK(deno_val->Set(context, deno::v8_str("core"), core_val).FromJust());
auto print_tmpl = v8::FunctionTemplate::New(isolate, Print);
auto print_val = print_tmpl->GetFunction(context).ToLocalChecked();
CHECK(deno_val->Set(context, deno::v8_str("print"), print_val).FromJust());
CHECK(core_val->Set(context, deno::v8_str("print"), print_val).FromJust());
auto recv_tmpl = v8::FunctionTemplate::New(isolate, Recv);
auto recv_val = recv_tmpl->GetFunction(context).ToLocalChecked();
CHECK(deno_val->Set(context, deno::v8_str("recv"), recv_val).FromJust());
CHECK(core_val->Set(context, deno::v8_str("recv"), recv_val).FromJust());
auto send_tmpl = v8::FunctionTemplate::New(isolate, Send);
auto send_val = send_tmpl->GetFunction(context).ToLocalChecked();
CHECK(deno_val->Set(context, deno::v8_str("send"), send_val).FromJust());
CHECK(core_val->Set(context, deno::v8_str("send"), send_val).FromJust());
auto eval_context_tmpl = v8::FunctionTemplate::New(isolate, EvalContext);
auto eval_context_val =
eval_context_tmpl->GetFunction(context).ToLocalChecked();
CHECK(deno_val->Set(context, deno::v8_str("evalContext"), eval_context_val)
CHECK(core_val->Set(context, deno::v8_str("evalContext"), eval_context_val)
.FromJust());
auto error_to_json_tmpl = v8::FunctionTemplate::New(isolate, ErrorToJSON);
auto error_to_json_val =
error_to_json_tmpl->GetFunction(context).ToLocalChecked();
CHECK(deno_val->Set(context, deno::v8_str("errorToJSON"), error_to_json_val)
CHECK(core_val->Set(context, deno::v8_str("errorToJSON"), error_to_json_val)
.FromJust());
CHECK(deno_val->SetAccessor(context, deno::v8_str("shared"), Shared)
CHECK(core_val->SetAccessor(context, deno::v8_str("shared"), Shared)
.FromJust());
}

12
libdeno/deno.h
View file

@ -23,8 +23,8 @@ typedef struct deno_s Deno;
// A callback to receive a message from a libdeno.send() javascript call.
// control_buf is valid for only for the lifetime of this callback.
// data_buf is valid until deno_respond() is called.
typedef void (*deno_recv_cb)(void* user_data, deno_buf control_buf,
deno_buf zerop_copy_buf);
typedef void (*denorecv_cb)(void* user_data, deno_buf control_buf,
deno_buf zerop_copy_buf);
void deno_init();
const char* deno_v8_version();
@ -34,7 +34,7 @@ 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.
denorecv_cb recv_cb; // Maps to libdeno.send() calls.
} deno_config;
// Create a new deno isolate.
@ -57,13 +57,13 @@ void deno_unlock(Deno* d);
void deno_execute(Deno* d, void* user_data, const char* js_filename,
const char* js_source);
// deno_respond sends up to one message back for every deno_recv_cb made.
// deno_respond sends up to one message back for every denorecv_cb made.
//
// If this is called during deno_recv_cb, the issuing libdeno.send() in
// If this is called during denorecv_cb, the issuing libdeno.send() in
// javascript will synchronously return the specified buf as an ArrayBuffer (or
// null if buf is empty).
//
// If this is called after deno_recv_cb has returned, the deno_respond
// If this is called after denorecv_cb has returned, the deno_respond
// will call into the JS callback specified by libdeno.recv().
//
// (Ideally, but not currently: After calling deno_respond(), the caller no

4
libdeno/internal.h
View file

@ -104,7 +104,7 @@ class DenoIsolate {
const v8::FunctionCallbackInfo<v8::Value>* current_args_;
v8::SnapshotCreator* snapshot_creator_;
void* global_import_buf_ptr_;
deno_recv_cb recv_cb_;
denorecv_cb recv_cb_;
size_t next_zero_copy_id_;
void* user_data_;
@ -170,7 +170,7 @@ static intptr_t external_references[] = {
static const deno_buf empty_buf = {nullptr, 0, nullptr, 0, 0};
Deno* NewFromSnapshot(void* user_data, deno_recv_cb cb);
Deno* NewFromSnapshot(void* user_data, denorecv_cb cb);
void InitializeContext(v8::Isolate* isolate, v8::Local<v8::Context> context);

12
js/libdeno.ts → libdeno/libdeno.d.ts vendored
View file

@ -1,8 +1,4 @@
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
import { window } from "./window";
// The libdeno functions are moved so that users can't access them.
type MessageCallback = (msg: Uint8Array) => void;
interface EvalErrorInfo {
// Is the object thrown a native Error?
@ -16,7 +12,11 @@ interface EvalErrorInfo {
thrown: any;
}
interface Libdeno {
declare interface MessageCallback {
(msg: Uint8Array): void;
}
declare interface DenoCore {
recv(cb: MessageCallback): void;
send(
@ -38,5 +38,3 @@ interface Libdeno {
errorToJSON: (e: Error) => string;
}
export const libdeno = window.libdeno as Libdeno;

2
libdeno/libdeno_test.cc
View file

@ -320,7 +320,7 @@ TEST(LibDenoTest, SharedAtomics) {
deno_buf shared = {nullptr, 0, reinterpret_cast<uint8_t*>(s), sizeof s, 0};
Deno* d = deno_new(deno_config{0, empty, shared, nullptr});
deno_execute(d, nullptr, "a.js",
"Atomics.add(new Int32Array(libdeno.shared), 0, 1)");
"Atomics.add(new Int32Array(Deno.core.shared), 0, 1)");
EXPECT_EQ(nullptr, deno_last_exception(d));
EXPECT_EQ(s[0], 1);
EXPECT_EQ(s[1], 1);

47
libdeno/libdeno_test.js
View file

@ -10,7 +10,7 @@ function assert(cond) {
}
global.CanCallFunction = () => {
libdeno.print("Hello world from foo");
Deno.core.print("Hello world from foo");
return "foo";
};
@ -28,15 +28,15 @@ global.TypedArraySnapshots = () => {
global.RecvReturnEmpty = () => {
const m1 = new Uint8Array("abc".split("").map(c => c.charCodeAt(0)));
const m2 = m1.slice();
const r1 = libdeno.send(m1);
const r1 = Deno.core.send(m1);
assert(r1 == null);
const r2 = libdeno.send(m2);
const r2 = Deno.core.send(m2);
assert(r2 == null);
};
global.RecvReturnBar = () => {
const m = new Uint8Array("abc".split("").map(c => c.charCodeAt(0)));
const r = libdeno.send(m);
const r = Deno.core.send(m);
assert(r instanceof Uint8Array);
assert(r.byteLength === 3);
const rstr = String.fromCharCode(...r);
@ -44,10 +44,10 @@ global.RecvReturnBar = () => {
};
global.DoubleRecvFails = () => {
// libdeno.recv is an internal function and should only be called once from the
// Deno.core.recv is an internal function and should only be called once from the
// runtime.
libdeno.recv((channel, msg) => assert(false));
libdeno.recv((channel, msg) => assert(false));
Deno.core.recv((channel, msg) => assert(false));
Deno.core.recv((channel, msg) => assert(false));
};
global.SendRecvSlice = () => {
@ -58,7 +58,7 @@ global.SendRecvSlice = () => {
buf[0] = 100 + i;
buf[buf.length - 1] = 100 - i;
// On the native side, the slice is shortened by 19 bytes.
buf = libdeno.send(buf);
buf = Deno.core.send(buf);
assert(buf.byteOffset === i * 11);
assert(buf.byteLength === abLen - i * 30 - 19);
assert(buf.buffer.byteLength == abLen);
@ -78,17 +78,17 @@ global.JSSendArrayBufferViewTypes = () => {
const ab1 = new ArrayBuffer(4321);
const u8 = new Uint8Array(ab1, 2468, 1000);
u8[0] = 1;
libdeno.send(u8);
Deno.core.send(u8);
// Send Uint32Array.
const ab2 = new ArrayBuffer(4321);
const u32 = new Uint32Array(ab2, 2468, 1000 / Uint32Array.BYTES_PER_ELEMENT);
u32[0] = 0x02020202;
libdeno.send(u32);
Deno.core.send(u32);
// Send DataView.
const ab3 = new ArrayBuffer(4321);
const dv = new DataView(ab3, 2468, 1000);
dv.setUint8(0, 3);
libdeno.send(dv);
Deno.core.send(dv);
};
// The following join has caused SnapshotBug to segfault when using kKeep.
@ -110,7 +110,7 @@ global.ZeroCopyBuf = () => {
const b = zeroCopyBuf;
// The second parameter of send should modified by the
// privileged side.
const r = libdeno.send(a, b);
const r = Deno.core.send(a, b);
assert(r == null);
// b is different.
assert(b[0] === 4);
@ -129,15 +129,15 @@ global.CheckPromiseErrors = () => {
try {
await fn();
} catch (e) {
libdeno.send(new Uint8Array([42]));
Deno.core.send(new Uint8Array([42]));
}
})();
};
global.Shared = () => {
const ab = libdeno.shared;
const ab = Deno.core.shared;
assert(ab instanceof SharedArrayBuffer);
assert(libdeno.shared != undefined);
assert(Deno.core.shared != undefined);
assert(ab.byteLength === 3);
const ui8 = new Uint8Array(ab);
assert(ui8[0] === 0);
@ -149,45 +149,46 @@ global.Shared = () => {
};
global.LibDenoEvalContext = () => {
const [result, errInfo] = libdeno.evalContext("let a = 1; a");
const [result, errInfo] = Deno.core.evalContext("let a = 1; a");
assert(result === 1);
assert(!errInfo);
const [result2, errInfo2] = libdeno.evalContext("a = a + 1; a");
const [result2, errInfo2] = Deno.core.evalContext("a = a + 1; a");
assert(result2 === 2);
assert(!errInfo2);
};
global.LibDenoEvalContextError = () => {
const [result, errInfo] = libdeno.evalContext("not_a_variable");
const [result, errInfo] = Deno.core.evalContext("not_a_variable");
assert(!result);
assert(!!errInfo);
assert(errInfo.isNativeError); // is a native error (ReferenceError)
assert(!errInfo.isCompileError); // is NOT a compilation error
assert(errInfo.thrown.message === "not_a_variable is not defined");
const [result2, errInfo2] = libdeno.evalContext("throw 1");
const [result2, errInfo2] = Deno.core.evalContext("throw 1");
assert(!result2);
assert(!!errInfo2);
assert(!errInfo2.isNativeError); // is NOT a native error
assert(!errInfo2.isCompileError); // is NOT a compilation error
assert(errInfo2.thrown === 1);
const [result3, errInfo3] =
libdeno.evalContext("class AError extends Error {}; throw new AError('e')");
const [result3, errInfo3] = Deno.core.evalContext(
"class AError extends Error {}; throw new AError('e')"
);
assert(!result3);
assert(!!errInfo3);
assert(errInfo3.isNativeError); // extend from native error, still native error
assert(!errInfo3.isCompileError); // is NOT a compilation error
assert(errInfo3.thrown.message === "e");
const [result4, errInfo4] = libdeno.evalContext("{");
const [result4, errInfo4] = Deno.core.evalContext("{");
assert(!result4);
assert(!!errInfo4);
assert(errInfo4.isNativeError); // is a native error (SyntaxError)
assert(errInfo4.isCompileError); // is a compilation error! (braces not closed)
assert(errInfo4.thrown.message === "Unexpected end of input");
const [result5, errInfo5] = libdeno.evalContext("eval('{')");
const [result5, errInfo5] = Deno.core.evalContext("eval('{')");
assert(!result5);
assert(!!errInfo5);
assert(errInfo5.isNativeError); // is a native error (SyntaxError)

6
libdeno/modules_test.cc
View file

@ -19,7 +19,7 @@ TEST(ModulesTest, Resolution) {
static deno_mod a = deno_mod_new(d, true, "a.js",
"import { b } from 'b.js'\n"
"if (b() != 'b') throw Error();\n"
"libdeno.send(new Uint8Array([4]));");
"Deno.core.send(new Uint8Array([4]));");
EXPECT_NE(a, 0);
EXPECT_EQ(nullptr, deno_last_exception(d));
@ -71,7 +71,7 @@ TEST(ModulesTest, ResolutionError) {
static deno_mod a = deno_mod_new(d, true, "a.js",
"import 'bad'\n"
"libdeno.send(new Uint8Array([4]));");
"Deno.core.send(new Uint8Array([4]));");
EXPECT_NE(a, 0);
EXPECT_EQ(nullptr, deno_last_exception(d));
@ -105,7 +105,7 @@ TEST(ModulesTest, ImportMetaUrl) {
static deno_mod a =
deno_mod_new(d, true, "a.js",
"if ('a.js' != import.meta.url) throw 'hmm'\n"
"libdeno.send(new Uint8Array([4]));");
"Deno.core.send(new Uint8Array([4]));");
EXPECT_NE(a, 0);
EXPECT_EQ(nullptr, deno_last_exception(d));

8
tsconfig.json
View file

@ -22,5 +22,11 @@
"target": "esnext",
"types": []
},
"files": ["js/lib.web_assembly.d.ts", "js/main.ts", "js/compiler.ts"]
"files": [
"js/lib.web_assembly.d.ts",
"core/core.d.ts",
"libdeno/libdeno.d.ts",
"js/main.ts",
"js/compiler.ts"
]
}