@taliesinb/mash 0.0.0-stage → 0.1.0

package/src/vm/state.ts

@@ -0,0 +1,267 @@
+/**
+ * Shell state: variables (with bash's dynamic scoping), functions, options,
+ * positional parameters and the working directory. A subshell gets a deep
+ * copy via {@link ShellState.clone}.
+ */
+
+import * as os from 'node:os'
+import type * as A from '../parser/ast.ts'
+
+/** The host process's umask (read once; children inherit it unless the script changes it). */
+export const HOST_UMASK: number = (() => {
+  const m = process.umask(0o022)
+  process.umask(m)
+  return m
+})()
+
+export type VarValue =
+  | { kind: 'string'; value: string }
+  | { kind: 'indexed'; values: Map<number, string> }
+  | { kind: 'assoc'; values: Map<string, string> }
+
+export interface Variable {
+  /** null: declared but unset (`local x`, `declare -a x` before assignment keeps kind via attrs). */
+  value: VarValue | null
+  exported: boolean
+  readonly: boolean
+  integer: boolean
+  lower: boolean
+  upper: boolean
+  /** `declare -a` / `-A` without a value yet. */
+  declaredKind?: 'indexed' | 'assoc'
+}
+
+export interface FunctionEntry {
+  def: A.FunctionDef
+  /** `export -f`: passed to child bash processes (BASH_FUNC_name%%) and inline scripts. */
+  exported?: boolean
+}
+
+export interface ShellOptions {
+  errexit: boolean
+  nounset: boolean
+  pipefail: boolean
+  xtrace: boolean
+  noglob: boolean
+  noclobber: boolean
+  allexport: boolean
+  noexec: boolean
+  verbose: boolean
+}
+
+export const SET_O_NAMES: Record<string, keyof ShellOptions> = {
+  errexit: 'errexit', nounset: 'nounset', pipefail: 'pipefail', xtrace: 'xtrace', noglob: 'noglob',
+  noclobber: 'noclobber', allexport: 'allexport', noexec: 'noexec', verbose: 'verbose',
+}
+
+export const SET_FLAGS: Record<string, keyof ShellOptions> = {
+  e: 'errexit', u: 'nounset', x: 'xtrace', f: 'noglob', C: 'noclobber', a: 'allexport', n: 'noexec', v: 'verbose',
+}
+
+export const KNOWN_SHOPTS = [
+  'nullglob', 'failglob', 'dotglob', 'globstar', 'nocaseglob', 'nocasematch', 'extglob', 'lastpipe', 'patsub_replacement',
+  'expand_aliases', 'inherit_errexit', 'globasciiranges', 'checkwinsize', 'histappend', 'sourcepath', 'xpg_echo',
+] as const
+
+function cloneValue(v: VarValue | null): VarValue | null {
+  if (v === null) return null
+  if (v.kind === 'string') return { kind: 'string', value: v.value }
+  if (v.kind === 'indexed') return { kind: 'indexed', values: new Map(v.values) }
+  return { kind: 'assoc', values: new Map(v.values) }
+}
+
+function cloneVar(v: Variable): Variable {
+  return { ...v, value: cloneValue(v.value) }
+}
+
+/** bash's OSTYPE / HOSTTYPE / MACHTYPE for the host (`darwin24` / `linux-gnu`, `x86_64`, ...). */
+function hostTypeVars(): Record<string, string> {
+  const darwin = process.platform === 'darwin'
+  const hosttype = process.arch === 'x64' ? 'x86_64' : process.arch === 'arm64' ? (darwin ? 'arm64' : 'aarch64') : process.arch
+  const ostype = darwin ? `darwin${os.release().split('.')[0]}` : process.platform === 'linux' ? 'linux-gnu' : process.platform
+  const vendor = darwin ? 'apple' : hosttype === 'x86_64' ? 'pc' : 'unknown'
+  return { OSTYPE: ostype, HOSTTYPE: hosttype, MACHTYPE: `${hosttype}-${vendor}-${ostype}` }
+}
+
+/**
+ * The variables a new bash process sets for itself (after importing the
+ * environment): the top-level shell and nested scripts run in the VM.
+ */
+export function initShellVars(state: ShellState): void {
+  const set = (k: string, value: VarValue): void => void state.globals.set(k, newVar(value))
+  set('BASH_VERSION', { kind: 'string', value: '5.2.0(1)-mash' })
+  // like bash's set_if_not: values from the environment win
+  for (const [k, v] of Object.entries(hostTypeVars())) if (!state.globals.has(k)) set(k, { kind: 'string', value: v })
+  set('PS4', { kind: 'string', value: '+ ' })
+  set('IFS', { kind: 'string', value: ' \t\n' })
+  set('OPTIND', { kind: 'string', value: '1' })
+  // PIPESTATUS is empty until the first command runs (bash 3.2 and 5.2 alike;
+  // the "(0)" seen in an earlier CI run came from commands in a sourced ~/.bashrc)
+}
+
+export function newVar(value: VarValue | null, attrs: Partial<Variable> = {}): Variable {
+  return { value, exported: false, readonly: false, integer: false, lower: false, upper: false, ...attrs }
+}
+
+export class ShellState {
+  globals = new Map<string, Variable>()
+  /** Function-local scopes, innermost last. */
+  locals: Map<string, Variable>[] = []
+  functions = new Map<string, FunctionEntry>()
+  options: ShellOptions = {
+    errexit: false, nounset: false, pipefail: false, xtrace: false, noglob: false,
+    noclobber: false, allexport: false, noexec: false, verbose: false,
+  }
+  // patsub_replacement: bash 5.2's default (`&` in ${x/p/r} is the match)
+  shopts = new Set<string>(['globasciiranges', 'sourcepath', 'patsub_replacement'])
+  positional: string[] = []
+  arg0 = 'mash'
+  cwd: string
+  lastStatus = 0
+  lastBgPid: number | null = null
+  traps = new Map<string, string>()
+  /**
+   * In a subshell, the parent's traps, which `trap`/`trap -p` still list until
+   * the subshell changes a trap (bash 4.2+; lets `$(trap -p)` save them).
+   */
+  parentTraps: Map<string, string> | undefined = undefined
+  dirStack: string[] = []
+  /** Command hash table (name → resolved path). */
+  hash = new Map<string, string>()
+  aliases = new Map<string, string>()
+  /** Function call stack (for FUNCNAME). */
+  funcStack: string[] = []
+  /** File creation mask applied to redirections and child processes. */
+  umask = HOST_UMASK
+  /** Alias expansion depth guard. */
+  aliasDepth = 0
+
+  constructor(cwd: string) {
+    this.cwd = cwd
+  }
+
+  clone(): ShellState {
+    const s = new ShellState(this.cwd)
+    for (const [k, v] of this.globals) s.globals.set(k, cloneVar(v))
+    s.locals = this.locals.map((scope) => {
+      const m = new Map<string, Variable>()
+      for (const [k, v] of scope) m.set(k, cloneVar(v))
+      return m
+    })
+    s.functions = new Map(this.functions)
+    s.options = { ...this.options }
+    s.shopts = new Set(this.shopts)
+    s.positional = [...this.positional]
+    s.arg0 = this.arg0
+    s.lastStatus = this.lastStatus
+    s.lastBgPid = this.lastBgPid
+    s.traps = new Map(this.traps)
+    s.parentTraps = this.parentTraps
+    s.dirStack = [...this.dirStack]
+    s.hash = new Map(this.hash)
+    s.aliases = new Map(this.aliases)
+    s.funcStack = [...this.funcStack]
+    s.umask = this.umask
+    return s
+  }
+
+  /** Find a variable following dynamic scope (innermost function scope first). */
+  lookup(name: string): Variable | undefined {
+    for (let i = this.locals.length - 1; i >= 0; i--) {
+      const v = this.locals[i].get(name)
+      if (v) return v
+    }
+    return this.globals.get(name)
+  }
+
+  /** The scope map holding `name`, or the global scope if none does. */
+  scopeOf(name: string): Map<string, Variable> {
+    for (let i = this.locals.length - 1; i >= 0; i--) {
+      if (this.locals[i].has(name)) return this.locals[i]
+    }
+    return this.globals
+  }
+
+  /** String value of a scalar (or element 0 of an array), undefined if unset. */
+  getString(name: string): string | undefined {
+    const v = this.lookup(name)
+    if (!v || v.value === null) return undefined
+    if (v.value.kind === 'string') return v.value.value
+    if (v.value.kind === 'indexed') return v.value.values.get(0)
+    return v.value.values.get('0')
+  }
+
+  isSet(name: string): boolean {
+    const v = this.lookup(name)
+    return v !== undefined && v.value !== null
+  }
+
+  /** Declare a local in the innermost function scope (or global when not in a function). */
+  declareLocal(name: string): Variable {
+    const scope = this.locals.length > 0 ? this.locals[this.locals.length - 1] : this.globals
+    let v = scope.get(name)
+    if (!v) {
+      v = newVar(null)
+      scope.set(name, v)
+    }
+    return v
+  }
+
+  /** Get or create (in the scope that holds it, else global) the variable record. */
+  ensure(name: string): Variable {
+    const scope = this.scopeOf(name)
+    let v = scope.get(name)
+    if (!v) {
+      v = newVar(null)
+      if (this.options.allexport) v.exported = true
+      scope.set(name, v)
+    }
+    return v
+  }
+
+  unset(name: string): boolean {
+    const scope = this.scopeOf(name)
+    const v = scope.get(name)
+    if (v?.readonly) return false
+    if (scope === this.globals) scope.delete(name)
+    else if (v) {
+      // bash: unsetting a local makes it unset in that scope (still shadows)
+      v.value = null
+    }
+    return true
+  }
+
+  /** The environment passed to child processes: exported scalars. */
+  environment(): Record<string, string> {
+    const env: Record<string, string> = {}
+    const visit = (scope: Map<string, Variable>): void => {
+      for (const [k, v] of scope) {
+        if (!v.exported) {
+          // a non-exported local shadows an exported global of the same name
+          if (k in env && scope !== this.globals) delete env[k]
+          continue
+        }
+        if (v.value === null) continue
+        if (v.value.kind === 'string') env[k] = v.value.value
+        else if (v.value.kind === 'indexed') env[k] = v.value.values.get(0) ?? ''
+      }
+    }
+    visit(this.globals)
+    for (const scope of this.locals) visit(scope)
+    return env
+  }
+
+  /** All variable names visible (for `${!prefix*}`, `set`, `declare -p`). */
+  visibleNames(): string[] {
+    const names = new Set<string>(this.globals.keys())
+    for (const scope of this.locals) for (const k of scope.keys()) names.add(k)
+    return [...names].sort()
+  }
+}
+
+/** Format `$-` from the options. */
+export function dashFlags(state: ShellState): string {
+  let s = 'h'
+  for (const [flag, opt] of Object.entries(SET_FLAGS)) if (state.options[opt]) s += flag
+  return s + 'B'
+}

