process.gr

/**
 * Utilities for accessing functionality and information about the Grain program's process.
 *
 * This includes things like accessing environment variables and sending signals.
 *
 * @example from "wasi/process" include Process
 */
module Process

from "runtime/unsafe/wasmi32" include WasmI32
use WasmI32.{ (+), (*), (>>), (>>>), (&), (==), (!=), (<) }
from "runtime/unsafe/memory" include Memory
from "runtime/wasi" include Wasi
from "runtime/dataStructures" include DataStructures
use DataStructures.{ tagSimpleNumber, allocateArray, allocateString }

/**
 * Signals that can be sent to the host system.
 */
provide enum Signal {
  /**
   * Hangup.
   */
  HUP,
  /**
   * Terminate interrupt signal.
   */
  INT,
  /**
   * Terminal quit signal.
   */
  QUIT,
  /**
   * Illegal instruction.
   */
  ILL,
  /**
   * Trace/breakpoint trap.
   */
  TRAP,
  /**
   * Process abort signal.
   */
  ABRT,
  /**
   * Access to an undefined portion of a memory object.
   */
  BUS,
  /**
   * Erroneous arithmetic operation.
   */
  FPE,
  /**
   * Kill.
   */
  KILL,
  /**
   * User-defined signal 1.
   */
  USR1,
  /**
   * Invalid memory reference.
   */
  SEGV,
  /**
   * User-defined signal 2.
   */
  USR2,
  /**
   * Write on a pipe with no one to read it.
   */
  PIPE,
  /**
   * Alarm clock.
   */
  ALRM,
  /**
   * Termination signal.
   */
  TERM,
  /**
   * Child process terminated, stopped, or continued.
   */
  CHLD,
  /**
   * Continue executing, if stopped.
   */
  CONT,
  /**
   * Stop executing.
   */
  STOP,
  /**
   * Terminal stop signal.
   */
  TSTP,
  /**
   * Background process attempting read.
   */
  TTIN,
  /**
   * Background process attempting write.
   */
  TTOU,
  /**
   * High bandwidth data is available at a socket.
   */
  URG,
  /**
   * CPU time limit exceeded.
   */
  XCPU,
  /**
   * File size limit exceeded.
   */
  XFSZ,
  /**
   * Virtual timer expired.
   */
  VTALRM,
  PROF,
  WINCH,
  POLL,
  PWR,
  /**
   * Bad system call.
   */
  SYS,
}

/**
 * Access command line arguments.
 *
 * @returns `Ok(args)` of an array containing positional string arguments to the process if successful or `Err(exception)` otherwise
 */
@unsafe
provide let argv = () => {
  let argcPtr = Memory.malloc(8n)
  let argvBufSizePtr = argcPtr + 4n

  let err = Wasi.args_sizes_get(argcPtr, argvBufSizePtr)
  if (err != Wasi._ESUCCESS) {
    Memory.free(argcPtr)
    return Err(Wasi.SystemError(tagSimpleNumber(err)))
  }

  let argc = WasmI32.load(argcPtr, 0n)
  Memory.free(argcPtr)

  let argsLength = argc * 4n
  let arr = allocateArray(argc)

  if (WasmI32.eqz(argsLength)) {
    return Ok(WasmI32.toGrain(arr): Array<String>)
  }

  let argvBufSize = WasmI32.load(argvBufSizePtr, 0n)

  let argvPtr = Memory.malloc(argc * 4n)
  let argvBufPtr = Memory.malloc(argvBufSize)

  let err = Wasi.args_get(argvPtr, argvBufPtr)
  if (err != Wasi._ESUCCESS) {
    Memory.free(argvPtr)
    Memory.free(argvBufPtr)
    return Err(Wasi.SystemError(tagSimpleNumber(err)))
  }

  for (let mut i = 0n; i < argsLength; i += 4n) {
    let strPtr = WasmI32.load(argvPtr + i, 0n)
    let mut strLength = 0n
    while (WasmI32.load8U(strPtr + strLength, 0n) != 0n) {
      strLength += 1n
    }

    let grainStrPtr = allocateString(strLength)
    Memory.copy(grainStrPtr + 8n, strPtr, strLength)

    WasmI32.store(arr + i, grainStrPtr, 8n)
  }

  Memory.free(argvPtr)
  Memory.free(argvBufPtr)

  return Ok(WasmI32.toGrain(arr): Array<String>)
}

