summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--BUILD.gn18
-rw-r--r--js/console.ts6
-rw-r--r--js/deno.d.ts4
-rw-r--r--js/dispatch.ts55
-rw-r--r--js/globals.ts28
-rw-r--r--js/main.ts55
-rw-r--r--js/msg_generated.ts1558
-rw-r--r--js/os.ts89
-rw-r--r--js/runtime.ts31
-rw-r--r--js/util.ts5
-rw-r--r--src/handlers.h9
-rw-r--r--src/handlers.rs27
-rw-r--r--src/main.cc67
-rw-r--r--src/msg.fbs101
14 files changed, 1874 insertions, 179 deletions
diff --git a/BUILD.gn b/BUILD.gn
index def162d42..b76439f38 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -8,6 +8,9 @@ import("//build_extra/rust/rust.gni")
config("deno_config") {
include_dirs = [ "third_party/v8" ] # This allows us to v8/src/base/ libraries.
configs = [ "third_party/v8:external_config" ]
+ if (is_debug) {
+ defines = [ "DEBUG" ]
+ }
}
rust_executable("deno") {
@@ -26,14 +29,21 @@ rust_component("libc") {
]
}
+rust_component("handlers") {
+ source_root = "src/handlers.rs"
+ extern = [ ":libc" ]
+}
+
executable("deno_cc") {
sources = [
"src/main.cc",
]
deps = [
":flatbufferjs",
+ ":handlers",
":libdeno",
":msg_cpp",
+ "//build_extra/rust:stdlib",
]
configs += [ ":deno_config" ]
}
@@ -99,8 +109,16 @@ flatbuffer("msg_cpp") {
run_node("bundle") {
out_dir = "$target_gen_dir/bundle/"
sources = [
+ "js/console.ts",
+ "js/deno.d.ts",
+ "js/dispatch.ts",
+ "js/globals.ts",
"js/main.ts",
"js/msg_generated.ts",
+ "js/os.ts",
+ "js/runtime.ts",
+ "js/types.ts",
+ "js/util.ts",
"package.json", # The `browserslist` field controls Babel behavior.
]
outputs = [
diff --git a/js/console.ts b/js/console.ts
index af92c8871..1ec727f14 100644
--- a/js/console.ts
+++ b/js/console.ts
@@ -1,5 +1,3 @@
-const print = V8Worker2.print;
-
// tslint:disable-next-line:no-any
type ConsoleContext = Set<any>;
@@ -102,7 +100,7 @@ function stringifyArgs(args: any[]): string {
export class Console {
// tslint:disable-next-line:no-any
log(...args: any[]): void {
- print(stringifyArgs(args));
+ deno.print(stringifyArgs(args));
}
debug = this.log;
@@ -110,7 +108,7 @@ export class Console {
// tslint:disable-next-line:no-any
warn(...args: any[]): void {
- print(`ERROR: ${stringifyArgs(args)}`);
+ deno.print(`ERROR: ${stringifyArgs(args)}`);
}
error = this.warn;
diff --git a/js/deno.d.ts b/js/deno.d.ts
index 9b7ca31a2..748ee32ce 100644
--- a/js/deno.d.ts
+++ b/js/deno.d.ts
@@ -1,9 +1,9 @@
// Copyright 2018 Ryan Dahl <ry@tinyclouds.org>
// All rights reserved. MIT License.
-type MessageCallback = (msg: ArrayBuffer) => void;
+type MessageCallback = (channel: string, msg: ArrayBuffer) => void;
interface Deno {
- recv(channel: string, cb: MessageCallback): void;
+ recv(cb: MessageCallback): void;
send(channel: string, msg: ArrayBuffer): null | ArrayBuffer;
print(x: string): void;
}
diff --git a/js/dispatch.ts b/js/dispatch.ts
index a83e5a0e5..6668014b9 100644
--- a/js/dispatch.ts
+++ b/js/dispatch.ts
@@ -1,13 +1,11 @@
// Copyright 2018 Ryan Dahl <ry@tinyclouds.org>
// All rights reserved. MIT License.
import { typedArrayToArrayBuffer } from "./util";
-import { _global } from "./globals";
-import { deno as pb } from "./msg.pb";
+import { deno as fbs } from "./msg_generated";
export type MessageCallback = (msg: Uint8Array) => void;
//type MessageStructCallback = (msg: pb.IMsg) => void;
-const send = V8Worker2.send;
const channels = new Map<string, MessageCallback[]>();
export function sub(channel: string, cb: MessageCallback): void {
@@ -19,55 +17,14 @@ export function sub(channel: string, cb: MessageCallback): void {
subscribers.push(cb);
}
-/*
-export function subMsg(channel: string, cb: MessageStructCallback): void {
- sub(channel, (payload: Uint8Array) => {
- const msg = pb.Msg.decode(payload);
- if (msg.error != null) {
- f.onError(new Error(msg.error));
- } else {
- cb(msg);
- }
- });
-}
- */
-
-export function pub(channel: string, payload: Uint8Array): null | ArrayBuffer {
- const msg = pb.BaseMsg.fromObject({ channel, payload });
- const ui8 = pb.BaseMsg.encode(msg).finish();
- const ab = typedArrayToArrayBuffer(ui8);
- return send(ab);
-}
-
-// Internal version of "pub".
-// TODO add internal version of "sub"
-export function pubInternal(channel: string, obj: pb.IMsg): null | pb.Msg {
- const msg = pb.Msg.fromObject(obj);
- const ui8 = pb.Msg.encode(msg).finish();
- const resBuf = pub(channel, ui8);
- if (resBuf != null && resBuf.byteLength > 0) {
- const res = pb.Msg.decode(new Uint8Array(resBuf));
- if (res != null && res.error != null && res.error.length > 0) {
- throw Error(res.error);
- }
- return res;
- } else {
- return null;
- }
-}
-
-V8Worker2.recv((ab: ArrayBuffer) => {
- const msg = pb.BaseMsg.decode(new Uint8Array(ab));
- const subscribers = channels.get(msg.channel);
+deno.recv((channel: string, ab: ArrayBuffer) => {
+ const subscribers = channels.get(channel);
if (subscribers == null) {
- throw Error(`No subscribers for channel "${msg.channel}".`);
+ throw Error(`No subscribers for channel "${channel}".`);
}
+ const ui8 = new Uint8Array(ab);
for (const subscriber of subscribers) {
- subscriber(msg.payload);
+ subscriber(ui8);
}
});
-
-// Delete the V8Worker2 from the global object, so that no one else can receive
-// messages.
-_global["V8Worker2"] = null;
diff --git a/js/globals.ts b/js/globals.ts
index cca72d172..81e6bdf12 100644
--- a/js/globals.ts
+++ b/js/globals.ts
@@ -1,6 +1,5 @@
// Copyright 2018 Ryan Dahl <ry@tinyclouds.org>
// All rights reserved. MIT License.
-import * as timer from "./timers";
// If you use the eval function indirectly, by invoking it via a reference
// other than eval, as of ECMAScript 5 it works in the global scope rather than
@@ -11,22 +10,23 @@ export const globalEval = eval;
// A reference to the global object.
// TODO The underscore is because it's conflicting with @types/node.
-export const _global = globalEval("this");
+export const window = globalEval("this");
-_global["window"] = _global; // Create a window object.
-import "./url";
+window["window"] = window; // Create a window object.
+// import "./url";
-_global["setTimeout"] = timer.setTimeout;
-_global["setInterval"] = timer.setInterval;
-_global["clearTimeout"] = timer.clearTimer;
-_global["clearInterval"] = timer.clearTimer;
+// import * as timer from "./timers";
+// window["setTimeout"] = timer.setTimeout;
+// window["setInterval"] = timer.setInterval;
+// window["clearTimeout"] = timer.clearTimer;
+// window["clearInterval"] = timer.clearTimer;
import { Console } from "./console";
-_global["console"] = new Console();
+window["console"] = new Console();
-import { fetch } from "./fetch";
-_global["fetch"] = fetch;
+// import { fetch } from "./fetch";
+// window["fetch"] = fetch;
-import { TextEncoder, TextDecoder } from "text-encoding";
-_global["TextEncoder"] = TextEncoder;
-_global["TextDecoder"] = TextDecoder;
+// import { TextEncoder, TextDecoder } from "text-encoding";
+// window["TextEncoder"] = TextEncoder;
+// window["TextDecoder"] = TextDecoder;
diff --git a/js/main.ts b/js/main.ts
index 43bd0e03f..6ba38f669 100644
--- a/js/main.ts
+++ b/js/main.ts
@@ -4,30 +4,59 @@ import * as ts from "typescript";
import { flatbuffers } from "flatbuffers";
import { deno as fbs } from "./msg_generated";
+import { assert } from "./util";
+
+// import * as runtime from "./runtime";
const globalEval = eval;
const window = globalEval("this");
+function startMsg(): ArrayBuffer {
+ const builder = new flatbuffers.Builder();
+ const msg = fbs.Start.createStart(builder, 0);
+ fbs.Base.startBase(builder);
+ fbs.Base.addMsg(builder, msg);
+ fbs.Base.addMsgType(builder, fbs.Any.Start);
+ builder.finish(fbs.Base.endBase(builder));
+ return typedArrayToArrayBuffer(builder.asUint8Array());
+}
+
window["denoMain"] = () => {
deno.print(`ts.version: ${ts.version}`);
- const res = deno.send("startDeno2", emptyArrayBuffer());
- // deno.print(`after`);
- const resUi8 = new Uint8Array(res);
- const bb = new flatbuffers.ByteBuffer(resUi8);
- const msg = fbs.Msg.getRootAsMsg(bb);
+ // 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
+ // argv and other info.
+ const res = deno.send("start", startMsg());
+
+ // TODO(ry) Remove this conditional once main.rs gets up to speed.
+ if (res == null) {
+ console.log(`The 'Start' message got a null response. Normally this would
+ be an error but main.rs currently does this."); Exiting without error.`);
+ return;
+ }
- // startDebugFlag: debugFlag,
- // startMainJs: mainJs,
- // startMainMap: mainMap
- const cwd = msg.startCwd();
+ // Deserialize res into startResMsg.
+ const bb = new flatbuffers.ByteBuffer(new Uint8Array(res));
+ const base = fbs.Base.getRootAsBase(bb);
+ assert(fbs.Any.StartRes === base.msgType());
+ const startResMsg = new fbs.StartRes();
+ assert(base.msg(startResMsg) != null);
+
+ const cwd = startResMsg.cwd();
deno.print(`cwd: ${cwd}`);
const argv: string[] = [];
- for (let i = 0; i < msg.startArgvLength(); i++) {
- argv.push(msg.startArgv(i));
+ for (let i = 0; i < startResMsg.argvLength(); i++) {
+ argv.push(startResMsg.argv(i));
}
deno.print(`argv ${argv}`);
+
+ /* TODO(ry) Uncomment to test further message passing.
+ const inputFn = argv[0];
+ const mod = runtime.resolveModule(inputFn, `${cwd}/`);
+ mod.compileAndRun();
+ */
};
function typedArrayToArrayBuffer(ta: Uint8Array): ArrayBuffer {
@@ -36,7 +65,3 @@ function typedArrayToArrayBuffer(ta: Uint8Array): ArrayBuffer {
ta.byteOffset + ta.byteLength
) as ArrayBuffer;
}
-
-function emptyArrayBuffer(): ArrayBuffer {
- return typedArrayToArrayBuffer(new Uint8Array([]));
-}
diff --git a/js/msg_generated.ts b/js/msg_generated.ts
index aa8f00012..e7e3a1f8e 100644
--- a/js/msg_generated.ts
+++ b/js/msg_generated.ts
@@ -4,15 +4,29 @@
* @enum
*/
export namespace deno{
-export enum Command{
- START= 0
+export enum Any{
+ NONE= 0,
+ Start= 1,
+ StartRes= 2,
+ CodeFetch= 3,
+ CodeFetchRes= 4,
+ CodeCache= 5,
+ Exit= 6,
+ TimerStart= 7,
+ TimerReady= 8,
+ TimerClear= 9,
+ FetchReq= 10,
+ FetchRes= 11,
+ ReadFileSync= 12,
+ ReadFileSyncRes= 13,
+ WriteFileSync= 14
}};
/**
* @constructor
*/
export namespace deno{
-export class Msg {
+export class Base {
/**
* @type {flatbuffers.ByteBuffer}
*/
@@ -25,9 +39,9 @@ export class Msg {
/**
* @param {number} i
* @param {flatbuffers.ByteBuffer} bb
- * @returns {Msg}
+ * @returns {Base}
*/
-__init(i:number, bb:flatbuffers.ByteBuffer):Msg {
+__init(i:number, bb:flatbuffers.ByteBuffer):Base {
this.bb_pos = i;
this.bb = bb;
return this;
@@ -35,27 +49,136 @@ __init(i:number, bb:flatbuffers.ByteBuffer):Msg {
/**
* @param {flatbuffers.ByteBuffer} bb
- * @param {Msg=} obj
- * @returns {Msg}
+ * @param {Base=} obj
+ * @returns {Base}
*/
-static getRootAsMsg(bb:flatbuffers.ByteBuffer, obj?:Msg):Msg {
- return (obj || new Msg).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+static getRootAsBase(bb:flatbuffers.ByteBuffer, obj?:Base):Base {
+ return (obj || new Base).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};
/**
- * @returns {deno.Command}
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
*/
-command():deno.Command {
+error():string|null
+error(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+error(optionalEncoding?:any):string|Uint8Array|null {
var offset = this.bb!.__offset(this.bb_pos, 4);
- return offset ? /** @type {deno.Command} */ (this.bb!.readInt8(this.bb_pos + offset)) : deno.Command.START;
+ return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
};
/**
- * @param {deno.Command} value
+ * @returns {deno.Any}
+ */
+msgType():deno.Any {
+ var offset = this.bb!.__offset(this.bb_pos, 6);
+ return offset ? /** @type {deno.Any} */ (this.bb!.readUint8(this.bb_pos + offset)) : deno.Any.NONE;
+};
+
+/**
+ * @param {deno.Any} value
* @returns {boolean}
*/
-mutate_command(value:deno.Command):boolean {
- var offset = this.bb!.__offset(this.bb_pos, 4);
+mutate_msg_type(value:deno.Any):boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 6);
+
+ if (offset === 0) {
+ return false;
+ }
+
+ this.bb!.writeUint8(this.bb_pos + offset, value);
+ return true;
+};
+
+/**
+ * @param {flatbuffers.Table} obj
+ * @returns {?flatbuffers.Table}
+ */
+msg<T extends flatbuffers.Table>(obj:T):T|null {
+ var offset = this.bb!.__offset(this.bb_pos, 8);
+ return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ */
+static startBase(builder:flatbuffers.Builder) {
+ builder.startObject(3);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} errorOffset
+ */
+static addError(builder:flatbuffers.Builder, errorOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(0, errorOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {deno.Any} msgType
+ */
+static addMsgType(builder:flatbuffers.Builder, msgType:deno.Any) {
+ builder.addFieldInt8(1, msgType, deno.Any.NONE);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} msgOffset
+ */
+static addMsg(builder:flatbuffers.Builder, msgOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(2, msgOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @returns {flatbuffers.Offset}
+ */
+static endBase(builder:flatbuffers.Builder):flatbuffers.Offset {
+ var offset = builder.endObject();
+ return offset;
+};
+
+}
+}
+/**
+ * @constructor
+ */
+export namespace deno{
+export class Start {
+ /**
+ * @type {flatbuffers.ByteBuffer}
+ */
+ bb: flatbuffers.ByteBuffer|null = null;
+
+ /**
+ * @type {number}
+ */
+ bb_pos:number = 0;
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {Start}
+ */
+__init(i:number, bb:flatbuffers.ByteBuffer):Start {
+ this.bb_pos = i;
+ this.bb = bb;
+ return this;
+};
+
+/**
+ * @returns {number}
+ */
+unused():number {
+ return this.bb!.readInt8(this.bb_pos);
+};
+
+/**
+ * @param {number} value
+ * @returns {boolean}
+ */
+mutate_unused(value:number):boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 0);
if (offset === 0) {
return false;
@@ -66,24 +189,1000 @@ mutate_command(value:deno.Command):boolean {
};
/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} unused
+ * @returns {flatbuffers.Offset}
+ */
+static createStart(builder:flatbuffers.Builder, unused: number):flatbuffers.Offset {
+ builder.prep(1, 1);
+ builder.writeInt8(unused);
+ return builder.offset();
+};
+
+}
+}
+/**
+ * @constructor
+ */
+export namespace deno{
+export class StartRes {
+ /**
+ * @type {flatbuffers.ByteBuffer}
+ */
+ bb: flatbuffers.ByteBuffer|null = null;
+
+ /**
+ * @type {number}
+ */
+ bb_pos:number = 0;
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {StartRes}
+ */
+__init(i:number, bb:flatbuffers.ByteBuffer):StartRes {
+ this.bb_pos = i;
+ this.bb = bb;
+ return this;
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {StartRes=} obj
+ * @returns {StartRes}
+ */
+static getRootAsStartRes(bb:flatbuffers.ByteBuffer, obj?:StartRes):StartRes {
+ return (obj || new StartRes).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
* @param {flatbuffers.Encoding=} optionalEncoding
* @returns {string|Uint8Array|null}
*/
-startCwd():string|null
-startCwd(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
-startCwd(optionalEncoding?:any):string|Uint8Array|null {
+cwd():string|null
+cwd(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+cwd(optionalEncoding?:any):string|Uint8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
+ return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+};
+
+/**
+ * @param {number} index
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array}
+ */
+argv(index: number):string
+argv(index: number,optionalEncoding:flatbuffers.Encoding):string|Uint8Array
+argv(index: number,optionalEncoding?:any):string|Uint8Array|null {
var offset = this.bb!.__offset(this.bb_pos, 6);
+ return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
+};
+
+/**
+ * @returns {number}
+ */
+argvLength():number {
+ var offset = this.bb!.__offset(this.bb_pos, 6);
+ return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @returns {boolean}
+ */
+debugFlag():boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 8);
+ return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;
+};
+
+/**
+ * @param {boolean} value
+ * @returns {boolean}
+ */
+mutate_debug_flag(value:boolean):boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 8);
+
+ if (offset === 0) {
+ return false;
+ }
+
+ this.bb!.writeInt8(this.bb_pos + offset, +value);
+ return true;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ */
+static startStartRes(builder:flatbuffers.Builder) {
+ builder.startObject(3);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} cwdOffset
+ */
+static addCwd(builder:flatbuffers.Builder, cwdOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(0, cwdOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} argvOffset
+ */
+static addArgv(builder:flatbuffers.Builder, argvOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(1, argvOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {Array.<flatbuffers.Offset>} data
+ * @returns {flatbuffers.Offset}
+ */
+static createArgvVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset {
+ builder.startVector(4, data.length, 4);
+ for (var i = data.length - 1; i >= 0; i--) {
+ builder.addOffset(data[i]);
+ }
+ return builder.endVector();
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} numElems
+ */
+static startArgvVector(builder:flatbuffers.Builder, numElems:number) {
+ builder.startVector(4, numElems, 4);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {boolean} debugFlag
+ */
+static addDebugFlag(builder:flatbuffers.Builder, debugFlag:boolean) {
+ builder.addFieldInt8(2, +debugFlag, +false);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @returns {flatbuffers.Offset}
+ */
+static endStartRes(builder:flatbuffers.Builder):flatbuffers.Offset {
+ var offset = builder.endObject();
+ return offset;
+};
+
+}
+}
+/**
+ * @constructor
+ */
+export namespace deno{
+export class CodeFetch {
+ /**
+ * @type {flatbuffers.ByteBuffer}
+ */
+ bb: flatbuffers.ByteBuffer|null = null;
+
+ /**
+ * @type {number}
+ */
+ bb_pos:number = 0;
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {CodeFetch}
+ */
+__init(i:number, bb:flatbuffers.ByteBuffer):CodeFetch {
+ this.bb_pos = i;
+ this.bb = bb;
+ return this;
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {CodeFetch=} obj
+ * @returns {CodeFetch}
+ */
+static getRootAsCodeFetch(bb:flatbuffers.ByteBuffer, obj?:CodeFetch):CodeFetch {
+ return (obj || new CodeFetch).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+moduleSpecifier():string|null
+moduleSpecifier(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+moduleSpecifier(optionalEncoding?:any):string|Uint8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
};
/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+containingFile():string|null
+containingFile(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+containingFile(optionalEncoding?:any):string|Uint8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 6);
+ return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ */
+static startCodeFetch(builder:flatbuffers.Builder) {
+ builder.startObject(2);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} moduleSpecifierOffset
+ */
+static addModuleSpecifier(builder:flatbuffers.Builder, moduleSpecifierOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(0, moduleSpecifierOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} containingFileOffset
+ */
+static addContainingFile(builder:flatbuffers.Builder, containingFileOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(1, containingFileOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @returns {flatbuffers.Offset}
+ */
+static endCodeFetch(builder:flatbuffers.Builder):flatbuffers.Offset {
+ var offset = builder.endObject();
+ return offset;
+};
+
+}
+}
+/**
+ * @constructor
+ */
+export namespace deno{
+export class CodeFetchRes {
+ /**
+ * @type {flatbuffers.ByteBuffer}
+ */
+ bb: flatbuffers.ByteBuffer|null = null;
+
+ /**
+ * @type {number}
+ */
+ bb_pos:number = 0;
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {CodeFetchRes}
+ */
+__init(i:number, bb:flatbuffers.ByteBuffer):CodeFetchRes {
+ this.bb_pos = i;
+ this.bb = bb;
+ return this;
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {CodeFetchRes=} obj
+ * @returns {CodeFetchRes}
+ */
+static getRootAsCodeFetchRes(bb:flatbuffers.ByteBuffer, obj?:CodeFetchRes):CodeFetchRes {
+ return (obj || new CodeFetchRes).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+moduleName():string|null
+moduleName(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+moduleName(optionalEncoding?:any):string|Uint8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
+ return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+filename():string|null
+filename(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+filename(optionalEncoding?:any):string|Uint8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 6);
+ return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+sourceCode():string|null
+sourceCode(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+sourceCode(optionalEncoding?:any):string|Uint8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 8);
+ return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+outputCode():string|null
+outputCode(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+outputCode(optionalEncoding?:any):string|Uint8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 10);
+ return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ */
+static startCodeFetchRes(builder:flatbuffers.Builder) {
+ builder.startObject(4);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} moduleNameOffset
+ */
+static addModuleName(builder:flatbuffers.Builder, moduleNameOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(0, moduleNameOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} filenameOffset
+ */
+static addFilename(builder:flatbuffers.Builder, filenameOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(1, filenameOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} sourceCodeOffset
+ */
+static addSourceCode(builder:flatbuffers.Builder, sourceCodeOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(2, sourceCodeOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} outputCodeOffset
+ */
+static addOutputCode(builder:flatbuffers.Builder, outputCodeOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(3, outputCodeOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @returns {flatbuffers.Offset}
+ */
+static endCodeFetchRes(builder:flatbuffers.Builder):flatbuffers.Offset {
+ var offset = builder.endObject();
+ return offset;
+};
+
+}
+}
+/**
+ * @constructor
+ */
+export namespace deno{
+export class CodeCache {
+ /**
+ * @type {flatbuffers.ByteBuffer}
+ */
+ bb: flatbuffers.ByteBuffer|null = null;
+
+ /**
+ * @type {number}
+ */
+ bb_pos:number = 0;
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {CodeCache}
+ */
+__init(i:number, bb:flatbuffers.ByteBuffer):CodeCache {
+ this.bb_pos = i;
+ this.bb = bb;
+ return this;
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {CodeCache=} obj
+ * @returns {CodeCache}
+ */
+static getRootAsCodeCache(bb:flatbuffers.ByteBuffer, obj?:CodeCache):CodeCache {
+ return (obj || new CodeCache).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+filename():string|null
+filename(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+filename(optionalEncoding?:any):string|Uint8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
+ return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+sourceCode():string|null
+sourceCode(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+sourceCode(optionalEncoding?:any):string|Uint8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 6);
+ return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+outputCode():string|null
+outputCode(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+outputCode(optionalEncoding?:any):string|Uint8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 8);
+ return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ */
+static startCodeCache(builder:flatbuffers.Builder) {
+ builder.startObject(3);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} filenameOffset
+ */
+static addFilename(builder:flatbuffers.Builder, filenameOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(0, filenameOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} sourceCodeOffset
+ */
+static addSourceCode(builder:flatbuffers.Builder, sourceCodeOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(1, sourceCodeOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} outputCodeOffset
+ */
+static addOutputCode(builder:flatbuffers.Builder, outputCodeOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(2, outputCodeOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @returns {flatbuffers.Offset}
+ */
+static endCodeCache(builder:flatbuffers.Builder):flatbuffers.Offset {
+ var offset = builder.endObject();
+ return offset;
+};
+
+}
+}
+/**
+ * @constructor
+ */
+export namespace deno{
+export class Exit {
+ /**
+ * @type {flatbuffers.ByteBuffer}
+ */
+ bb: flatbuffers.ByteBuffer|null = null;
+
+ /**
+ * @type {number}
+ */
+ bb_pos:number = 0;
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {Exit}
+ */
+__init(i:number, bb:flatbuffers.ByteBuffer):Exit {
+ this.bb_pos = i;
+ this.bb = bb;
+ return this;
+};
+
+/**
+ * @returns {number}
+ */
+code():number {
+ return this.bb!.readInt32(this.bb_pos);
+};
+
+/**
+ * @param {number} value
+ * @returns {boolean}
+ */
+mutate_code(value:number):boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 0);
+
+ if (offset === 0) {
+ return false;
+ }
+
+ this.bb!.writeInt32(this.bb_pos + offset, value);
+ return true;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} code
+ * @returns {flatbuffers.Offset}
+ */
+static createExit(builder:flatbuffers.Builder, code: number):flatbuffers.Offset {
+ builder.prep(4, 4);
+ builder.writeInt32(code);
+ return builder.offset();
+};
+
+}
+}
+/**
+ * @constructor
+ */
+export namespace deno{
+export class TimerStart {
+ /**
+ * @type {flatbuffers.ByteBuffer}
+ */
+ bb: flatbuffers.ByteBuffer|null = null;
+
+ /**
+ * @type {number}
+ */
+ bb_pos:number = 0;
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {TimerStart}
+ */
+__init(i:number, bb:flatbuffers.ByteBuffer):TimerStart {
+ this.bb_pos = i;
+ this.bb = bb;
+ return this;
+};
+
+/**
+ * @returns {number}
+ */
+id():number {
+ return this.bb!.readUint32(this.bb_pos);
+};
+
+/**
+ * @param {number} value
+ * @returns {boolean}
+ */
+mutate_id(value:number):boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 0);
+
+ if (offset === 0) {
+ return false;
+ }
+
+ this.bb!.writeUint32(this.bb_pos + offset, value);
+ return true;
+};
+
+/**
+ * @returns {boolean}
+ */
+interval():boolean {
+ return !!this.bb!.readInt8(this.bb_pos + 4);
+};
+
+/**
+ * @param {boolean} value
+ * @returns {boolean}
+ */
+mutate_interval(value:boolean):boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
+
+ if (offset === 0) {
+ return false;
+ }
+
+ this.bb!.writeInt8(this.bb_pos + offset, +value);
+ return true;
+};
+
+/**
+ * @returns {number}
+ */
+delay():number {
+ return this.bb!.readInt32(this.bb_pos + 8);
+};
+
+/**
+ * @param {number} value
+ * @returns {boolean}
+ */
+mutate_delay(value:number):boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 8);
+
+ if (offset === 0) {
+ return false;
+ }
+
+ this.bb!.writeInt32(this.bb_pos + offset, value);
+ return true;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} id
+ * @param {boolean} interval
+ * @param {number} delay
+ * @returns {flatbuffers.Offset}
+ */
+static createTimerStart(builder:flatbuffers.Builder, id: number, interval: boolean, delay: number):flatbuffers.Offset {
+ builder.prep(4, 12);
+ builder.writeInt32(delay);
+ builder.pad(3);
+ builder.writeInt8(+interval);
+ builder.writeInt32(id);
+ return builder.offset();
+};
+
+}
+}
+/**
+ * @constructor
+ */
+export namespace deno{
+export class TimerReady {
+ /**
+ * @type {flatbuffers.ByteBuffer}
+ */
+ bb: flatbuffers.ByteBuffer|null = null;
+
+ /**
+ * @type {number}
+ */
+ bb_pos:number = 0;
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {TimerReady}
+ */
+__init(i:number, bb:flatbuffers.ByteBuffer):TimerReady {
+ this.bb_pos = i;
+ this.bb = bb;
+ return this;
+};
+
+/**
+ * @returns {number}
+ */
+id():number {
+ return this.bb!.readUint32(this.bb_pos);
+};
+
+/**
+ * @param {number} value
+ * @returns {boolean}
+ */
+mutate_id(value:number):boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 0);
+
+ if (offset === 0) {
+ return false;
+ }
+
+ this.bb!.writeUint32(this.bb_pos + offset, value);
+ return true;
+};
+
+/**
+ * @returns {boolean}
+ */
+done():boolean {
+ return !!this.bb!.readInt8(this.bb_pos + 4);
+};
+
+/**
+ * @param {boolean} value
+ * @returns {boolean}
+ */
+mutate_done(value:boolean):boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
+
+ if (offset === 0) {
+ return false;
+ }
+
+ this.bb!.writeInt8(this.bb_pos + offset, +value);
+ return true;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} id
+ * @param {boolean} done
+ * @returns {flatbuffers.Offset}
+ */
+static createTimerReady(builder:flatbuffers.Builder, id: number, done: boolean):flatbuffers.Offset {
+ builder.prep(4, 8);
+ builder.pad(3);
+ builder.writeInt8(+done);
+ builder.writeInt32(id);
+ return builder.offset();
+};
+
+}
+}
+/**
+ * @constructor
+ */
+export namespace deno{
+export class TimerClear {
+ /**
+ * @type {flatbuffers.ByteBuffer}
+ */
+ bb: flatbuffers.ByteBuffer|null = null;
+
+ /**
+ * @type {number}
+ */
+ bb_pos:number = 0;
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {TimerClear}
+ */
+__init(i:number, bb:flatbuffers.ByteBuffer):TimerClear {
+ this.bb_pos = i;
+ this.bb = bb;
+ return this;
+};
+
+/**
+ * @returns {number}
+ */
+id():number {
+ return this.bb!.readUint32(this.bb_pos);
+};
+
+/**
+ * @param {number} value
+ * @returns {boolean}
+ */
+mutate_id(value:number):boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 0);
+
+ if (offset === 0) {
+ return false;
+ }
+
+ this.bb!.writeUint32(this.bb_pos + offset, value);
+ return true;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} id
+ * @returns {flatbuffers.Offset}
+ */
+static createTimerClear(builder:flatbuffers.Builder, id: number):flatbuffers.Offset {
+ builder.prep(4, 4);
+ builder.writeInt32(id);
+ return builder.offset();
+};
+
+}
+}
+/**
+ * @constructor
+ */
+export namespace deno{
+export class FetchReq {
+ /**
+ * @type {flatbuffers.ByteBuffer}
+ */
+ bb: flatbuffers.ByteBuffer|null = null;
+
+ /**
+ * @type {number}
+ */
+ bb_pos:number = 0;
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {FetchReq}
+ */
+__init(i:number, bb:flatbuffers.ByteBuffer):FetchReq {
+ this.bb_pos = i;
+ this.bb = bb;
+ return this;
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {FetchReq=} obj
+ * @returns {FetchReq}
+ */
+static getRootAsFetchReq(bb:flatbuffers.ByteBuffer, obj?:FetchReq):FetchReq {
+ return (obj || new FetchReq).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @returns {number}
+ */
+id():number {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
+ return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @param {number} value
+ * @returns {boolean}
+ */
+mutate_id(value:number):boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
+
+ if (offset === 0) {
+ return false;
+ }
+
+ this.bb!.writeUint32(this.bb_pos + offset, value);
+ return true;
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+url():string|null
+url(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+url(optionalEncoding?:any):string|Uint8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 6);
+ return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ */
+static startFetchReq(builder:flatbuffers.Builder) {
+ builder.startObject(2);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} id
+ */
+static addId(builder:flatbuffers.Builder, id:number) {
+ builder.addFieldInt32(0, id, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} urlOffset
+ */
+static addUrl(builder:flatbuffers.Builder, urlOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(1, urlOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @returns {flatbuffers.Offset}
+ */
+static endFetchReq(builder:flatbuffers.Builder):flatbuffers.Offset {
+ var offset = builder.endObject();
+ return offset;
+};
+
+}
+}
+/**
+ * @constructor
+ */
+export namespace deno{
+export class FetchRes {
+ /**
+ * @type {flatbuffers.ByteBuffer}
+ */
+ bb: flatbuffers.ByteBuffer|null = null;
+
+ /**
+ * @type {number}
+ */
+ bb_pos:number = 0;
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {FetchRes}
+ */
+__init(i:number, bb:flatbuffers.ByteBuffer):FetchRes {
+ this.bb_pos = i;
+ this.bb = bb;
+ return this;
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {FetchRes=} obj
+ * @returns {FetchRes}
+ */
+static getRootAsFetchRes(bb:flatbuffers.ByteBuffer, obj?:FetchRes):FetchRes {
+ return (obj || new FetchRes).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @returns {number}
+ */
+id():number {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
+ return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @param {number} value
+ * @returns {boolean}
+ */
+mutate_id(value:number):boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
+
+ if (offset === 0) {
+ return false;
+ }
+
+ this.bb!.writeUint32(this.bb_pos + offset, value);
+ return true;
+};
+
+/**
+ * @returns {number}
+ */
+status():number {
+ var offset = this.bb!.__offset(this.bb_pos, 6);
+ return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @param {number} value
+ * @returns {boolean}
+ */
+mutate_status(value:number):boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 6);
+
+ if (offset === 0) {
+ return false;
+ }
+
+ this.bb!.writeInt32(this.bb_pos + offset, value);
+ return true;
+};
+
+/**
* @param {number} index
* @param {flatbuffers.Encoding=} optionalEncoding
* @returns {string|Uint8Array}
*/
-startArgv(index: number):string
-startArgv(index: number,optionalEncoding:flatbuffers.Encoding):string|Uint8Array
-startArgv(index: number,optionalEncoding?:any):string|Uint8Array|null {
+headerLine(index: number):string
+headerLine(index: number,optionalEncoding:flatbuffers.Encoding):string|Uint8Array
+headerLine(index: number,optionalEncoding?:any):string|Uint8Array|null {
var offset = this.bb!.__offset(this.bb_pos, 8);
return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
};
@@ -91,40 +1190,65 @@ startArgv(index: number,optionalEncoding?:any):string|Uint8Array|null {
/**
* @returns {number}
*/
-startArgvLength():number {
+headerLineLength():number {
var offset = this.bb!.__offset(this.bb_pos, 8);
return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
};
/**
+ * @param {number} index
+ * @returns {number}
+ */
+body(index: number):number|null {
+ var offset = this.bb!.__offset(this.bb_pos, 10);
+ return offset ? this.bb!.readInt8(this.bb!.__vector(this.bb_pos + offset) + index) : 0;
+};
+
+/**
+ * @returns {number}
+ */
+bodyLength():number {
+ var offset = this.bb!.__offset(this.bb_pos, 10);
+ return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @returns {Int8Array}
+ */
+bodyArray():Int8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 10);
+ return offset ? new Int8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;
+};
+
+/**
* @param {flatbuffers.Builder} builder
*/
-static startMsg(builder:flatbuffers.Builder) {
- builder.startObject(3);
+static startFetchRes(builder:flatbuffers.Builder) {
+ builder.startObject(4);
};
/**
* @param {flatbuffers.Builder} builder
- * @param {deno.Command} command
+ * @param {number} id
*/
-static addCommand(builder:flatbuffers.Builder, command:deno.Command) {
- builder.addFieldInt8(0, command, deno.Command.START);
+static addId(builder:flatbuffers.Builder, id:number) {
+ builder.addFieldInt32(0, id, 0);
};
/**
* @param {flatbuffers.Builder} builder
- * @param {flatbuffers.Offset} startCwdOffset
+ * @param {number} status
*/
-static addStartCwd(builder:flatbuffers.Builder, startCwdOffset:flatbuffers.Offset) {
- builder.addFieldOffset(1, startCwdOffset, 0);
+static addStatus(builder:flatbuffers.Builder, status:number) {
+ builder.addFieldInt32(1, status, 0);
};
/**
* @param {flatbuffers.Builder} builder
- * @param {flatbuffers.Offset} startArgvOffset
+ * @param {flatbuffers.Offset} headerLineOffset
*/
-static addStartArgv(builder:flatbuffers.Builder, startArgvOffset:flatbuffers.Offset) {
- builder.addFieldOffset(2, startArgvOffset, 0);
+static addHeaderLine(builder:flatbuffers.Builder, headerLineOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(2, headerLineOffset, 0);
};
/**
@@ -132,7 +1256,7 @@ static addStartArgv(builder:flatbuffers.Builder, startArgvOffset:flatbuffers.Off
* @param {Array.<flatbuffers.Offset>} data
* @returns {flatbuffers.Offset}
*/
-static createStartArgvVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset {
+static createHeaderLineVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset {
builder.startVector(4, data.length, 4);
for (var i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
@@ -144,15 +1268,377 @@ static createStartArgvVector(builder:flatbuffers.Builder, data:flatbuffers.Offse
* @param {flatbuffers.Builder} builder
* @param {number} numElems
*/
-static startStartArgvVector(builder:flatbuffers.Builder, numElems:number) {
+static startHeaderLineVector(builder:flatbuffers.Builder, numElems:number) {
builder.startVector(4, numElems, 4);
};
/**
* @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} bodyOffset
+ */
+static addBody(builder:flatbuffers.Builder, bodyOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(3, bodyOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {Array.<number>} data
+ * @returns {flatbuffers.Offset}
+ */
+static createBodyVector(builder:flatbuffers.Builder, data:number[] | Uint8Array):flatbuffers.Offset {
+ builder.startVector(1, data.length, 1);
+ for (var i = data.length - 1; i >= 0; i--) {
+ builder.addInt8(data[i]);
+ }
+ return builder.endVector();
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} numElems
+ */
+static startBodyVector(builder:flatbuffers.Builder, numElems:number) {
+ builder.startVector(1, numElems, 1);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @returns {flatbuffers.Offset}
+ */
+static endFetchRes(builder:flatbuffers.Builder):flatbuffers.Offset {
+ var offset = builder.endObject();
+ return offset;
+};
+
+}
+}
+/**
+ * @constructor
+ */
+export namespace deno{
+export class ReadFileSync {
+ /**
+ * @type {flatbuffers.ByteBuffer}
+ */
+ bb: flatbuffers.ByteBuffer|null = null;
+
+ /**
+ * @type {number}
+ */
+ bb_pos:number = 0;
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {ReadFileSync}
+ */
+__init(i:number, bb:flatbuffers.ByteBuffer):ReadFileSync {
+ this.bb_pos = i;
+ this.bb = bb;
+ return this;
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {ReadFileSync=} obj
+ * @returns {ReadFileSync}
+ */
+static getRootAsReadFileSync(bb:flatbuffers.ByteBuffer, obj?:ReadFileSync):ReadFileSync {
+ return (obj || new ReadFileSync).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+filename():string|null
+filename(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+filename(optionalEncoding?:any):string|Uint8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
+ return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ */
+static startReadFileSync(builder:flatbuffers.Builder) {
+ builder.startObject(1);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} filenameOffset
+ */
+static addFilename(builder:flatbuffers.Builder, filenameOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(0, filenameOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @returns {flatbuffers.Offset}
+ */
+static endReadFileSync(builder:flatbuffers.Builder):flatbuffers.Offset {
+ var offset = builder.endObject();
+ return offset;
+};
+
+}
+}
+/**
+ * @constructor
+ */
+export namespace deno{
+export class ReadFileSyncRes {
+ /**
+ * @type {flatbuffers.ByteBuffer}
+ */
+ bb: flatbuffers.ByteBuffer|null = null;
+
+ /**
+ * @type {number}
+ */
+ bb_pos:number = 0;
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {ReadFileSyncRes}
+ */
+__init(i:number, bb:flatbuffers.ByteBuffer):ReadFileSyncRes {
+ this.bb_pos = i;
+ this.bb = bb;
+ return this;
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {ReadFileSyncRes=} obj
+ * @returns {ReadFileSyncRes}
+ */
+static getRootAsReadFileSyncRes(bb:flatbuffers.ByteBuffer, obj?:ReadFileSyncRes):ReadFileSyncRes {
+ return (obj || new ReadFileSyncRes).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @param {number} index
+ * @returns {number}
+ */
+data(index: number):number|null {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
+ return offset ? this.bb!.readInt8(this.bb!.__vector(this.bb_pos + offset) + index) : 0;
+};
+
+/**
+ * @returns {number}
+ */
+dataLength():number {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
+ return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @returns {Int8Array}
+ */
+dataArray():Int8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
+ return offset ? new Int8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ */
+static startReadFileSyncRes(builder:flatbuffers.Builder) {
+ builder.startObject(1);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} dataOffset
+ */
+static addData(builder:flatbuffers.Builder, dataOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(0, dataOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {Array.<number>} data
+ * @returns {flatbuffers.Offset}
+ */
+static createDataVector(builder:flatbuffers.Builder, data:number[] | Uint8Array):flatbuffers.Offset {
+ builder.startVector(1, data.length, 1);
+ for (var i = data.length - 1; i >= 0; i--) {
+ builder.addInt8(data[i]);
+ }
+ return builder.endVector();
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} numElems
+ */
+static startDataVector(builder:flatbuffers.Builder, numElems:number) {
+ builder.startVector(1, numElems, 1);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @returns {flatbuffers.Offset}
+ */
+static endReadFileSyncRes(builder:flatbuffers.Builder):flatbuffers.Offset {
+ var offset = builder.endObject();
+ return offset;
+};
+
+}
+}
+/**
+ * @constructor
+ */
+export namespace deno{
+export class WriteFileSync {
+ /**
+ * @type {flatbuffers.ByteBuffer}
+ */
+ bb: flatbuffers.ByteBuffer|null = null;
+
+ /**
+ * @type {number}
+ */
+ bb_pos:number = 0;
+/**
+ * @param {number} i
+ * @param {flatbuffers.ByteBuffer} bb
+ * @returns {WriteFileSync}
+ */
+__init(i:number, bb:flatbuffers.ByteBuffer):WriteFileSync {
+ this.bb_pos = i;
+ this.bb = bb;
+ return this;
+};
+
+/**
+ * @param {flatbuffers.ByteBuffer} bb
+ * @param {WriteFileSync=} obj
+ * @returns {WriteFileSync}
+ */
+static getRootAsWriteFileSync(bb:flatbuffers.ByteBuffer, obj?:WriteFileSync):WriteFileSync {
+ return (obj || new WriteFileSync).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+};
+
+/**
+ * @param {flatbuffers.Encoding=} optionalEncoding
+ * @returns {string|Uint8Array|null}
+ */
+filename():string|null
+filename(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
+filename(optionalEncoding?:any):string|Uint8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 4);
+ return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
+};
+
+/**
+ * @param {number} index
+ * @returns {number}
+ */
+data(index: number):number|null {
+ var offset = this.bb!.__offset(this.bb_pos, 6);
+ return offset ? this.bb!.readInt8(this.bb!.__vector(this.bb_pos + offset) + index) : 0;
+};
+
+/**
+ * @returns {number}
+ */
+dataLength():number {
+ var offset = this.bb!.__offset(this.bb_pos, 6);
+ return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @returns {Int8Array}
+ */
+dataArray():Int8Array|null {
+ var offset = this.bb!.__offset(this.bb_pos, 6);
+ return offset ? new Int8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;
+};
+
+/**
+ * @returns {number}
+ */
+perm():number {
+ var offset = this.bb!.__offset(this.bb_pos, 8);
+ return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @param {number} value
+ * @returns {boolean}
+ */
+mutate_perm(value:number):boolean {
+ var offset = this.bb!.__offset(this.bb_pos, 8);
+
+ if (offset === 0) {
+ return false;
+ }
+
+ this.bb!.writeUint32(this.bb_pos + offset, value);
+ return true;
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ */
+static startWriteFileSync(builder:flatbuffers.Builder) {
+ builder.startObject(3);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} filenameOffset
+ */
+static addFilename(builder:flatbuffers.Builder, filenameOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(0, filenameOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} dataOffset
+ */
+static addData(builder:flatbuffers.Builder, dataOffset:flatbuffers.Offset) {
+ builder.addFieldOffset(1, dataOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {Array.<number>} data
+ * @returns {flatbuffers.Offset}
+ */
+static createDataVector(builder:flatbuffers.Builder, data:number[] | Uint8Array):flatbuffers.Offset {
+ builder.startVector(1, data.length, 1);
+ for (var i = data.length - 1; i >= 0; i--) {
+ builder.addInt8(data[i]);
+ }
+ return builder.endVector();
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} numElems
+ */
+static startDataVector(builder:flatbuffers.Builder, numElems:number) {
+ builder.startVector(1, numElems, 1);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} perm
+ */
+static addPerm(builder:flatbuffers.Builder, perm:number) {
+ builder.addFieldInt32(2, perm, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
* @returns {flatbuffers.Offset}
*/
-static endMsg(builder:flatbuffers.Builder):flatbuffers.Offset {
+static endWriteFileSync(builder:flatbuffers.Builder):flatbuffers.Offset {
var offset = builder.endObject();
return offset;
};
diff --git a/js/os.ts b/js/os.ts
index a51c6ec5d..686ba0c90 100644
--- a/js/os.ts
+++ b/js/os.ts
@@ -1,32 +1,54 @@
// Copyright 2018 Ryan Dahl <ry@tinyclouds.org>
// All rights reserved. MIT License.
import { ModuleInfo } from "./types";
-import { pubInternal } from "./dispatch";
-import { deno as pb } from "./msg.pb";
-import { assert } from "./util";
+import { deno as fbs } from "./msg_generated";
+import { assert, typedArrayToArrayBuffer } from "./util";
+import { flatbuffers } from "flatbuffers";
export function exit(exitCode = 0): void {
+ assert(false, "Not Implemented");
+ /*
pubInternal("os", {
- command: pb.Msg.Command.EXIT,
+ command: fbs.Command.EXIT,
exitCode
});
+ */
}
export function codeFetch(
moduleSpecifier: string,
containingFile: string
): ModuleInfo {
- const res = pubInternal("os", {
- command: pb.Msg.Command.CODE_FETCH,
- codeFetchModuleSpecifier: moduleSpecifier,
- codeFetchContainingFile: containingFile
- });
- assert(res.command === pb.Msg.Command.CODE_FETCH_RES);
+ console.log("Hello from codeFetch");
+
+ // Send CodeFetch message
+ const builder = new flatbuffers.Builder();
+ const moduleSpecifier_ = builder.createString(moduleSpecifier);
+ const containingFile_ = builder.createString(containingFile);
+ fbs.CodeFetch.startCodeFetch(builder);
+ fbs.CodeFetch.addModuleSpecifier(builder, moduleSpecifier_);
+ fbs.CodeFetch.addContainingFile(builder, containingFile_);
+ const msg = fbs.CodeFetch.endCodeFetch(builder);
+ fbs.Base.startBase(builder);
+ fbs.Base.addMsg(builder, msg);
+ fbs.Base.addMsgType(builder, fbs.Any.CodeFetch);
+ builder.finish(fbs.Base.endBase(builder));
+ const payload = typedArrayToArrayBuffer(builder.asUint8Array());
+ const resBuf = deno.send("x", payload);
+
+ console.log("CodeFetch sent");
+
+ // Process CodeFetchRes
+ const bb = new flatbuffers.ByteBuffer(new Uint8Array(resBuf));
+ const baseRes = fbs.Base.getRootAsBase(bb);
+ assert(fbs.Any.CodeFetchRes === baseRes.msgType());
+ const codeFetchRes = new fbs.CodeFetchRes();
+ assert(baseRes.msg(codeFetchRes) != null);
return {
- moduleName: res.codeFetchResModuleName,
- filename: res.codeFetchResFilename,
- sourceCode: res.codeFetchResSourceCode,
- outputCode: res.codeFetchResOutputCode
+ moduleName: codeFetchRes.moduleName(),
+ filename: codeFetchRes.filename(),
+ sourceCode: codeFetchRes.sourceCode(),
+ outputCode: codeFetchRes.outputCode(),
};
}
@@ -35,20 +57,40 @@ export function codeCache(
sourceCode: string,
outputCode: string
): void {
- pubInternal("os", {
- command: pb.Msg.Command.CODE_CACHE,
- codeCacheFilename: filename,
- codeCacheSourceCode: sourceCode,
- codeCacheOutputCode: outputCode
- });
+ const builder = new flatbuffers.Builder();
+
+ const filename_ = builder.createString(filename);
+ const sourceCode_ = builder.createString(sourceCode);
+ const outputCode_ = builder.createString(outputCode);
+
+ fbs.CodeCache.startCodeCache(builder);
+ fbs.CodeCache.addFilename(builder, filename_);
+ fbs.CodeCache.addSourceCode(builder, sourceCode_);
+ fbs.CodeCache.addOutputCode(builder, outputCode_);
+ const msg = fbs.CodeCache.endCodeCache(builder);
+
+ fbs.Base.startBase(builder);
+ fbs.Base.addMsg(builder, msg);
+ builder.finish(fbs.Base.endBase(builder));
+
+ // Maybe need to do another step?
+ // Base.finishBaseBuffer(builder, base);
+
+ const payload = typedArrayToArrayBuffer(builder.asUint8Array());
+ const resBuf = deno.send("x", payload);
+ assert(resBuf === null);
}
export function readFileSync(filename: string): Uint8Array {
+ assert(false, "Not Implemented");
+ return null;
+ /*
const res = pubInternal("os", {
- command: pb.Msg.Command.READ_FILE_SYNC,
+ command: fbs.Command.READ_FILE_SYNC,
readFileSyncFilename: filename
});
return res.readFileSyncData;
+ */
}
export function writeFileSync(
@@ -56,10 +98,13 @@ export function writeFileSync(
data: Uint8Array,
perm: number
): void {
+ assert(false, "Not Implemented");
+ /*
pubInternal("os", {
- command: pb.Msg.Command.WRITE_FILE_SYNC,
+ command: fbs.Command.WRITE_FILE_SYNC,
writeFileSyncFilename: filename,
writeFileSyncData: data,
writeFileSyncPerm: perm
});
+ */
}
diff --git a/js/runtime.ts b/js/runtime.ts
index 46538c80f..1cd1bdad1 100644
--- a/js/runtime.ts
+++ b/js/runtime.ts
@@ -12,9 +12,9 @@ import * as ts from "typescript";
import * as util from "./util";
import { log } from "./util";
import * as os from "./os";
-import * as sourceMaps from "./v8_source_maps";
-import { _global, globalEval } from "./globals";
-import * as deno from "./deno";
+//import * as sourceMaps from "./v8_source_maps";
+import { window, globalEval } from "./globals";
+//import * as deno from "./deno";
const EOL = "\n";
@@ -22,18 +22,20 @@ const EOL = "\n";
export type AmdFactory = (...args: any[]) => undefined | object;
export type AmdDefine = (deps: string[], factory: AmdFactory) => void;
-// Uncaught exceptions are sent to window.onerror by v8worker2.
-// https://git.io/vhOsf
+/*
+// Uncaught exceptions are sent to window.onerror by the privlaged binding.
window.onerror = (message, source, lineno, colno, error) => {
// TODO Currently there is a bug in v8_source_maps.ts that causes a segfault
// if it is used within window.onerror. To workaround we uninstall the
// Error.prepareStackTrace handler. Users will get unmapped stack traces on
// uncaught exceptions until this issue is fixed.
- Error.prepareStackTrace = null;
+ //Error.prepareStackTrace = null;
console.log(error.message, error.stack);
os.exit(1);
};
+*/
+/*
export function setup(mainJs: string, mainMap: string): void {
sourceMaps.install({
installPrepareStackTrace: true,
@@ -52,6 +54,7 @@ export function setup(mainJs: string, mainMap: string): void {
}
});
}
+*/
// This class represents a module. We call it FileModule to make it explicit
// that each module represents a single file.
@@ -79,6 +82,7 @@ export class FileModule {
}
compileAndRun(): void {
+ util.log("compileAndRun", this.sourceCode);
if (!this.outputCode) {
// If there is no cached outputCode, then compile the code.
util.assert(
@@ -89,7 +93,6 @@ export class FileModule {
this.outputCode = compiler.compile(this.fileName);
os.codeCache(this.fileName, this.sourceCode, this.outputCode);
}
- util.log("compileAndRun", this.sourceCode);
execute(this.fileName, this.outputCode);
}
@@ -142,17 +145,11 @@ export function resolveModule(
moduleSpecifier: string,
containingFile: string
): null | FileModule {
- //util.log("resolveModule", { moduleSpecifier, containingFile });
+ util.log("resolveModule", { moduleSpecifier, containingFile });
util.assert(moduleSpecifier != null && moduleSpecifier.length > 0);
// We ask golang to sourceCodeFetch. It will load the sourceCode and if
// there is any outputCode cached, it will return that as well.
- let fetchResponse;
- try {
- fetchResponse = os.codeFetch(moduleSpecifier, containingFile);
- } catch (e) {
- // TODO Only catch "no such file or directory" errors. Need error codes.
- return null;
- }
+ const fetchResponse = os.codeFetch(moduleSpecifier, containingFile);
const { filename, sourceCode, outputCode } = fetchResponse;
if (sourceCode.length === 0) {
return null;
@@ -180,10 +177,10 @@ function resolveModuleName(
function execute(fileName: string, outputCode: string): void {
util.assert(outputCode && outputCode.length > 0);
- _global["define"] = makeDefine(fileName);
+ window["define"] = makeDefine(fileName);
outputCode += `\n//# sourceURL=${fileName}`;
globalEval(outputCode);
- _global["define"] = null;
+ window["define"] = null;
}
// This is a singleton class. Use Compiler.instance() to access.
diff --git a/js/util.ts b/js/util.ts
index 70cb79a55..9f87ab63d 100644
--- a/js/util.ts
+++ b/js/util.ts
@@ -1,6 +1,9 @@
// Copyright 2018 Ryan Dahl <ry@tinyclouds.org>
// All rights reserved. MIT License.
-import { debug } from "./main";
+
+//import { debug } from "./main";
+const debug = true;
+
import { TypedArray } from "./types";
// Internal logging for deno. Use the "debug" variable above to control
diff --git a/src/handlers.h b/src/handlers.h
new file mode 100644
index 000000000..921ae62b1
--- /dev/null
+++ b/src/handlers.h
@@ -0,0 +1,9 @@
+// Copyright 2018 Ryan Dahl <ry@tinyclouds.org>
+// All rights reserved. MIT License.
+#ifndef HANDLERS_H_
+#define HANDLERS_H_
+extern "C" {
+void handle_code_fetch(const char* module_specifier,
+ const char* containing_file);
+}
+#endif // HANDLERS_H_
diff --git a/src/handlers.rs b/src/handlers.rs
new file mode 100644
index 000000000..64a076f11
--- /dev/null
+++ b/src/handlers.rs
@@ -0,0 +1,27 @@
+// Copyright 2018 Ryan Dahl <ry@tinyclouds.org>
+// All rights reserved. MIT License.
+extern crate libc;
+
+use libc::c_char;
+use std::ffi::CStr;
+
+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())
+}
+
+#[no_mangle]
+pub extern "C" fn handle_code_fetch(
+ 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);
+
+ println!(
+ "handle_code_fetch. module_specifier = {} containing_file = {}",
+ module_specifier, containing_file
+ );
+
+ unimplemented!();
+}
diff --git a/src/main.cc b/src/main.cc
index 9596dbddf..9dee442df 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -12,15 +12,17 @@
#include "deno.h"
#include "flatbuffers/flatbuffers.h"
+#include "src/handlers.h"
#include "src/msg_generated.h"
#include "third_party/v8/src/base/logging.h"
+namespace deno {
+
static char** global_argv;
static int global_argc;
-void MessagesFromJS(Deno* d, const char* channel, deno_buf buf) {
- printf("MessagesFromJS %s\n", channel);
-
+// Sends StartRes message
+void HandleStart(Deno* d) {
flatbuffers::FlatBufferBuilder builder;
char cwdbuf[1024];
@@ -32,22 +34,56 @@ void MessagesFromJS(Deno* d, const char* channel, deno_buf buf) {
for (int i = 0; i < global_argc; ++i) {
args.push_back(builder.CreateString(global_argv[i]));
}
- auto start_argv = builder.CreateVector(args);
-
- deno::MsgBuilder msg_builder(builder);
- msg_builder.add_command(deno::Command_START);
- msg_builder.add_start_cwd(start_cwd);
- msg_builder.add_start_argv(start_argv);
-
- auto response = msg_builder.Finish();
- builder.Finish(response);
+ auto start_argv = builder.CreateVector(args);
+ auto start_msg = CreateStartRes(builder, start_cwd, start_argv);
+ auto base = CreateBase(builder, 0, Any_StartRes, start_msg.Union());
+ builder.Finish(base);
deno_buf bufout{reinterpret_cast<const char*>(builder.GetBufferPointer()),
builder.GetSize()};
deno_set_response(d, bufout);
}
-int main(int argc, char** argv) {
+void HandleCodeFetch(Deno* d, const CodeFetch* msg) {
+ auto module_specifier = msg->module_specifier()->c_str();
+ auto containing_file = msg->containing_file()->c_str();
+ printf("HandleCodeFetch module_specifier = %s containing_file = %s\n",
+ module_specifier, containing_file);
+ // Call into rust.
+ handle_code_fetch(module_specifier, containing_file);
+}
+
+void MessagesFromJS(Deno* d, const char* channel, deno_buf buf) {
+ auto data = reinterpret_cast<const uint8_t*>(buf.data);
+ flatbuffers::Verifier verifier(data, buf.len);
+ DCHECK(verifier.VerifyBuffer<Base>());
+
+ auto base = flatbuffers::GetRoot<Base>(buf.data);
+ auto msg_type = base->msg_type();
+ const char* msg_type_name = EnumNamesAny()[msg_type];
+ printf("MessagesFromJS channel %s, msg_type = %d, msg_type_name = %s\n",
+ channel, msg_type, msg_type_name);
+ switch (msg_type) {
+ case Any_Start:
+ HandleStart(d);
+ break;
+
+ case Any_CodeFetch:
+ HandleCodeFetch(d, base->msg_as_CodeFetch());
+ break;
+
+ case Any_NONE:
+ CHECK(false && "Got message with msg_type == Any_NONE");
+ break;
+
+ default:
+ printf("Unhandled message %s\n", msg_type_name);
+ CHECK(false && "Unhandled message");
+ break;
+ }
+}
+
+int deno_main(int argc, char** argv) {
deno_init();
deno_set_flags(&argc, argv);
@@ -61,4 +97,9 @@ int main(int argc, char** argv) {
exit(1);
}
deno_delete(d);
+ return 0;
}
+
+} // namespace deno
+
+int main(int argc, char** argv) { return deno::deno_main(argc, argv); }
diff --git a/src/msg.fbs b/src/msg.fbs
index 3dbb8e420..bda3d6354 100644
--- a/src/msg.fbs
+++ b/src/msg.fbs
@@ -1,12 +1,101 @@
namespace deno;
-enum Command: byte {
- START = 0,
+union Any {
+ Start,
+ StartRes,
+ CodeFetch,
+ CodeFetchRes,
+ CodeCache,
+ Exit,
+ TimerStart,
+ TimerReady,
+ TimerClear,
+ FetchReq,
+ FetchRes,
+ ReadFileSync,
+ ReadFileSyncRes,
+ WriteFileSync,
}
-table Msg {
- command: Command;
- start_cwd: string;
- start_argv: [string];
+table Base {
+ error: string;
+ msg: Any;
}
+struct Start {
+ unused: int8;
+}
+
+table StartRes {
+ cwd: string;
+ argv: [string];
+ debug_flag: bool;
+}
+
+table CodeFetch {
+ module_specifier: string;
+ containing_file: string;
+}
+
+table CodeFetchRes {
+ // If it's a non-http module, moduleName and filename will be the same.
+ // For http modules, moduleName is its resolved http URL, and filename
+ // is the location of the locally downloaded source code.
+ module_name: string;
+ filename: string;
+ source_code: string;
+ output_code: string; // Non-empty only if cached.
+}
+
+table CodeCache {
+ filename: string;
+ source_code: string;
+ output_code: string;
+}
+
+struct Exit {
+ code: int;
+}
+
+struct TimerStart {
+ id: uint;
+ interval: bool;
+ delay: int;
+}
+
+struct TimerReady {
+ id: uint;
+ done: bool;
+}
+
+struct TimerClear {
+ id: uint;
+}
+
+table FetchReq {
+ id: uint;
+ url: string;
+ // header_line: [string];
+}
+
+table FetchRes {
+ id: uint;
+ status: int;
+ header_line: [string];
+ body: [byte];
+}
+
+table ReadFileSync {
+ filename: string;
+}
+
+table ReadFileSyncRes {
+ data: [byte];
+}
+
+table WriteFileSync {
+ filename: string;
+ data: [byte];
+ perm: uint;
+ // perm specified by https://godoc.org/os#FileMode
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-17 13:40:50 +0000