@taliesinb/mash 0.0.0-stage → 0.1.0

package/src/vm/pattern.ts

@@ -0,0 +1,477 @@
+/**
+ * Shell pattern matching (`case`, `[[ == ]]`, `${x#pat}`, pathname globs).
+ *
+ * Patterns are strings in which quoted characters have been backslash-escaped
+ * (see `quotePattern`), so `"*"` from a quoted word matches a literal star.
+ */
+
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+const CLASSES: Record<string, string> = {
+  alpha: 'a-zA-Z', digit: '0-9', alnum: 'a-zA-Z0-9', upper: 'A-Z', lower: 'a-z',
+  space: ' \\t\\n\\r\\f\\v', blank: ' \\t', punct: '!-\\/:-@\\[-`{-~', xdigit: '0-9a-fA-F',
+  word: 'a-zA-Z0-9_', cntrl: '\\x00-\\x1f\\x7f', print: '\\x20-\\x7e', graph: '\\x21-\\x7e',
+}
+
+/** Escape pattern metacharacters so `s` matches literally. */
+export function quotePattern(s: string): string {
+  return s.replace(/[\\*?[\]]/g, (c) => '\\' + c)
+}
+
+/** True if the pattern contains an unescaped `*`, `?` or `[`. */
+export function hasGlobChars(pat: string): boolean {
+  for (let i = 0; i < pat.length; i++) {
+    const c = pat[i]
+    if (c === '\\') {
+      i++
+      continue
+    }
+    if (c === '*' || c === '?') return true
+    if ((c === '@' || c === '+' || c === '!') && pat[i + 1] === '(') return true
+    if (c === '[' && pat.indexOf(']', i + 2) !== -1) return true
+  }
+  return false
+}
+
+/** Remove pattern escapes: the literal string a glob-free pattern denotes. */
+export function unescapePattern(pat: string): string {
+  return pat.replace(/\\(.)/gs, '$1')
+}
+
+function escapeRegex(c: string): string {
+  return /[\\^$.*+?()[\]{}|/-]/.test(c) ? '\\' + c : c
+}
+
+export interface PatternOptions {
+  /** Pathname matching: `*` and `?` do not match `/`. */
+  pathname?: boolean
+  nocase?: boolean
+}
+
+/** Translate a shell pattern to regex source (unanchored). */
+export function patternToRegexSource(pat: string, opts: PatternOptions = {}): string {
+  let re = ''
+  const any = opts.pathname ? '[^/]' : '[\\s\\S]'
+  for (let i = 0; i < pat.length; i++) {
+    const c = pat[i]
+    if (c === '\\') {
+      i++
+      if (i < pat.length) re += escapeRegex(pat[i])
+      else re += '\\\\'
+      continue
+    }
+    if ('@*+?!'.includes(c) && pat[i + 1] === '(') {
+      // extglob: @(a|b) *(a|b) +(a|b) ?(a|b) !(a|b)
+      const close = groupEnd(pat, i + 1)
+      if (close !== -1) {
+        const alts = splitAlternatives(pat.slice(i + 2, close)).map((a) => patternToRegexSource(a, opts))
+        const group = `(?:${alts.join('|')})`
+        switch (c) {
+          case '@': re += group; break
+          case '*': re += group + '*'; break
+          case '+': re += group + '+'; break
+          case '?': re += group + '?'; break
+          case '!': re += `(?:(?!${group}$)${any}*?)`; break
+        }
+        i = close
+        continue
+      }
+    }
+    if (c === '*') {
+      while (pat[i + 1] === '*') i++
+      re += any + '*'
+      continue
+    }
+    if (c === '?') {
+      re += any
+      continue
+    }
+    if (c === '[') {
+      // bracket expression
+      let j = i + 1
+      let negate = false
+      if (pat[j] === '!' || pat[j] === '^') {
+        negate = true
+        j++
+      }
+      let body = ''
+      let first = true
+      let closed = false
+      for (; j < pat.length; j++) {
+        const d = pat[j]
+        if (d === ']' && !first) {
+          closed = true
+          break
+        }
+        first = false
+        if (d === '[' && pat[j + 1] === ':') {
+          const end = pat.indexOf(':]', j + 2)
+          if (end !== -1) {
+            const name = pat.slice(j + 2, end)
+            body += CLASSES[name] ?? ''
+            j = end + 1
+            continue
+          }
+        }
+        if (d === '\\' && j + 1 < pat.length) {
+          j++
+          body += '\\' + pat[j]
+          continue
+        }
+        if (d === '-' && body !== '' && pat[j + 1] !== ']') {
+          body += '-'
+          continue
+        }
+        body += /[\\\]^[]/.test(d) ? '\\' + d : d
+      }
+      if (!closed) {
+        re += '\\['
+        continue
+      }
+      re += (negate ? '[^' : '[') + body + (opts.pathname && negate ? '/' : '') + ']'
+      i = j
+      continue
+    }
+    re += escapeRegex(c)
+  }
+  return re
+}
+
+function groupEnd(pat: string, open: number): number {
+  let depth = 0
+  for (let i = open; i < pat.length; i++) {
+    if (pat[i] === '\\') {
+      i++
+      continue
+    }
+    if (pat[i] === '(') depth++
+    else if (pat[i] === ')' && --depth === 0) return i
+  }
+  return -1
+}
+
+function splitAlternatives(s: string): string[] {
+  const out: string[] = []
+  let depth = 0
+  let cur = ''
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i]
+    if (c === '\\') {
+      cur += c + (s[i + 1] ?? '')
+      i++
+      continue
+    }
+    if (c === '(') depth++
+    else if (c === ')') depth--
+    if (c === '|' && depth === 0) {
+      out.push(cur)
+      cur = ''
+      continue
+    }
+    cur += c
+  }
+  out.push(cur)
+  return out
+}
+
+const cache = new Map<string, RegExp>()
+
+/** Patterns with `!(...)` not at the very end need a backtracking matcher (regex cannot express it). */
+function needsMatcher(pat: string): boolean {
+  for (let i = 0; i < pat.length; i++) {
+    if (pat[i] === '\\') {
+      i++
+      continue
+    }
+    if (pat[i] === '!' && pat[i + 1] === '(') {
+      const close = groupEnd(pat, i + 1)
+      return close !== -1 && close !== pat.length - 1
+    }
+  }
+  return false
+}
+
+type PNode =
+  | { k: 'lit'; c: string }
+  | { k: 'any' }
+  | { k: 'star' }
+  | { k: 'class'; re: RegExp }
+  | { k: 'group'; op: string; alts: PNode[][] }
+
+function compileNodes(pat: string, opts: PatternOptions): PNode[] {
+  const out: PNode[] = []
+  for (let i = 0; i < pat.length; i++) {
+    const c = pat[i]
+    if (c === '\\') {
+      i++
+      if (i < pat.length) out.push({ k: 'lit', c: pat[i] })
+      continue
+    }
+    if ('@*+?!'.includes(c) && pat[i + 1] === '(') {
+      const close = groupEnd(pat, i + 1)
+      if (close !== -1) {
+        out.push({ k: 'group', op: c, alts: splitAlternatives(pat.slice(i + 2, close)).map((a) => compileNodes(a, opts)) })
+        i = close
+        continue
+      }
+    }
+    if (c === '*') out.push({ k: 'star' })
+    else if (c === '?') out.push({ k: 'any' })
+    else if (c === '[') {
+      const end = pat.indexOf(']', i + 2)
+      if (end === -1) out.push({ k: 'lit', c })
+      else {
+        out.push({ k: 'class', re: new RegExp('^' + patternToRegexSource(pat.slice(i, end + 1), opts) + '$', opts.nocase ? 'i' : '') })
+        i = end
+      }
+    } else out.push({ k: 'lit', c })
+  }
+  return out
+}
+
+function matchNodes(nodes: PNode[], ni: number, s: string, si: number, end: number, opts: PatternOptions): boolean {
+  if (ni === nodes.length) return si === end
+  const n = nodes[ni]
+  const okChar = (ch: string): boolean => !(opts.pathname && ch === '/')
+  switch (n.k) {
+    case 'lit':
+      return si < end && (opts.nocase ? s[si].toLowerCase() === n.c.toLowerCase() : s[si] === n.c) && matchNodes(nodes, ni + 1, s, si + 1, end, opts)
+    case 'any':
+      return si < end && okChar(s[si]) && matchNodes(nodes, ni + 1, s, si + 1, end, opts)
+    case 'class':
+      return si < end && n.re.test(s[si]) && matchNodes(nodes, ni + 1, s, si + 1, end, opts)
+    case 'star':
+      for (let k = si; k <= end; k++) {
+        if (matchNodes(nodes, ni + 1, s, k, end, opts)) return true
+        if (k < end && !okChar(s[k])) return false
+      }
+      return false
+    case 'group': {
+      const altMatches = (from: number, to: number): boolean => n.alts.some((a) => matchNodes(a, 0, s, from, to, opts))
+      if (n.op === '!') {
+        for (let k = si; k <= end; k++) if (!altMatches(si, k) && matchNodes(nodes, ni + 1, s, k, end, opts)) return true
+        return false
+      }
+      if (n.op === '@' || n.op === '?') {
+        if (n.op === '?' && matchNodes(nodes, ni + 1, s, si, end, opts)) return true
+        for (let k = si; k <= end; k++) if (altMatches(si, k) && matchNodes(nodes, ni + 1, s, k, end, opts)) return true
+        return false
+      }
+      // * and +: one or more repetitions (or zero for *)
+      const rep = (from: number, count: number): boolean => {
+        if ((n.op === '*' || count > 0) && matchNodes(nodes, ni + 1, s, from, end, opts)) return true
+        for (let k = from + 1; k <= end; k++) if (altMatches(from, k) && rep(k, count + 1)) return true
+        return false
+      }
+      return rep(si, 0)
+    }
+  }
+}
+
+/** A compiled pattern: a RegExp when possible, else a backtracking matcher with the same `test` API. */
+export function patternRegex(pat: string, opts: PatternOptions = {}): { test(s: string): boolean } {
+  if (needsMatcher(pat)) {
+    const nodes = compileNodes(pat, opts)
+    return { test: (s: string) => matchNodes(nodes, 0, s, 0, s.length, opts) }
+  }
+  return patternRegexOnly(pat, opts)
+}
+
+function patternRegexOnly(pat: string, opts: PatternOptions = {}): RegExp {
+  const key = `${opts.pathname ? 'p' : ''}${opts.nocase ? 'i' : ''}:${pat}`
+  let r = cache.get(key)
+  if (!r) {
+    r = new RegExp('^(?:' + patternToRegexSource(pat, opts) + ')$', opts.nocase ? 'is' : 's')
+    if (cache.size > 2000) cache.clear()
+    cache.set(key, r)
+  }
+  return r
+}
+
+export function matchPattern(s: string, pat: string, opts: PatternOptions = {}): boolean {
+  return patternRegex(pat, opts).test(s)
+}
+
+/** `${x#pat}` / `${x##pat}` */
+export function removePrefix(s: string, pat: string, longest: boolean): string {
+  const re = patternRegex(pat)
+  if (longest) {
+    for (let i = s.length; i >= 0; i--) if (re.test(s.slice(0, i))) return s.slice(i)
+  } else {
+    for (let i = 0; i <= s.length; i++) if (re.test(s.slice(0, i))) return s.slice(i)
+  }
+  return s
+}
+
+/** `${x%pat}` / `${x%%pat}` */
+export function removeSuffix(s: string, pat: string, longest: boolean): string {
+  const re = patternRegex(pat)
+  if (longest) {
+    for (let i = 0; i <= s.length; i++) if (re.test(s.slice(i))) return s.slice(0, i)
+  } else {
+    for (let i = s.length; i >= 0; i--) if (re.test(s.slice(i))) return s.slice(0, i)
+  }
+  return s
+}
+
+/** `${x/pat/rep}` and friends. */
+/**
+ * `${s/pat/rep}`. `rep` is a string, or a function of the matched text (bash
+ * 5.2 `patsub_replacement`: an unquoted `&` in the replacement is the match).
+ */
+export function replacePattern(s: string, pat: string, rep: string | ((match: string) => string), mode: 'first' | 'all' | 'prefix' | 'suffix'): string {
+  const re = patternRegex(pat)
+  const r = typeof rep === 'string' ? (): string => rep : rep
+  if (mode === 'prefix') {
+    for (let j = s.length; j >= 0; j--) if (re.test(s.slice(0, j))) return r(s.slice(0, j)) + s.slice(j)
+    return s
+  }
+  if (mode === 'suffix') {
+    for (let i = 0; i <= s.length; i++) if (re.test(s.slice(i))) return s.slice(0, i) + r(s.slice(i))
+    return s
+  }
+  if (pat === '') return s
+  let out = ''
+  let i = 0
+  while (i <= s.length) {
+    let matched = -1
+    for (let j = s.length; j > i; j--) {
+      if (re.test(s.slice(i, j))) {
+        matched = j
+        break
+      }
+    }
+    if (matched === -1) {
+      if (i < s.length) out += s[i]
+      i++
+      continue
+    }
+    out += r(s.slice(i, matched))
+    i = matched
+    if (mode === 'first') return out + s.slice(i)
+  }
+  return out
+}
+
+// ---------------------------------------------------------------------------
+// Pathname expansion
+// ---------------------------------------------------------------------------
+
+export interface GlobOptions {
+  cwd: string
+  dotglob?: boolean
+  globstar?: boolean
+  nocase?: boolean
+}
+
+function splitPattern(pat: string): string[] {
+  const segs: string[] = []
+  let cur = ''
+  for (let i = 0; i < pat.length; i++) {
+    const c = pat[i]
+    if (c === '\\' && i + 1 < pat.length) {
+      cur += c + pat[i + 1]
+      i++
+      continue
+    }
+    if (c === '/') {
+      segs.push(cur)
+      cur = ''
+      continue
+    }
+    cur += c
+  }
+  segs.push(cur)
+  return segs
+}
+
+function readdirSafe(dir: string): string[] {
+  try {
+    return fs.readdirSync(dir)
+  } catch {
+    return []
+  }
+}
+
+function isDir(p: string): boolean {
+  try {
+    return fs.statSync(p).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+function exists(p: string): boolean {
+  try {
+    fs.lstatSync(p)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Expand a pathname pattern against the filesystem. Returns matches sorted
+ * (C locale), or an empty array when nothing matches.
+ */
+export function globPaths(pattern: string, opts: GlobOptions): string[] {
+  const absolute = pattern.startsWith('/')
+  const segs = splitPattern(absolute ? pattern.slice(1) : pattern)
+  // candidates are [displayPath, fsPath]
+  let current: [string, string][] = [[absolute ? '/' : '', absolute ? '/' : opts.cwd]]
+  for (let si = 0; si < segs.length; si++) {
+    const seg = segs[si]
+    const last = si === segs.length - 1
+    const next: [string, string][] = []
+    const join = (display: string, name: string): string => (display === '' ? name : display.endsWith('/') ? display + name : display + '/' + name)
+    if (seg === '') {
+      // trailing slash or `//`
+      for (const [d, f] of current) if (isDir(f)) next.push([d.endsWith('/') ? d : d + '/', f])
+      current = next
+      continue
+    }
+    if (!hasGlobChars(seg)) {
+      const name = unescapePattern(seg)
+      for (const [d, f] of current) {
+        const fp = path.join(f, name)
+        if (last ? exists(fp) : isDir(fp)) next.push([join(d, name), fp])
+      }
+      current = next
+      continue
+    }
+    if (seg === '**' && opts.globstar) {
+      for (const [d, f] of current) {
+        // zero or more directories
+        const stack: [string, string][] = [[d, f]]
+        while (stack.length > 0) {
+          const [dd, ff] = stack.pop()!
+          next.push([dd, ff])
+          for (const name of readdirSafe(ff).sort()) {
+            if (name.startsWith('.') && !opts.dotglob) continue
+            const fp = path.join(ff, name)
+            if (isDir(fp)) stack.push([join(dd, name), fp])
+            else if (last) next.push([join(dd, name), fp])
+          }
+        }
+      }
+      current = next.filter(([d]) => d !== '' || !last)
+      continue
+    }
+    const re = patternRegex(seg, { pathname: true, nocase: opts.nocase })
+    const allowDot = seg.startsWith('.') || seg.startsWith('\\.') || opts.dotglob
+    for (const [d, f] of current) {
+      for (const name of readdirSafe(f)) {
+        if (name.startsWith('.') && !allowDot) continue
+        if (name === '.' || name === '..') continue
+        if (!re.test(name)) continue
+        const fp = path.join(f, name)
+        if (!last && !isDir(fp)) continue
+        next.push([join(d, name), fp])
+      }
+    }
+    current = next
+  }
+  const out = current.map(([d]) => d).filter((d) => d !== '')
+  return [...new Set(out)].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+}

package/src/vm/proc.ts

@@ -0,0 +1,147 @@
+/**
+ * Execution contexts. A {@link Proc} is one shell "process" as the script
+ * sees it: a {@link ShellState} plus an fd table and a virtual pid. Contexts
+ * that differ only in fds or errexit suppression (redirected builtins, `if`
+ * conditions) are derived views sharing the same state.
+ */
+
+import type { ChildProcess } from 'node:child_process'
+import { FdTable } from './io.ts'
+import { ShellState } from './state.ts'
+
+export class ExitSignal {
+  readonly status: number
+  constructor(status: number) {
+    this.status = status
+  }
+}
+
+export class ReturnSignal {
+  readonly status: number
+  constructor(status: number) {
+    this.status = status
+  }
+}
+
+export class LoopSignal {
+  readonly kind: 'break' | 'continue'
+  levels: number
+  constructor(kind: 'break' | 'continue', levels: number) {
+    this.kind = kind
+    this.levels = levels
+  }
+}
+
+/** Abort the whole run (policy abort, external cancellation). */
+export class AbortRun extends Error {
+  readonly status: number
+  constructor(reason: string, status = 126) {
+    super(reason)
+    this.name = 'AbortRun'
+    this.status = status
+  }
+}
+
+/** A fatal expansion error: prints a message and exits the (sub)shell. */
+export class FatalError extends Error {
+  readonly status: number
+  constructor(message: string, status = 1) {
+    super(message)
+    this.name = 'FatalError'
+    this.status = status
+  }
+}
+
+/**
+ * An expansion error that discards the current top-level command (bash's
+ * `jump_to_top_level(DISCARD)`, e.g. arithmetic errors): the script goes on
+ * with the next top-level command, `eval` fails with status 1.
+ */
+export class DiscardError extends Error {
+  readonly status: number
+  constructor(message: string, status = 1) {
+    super(message)
+    this.name = 'DiscardError'
+    this.status = status
+  }
+}
+
+/** A non-fatal command error: prints a message, the command fails with `status`. */
+export class CommandError extends Error {
+  readonly status: number
+  constructor(message: string, status = 1) {
+    super(message)
+    this.name = 'CommandError'
+    this.status = status
+  }
+}
+
+export interface Job {
+  pid: number
+  nodeId: number
+  done: Promise<number>
+  status: number | null
+  kill(signal?: NodeJS.Signals): void
+}
+
+export class Proc {
+  state: ShellState
+  fds: FdTable
+  /** Virtual `$BASHPID`. */
+  pid: number
+  parentPid: number
+  /** `$BASH_SUBSHELL` */
+  depth: number
+  /** >0 inside if/while conditions, `!`, and non-final `&&`/`||` items. */
+  errexitSuppressed = 0
+  loopDepth = 0
+  /** Background jobs started from this shell process. */
+  jobs: Map<number, Job>
+  /** Status of the last command substitution (for `x=$(false)`). */
+  lastSubstStatus: number | null = null
+  /** Line currently executing ($LINENO). */
+  line = 0
+  /** Process-substitution fds to close when the current command finishes (shared by derived views). */
+  procSubstFds: { fds: FdTable; fd: number }[] = []
+  /** Running `source`: `return` is allowed. */
+  sourcing = false
+  /** Set inside background jobs: aborted by `kill` on the job. */
+  jobSignal: AbortSignal | undefined = undefined
+  /** OS child processes started inside a background job (for `kill $!`). */
+  jobChildren: Set<ChildProcess> | undefined = undefined
+  /** Exit-trap ownership: traps set in this process. */
+  readonly isSubshell: boolean
+
+  constructor(state: ShellState, fds: FdTable, pid: number, parentPid: number, depth: number, jobs: Map<number, Job>, isSubshell: boolean) {
+    this.state = state
+    this.fds = fds
+    this.pid = pid
+    this.parentPid = parentPid
+    this.depth = depth
+    this.jobs = jobs
+    this.isSubshell = isSubshell
+  }
+
+  /** A view sharing state, with different fds and/or errexit suppression. */
+  derive(opts: { fds?: FdTable; suppress?: boolean; loop?: boolean }): Proc {
+    const p = Object.create(Proc.prototype) as Proc
+    Object.assign(p, this)
+    if (opts.fds) p.fds = opts.fds
+    if (opts.suppress) p.errexitSuppressed = this.errexitSuppressed + 1
+    if (opts.loop) p.loopDepth = this.loopDepth + 1
+    return p
+  }
+
+  /** A subshell: deep-copied state (traps reset), cloned fds. */
+  subshell(pid: number): Proc {
+    const state = this.state.clone()
+    state.parentTraps = this.state.parentTraps ?? new Map(this.state.traps)
+    state.traps.clear()
+    const p = new Proc(state, this.fds.clone(), pid, this.pid, this.depth + 1, new Map(), true)
+    p.errexitSuppressed = this.errexitSuppressed
+    p.line = this.line
+    p.jobSignal = this.jobSignal
+    p.jobChildren = this.jobChildren
+    return p
+  }
+}