How to pass arguments to hermes/shermes?

[guest271314]

Typically arguments can be passed to programs in the form program a b c.

For example, when using shermes -emit-c we'll get a .c file with a main function

int main(int argc, char **argv) {
  SHRuntime *shr = _sh_init(argc, argv);
  init_console_bindings(shr);
  bool success = _sh_initialize_units(shr, 1, CREATE_THIS_UNIT);
  _sh_done(shr);
  return success ? 0 : 1;
}

After compilation to an executable, how do we pass arguments to that program that can be acted on dynamically by the program?

[tmikov]

We will make this easier, but for now the recommended way to do this is to compile to a named SHUnit and manually link that unit into your own main app.

$ shermes -c --exported-unit=hello  hello.js
# This produced an object file, hello.o, exporting the unit by name
$ nm hello.o
...
0000000000000000 T _sh_export_hello
...

Example main app that filters and saves CLI args:

#include "hermes/VM/static_h.h"

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

void init_console_bindings(SHRuntime *shr);

SHUnit *sh_export_hello(void);

static int s_argc;
static char ** s_argv;

// Make the args available to the FFI.
int get_argc(void) { return s_argc; }
char ** get_argv(void) { return s_argv; }

int main(int argc, char **argv) {
  // Copy all args up to "--" to pass to the VM.
  int vm_argc = 1;
  char ** vm_argv = (char **)malloc(sizeof(char *) * argc);
  vm_argv[0] = argv[0];
  while (vm_argc < argc && strcmp(argv[vm_argc], "--") != 0) {
      vm_argv[vm_argc] = argv[vm_argc];
      ++vm_argc;
  }
  // Shift the rest as args to pass to the code.
  if (vm_argc < argc) {
      memmove(argv + 1, argv + vm_argc + 1, sizeof(char *)*(argc - vm_argc - 1));
      argc = argc - vm_argc;
  } else {
      argc = 1;
  }
  s_argc = argc;
  s_argv = argv;
  // Debug print the collected args.
#ifndef NDEBUG
  printf("vm args:");
  for(int i = 0; i < vm_argc; ++i)
      printf(" %s", vm_argv[i]);
  putchar('\n');
  printf("main args:");
  for(int i = 0; i < s_argc; ++i)
      printf(" %s", s_argv[i]);
  putchar('\n');
#endif

  SHRuntime *shr = _sh_init(vm_argc, vm_argv);
  init_console_bindings(shr);
  bool success = _sh_initialize_units(shr, 1, sh_export_hello);
  _sh_done(shr);
  return success ? 0 : 1;
}

# Compile main.c
cc main.c -c -O3 \
     -I{$HermesBuildPath?}/lib/config -I{$HermesSourcePath?}/include \
     -fno-strict-aliasing -fno-strict-overflow
       
# Link executable
c++ main.o hello.o -o hello
    -L{$HermesBuildPath?}/lib -L{$HermesBuildPath?}/jsi -L{$HermesBuildPath?}/tools/shermes \
    -lshermes_console -lhermesvm  \
    -Wl,-rpath {$HermesBuildPath?}/lib \
    -Wl,-rpath {$HermesBuildPath?}/jsi \
    -Wl,-rpath {$HermesBuildPath?}/tools/shermes
    
# Run executable
./hello --gc-max-heap=100M -- 42
vm args: ./hello --gc-max-heap=100M
main args: ./hello 42    

(The exact paths and flags may have to be tweaked depending on the use case, for example Wasm, etc).

[guest271314]

I would suggest something conspicuous like globalThis.argc and globalThis.argv.

It's alright to define those on the global object. All JavaScript engines and runtimes add their own stuff to the global object, outside of ECMA-262.

To me I/O should be defined in ECMA-262. So there's a model for consistency. There is none now. Test 10 different JavaScript engines and runtimes, maybe 2 don't implement reading arguments or stdin at all, the other 8 implement reading stdin differently. That's 80% of a 10 engine/runtime sampling that implement reading arguments and reading stdin.

[tmikov]

In previous exchanges I have already explained the difference between a JS engine like v8 and a JS runtime like NodeJS. One uses a JS engine in order to build a JS runtime. The runtime adds all the I/O, system libraries, etc. A JS engine has no business dealing with command line arguments.

Static Hermes is a JS engine, not a runtime. Thus, it doesn't expose any I/O functionality (except print() for simple debugging).

In this case, Static Hermes gives you the ability to do whatever you want, including accessing CLI args. The example main.c I provided above already does everything necessary in order to access the arguments from JS. For example like this:

const _sh_ptr_read_ptr = $SHBuiltin.extern_c(
  { declared: true },
  function _sh_ptr_read_ptr(buf: c_ptr, offset: c_int): c_ptr {
    throw 0;
  }
);
const _sh_asciiz_to_string = $SHBuiltin.extern_c(
  { declared: true, hv: true },
  function _sh_asciiz_to_string(runtime: c_ptr, str: c_ptr, len: c_ptrdiff_t): string { throw 0; }
);
const _get_argc = $SHBuiltin.extern_c(
  { },
  function get_argc(): c_int { throw 0; }
);
const _get_argv = $SHBuiltin.extern_c(
  { },
  function get_argv(): c_ptr { throw 0; }
);

function initArgs() {
    let argc = _get_argc();
    let argv = _get_argv();
    let args = Array();

    for(let i = 0; i < argc; ++i) {
        let arg = _sh_ptr_read_ptr(argv, i);
        args.push(_sh_asciiz_to_string($SHBuiltin.c_native_runtime(), arg, -1));
    }

    globalThis.args = args;
}

initArgs();

print(JSON.stringify(globalThis.args));

[guest271314]

undefined reference to `get_argc'
undefined reference to `get_argv'

[guest271314]

I'll work with the code you posted. Thanks.

[guest271314]

Got it working.

./compile-with-args.sh
Done
./hello -- 4 5
5 of 23 (0-indexed, factorial 24) => [0,3,2,1]