Add support for stdin stream and chunked utility function.

This is required by the amaranth-yosys invocation.

README.md

@@ -40,10 +40,11 @@ Utility API reference
 This package also exports utilities that are useful when running other JavaScript YoWASP packages. These can be used as:
 
 ```js
-import { lineBuffered } from '@yowasp/runtime/util';
+import { lineBuffered, chunked } from '@yowasp/runtime/util';
 ```
 
-- The `lineBuffered(processLine)` function takes a function `processLine(line)` that accepts a line of text (e.g. `console.log`), and returns a function `processBytes(bytes)` that accepts a `Uint8Array` of encoded characters. Each byte sequence ending in the `\n` byte, not including it, is decoded as UTF-8 (invalid sequences are substituted with a replacement character) and passed to `processLine()`.
+- The `lineBuffered(processLine)` function takes a function `processLine(line)` that accepts a line of text (e.g. `console.log`), and returns a function `processBytes(bytes)` that accepts a `Uint8Array` of encoded characters (or `null`, which is ignored). Each byte sequence ending in the `\n` byte, not including it, is decoded as UTF-8 (invalid sequences are substituted with a replacement character) and passed to `processLine()`.
+- The `chunked(text)` function takes text and returns a function `getChunk(byteLength)` that slices off a `Uint8Array` of UTF-8 code points of the requested length and returns it. Once it exhausts the input, `getChunk()` returns `null` whenever it is called.
 
 
 License

lib/api.d.ts

@@ -2,10 +2,14 @@ export type Tree = {
     [name: string]: Tree | string | Uint8Array
 };
 
+export type InputStream =
+    (byteLength: number) => Uint8Array | null;
+
 export type OutputStream =
     (bytes: Uint8Array | null) => void;
 
 export type RunOptions = {
+    stdin?:  InputStream  | null;
     stdout?: OutputStream | null,
     stderr?: OutputStream | null,
     decodeASCII?: boolean

lib/api.js

@@ -53,13 +53,14 @@ export class Application {
     }
 
     // The `printLine` option is deprecated and not documented but still accepted for compatibility.
-    execute(args, files = {}, { stdout, stderr, decodeASCII = true, printLine } = {}) {
+    execute(args, files = {}, { stdin, stdout, stderr, decodeASCII = true, printLine } = {}) {
         const environment = new Environment();
         environment.args = [this.argv0].concat(args);
         environment.root = directoryFromTree(files);
         for (const [dirName, dirContents] of Object.entries(this.resourceData.filesystem))
             environment.root.files[dirName] = directoryFromTree(dirContents);
         const lineBufferedConsole = lineBuffered(printLine ?? console.log);
+        environment.stdin  = stdin  === undefined ? null : stdin;
         environment.stdout = stdout === undefined ? lineBufferedConsole : stdout;
         environment.stderr = stderr === undefined ? lineBufferedConsole : stderr;
 

lib/util.d.ts

@@ -1 +1,2 @@
 export function lineBuffered(processLine: (line: string) => void): (bytes: Uint8Array) => void;
+export function chunked(text: string): (byteLength: number) => Uint8Array | null;

lib/util.js

@@ -20,3 +20,15 @@ export function lineBuffered(processLine) {
         buffer = buffer.subarray(newlineAt + 1);
     };
 }
+
+export function chunked(text) {
+    let buffer = new TextEncoder().encode(text);
+    return (length) => {
+        if (buffer.length === 0)
+            return null;
+
+        let chunk = buffer.subarray(0, length);
+        buffer = buffer.subarray(length);
+        return chunk;
+    };
+}

lib/wasi-virt.js

@@ -75,6 +75,22 @@ class OutputStream {
   }
 }
 
+class CallbackInputStream extends InputStream {
+  constructor(callback = null) {
+    super();
+    this.callback = callback;
+  }
+
+  read(len) {
+    if (this.callback === null)
+      throw { tag: 'closed' };
+    let contents = this.callback(Number(len));
+    if (contents === null)
+      throw { tag: 'closed' };
+    return contents;
+  }
+}
+
 class CallbackOutputStream extends OutputStream {
   constructor(callback = null) {
     super();
@@ -350,7 +366,7 @@ export class Environment {
   constructor() {
     this.prng = new Xoroshiro128StarStar(1n);
 
-    this.standardInputStream = new InputStream();
+    this.standardInputStream = new CallbackInputStream();
     this.standardOutputStream = new CallbackOutputStream();
     this.standardErrorStream = new CallbackOutputStream();
 
@@ -398,6 +414,14 @@ export class Environment {
     };
   }
 
+  get stdin() {
+    return this.standardInputStream.callback;
+  }
+
+  set stdin(callback) {
+    this.standardInputStream.callback = callback;
+  }
+
   get stdout() {
     return this.standardOutputStream.callback;
   }

test/yowasp_runtime_test/index.js

@@ -1,5 +1,5 @@
 import { Application, Exit } from '@yowasp/runtime';
-import { lineBuffered } from '@yowasp/runtime/util';
+import { lineBuffered, chunked } from '@yowasp/runtime/util';
 import { instantiate } from './gen/copy.js';
 
 
@@ -42,13 +42,21 @@ if (!(files5['b.txt'] instanceof Uint8Array && files5['b.txt'].length === 1 && f
 
 let files6 = await yowaspRuntimeTest.run([], {'sp.txt': '\r\n\t'});
 if (files6['sp.txt'] !== '\r\n\t')
-    throw 'test 6';
+    throw 'test 6 failed';
 
 let files7 = await yowaspRuntimeTest.run([]);
 if (typeof files7['share'] !== 'undefined')
-    throw 'test 7';
+    throw 'test 7 failed';
+
+lines = [];
+await yowaspRuntimeTest.run([], {}, {
+    stdin: chunked('some text\n'),
+    stdout: lineBuffered((line) => lines.push(line))
+});
+if (!(lines.length === 1 || lines[0] === 'some text'))
+    throw 'test 8 failed';
 
 await yowaspRuntimeTest.preload();
 
 if ((yowaspRuntimeTest.execute(['share/foo.txt', 'foo.txt'], {}))['foo.txt'] !== 'contents of foo')
-    throw 'test 8 failed';
+    throw 'test 9 failed';