/**
 * Access environment variables.
 *
 * @returns `Ok(vars)` of an array containing environment variables supplied to the process if successful or `Err(exception)` otherwise
 */
@unsafe
provide let env = () => {
  let envcPtr = Memory.malloc(8n)
  let envvBufSizePtr = envcPtr + 4n

  let err = Wasi.environ_sizes_get(envcPtr, envvBufSizePtr)
  if (err != Wasi._ESUCCESS) {
    Memory.free(envcPtr)
    return Err(Wasi.SystemError(tagSimpleNumber(err)))
  }
  let envc = WasmI32.load(envcPtr, 0n)
  let envvBufSize = WasmI32.load(envvBufSizePtr, 0n)

  if (WasmI32.eqz(envc)) {
    Memory.free(envcPtr)
    return Ok([>]: Array<String>)
  }

  let envvPtr = Memory.malloc(envc * 4n)
  let envvBufPtr = Memory.malloc(envvBufSize)

  let err = Wasi.environ_get(envvPtr, envvBufPtr)
  if (err != Wasi._ESUCCESS) {
    Memory.free(envcPtr)
    Memory.free(envvPtr)
    Memory.free(envvBufPtr)
    return Err(Wasi.SystemError(tagSimpleNumber(err)))
  }
  let arr = allocateArray(envc)

  let envsLength = envc * 4n
  for (let mut i = 0n; i < envsLength; i += 4n) {
    let strPtr = WasmI32.load(envvPtr + i, 0n)
    let mut strLength = 0n
    while (WasmI32.load8U(strPtr + strLength, 0n) != 0n) {
      strLength += 1n
    }

    let grainStrPtr = allocateString(strLength)
    Memory.copy(grainStrPtr + 8n, strPtr, strLength)

    WasmI32.store(arr + i, grainStrPtr, 8n)
  }

  Memory.free(envcPtr)
  Memory.free(envvPtr)
  Memory.free(envvBufPtr)

  return Ok(WasmI32.toGrain(arr): Array<String>)
}

/**
 * Terminate the process normally.
 *
 * @param code: The value to exit with. An exit code of 0 is considered normal, with other values having meaning depending on the platform
 * @returns `Err(exception)` if unsuccessful. Will not actually return a value if successful, as the process has ended
 */
@unsafe
provide let exit = (code: Number) => {
  let mut code = WasmI32.fromGrain(code)

  if ((code & 1n) == 0n) {
    return Err(InvalidArgument("Invalid exit code"))
  }
  code = code >> 1n
  Wasi.proc_exit(code)
  // Never actually hit because it exited
  return Ok(void)
}

/**
 * Send a signal to the process of the calling thread.
 *
 * @param signal: The signal to send
 * @returns `Ok(void)` if successful or `Err(exception)` otherwise
 */
@unsafe
provide let sigRaise = (signal: Signal) => {
  let signal = WasmI32.fromGrain(signal)
  let signal = WasmI32.load(signal, 12n) >> 1n
  let err = Wasi.proc_raise(signal)
  if (err != Wasi._ESUCCESS) {
    return Err(Wasi.SystemError(tagSimpleNumber(err)))
  }
  return Ok(void)
}

/**
 * Yield execution to the calling thread.
 *
 * @returns `Ok(void)` if successful or `Err(exception)` otherwise
 */
@unsafe
provide let schedYield = () => {
  let err = Wasi.sched_yield()
  if (err != Wasi._ESUCCESS) {
    return Err(Wasi.SystemError(tagSimpleNumber(err)))
  }
  return Ok(void)
}