package/src/vm/test.ts

@@ -0,0 +1,253 @@
+/**
+ * `[[ ... ]]` and `test` / `[` evaluation.
+ */
+
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import type * as A from '../parser/ast.ts'
+import { ArithError } from './arith.ts'
+import type { Interpreter } from './interp.ts'
+import { matchPattern } from './pattern.ts'
+import { CommandError, type Proc } from './proc.ts'
+import { newVar, SET_O_NAMES } from './state.ts'
+
+function statSafe(p: string, link = false): fs.Stats | null {
+  try {
+    return link ? fs.lstatSync(p) : fs.statSync(p)
+  } catch {
+    return null
+  }
+}
+
+function access(p: string, mode: number): boolean {
+  try {
+    fs.accessSync(p, mode)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function fileTest(op: string, operand: string, proc: Proc): boolean {
+  const p = path.resolve(proc.state.cwd, operand)
+  switch (op) {
+    case '-e': case '-a': return statSafe(p) !== null
+    case '-f': return statSafe(p)?.isFile() ?? false
+    case '-d': return statSafe(p)?.isDirectory() ?? false
+    case '-h': case '-L': return statSafe(p, true)?.isSymbolicLink() ?? false
+    case '-s': return (statSafe(p)?.size ?? 0) > 0
+    case '-r': return access(p, fs.constants.R_OK)
+    case '-w': return access(p, fs.constants.W_OK)
+    case '-x': return access(p, fs.constants.X_OK)
+    case '-p': return statSafe(p)?.isFIFO() ?? false
+    case '-S': return statSafe(p)?.isSocket() ?? false
+    case '-b': return statSafe(p)?.isBlockDevice() ?? false
+    case '-c': return statSafe(p)?.isCharacterDevice() ?? false
+    case '-g': return ((statSafe(p)?.mode ?? 0) & 0o2000) !== 0
+    case '-u': return ((statSafe(p)?.mode ?? 0) & 0o4000) !== 0
+    case '-k': return ((statSafe(p)?.mode ?? 0) & 0o1000) !== 0
+    case '-O': return statSafe(p)?.uid === process.getuid?.()
+    case '-G': return statSafe(p)?.gid === process.getgid?.()
+    case '-N': {
+      const s = statSafe(p)
+      return s !== null && s.mtimeMs > s.atimeMs
+    }
+    case '-t': return false
+    default: throw new CommandError(`${op}: unary operator expected`, 2)
+  }
+}
+
+function unaryTest(op: string, operand: string, proc: Proc): boolean {
+  switch (op) {
+    case '-n': return operand !== ''
+    case '-z': return operand === ''
+    case '-v': {
+      const m = /^([A-Za-z_][A-Za-z0-9_]*)(?:\[(.*)\])?$/.exec(operand)
+      if (!m) return false
+      const v = proc.state.lookup(m[1])
+      if (!v || v.value === null) return false
+      if (m[2] === undefined) return true
+      if (v.value.kind === 'indexed') return v.value.values.has(Number(m[2]))
+      if (v.value.kind === 'assoc') return v.value.values.has(m[2])
+      return m[2] === '0'
+    }
+    case '-o': {
+      const opt = SET_O_NAMES[operand]
+      return opt !== undefined && proc.state.options[opt]
+    }
+    case '-t': return false
+    default: return fileTest(op, operand, proc)
+  }
+}
+
+function intOf(s: string): bigint {
+  const t = s.trim()
+  if (!/^[+-]?\d+$/.test(t)) throw new CommandError(`${s}: integer expression expected`, 2)
+  return BigInt(t)
+}
+
+function binaryTest(op: string, a: string, b: string, proc: Proc): boolean {
+  switch (op) {
+    case '=': case '==': return a === b
+    case '!=': return a !== b
+    case '<': return a < b
+    case '>': return a > b
+    case '-eq': return intOf(a) === intOf(b)
+    case '-ne': return intOf(a) !== intOf(b)
+    case '-lt': return intOf(a) < intOf(b)
+    case '-le': return intOf(a) <= intOf(b)
+    case '-gt': return intOf(a) > intOf(b)
+    case '-ge': return intOf(a) >= intOf(b)
+    case '-nt': case '-ot': {
+      const sa = statSafe(path.resolve(proc.state.cwd, a))
+      const sb = statSafe(path.resolve(proc.state.cwd, b))
+      if (op === '-nt') return sa !== null && (sb === null || sa.mtimeMs > sb.mtimeMs)
+      return sb !== null && (sa === null || sa.mtimeMs < sb.mtimeMs)
+    }
+    case '-ef': {
+      const sa = statSafe(path.resolve(proc.state.cwd, a))
+      const sb = statSafe(path.resolve(proc.state.cwd, b))
+      return sa !== null && sb !== null && sa.dev === sb.dev && sa.ino === sb.ino
+    }
+    default: throw new CommandError(`${op}: binary operator expected`, 2)
+  }
+}
+
+/** POSIX ERE → JS regex source (character classes, mostly). */
+function ereToJs(re: string): string {
+  return re.replace(/\[:(alpha|digit|alnum|upper|lower|space|blank|punct|xdigit|word|cntrl|print|graph):\]/g, (_, c: string) => ({
+    alpha: 'a-zA-Z', digit: '0-9', alnum: 'a-zA-Z0-9', upper: 'A-Z', lower: 'a-z', space: '\\s', blank: ' \\t',
+    punct: '!-\\/:-@\\[-`{-~', xdigit: '0-9a-fA-F', word: '\\w', cntrl: '\\x00-\\x1f', print: '\\x20-\\x7e', graph: '\\x21-\\x7e',
+  } as Record<string, string>)[c])
+}
+
+async function expandRegex(word: A.Word, proc: Proc, interp: Interpreter): Promise<string> {
+  let out = ''
+  for (const part of word.parts) {
+    const w: A.Word = { ...word, parts: [part] }
+    const s = await interp.expander.expandString(w, proc)
+    const quoted = part.type === 'SglQuoted' || part.type === 'DblQuoted' || part.type === 'Escaped'
+    out += quoted ? s.replace(/[\\^$.*+?()[\]{}|/]/g, (c) => '\\' + c) : s
+  }
+  return out
+}
+
+const ARITH_OPS = new Set(['-eq', '-ne', '-lt', '-le', '-gt', '-ge'])
+
+export async function evalCond(e: A.CondExpr, proc: Proc, interp: Interpreter): Promise<boolean> {
+  switch (e.type) {
+    case 'CondGroup': return evalCond(e.expr, proc, interp)
+    case 'CondNot': return !(await evalCond(e.operand, proc, interp))
+    case 'CondAndOr': {
+      const l = await evalCond(e.left, proc, interp)
+      if (e.op === '&&') return l && (await evalCond(e.right, proc, interp))
+      return l || (await evalCond(e.right, proc, interp))
+    }
+    case 'CondWord': return (await interp.expander.expandString(e.word, proc)) !== ''
+    case 'CondUnary': return unaryTest(e.op, await interp.expander.expandString(e.operand, proc), proc)
+    case 'CondBinary': {
+      const left = await interp.expander.expandString(e.left, proc)
+      if (e.op === '==' || e.op === '=' || e.op === '!=') {
+        const pat = await interp.expander.expandPattern(e.right, proc)
+        const m = matchPattern(left, pat, { nocase: proc.state.shopts.has('nocasematch') })
+        return e.op === '!=' ? !m : m
+      }
+      if (e.op === '=~') {
+        const src = await expandRegex(e.right, proc, interp)
+        let re: RegExp
+        try {
+          re = new RegExp(ereToJs(src), proc.state.shopts.has('nocasematch') ? 'i' : '')
+        } catch {
+          throw new CommandError(`invalid regular expression: ${src}`, 2)
+        }
+        const m = re.exec(left)
+        const values = new Map<number, string>()
+        if (m) m.forEach((g, i) => values.set(i, g ?? ''))
+        proc.state.globals.set('BASH_REMATCH', newVar({ kind: 'indexed', values }))
+        return m !== null
+      }
+      const right = await interp.expander.expandString(e.right, proc)
+      if (ARITH_OPS.has(e.op)) {
+        try {
+          const a = await interp.arithText(left, proc)
+          const b = await interp.arithText(right, proc)
+          return binaryTest(e.op, String(a), String(b), proc)
+        } catch (err) {
+          if (err instanceof ArithError) throw new CommandError(err.message, 2)
+          throw err
+        }
+      }
+      return binaryTest(e.op, left, right, proc)
+    }
+  }
+}
+
+const UNARY = new Set(['-a', '-b', '-c', '-d', '-e', '-f', '-g', '-h', '-k', '-p', '-r', '-s', '-t', '-u', '-w', '-x', '-G', '-L', '-N', '-O', '-S', '-z', '-n', '-o', '-v'])
+const BINARY = new Set(['=', '==', '!=', '<', '>', '-eq', '-ne', '-lt', '-le', '-gt', '-ge', '-nt', '-ot', '-ef'])
+
+/** `test` / `[`: returns 0 (true), 1 (false); throws CommandError(2) on syntax errors. */
+export function evalTest(args: string[], proc: Proc): number {
+  const tooMany = (): never => {
+    throw new CommandError('too many arguments', 2)
+  }
+  const parseOr = (a: string[]): boolean => {
+    // split on -o at top level (lowest precedence), respecting parens
+    let depth = 0
+    for (let i = a.length - 1; i >= 0; i--) {
+      if (a[i] === ')') depth++
+      else if (a[i] === '(') depth--
+      else if (a[i] === '-o' && depth === 0 && i > 0 && i < a.length - 1) return parseOr(a.slice(0, i)) || parseAnd(a.slice(i + 1))
+    }
+    return parseAnd(a)
+  }
+  const parseAnd = (a: string[]): boolean => {
+    let depth = 0
+    for (let i = a.length - 1; i >= 0; i--) {
+      if (a[i] === ')') depth++
+      else if (a[i] === '(') depth--
+      else if (a[i] === '-a' && depth === 0 && i > 0 && i < a.length - 1) return parseAnd(a.slice(0, i)) && prim(a.slice(i + 1), true)
+    }
+    return prim(a, true)
+  }
+  const prim = (a: string[], fromLogic = false): boolean => {
+    switch (a.length) {
+      case 0: return false
+      case 1: return a[0] !== ''
+      case 2:
+        if (a[0] === '!') return !prim(a.slice(1))
+        if (UNARY.has(a[0])) return unaryTest(a[0], a[1], proc)
+        throw new CommandError(`${a[0]}: unary operator expected`, 2)
+      case 3:
+        if (BINARY.has(a[1])) return binaryTest(a[1], a[0], a[2], proc)
+        if (a[0] === '!') return !prim(a.slice(1))
+        if (a[0] === '(' && a[2] === ')') return prim([a[1]])
+        if (a[1] === '-a' || a[1] === '-o') return parseOr(a)
+        throw new CommandError(`${a[1]}: binary operator expected`, 2)
+      case 4:
+        if (a[0] === '!') return !prim(a.slice(1))
+        if (a[0] === '(' && a[3] === ')') return prim(a.slice(1, 3))
+        if (fromLogic || (!a.includes('-a') && !a.includes('-o'))) tooMany()
+        return parseOr(a)
+      default:
+        if (a[0] === '!' && !a.includes('-a') && !a.includes('-o')) return !prim(a.slice(1))
+        if (a[0] === '(' && a[a.length - 1] === ')') {
+          // only if parens balance as a group
+          let depth = 0
+          let wraps = true
+          for (let i = 0; i < a.length - 1; i++) {
+            if (a[i] === '(') depth++
+            else if (a[i] === ')') depth--
+            if (depth === 0) {
+              wraps = false
+              break
+            }
+          }
+          if (wraps) return prim(a.slice(1, -1))
+        }
+        if (fromLogic || (!a.includes('-a') && !a.includes('-o'))) tooMany()
+        return parseOr(a)
+    }
+  }
+  const hasLogic = args.length > 4 && (args.includes('-a') || args.includes('-o'))
+  return (hasLogic ? parseOr(args) : prim(args)) ? 0 : 1
+}