@live-codes/ocaml 0.0.0-stage → 0.1.0

package/assets/compiler/worker.js

@@ -0,0 +1,46 @@
+// The compiler worker: one compiler per worker.
+//
+// A js_of_ocaml program runs its main on load and returns, so a worker cannot
+// run two of them -- each compile needs a fresh one, created and terminated.
+//
+// Everything the compiler needs arrives through the virtual filesystem and the
+// environment; its output is collected by overriding console, because with the
+// browser filesystem fd 1 and fd 2 are wired to console.log and console.error
+// (runtime/js/fs_fake.js). A worker has no other way in: the output never
+// reaches a file the page can read.
+self.onmessage = (event) => {
+	const { script, files, env, argv, fs = [] } = event.data;
+	const out = [];
+	const err = [];
+	const realLog = console.log;
+	const realError = console.error;
+
+	console.log = (...args) => out.push(args.join(' '));
+	console.error = (...args) => err.push(args.join(' '));
+
+	try {
+		globalThis.jsoo_fs_tmp = files;
+		globalThis.jsoo_env = env;
+		// Browsers have no `process`; js_of_ocaml reads `process?.argv` for argv,
+		// so a fake one is enough. Note Sys.argv.(0) is argv[1].
+		globalThis.process = { argv };
+		// Filesystem artifacts first. Nothing has defined `jsoo_create_file` yet,
+		// so they queue their files on `jsoo_fs_tmp` -- and the program's runtime
+		// replays that queue at start-up. Loading them after the program would
+		// take the other branch and register the files directly, so the order is
+		// not load-bearing, but this is the cheaper one.
+		for (const url of fs) importScripts(url);
+		importScripts(script);
+		// The chunks go back as they arrived, not joined: the caller knows how to
+		// put them together, and joining here would lose the newlines between
+		// them. js_of_ocaml's stdout is line-buffered, so it hands over one call
+		// per line, and a program that arrives as a single line is a program
+		// swallowed by its own header comment.
+		self.postMessage({ out, err });
+	} catch (error) {
+		self.postMessage({ out, err: [...err, String((error && error.message) || error)] });
+	} finally {
+		console.log = realLog;
+		console.error = realError;
+	}
+};

package/assets/interpreter/libs/manifest.txt

@@ -0,0 +1 @@
+greet	greet.cma	greet.cmi

package/assets/interpreter/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/assets/interpreter/stdlib/units.txt

@@ -0,0 +1,75 @@
+camlinternalFormat.cmi
+camlinternalFormatBasics.cmi
+camlinternalLazy.cmi
+camlinternalMod.cmi
+camlinternalOO.cmi
+std_exit.cmi
+stdlib.cmi
+stdlib__Arg.cmi
+stdlib__Array.cmi
+stdlib__ArrayLabels.cmi
+stdlib__Atomic.cmi
+stdlib__Bigarray.cmi
+stdlib__Bool.cmi
+stdlib__Buffer.cmi
+stdlib__Bytes.cmi
+stdlib__BytesLabels.cmi
+stdlib__Callback.cmi
+stdlib__Char.cmi
+stdlib__Complex.cmi
+stdlib__Condition.cmi
+stdlib__Digest.cmi
+stdlib__Domain.cmi
+stdlib__Dynarray.cmi
+stdlib__Effect.cmi
+stdlib__Either.cmi
+stdlib__Ephemeron.cmi
+stdlib__Filename.cmi
+stdlib__Float.cmi
+stdlib__Format.cmi
+stdlib__Fun.cmi
+stdlib__Gc.cmi
+stdlib__Hashtbl.cmi
+stdlib__Iarray.cmi
+stdlib__In_channel.cmi
+stdlib__Int.cmi
+stdlib__Int32.cmi
+stdlib__Int64.cmi
+stdlib__Lazy.cmi
+stdlib__Lexing.cmi
+stdlib__List.cmi
+stdlib__ListLabels.cmi
+stdlib__Map.cmi
+stdlib__Marshal.cmi
+stdlib__MoreLabels.cmi
+stdlib__Mutex.cmi
+stdlib__Nativeint.cmi
+stdlib__Obj.cmi
+stdlib__Oo.cmi
+stdlib__Option.cmi
+stdlib__Out_channel.cmi
+stdlib__Pair.cmi
+stdlib__Parsing.cmi
+stdlib__Pqueue.cmi
+stdlib__Printexc.cmi
+stdlib__Printf.cmi
+stdlib__Queue.cmi
+stdlib__Random.cmi
+stdlib__Repr.cmi
+stdlib__Result.cmi
+stdlib__Scanf.cmi
+stdlib__Semaphore.cmi
+stdlib__Seq.cmi
+stdlib__Set.cmi
+stdlib__Stack.cmi
+stdlib__StdLabels.cmi
+stdlib__String.cmi
+stdlib__StringLabels.cmi
+stdlib__Sys.cmi
+stdlib__Type.cmi
+stdlib__Uchar.cmi
+stdlib__Unit.cmi
+stdlib__Weak.cmi
+topdirs.cmi
+unix.cmi
+unixLabels.cmi

package/assets/interpreter/worker-entry.js

@@ -0,0 +1,39 @@
+// A message-loop adapter around the runtime library.
+//
+// The runtime in worker.js is a *library*: it exposes `self.ocamlWasm` and does
+// not touch `onmessage`, so a host that is already a worker (LiveCodes' compiler
+// worker, for instance) can `importScripts('worker.js')` and call
+// `self.ocamlWasm.run(...)` directly, keeping its own protocol.
+//
+// This file is the other case: standalone use, where nobody else owns the
+// message loop, so something has to provide one. It is deliberately the only
+// place the postMessage protocol exists.
+
+importScripts('worker.js');
+
+// The runtime cannot tell where it was loaded from once it is `importScripts`ed
+// into a worker that lives elsewhere -- relative asset paths would resolve
+// against the *host*. The adapter does know its own location, so it says.
+self.ocamlWasm.setBaseUrl(new URL('./', self.location.href).href);
+
+self.addEventListener('message', (event) => {
+  const result = self.ocamlWasm.run(event.data);
+  // The exit code travels as it is. `postMessage` clones null perfectly well,
+  // and stringifying it -- which this used to do -- turned "never ran" into the
+  // string "null", which the caller then compared against null, failed, and
+  // turned into NaN.
+  self.postMessage([
+    'result',
+    result.exitCode,
+    result.stdout,
+    result.stderr,
+    result.outcome,
+    result.output,
+    result.diagnostics,
+  ]);
+});
+
+// The page waits for this before enabling Run, so pay initialisation here
+// rather than on the first run.
+self.ocamlWasm.init();
+self.postMessage(['ready', 'Toplevel ready.']);