@px-petals/roku.motion-web 1.0.0 → 1.1.0

package/script/luau/vm/vm.run.js

@@ -0,0 +1,842 @@
+/**
+ * The interpreter: call frames and the instruction loop.
+ *
+ * A frame is a closure, a `base` index into the VM's shared value stack (its
+ * registers are `stack[base + n]`), the saved `pc`, and where its results go
+ * (`ret`, the slot its function was called from, and `nres`, how many the
+ * caller wants, -1 for all). A call from Lua to Lua pushes a frame and keeps
+ * looping, so Lua recursion does not grow the JS stack; calls through native
+ * functions (metamethods, `pcall`, `table.sort`) nest `execute`.
+ *
+ * Instructions are 32-bit words: opcode in the low byte, then A, B and C as
+ * bytes, or A and a signed 16-bit D, or a signed 24-bit E. Cases are numbered
+ * by opcode (see `load.ops.js`; a test keeps the two in step).
+ */
+
+/** @import { ClosureRef, TableTemplate } from '../load/load.js' */
+
+import { arith, concat, equals, index, length, lessEqual, lessThan, metamethod, rawSet, setIndex, toNumber, unm } from './vm.meta.js'
+import { EMPTY, LuaClosure, LuaTable, LuaThrow, NativeFunction, Upvalue, fail, typeName } from './vm.value.js'
+
+/** @typedef {import('./vm.js').VM} VM */
+
+/** Lua frames allowed before "stack overflow" */
+export const MAX_FRAMES = 20000
+
+/** One running Lua function */
+export class Frame {
+  /**
+   * @param {LuaClosure} cl
+   * @param {number}     base
+   * @param {number}     ret     stack slot the results go to
+   * @param {number}     nres    results wanted, -1 for all
+   * @param {any[] | null} varargs
+   */
+  constructor(cl, base, ret, nres, varargs) {
+    this.cl = cl
+    this.base = base
+    this.ret = ret
+    this.nres = nres
+    this.varargs = varargs
+    this.pc = 0
+    /** True for the frame a host `call` started: its return leaves `execute` */
+    this.entry = false
+  }
+}
+
+/**
+ * Pushes the frame for calling `cl`, whose function slot is `ra` with `nargs`
+ * arguments after it.
+ *
+ * @param   {VM}         vm
+ * @param   {LuaClosure} cl
+ * @param   {number}     ra
+ * @param   {number}     nargs
+ * @param   {number}     nres
+ * @returns {Frame}
+ */
+export function enter(vm, cl, ra, nargs, nres) {
+  const p = cl.proto
+  const stack = vm.stack
+  const base = ra + 1
+  if (vm.frames.length >= MAX_FRAMES) throw fail('stack overflow')
+  const need = base + p.maxStack + 8
+  while (stack.length < need) stack.push(undefined)
+  const np = p.numParams
+  let varargs = null
+  if (p.isVararg) varargs = nargs > np ? stack.slice(base + np, base + nargs) : EMPTY
+  for (let i = nargs; i < np; i++) stack[base + i] = undefined
+  const frame = new Frame(cl, base, ra, nres, varargs)
+  vm.frames.push(frame)
+  vm.sp = base + p.maxStack
+  return frame
+}
+
+/**
+ * @param   {VM}    vm
+ * @param   {Frame} frame
+ * @returns {number} the source line the frame is at, 0 when unknown
+ */
+export function lineOf(vm, frame) {
+  const lines = frame.cl.proto.lines
+  if (lines === null) return 0
+  const at = frame.pc - 1
+  return at >= 0 && at < lines.length ? lines[at] : 0
+}
+
+/**
+ * Adds the position to a string error that asked for one.
+ *
+ * @param {VM}    vm
+ * @param {any}   e
+ * @param {Frame} frame  the running frame
+ * @param {number} pc
+ */
+function locate(vm, e, frame, pc) {
+  frame.pc = pc
+  if (!(e instanceof LuaThrow) || e.level <= 0) return
+  const frames = vm.frames
+  // level 1 is the running Lua frame; a frame entered from native code (pcall, a metamethod, the host) has a native caller one level up, which has no position
+  let at = frames.length - 1
+  let native = false
+  for (let step = 1; step < e.level; step++) {
+    if (native) {
+      native = false
+      at--
+    } else if (frames[at] !== undefined && frames[at].entry) native = true
+    else at--
+  }
+  const target = native ? undefined : frames[at]
+  e.level = 0
+  if (target === undefined) return
+  const line = lineOf(vm, target)
+  if (line > 0) {
+    e.line = line
+    e.chunk = target.cl.proto.chunk
+    if (typeof e.value === 'string') e.value = e.chunk + ':' + line + ': ' + e.value
+  }
+}
+
+/**
+ * @param   {any[]} stack
+ * @param   {number} from
+ * @param   {number} to
+ * @returns {any[]}
+ */
+function slice(stack, from, to) {
+  return to > from ? stack.slice(from, to) : []
+}
+
+/**
+ * @param   {any} v
+ * @param   {string} what
+ * @returns {number}
+ */
+function forNumber(v, what) {
+  const n = toNumber(v)
+  if (n === undefined) throw fail("'for' " + what + ' value must be a number')
+  return n
+}
+
+/**
+ * Runs the top frame, and the frames it calls, until the frame marked `entry`
+ * returns.
+ *
+ * @param   {VM}    vm
+ * @returns {any[]} that frame's results
+ */
+export function execute(vm) {
+  const stack = vm.stack
+  const frames = vm.frames
+  let frame = frames[frames.length - 1]
+  let cl = frame.cl
+  let code = cl.proto.code
+  let k = cl.proto.k
+  let base = frame.base
+  let pc = frame.pc
+  let upvals = cl.upvals
+  /** One past the last value of a multi-value result */
+  let top = 0
+
+  try {
+    for (;;) {
+      const insn = code[pc++]
+      const ra = base + ((insn >> 8) & 255)
+      switch (insn & 255) {
+        case 0: // NOP
+        case 1: // BREAK
+        case 69: // COVERAGE
+          break
+
+        case 2: // LOADNIL
+          stack[ra] = undefined
+          break
+
+        case 3: // LOADB
+          stack[ra] = ((insn >> 16) & 255) !== 0
+          pc += (insn >> 24) & 255
+          break
+
+        case 4: // LOADN
+          stack[ra] = insn >> 16
+          break
+
+        case 5: // LOADK
+          stack[ra] = k[insn >> 16]
+          break
+
+        case 6: // MOVE
+          stack[ra] = stack[base + ((insn >> 16) & 255)]
+          break
+
+        case 7: { // GETGLOBAL
+          const key = k[code[pc++]]
+          const env = cl.env
+          let v = env.getStr(key)
+          if (v === undefined && env.meta !== undefined) v = index(vm, env, key)
+          stack[ra] = v
+          break
+        }
+
+        case 8: { // SETGLOBAL
+          const key = k[code[pc++]]
+          const env = cl.env
+          if (env.meta === undefined) rawSet(env, key, stack[ra])
+          else setIndex(vm, env, key, stack[ra])
+          break
+        }
+
+        case 9: { // GETUPVAL
+          const uv = upvals[(insn >> 16) & 255]
+          stack[ra] = uv.s !== null ? uv.s[uv.i] : uv.v
+          break
+        }
+
+        case 10: { // SETUPVAL
+          const uv = upvals[(insn >> 16) & 255]
+          if (uv.s !== null) uv.s[uv.i] = stack[ra]
+          else uv.v = stack[ra]
+          break
+        }
+
+        case 11: // CLOSEUPVALS
+          if (vm.openUpvals.length > 0) vm.closeUpvals(ra)
+          break
+
+        case 12: { // GETIMPORT
+          const aux = code[pc++]
+          const n = aux >>> 30
+          let v = index(vm, cl.env, k[(aux >> 20) & 1023])
+          if (n > 1) v = index(vm, v, k[(aux >> 10) & 1023])
+          if (n > 2) v = index(vm, v, k[aux & 1023])
+          stack[ra] = v
+          break
+        }
+
+        case 13: { // GETTABLE
+          const t = stack[base + ((insn >> 16) & 255)]
+          const key = stack[base + ((insn >> 24) & 255)]
+          let v
+          if (t instanceof LuaTable) {
+            v = t.get(key)
+            if (v === undefined && t.meta !== undefined) v = index(vm, t, key)
+          } else v = index(vm, t, key)
+          stack[ra] = v
+          break
+        }
+
+        case 14: { // SETTABLE
+          const t = stack[base + ((insn >> 16) & 255)]
+          const key = stack[base + ((insn >> 24) & 255)]
+          if (t instanceof LuaTable && t.meta === undefined && !t.frozen && key !== undefined && key === key) t.set(key, stack[ra])
+          else setIndex(vm, t, key, stack[ra])
+          break
+        }
+
+        case 15: { // GETTABLEKS
+          const t = stack[base + ((insn >> 16) & 255)]
+          const key = k[code[pc++]]
+          let v
+          if (t instanceof LuaTable) {
+            v = t.getStr(key)
+            if (v === undefined && t.meta !== undefined) v = index(vm, t, key)
+          } else v = index(vm, t, key)
+          stack[ra] = v
+          break
+        }
+
+        case 16: { // SETTABLEKS
+          const t = stack[base + ((insn >> 16) & 255)]
+          const key = k[code[pc++]]
+          if (t instanceof LuaTable && t.meta === undefined && !t.frozen) t.set(key, stack[ra])
+          else setIndex(vm, t, key, stack[ra])
+          break
+        }
+
+        case 17: { // GETTABLEN
+          const t = stack[base + ((insn >> 16) & 255)]
+          const key = ((insn >> 24) & 255) + 1
+          let v
+          if (t instanceof LuaTable) {
+            v = key <= t.arr.length ? t.arr[key - 1] : t.get(key)
+            if (v === undefined && t.meta !== undefined) v = index(vm, t, key)
+          } else v = index(vm, t, key)
+          stack[ra] = v
+          break
+        }
+
+        case 18: { // SETTABLEN
+          const t = stack[base + ((insn >> 16) & 255)]
+          const key = ((insn >> 24) & 255) + 1
+          if (t instanceof LuaTable && t.meta === undefined && !t.frozen) t.set(key, stack[ra])
+          else setIndex(vm, t, key, stack[ra])
+          break
+        }
+
+        case 19: { // NEWCLOSURE
+          const p = cl.proto.protos[insn >> 16]
+          /** @type {any[]} */
+          const ups = []
+          // the closure is in its register before its captures are read: a local function captures itself
+          stack[ra] = new LuaClosure(p, ups, cl.env)
+          for (let i = 0; i < p.numUpvals; i++) {
+            const cap = code[pc++]
+            const b = (cap >> 16) & 255
+            const kind = (cap >> 8) & 255
+            if (kind === 0) {
+              const uv = new Upvalue(stack, -1)
+              uv.s = null
+              uv.v = stack[base + b]
+              ups.push(uv)
+            } else if (kind === 1) ups.push(vm.findUpvalue(base + b))
+            else ups.push(upvals[b])
+          }
+          break
+        }
+
+        case 20: { // NAMECALL
+          const obj = stack[base + ((insn >> 16) & 255)]
+          const key = k[code[pc++]]
+          let fn
+          if (obj instanceof LuaTable) {
+            fn = obj.getStr(key)
+            if (fn === undefined && obj.meta !== undefined) fn = index(vm, obj, key)
+          } else fn = index(vm, obj, key)
+          if (fn === undefined) throw fail("attempt to call missing method '" + key + "' of " + typeName(obj))
+          stack[ra + 1] = obj
+          stack[ra] = fn
+          break
+        }
+
+        case 87: // CALLFB: a CALL that carries a feedback slot word
+          pc++
+        // falls through
+        case 21: { // CALL
+          const b = (insn >> 16) & 255
+          const nargs = b !== 0 ? b - 1 : top - ra - 1
+          const nres = ((insn >> 24) & 255) - 1
+          const fn = stack[ra]
+          if (fn instanceof LuaClosure) {
+            frame.pc = pc
+            frame = enter(vm, fn, ra, nargs, nres)
+            cl = fn
+            code = cl.proto.code
+            k = cl.proto.k
+            base = frame.base
+            pc = 0
+            upvals = cl.upvals
+            break
+          }
+          const args = slice(stack, ra + 1, ra + 1 + nargs)
+          let res
+          if (fn instanceof NativeFunction) {
+            frame.pc = pc
+            res = fn.fn(vm, args)
+            if (!Array.isArray(res)) res = [ res ]
+          } else {
+            frame.pc = pc
+            res = vm.call(fn, args)
+          }
+          const n = res.length
+          if (nres < 0) {
+            while (stack.length < ra + n + 8) stack.push(undefined)
+            for (let i = 0; i < n; i++) stack[ra + i] = res[i]
+            top = ra + n
+          } else {
+            for (let i = 0; i < nres; i++) stack[ra + i] = i < n ? res[i] : undefined
+          }
+          break
+        }
+
+        case 22: { // RETURN
+          const b = (insn >> 16) & 255
+          const n = b !== 0 ? b - 1 : top - ra
+          if (vm.openUpvals.length > 0) vm.closeUpvals(base)
+          if (frame.entry) {
+            const res = slice(stack, ra, ra + n)
+            frames.pop()
+            return res
+          }
+          const dest = frame.ret
+          const nres = frame.nres
+          if (nres < 0) {
+            for (let i = 0; i < n; i++) stack[dest + i] = stack[ra + i]
+            top = dest + n
+          } else {
+            for (let i = 0; i < nres; i++) stack[dest + i] = i < n ? stack[ra + i] : undefined
+          }
+          frames.pop()
+          frame = frames[frames.length - 1]
+          cl = frame.cl
+          code = cl.proto.code
+          k = cl.proto.k
+          base = frame.base
+          pc = frame.pc
+          upvals = cl.upvals
+          vm.sp = base + cl.proto.maxStack
+          break
+        }
+
+        case 23: // JUMP
+        case 24: // JUMPBACK
+          pc += insn >> 16
+          break
+
+        case 25: { // JUMPIF
+          const v = stack[ra]
+          if (v !== undefined && v !== false) pc += insn >> 16
+          break
+        }
+
+        case 26: { // JUMPIFNOT
+          const v = stack[ra]
+          if (v === undefined || v === false) pc += insn >> 16
+          break
+        }
+
+        case 27: { // JUMPIFEQ
+          const a = stack[ra]
+          const b = stack[base + code[pc]]
+          if (a === b || (typeof a === 'object' && equals(vm, a, b))) pc += insn >> 16
+          else pc++
+          break
+        }
+
+        case 30: { // JUMPIFNOTEQ
+          const a = stack[ra]
+          const b = stack[base + code[pc]]
+          if (a === b || (typeof a === 'object' && equals(vm, a, b))) pc++
+          else pc += insn >> 16
+          break
+        }
+
+        case 28: { // JUMPIFLE
+          const a = stack[ra]
+          const b = stack[base + code[pc]]
+          if (typeof a === 'number' && typeof b === 'number' ? a <= b : lessEqual(vm, a, b)) pc += insn >> 16
+          else pc++
+          break
+        }
+
+        case 31: { // JUMPIFNOTLE
+          const a = stack[ra]
+          const b = stack[base + code[pc]]
+          if (typeof a === 'number' && typeof b === 'number' ? a <= b : lessEqual(vm, a, b)) pc++
+          else pc += insn >> 16
+          break
+        }
+
+        case 29: { // JUMPIFLT
+          const a = stack[ra]
+          const b = stack[base + code[pc]]
+          if (typeof a === 'number' && typeof b === 'number' ? a < b : lessThan(vm, a, b)) pc += insn >> 16
+          else pc++
+          break
+        }
+
+        case 32: { // JUMPIFNOTLT
+          const a = stack[ra]
+          const b = stack[base + code[pc]]
+          if (typeof a === 'number' && typeof b === 'number' ? a < b : lessThan(vm, a, b)) pc++
+          else pc += insn >> 16
+          break
+        }
+
+        case 33: { // ADD
+          const b = stack[base + ((insn >> 16) & 255)]
+          const c = stack[base + ((insn >> 24) & 255)]
+          stack[ra] = typeof b === 'number' && typeof c === 'number' ? b + c : arith(vm, 'add', b, c)
+          break
+        }
+
+        case 34: { // SUB
+          const b = stack[base + ((insn >> 16) & 255)]
+          const c = stack[base + ((insn >> 24) & 255)]
+          stack[ra] = typeof b === 'number' && typeof c === 'number' ? b - c : arith(vm, 'sub', b, c)
+          break
+        }
+
+        case 35: { // MUL
+          const b = stack[base + ((insn >> 16) & 255)]
+          const c = stack[base + ((insn >> 24) & 255)]
+          stack[ra] = typeof b === 'number' && typeof c === 'number' ? b * c : arith(vm, 'mul', b, c)
+          break
+        }
+
+        case 36: { // DIV
+          const b = stack[base + ((insn >> 16) & 255)]
+          const c = stack[base + ((insn >> 24) & 255)]
+          stack[ra] = typeof b === 'number' && typeof c === 'number' ? b / c : arith(vm, 'div', b, c)
+          break
+        }
+
+        case 37: { // MOD
+          const b = stack[base + ((insn >> 16) & 255)]
+          const c = stack[base + ((insn >> 24) & 255)]
+          stack[ra] = typeof b === 'number' && typeof c === 'number' ? b - Math.floor(b / c) * c : arith(vm, 'mod', b, c)
+          break
+        }
+
+        case 38: { // POW
+          const b = stack[base + ((insn >> 16) & 255)]
+          const c = stack[base + ((insn >> 24) & 255)]
+          stack[ra] = typeof b === 'number' && typeof c === 'number' ? Math.pow(b, c) : arith(vm, 'pow', b, c)
+          break
+        }
+
+        case 81: { // IDIV
+          const b = stack[base + ((insn >> 16) & 255)]
+          const c = stack[base + ((insn >> 24) & 255)]
+          stack[ra] = typeof b === 'number' && typeof c === 'number' ? Math.floor(b / c) : arith(vm, 'idiv', b, c)
+          break
+        }
+
+        case 39: { // ADDK
+          const b = stack[base + ((insn >> 16) & 255)]
+          const c = k[(insn >> 24) & 255]
+          stack[ra] = typeof b === 'number' ? b + c : arith(vm, 'add', b, c)
+          break
+        }
+
+        case 40: { // SUBK
+          const b = stack[base + ((insn >> 16) & 255)]
+          const c = k[(insn >> 24) & 255]
+          stack[ra] = typeof b === 'number' ? b - c : arith(vm, 'sub', b, c)
+          break
+        }
+
+        case 41: { // MULK
+          const b = stack[base + ((insn >> 16) & 255)]
+          const c = k[(insn >> 24) & 255]
+          stack[ra] = typeof b === 'number' ? b * c : arith(vm, 'mul', b, c)
+          break
+        }
+
+        case 42: { // DIVK
+          const b = stack[base + ((insn >> 16) & 255)]
+          const c = k[(insn >> 24) & 255]
+          stack[ra] = typeof b === 'number' ? b / c : arith(vm, 'div', b, c)
+          break
+        }
+
+        case 43: { // MODK
+          const b = stack[base + ((insn >> 16) & 255)]
+          const c = k[(insn >> 24) & 255]
+          stack[ra] = typeof b === 'number' ? b - Math.floor(b / c) * c : arith(vm, 'mod', b, c)
+          break
+        }
+
+        case 44: { // POWK
+          const b = stack[base + ((insn >> 16) & 255)]
+          const c = k[(insn >> 24) & 255]
+          stack[ra] = typeof b === 'number' ? Math.pow(b, c) : arith(vm, 'pow', b, c)
+          break
+        }
+
+        case 82: { // IDIVK
+          const b = stack[base + ((insn >> 16) & 255)]
+          const c = k[(insn >> 24) & 255]
+          stack[ra] = typeof b === 'number' ? Math.floor(b / c) : arith(vm, 'idiv', b, c)
+          break
+        }
+
+        case 71: { // SUBRK
+          const b = k[(insn >> 16) & 255]
+          const c = stack[base + ((insn >> 24) & 255)]
+          stack[ra] = typeof c === 'number' ? b - c : arith(vm, 'sub', b, c)
+          break
+        }
+
+        case 72: { // DIVRK
+          const b = k[(insn >> 16) & 255]
+          const c = stack[base + ((insn >> 24) & 255)]
+          stack[ra] = typeof c === 'number' ? b / c : arith(vm, 'div', b, c)
+          break
+        }
+
+        case 45: { // AND
+          const b = stack[base + ((insn >> 16) & 255)]
+          stack[ra] = b === undefined || b === false ? b : stack[base + ((insn >> 24) & 255)]
+          break
+        }
+
+        case 46: { // OR
+          const b = stack[base + ((insn >> 16) & 255)]
+          stack[ra] = b === undefined || b === false ? stack[base + ((insn >> 24) & 255)] : b
+          break
+        }
+
+        case 47: { // ANDK
+          const b = stack[base + ((insn >> 16) & 255)]
+          stack[ra] = b === undefined || b === false ? b : k[(insn >> 24) & 255]
+          break
+        }
+
+        case 48: { // ORK
+          const b = stack[base + ((insn >> 16) & 255)]
+          stack[ra] = b === undefined || b === false ? k[(insn >> 24) & 255] : b
+          break
+        }
+
+        case 49: { // CONCAT
+          const b = base + ((insn >> 16) & 255)
+          const c = base + ((insn >> 24) & 255)
+          let acc = stack[c]
+          for (let i = c - 1; i >= b; i--) acc = concat(vm, stack[i], acc)
+          stack[ra] = acc
+          break
+        }
+
+        case 50: { // NOT
+          const v = stack[base + ((insn >> 16) & 255)]
+          stack[ra] = v === undefined || v === false
+          break
+        }
+
+        case 51: { // MINUS
+          const v = stack[base + ((insn >> 16) & 255)]
+          stack[ra] = typeof v === 'number' ? -v : unm(vm, v)
+          break
+        }
+
+        case 52: { // LENGTH
+          const v = stack[base + ((insn >> 16) & 255)]
+          if (v instanceof LuaTable && v.meta === undefined) stack[ra] = v.arr.length
+          else stack[ra] = length(vm, v)
+          break
+        }
+
+        case 53: // NEWTABLE
+          pc++
+          stack[ra] = new LuaTable()
+          break
+
+        case 54: { // DUPTABLE
+          const tpl = /** @type {TableTemplate} */ (k[insn >> 16])
+          const t = new LuaTable()
+          for (let i = 0; i < tpl.keys.length; i++) t.set(tpl.keys[i], tpl.values[i])
+          stack[ra] = t
+          break
+        }
+
+        case 55: { // SETLIST
+          const start = base + ((insn >> 16) & 255)
+          const c = (insn >> 24) & 255
+          const n = c !== 0 ? c - 1 : top - start
+          const first = code[pc++]
+          const t = stack[ra]
+          if (n > 0) t.setRange(first, stack, start, n)
+          break
+        }
+
+        case 56: { // FORNPREP
+          let limit = stack[ra]
+          let step = stack[ra + 1]
+          let idx = stack[ra + 2]
+          if (typeof limit !== 'number') stack[ra] = limit = forNumber(limit, 'limit')
+          if (typeof step !== 'number') stack[ra + 1] = step = forNumber(step, 'step')
+          if (typeof idx !== 'number') stack[ra + 2] = idx = forNumber(idx, 'initial')
+          if (!(step > 0 ? idx <= limit : limit <= idx)) pc += insn >> 16
+          break
+        }
+
+        case 57: { // FORNLOOP
+          const step = stack[ra + 1]
+          const idx = stack[ra + 2] + step
+          stack[ra + 2] = idx
+          const limit = stack[ra]
+          if (step > 0 ? idx <= limit : limit <= idx) pc += insn >> 16
+          break
+        }
+
+        case 76: // FORGPREP
+        case 59: // FORGPREP_INEXT
+        case 61: { // FORGPREP_NEXT
+          const op = insn & 255
+          const f = stack[ra]
+          if (op === 59 && f === vm.inext && stack[ra + 1] instanceof LuaTable && stack[ra + 2] === 0) {
+            stack[ra] = undefined
+            stack[ra + 2] = 0
+          } else if (op === 61 && f === vm.next && stack[ra + 1] instanceof LuaTable && stack[ra + 2] === undefined) {
+            stack[ra] = undefined
+            stack[ra + 2] = 0
+          } else if (f instanceof LuaClosure || f instanceof NativeFunction) {
+            // called by FORGLOOP
+          } else {
+            const iter = metamethod(vm, f, '__iter')
+            if (iter !== undefined) {
+              frame.pc = pc
+              const res = vm.call(iter, [ f ])
+              stack[ra] = res[0]
+              stack[ra + 1] = res[1]
+              stack[ra + 2] = res[2]
+              if (stack[ra] === undefined) throw fail('attempt to call a nil value')
+            } else if (metamethod(vm, f, '__call') !== undefined) {
+              // called by FORGLOOP
+            } else if (f instanceof LuaTable) {
+              stack[ra + 1] = f
+              stack[ra] = undefined
+              stack[ra + 2] = 0
+            } else throw fail('attempt to iterate over a ' + typeName(f) + ' value')
+          }
+          pc += insn >> 16
+          break
+        }
+
+        case 58: { // FORGLOOP
+          const aux = code[pc]
+          const t = stack[ra + 1]
+          if (stack[ra] === undefined && t instanceof LuaTable) {
+            const pos = stack[ra + 2]
+            if (aux < 0) {
+              // ipairs: stops at the first nil
+              const arr = t.arr
+              if (pos >= arr.length || arr[pos] === undefined) {
+                pc++
+                break
+              }
+              stack[ra + 2] = pos + 1
+              stack[ra + 3] = pos + 1
+              stack[ra + 4] = arr[pos]
+              for (let i = 2; i < (aux & 255); i++) stack[ra + 3 + i] = undefined
+              pc += insn >> 16
+              break
+            }
+            const next = t.advance(pos)
+            if (next === null) {
+              pc++
+              break
+            }
+            stack[ra + 2] = next
+            stack[ra + 3] = t.ck
+            stack[ra + 4] = t.cv
+            for (let i = 2; i < aux; i++) stack[ra + 3 + i] = undefined
+            pc += insn >> 16
+            break
+          }
+          const nvars = aux & 255
+          frame.pc = pc
+          const res = vm.call(stack[ra], [ stack[ra + 1], stack[ra + 2] ])
+          for (let i = 0; i < nvars; i++) stack[ra + 3 + i] = res[i]
+          stack[ra + 2] = stack[ra + 3]
+          if (stack[ra + 3] === undefined) pc++
+          else pc += insn >> 16
+          break
+        }
+
+        case 63: { // GETVARARGS
+          const b = (insn >> 16) & 255
+          const va = /** @type {any[]} */ (frame.varargs)
+          if (b === 0) {
+            while (stack.length < ra + va.length + 8) stack.push(undefined)
+            for (let i = 0; i < va.length; i++) stack[ra + i] = va[i]
+            top = ra + va.length
+          } else {
+            for (let i = 0; i < b - 1; i++) stack[ra + i] = va[i]
+          }
+          break
+        }
+
+        case 64: { // DUPCLOSURE
+          const p = /** @type {ClosureRef} */ (k[insn >> 16]).proto
+          /** @type {any[]} */
+          const ups = []
+          // the closure is in its register before its captures are read: a local function captures itself
+          stack[ra] = new LuaClosure(p, ups, cl.env)
+          for (let i = 0; i < p.numUpvals; i++) {
+            const cap = code[pc++]
+            const b = (cap >> 16) & 255
+            const kind = (cap >> 8) & 255
+            if (kind === 0) {
+              const uv = new Upvalue(stack, -1)
+              uv.s = null
+              uv.v = stack[base + b]
+              ups.push(uv)
+            } else if (kind === 1) ups.push(vm.findUpvalue(base + b))
+            else ups.push(upvals[b])
+          }
+          break
+        }
+
+        case 65: // PREPVARARGS: the frame was set up on entry
+          break
+
+        case 66: // LOADKX
+          stack[ra] = k[code[pc++]]
+          break
+
+        case 67: // JUMPX
+          pc += insn >> 8
+          break
+
+        case 68: // FASTCALL
+        case 73: // FASTCALL1
+        case 89: // FASTPCALL
+          // the builtin runs through the ordinary call that follows
+          break
+
+        case 60: // FASTCALL3
+        case 74: // FASTCALL2
+        case 75: // FASTCALL2K
+          pc++
+          break
+
+        case 77: { // JUMPXEQKNIL
+          const aux = code[pc]
+          if ((stack[ra] === undefined) !== (aux < 0)) pc += insn >> 16
+          else pc++
+          break
+        }
+
+        case 78: { // JUMPXEQKB
+          const aux = code[pc]
+          const v = stack[ra]
+          if ((typeof v === 'boolean' && v === ((aux & 1) !== 0)) !== (aux < 0)) pc += insn >> 16
+          else pc++
+          break
+        }
+
+        case 79: { // JUMPXEQKN
+          const aux = code[pc]
+          const v = stack[ra]
+          if ((typeof v === 'number' && v === k[aux & 0xffffff]) !== (aux < 0)) pc += insn >> 16
+          else pc++
+          break
+        }
+
+        case 80: { // JUMPXEQKS
+          const aux = code[pc]
+          if ((stack[ra] === k[aux & 0xffffff]) !== (aux < 0)) pc += insn >> 16
+          else pc++
+          break
+        }
+
+        default:
+          throw fail('unsupported opcode ' + (insn & 255), 0)
+      }
+    }
+  } catch (e) {
+    locate(vm, e, frame, pc)
+    throw e
+  }
+}