Does hermes expose the capability to read standard input and write standard output?

[guest271314]

Does hermes expose the capability to read standard input and write standard output?

If yes, where is that documentation and tests located?

If no, are there any plans to implement reading standard input and writing standard output, and handling standard error?

[tmikov]

Unfortunately an I/O library is currently out of scope for Hermes, and is technically orthogonal to our work.

Such a library can be implemented, but it would likely be mostly engine-agnostic.

[tmikov]

Yes, it allows you to access the platform API easily.

[guest271314]

Still trying to figure out how to read standard input.

[guest271314]

Yes, it allows you to access the platform API easily.

I wouldn't say "easily", compared to QuickJS.

const path = "/proc/${pid}/fd/0";
  try {
    const size = new Uint32Array(1);
    const err = { errno: 0 };
    const pipe = std.open(
      path,
      "rb",
      err,
    );
    if (err.errno !== 0) {
      throw std.strerror(err.errno);
    }
    pipe.read(size.buffer, 0, 4);

I noticed that shermes only works when there's hermes/VM/static_h.h files, else it throws.

[tmikov]

@guest271314 Static Hermes allows calling of any C API and generates native code. As I have said before, if you prefer QuickJS, you are more than welcome to use it, no need to let us know.

[guest271314]

I'm just trying to figure out how to use shermes capability to read standard input

I built shermes, then deleted the hermes static_h directory. Now shermes says

./read.ts
/tmp/read.ts-6716fa.c:2:10: fatal error: hermes/VM/static_h.h: No such file or directory
    2 | #include "hermes/VM/static_h.h"
      |          ^~~~~~~~~~~~~~~~~~~~~~
compilation terminated.
/usr/bin/cc: execution failed

[guest271314]

FWIW

fopen-dev-stdin.ts

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

// https://github.com/facebook/hermes/tree/static_h/examples/ffi
"use strict";

// Emulate a module scope, since global scope is unsound.
(function (exports) {
  const c_null = $SHBuiltin.c_null();

  // stdio.h
  const _fopen = $SHBuiltin.extern_c(
    { include: "stdio.h" },
    function fopen(path: c_ptr, mode: c_ptr): c_ptr {
      throw 0;
    },
  );
/*
  const _stdin = $SHBuiltin.extern_c(
    { include: "stdio.h" },
    function stdin(): c_ptr {
      return 0
    }
  );
*/
  const _fclose = $SHBuiltin.extern_c(
    { include: "stdio.h" },
    function fclose(f: c_ptr): void {
    },
  );
  const _fread = $SHBuiltin.extern_c(
    { include: "stdio.h" },
    function fread(
      ptr: c_ptr,
      size: c_size_t,
      nitems: c_size_t,
      stream: c_ptr,
    ): c_size_t {
      throw 0;
    },
  );

  // stdlib.h
  const _malloc = $SHBuiltin.extern_c(
    { include: "stdlib.h" },
    function malloc(size: c_size_t): c_ptr {
      throw 0;
    },
  );
  const _free = $SHBuiltin.extern_c(
    { include: "stdlib.h" },
    function free(p: c_ptr): void {
    },
  );

  // string.h
  const _strerror_r = $SHBuiltin.extern_c(
    { include: "string.h" },
    function strerror_r(errnum: c_int, errbuf: c_ptr, buflen: c_size_t): c_int {
      throw 0;
    },
  );

  // Builtin provided by SH to wrap errno.
  const _sh_errno = $SHBuiltin.extern_c(
    { declared: true },
    function _sh_errno(): c_int {
      throw 0;
    },
  );

  // Pointer access builtins.
  const _ptr_write_char = $SHBuiltin.extern_c(
    { declared: true },
    function _sh_ptr_write_char(ptr: c_ptr, offset: c_int, v: c_char): void {
    },
  );
  const _ptr_read_uchar = $SHBuiltin.extern_c(
    { declared: true },
    function _sh_ptr_read_uchar(ptr: c_ptr, offset: c_int): c_uchar {
      throw 0;
    },
  );

  /// Allocate native memory using malloc() or throw an exception.
  function malloc(size: number): c_ptr {
    "inline";
    "use unsafe";

    let res = _malloc(size);
    if (res === 0) throw Error("OOM");
    return res;
  }

  /// Convert a JS string to ASCIIZ.
  function stringToAsciiz(s: any): c_ptr {
    "use unsafe";

    if (typeof s !== "string") s = String(s);
    let buf = malloc(s.length + 1);
    try {
      let i = 0;
      for (let e = s.length; i < e; ++i) {
        let code: number = s.charCodeAt(i);
        if (code > 127) throw Error("String is not ASCII");
        _ptr_write_char(buf, i, code);
      }
      _ptr_write_char(buf, i, 0);
      return buf;
    } catch (e) {
      _free(buf);
      throw e;
    }
  }

  /// Convert an ASCII string of certain size to a JS string.
  function asciiToString_unsafe(buf: c_ptr, size: number): string {
    let res = "";
    for (let i = 0; i < size; ++i) {
      let ch = _ptr_read_uchar(buf, i);
      // if (ch > 127) throw Error("String is not ASCII");
      res += String.fromCharCode(ch);
    }
    return res;
  }

  /// Convert an ASCIIZ string up to a maximum size to a JS string.
  function asciizToString_unsafe(buf: c_ptr, maxsize: number): string {
    let res = "";
    for (let i = 0; i < maxsize; ++i) {
      let ch = _ptr_read_uchar(buf, i);
      //if (ch > 127) throw Error("String is not ASCII");
      //if (ch === 0) break;
      res += String.fromCharCode(ch);
    }
    return res;
  }

  function strerror(errnum: number): string {
    "use unsafe";

    let errbuf = malloc(1024);
    try {
      _strerror_r(errnum, errbuf, 1024);
      return asciizToString_unsafe(errbuf, 1024);
    } finally {
      _free(errbuf);
    }
  }

  /// Very simple hack to ensure safety.
  let handles: c_ptr[] = [];
  // FIXME: fast array doesn't support .pop() yet.
  let closedHandles = Array();

  function fopen(path: string, mode: string): number {
    "use unsafe";

    let pathz: c_ptr = c_null;
    let modez: c_ptr = c_null;
    try {
      pathz = stringToAsciiz(path);
      modez = stringToAsciiz(mode);
      let filePtr = _fopen(pathz, modez);
      if (!filePtr) {
        let errnum = _sh_errno();
        throw Error(path + ": " + strerror(errnum));
      }
      // Allocate a handle.
      if (closedHandles.length > 0) {
        let f = closedHandles.pop();
        handles[f] = filePtr;
        return f;
      }
      handles.push(filePtr);
      return handles.length - 1;
    } finally {
      _free(pathz);
      _free(modez);
    }
  }

  function fclose(f: number): void {
    "use unsafe";

    if (f < 0 || f >= handles.length) throw Error("invalid file handle");
    if (handles[f]) {
      _fclose(handles[f]);
      handles[f] = c_null;
      closedHandles.push(f);
    }
  }

  function fread(size: number, f: number): string {
    "use unsafe";

    if (f < 0 || f >= handles.length) throw Error("invalid file handle");
    if (!handles[f]) throw Error("file is closed");

    if (size <= 0) throw Error("invalid size");
    let buf = malloc(size);
    try {
      let nr = _fread(buf, 1, size, handles[f]);
      return asciiToString_unsafe(buf, nr);
    } finally {
      _free(buf);
    }
  }

  function freadAll(f: number): string {
    let res = "";
    for (;;) {
      let s = fread(1024, f);
      if (!s) break;
      res += s;
    }
    return res;
  }

  let f = fopen("/dev/stdin", "r"); // "/proc/self/fd/0"
  try {
    let input = String(freadAll(f)).trim();
    print(input);
  } finally {
    fclose(f);
  }

  // Optionally force some methods to be emitted for debugging.
  // exports.foo = foo;
})({});

echo '4 5' | ./build-host/bin/shermes -exec -typed fopen-dev-stdin.ts
4 5