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

package/script/luau/vm/vm.meta.js

@@ -0,0 +1,401 @@
+/**
+ * What Lua does to values beyond the plain case: indexing through
+ * `__index` and `__newindex`, arithmetic and comparison through their
+ * metamethods, string coercion, concatenation, length, `tostring`. The
+ * interpreter takes the fast paths itself and calls these for the rest.
+ */
+
+import { fail, LuaClosure, LuaTable, NativeFunction, Vector, typeName } from './vm.value.js'
+import { mod, numberToString, stringToNumber } from './vm.num.js'
+
+/** @typedef {import('./vm.js').VM} VM */
+
+// Metatables
+// ■■■■■■■■■■
+
+/**
+ * @param   {VM}  vm
+ * @param   {any} v
+ * @returns {LuaTable | undefined} v's metatable: a table's own, the shared one for strings and vectors
+ */
+export function metatableOf(vm, v) {
+  if (v instanceof LuaTable) return v.meta
+  if (typeof v === 'string') return vm.stringMeta
+  if (v instanceof Vector) return vm.vectorMeta
+  return undefined
+}
+
+/**
+ * @param   {VM}     vm
+ * @param   {any}    v
+ * @param   {string} event  such as `__add`
+ * @returns {any}    the metamethod, or undefined
+ */
+export function metamethod(vm, v, event) {
+  const mt = metatableOf(vm, v)
+  return mt === undefined ? undefined : mt.getStr(event)
+}
+
+/**
+ * @param   {any} v
+ * @returns {boolean}
+ */
+export function isFunction(v) {
+  return v instanceof LuaClosure || v instanceof NativeFunction
+}
+
+/**
+ * @param   {VM}    vm
+ * @param   {any}   fn
+ * @param   {any[]} args
+ * @returns {any}   the first result
+ */
+function call1(vm, fn, args) {
+  return vm.call(fn, args)[0]
+}
+
+// Indexing
+// ■■■■■■■■
+
+/**
+ * `obj[key]`, with `__index`.
+ *
+ * @param   {VM}  vm
+ * @param   {any} obj
+ * @param   {any} key
+ * @returns {any}
+ */
+export function index(vm, obj, key) {
+  let o = obj
+  for (let loop = 0; loop < 100; loop++) {
+    let handler
+    if (o instanceof LuaTable) {
+      const v = o.get(key)
+      if (v !== undefined) return v
+      const mt = o.meta
+      if (mt === undefined) return undefined
+      handler = mt.getStr('__index')
+      if (handler === undefined) return undefined
+    } else {
+      if (o instanceof Vector && typeof key === 'string') {
+        const c = vectorField(o, key)
+        if (c !== undefined) return c
+      }
+      handler = metamethod(vm, o, '__index')
+      if (handler === undefined) throw indexError(o, key)
+    }
+    if (isFunction(handler)) return call1(vm, handler, [ o, key ])
+    o = handler
+  }
+  throw fail("'__index' chain too long; possible loop")
+}
+
+/**
+ * @param   {Vector} v
+ * @param   {string} key
+ * @returns {number | undefined}
+ */
+function vectorField(v, key) {
+  if (key === 'x' || key === 'X') return v.x
+  if (key === 'y' || key === 'Y') return v.y
+  if (key === 'z' || key === 'Z') return v.z
+  return undefined
+}
+
+/**
+ * @param   {any} o
+ * @param   {any} key
+ */
+function indexError(o, key) {
+  return fail('attempt to index ' + typeName(o) + (typeof key === 'string' ? " with '" + key + "'" : ''))
+}
+
+/**
+ * `t[key] = value` on the table itself, no metatable.
+ *
+ * @param {LuaTable} t
+ * @param {any}      key
+ * @param {any}      value
+ */
+export function rawSet(t, key, value) {
+  if (t.frozen) throw fail('attempt to modify a readonly table')
+  if (key === undefined) throw fail('table index is nil')
+  if (key !== key) throw fail('table index is NaN')
+  t.set(key, value)
+}
+
+/**
+ * `obj[key] = value`, with `__newindex`.
+ *
+ * @param {VM}  vm
+ * @param {any} obj
+ * @param {any} key
+ * @param {any} value
+ */
+export function setIndex(vm, obj, key, value) {
+  let o = obj
+  for (let loop = 0; loop < 100; loop++) {
+    let handler
+    if (o instanceof LuaTable) {
+      const mt = o.meta
+      if (mt === undefined || o.get(key) !== undefined) return rawSet(o, key, value)
+      handler = mt.getStr('__newindex')
+      if (handler === undefined) return rawSet(o, key, value)
+    } else {
+      handler = metamethod(vm, o, '__newindex')
+      if (handler === undefined) throw indexError(o, key)
+    }
+    if (isFunction(handler)) {
+      vm.call(handler, [ o, key, value ])
+      return
+    }
+    o = handler
+  }
+  throw fail("'__newindex' chain too long; possible loop")
+}
+
+// Arithmetic
+// ■■■■■■■■■■
+
+/** The event name of each arithmetic operator */
+const EVENTS = { add: '__add', sub: '__sub', mul: '__mul', div: '__div', mod: '__mod', pow: '__pow', idiv: '__idiv', unm: '__unm' }
+
+/**
+ * @param   {any} v
+ * @returns {number | undefined} v as a number: itself, or a numeric string
+ */
+export function toNumber(v) {
+  if (typeof v === 'number') return v
+  if (typeof v === 'string') return stringToNumber(v)
+  return undefined
+}
+
+/**
+ * @param   {string} op
+ * @param   {number} a
+ * @param   {number} b
+ * @returns {number}
+ */
+function arithNumbers(op, a, b) {
+  switch (op) {
+    case 'add': return a + b
+    case 'sub': return a - b
+    case 'mul': return a * b
+    case 'div': return a / b
+    case 'mod': return mod(a, b)
+    case 'pow': return Math.pow(a, b)
+    default: return Math.floor(a / b)
+  }
+}
+
+/**
+ * @param   {string} op
+ * @param   {Vector} a
+ * @param   {Vector} b
+ * @returns {Vector}
+ */
+function arithVectors(op, a, b) {
+  return new Vector(arithNumbers(op, a.x, b.x), arithNumbers(op, a.y, b.y), arithNumbers(op, a.z, b.z))
+}
+
+/**
+ * `a op b` for `add`, `sub`, `mul`, `div`, `mod`, `pow` and `idiv`.
+ *
+ * @param   {VM}     vm
+ * @param   {string} op
+ * @param   {any}    a
+ * @param   {any}    b
+ * @returns {any}
+ */
+export function arith(vm, op, a, b) {
+  const x = toNumber(a)
+  const y = toNumber(b)
+  if (x !== undefined && y !== undefined) return arithNumbers(op, x, y)
+  if (a instanceof Vector) {
+    if (b instanceof Vector && op !== 'pow' && op !== 'mod') return arithVectors(op, a, b)
+    if (y !== undefined && (op === 'mul' || op === 'div' || op === 'idiv')) return arithVectors(op, a, new Vector(y, y, y))
+  } else if (b instanceof Vector && x !== undefined && (op === 'mul' || op === 'div' || op === 'idiv')) {
+    return arithVectors(op, new Vector(x, x, x), b)
+  }
+  const event = /** @type {Record<string, string>} */ (EVENTS)[op]
+  let handler = metamethod(vm, a, event)
+  if (handler === undefined) handler = metamethod(vm, b, event)
+  if (handler !== undefined) return call1(vm, handler, [ a, b ])
+  const ta = typeName(a)
+  const tb = typeName(b)
+  throw fail('attempt to perform arithmetic (' + op + ') on ' + (ta === tb ? ta : ta + ' and ' + tb))
+}
+
+/**
+ * @param   {VM}  vm
+ * @param   {any} a
+ * @returns {any} -a
+ */
+export function unm(vm, a) {
+  const x = toNumber(a)
+  if (x !== undefined) return -x
+  if (a instanceof Vector) return new Vector(-a.x, -a.y, -a.z)
+  const handler = metamethod(vm, a, '__unm')
+  if (handler !== undefined) return call1(vm, handler, [ a, a ])
+  throw fail('attempt to perform arithmetic (unm) on ' + typeName(a))
+}
+
+// Comparison
+// ■■■■■■■■■■
+
+/**
+ * Lua's `==`.
+ *
+ * @param   {VM}  vm
+ * @param   {any} a
+ * @param   {any} b
+ * @returns {boolean}
+ */
+export function equals(vm, a, b) {
+  if (a === b) return true
+  if (a instanceof LuaTable && b instanceof LuaTable) {
+    const h1 = a.meta === undefined ? undefined : a.meta.getStr('__eq')
+    if (h1 === undefined) return false
+    const h2 = b.meta === undefined ? undefined : b.meta.getStr('__eq')
+    if (h1 !== h2) return false
+    return truthy(call1(vm, h1, [ a, b ]))
+  }
+  if (a instanceof Vector && b instanceof Vector) return a.x === b.x && a.y === b.y && a.z === b.z
+  return false
+}
+
+/**
+ * @param   {any} v
+ * @returns {boolean}
+ */
+export function truthy(v) {
+  return v !== undefined && v !== false
+}
+
+/**
+ * @param   {any} a
+ * @param   {any} b
+ * @param   {string} op  '<' or '<='
+ */
+function compareError(a, b, op) {
+  return fail('attempt to compare ' + typeName(a) + ' ' + op + ' ' + typeName(b))
+}
+
+/**
+ * `a < b`.
+ *
+ * @param   {VM}  vm
+ * @param   {any} a
+ * @param   {any} b
+ * @returns {boolean}
+ */
+export function lessThan(vm, a, b) {
+  const ta = typeof a
+  if (ta === typeof b && (ta === 'number' || ta === 'string')) return a < b
+  let handler = metamethod(vm, a, '__lt')
+  if (handler === undefined) handler = metamethod(vm, b, '__lt')
+  if (handler === undefined) throw compareError(a, b, '<')
+  return truthy(call1(vm, handler, [ a, b ]))
+}
+
+/**
+ * `a <= b`.
+ *
+ * @param   {VM}  vm
+ * @param   {any} a
+ * @param   {any} b
+ * @returns {boolean}
+ */
+export function lessEqual(vm, a, b) {
+  const ta = typeof a
+  if (ta === typeof b && (ta === 'number' || ta === 'string')) return a <= b
+  let handler = metamethod(vm, a, '__le')
+  if (handler === undefined) handler = metamethod(vm, b, '__le')
+  if (handler === undefined) throw compareError(a, b, '<=')
+  return truthy(call1(vm, handler, [ a, b ]))
+}
+
+// Strings
+// ■■■■■■■
+
+/**
+ * `a .. b`.
+ *
+ * @param   {VM}  vm
+ * @param   {any} a
+ * @param   {any} b
+ * @returns {any}
+ */
+export function concat(vm, a, b) {
+  const ta = typeof a
+  const tb = typeof b
+  if ((ta === 'string' || ta === 'number') && (tb === 'string' || tb === 'number')) {
+    return (ta === 'number' ? numberToString(a) : a) + (tb === 'number' ? numberToString(b) : b)
+  }
+  let handler = metamethod(vm, a, '__concat')
+  if (handler === undefined) handler = metamethod(vm, b, '__concat')
+  if (handler !== undefined) return call1(vm, handler, [ a, b ])
+  throw fail('attempt to concatenate ' + typeName(a) + ' with ' + typeName(b))
+}
+
+/**
+ * `#v`.
+ *
+ * @param   {VM}  vm
+ * @param   {any} v
+ * @returns {any}
+ */
+export function length(vm, v) {
+  if (typeof v === 'string') return v.length
+  if (v instanceof LuaTable) {
+    const handler = v.meta === undefined ? undefined : v.meta.getStr('__len')
+    return handler === undefined ? v.length() : call1(vm, handler, [ v ])
+  }
+  const handler = metamethod(vm, v, '__len')
+  if (handler !== undefined) return call1(vm, handler, [ v ])
+  throw fail('attempt to get length of a ' + typeName(v) + ' value')
+}
+
+/**
+ * @param   {number} id
+ * @returns {string} a stable fake address for an object
+ */
+function address(id) {
+  let hex = id.toString(16)
+  while (hex.length < 8) hex = '0' + hex
+  return '0x' + hex
+}
+
+/**
+ * Lua's `tostring`, with `__tostring` and `__name`.
+ *
+ * @param   {VM}  vm
+ * @param   {any} v
+ * @returns {string}
+ */
+export function tostring(vm, v) {
+  switch (typeof v) {
+    case 'undefined': return 'nil'
+    case 'boolean': return v ? 'true' : 'false'
+    case 'number': return numberToString(v)
+    case 'string': return v
+    default: break
+  }
+  if (v instanceof Vector) return numberToString(v.x) + ', ' + numberToString(v.y) + ', ' + numberToString(v.z)
+  if (v.id === 0) v.id = vm.newId()
+  if (v instanceof LuaTable) {
+    const mt = v.meta
+    if (mt !== undefined) {
+      const handler = mt.getStr('__tostring')
+      if (handler !== undefined) {
+        const s = call1(vm, handler, [ v ])
+        if (typeof s !== 'string') throw fail("'__tostring' must return a string")
+        return s
+      }
+      const name = mt.getStr('__name')
+      if (typeof name === 'string') return name + ': ' + address(v.id)
+    }
+    return 'table: ' + address(v.id)
+  }
+  return 'function: ' + address(v.id)
+}

package/script/luau/vm/vm.num.js

@@ -0,0 +1,236 @@
+/**
+ * Numbers as Lua prints and reads them: C's `%g`, `%e` and `%f` rendered from
+ * JS's own number formatting, and string-to-number the way `tonumber` and
+ * arithmetic coercion read them. No `Math` function newer than ES5 appears
+ * here, because the oldest browsers this runs in lack them.
+ */
+
+// Formatting
+// ■■■■■■■■■■
+
+/**
+ * The digits of a finite non-negative number rounded to `count` significant
+ * digits, and its decimal exponent.
+ *
+ * @param   {number} n
+ * @param   {number} count  1 to 21
+ * @returns {{ digits: string, exp: number }}
+ */
+function significant(n, count) {
+  if (n === 0) return { digits: zeros(count), exp: 0 }
+  const places = Math.min(Math.max(count, 1), 21) - 1
+  let s = n.toExponential(places)
+  // JS rounds an exact tie up; C rounds it to the even digit. A tie shows as a 5 and zeros past the cut.
+  const long = n.toExponential(Math.min(places + 30, 100))
+  const lp = long.indexOf('e')
+  const mantissa = long.slice(0, lp).replace('.', '')
+  if (/^50*$/.test(mantissa.slice(places + 1)) && (mantissa.charCodeAt(places) - 48) % 2 === 0) s = long.slice(0, lp).replace('.', '').slice(0, places + 1).replace(/^(.)/, places > 0 ? '$1.' : '$1') + long.slice(lp)
+  const e = s.indexOf('e')
+  return { digits: s.slice(0, e).replace('.', ''), exp: parseInt(s.slice(e + 1), 10) }
+}
+
+/**
+ * `n.toFixed(places)` with C's rounding of an exact tie to the even digit.
+ *
+ * @param   {number} n  finite, non-negative, under 1e21
+ * @param   {number} places
+ * @returns {string}
+ */
+function fixed(n, places) {
+  const s = n.toFixed(places)
+  if (places >= 70) return s
+  const long = n.toFixed(places + 30)
+  const dot = long.indexOf('.')
+  const cut = dot + 1 + places
+  if (/^50*$/.test(long.slice(cut)) && (long.charCodeAt(places === 0 ? dot - 1 : cut - 1) - 48) % 2 === 0) return places === 0 ? long.slice(0, dot) : long.slice(0, cut)
+  return s
+}
+
+/**
+ * @param   {number} n
+ * @returns {string} n zeros
+ */
+export function zeros(n) {
+  let out = ''
+  for (let i = 0; i < n; i++) out += '0'
+  return out
+}
+
+/** @param {string} s */
+function trimFraction(s) {
+  if (s.indexOf('.') < 0) return s
+  return s.replace(/0+$/, '').replace(/\.$/, '')
+}
+
+/**
+ * C's `%e`.
+ *
+ * @param   {number}  n
+ * @param   {number}  precision  digits after the point
+ * @param   {boolean} [alt]  keep the point when there are no digits after it
+ * @returns {string}  of the magnitude, no sign
+ */
+export function formatE(n, precision, alt) {
+  const { digits, exp } = significant(n, precision + 1)
+  const mantissa = digits.charAt(0) + (precision > 0 ? '.' + digits.slice(1) : alt ? '.' : '')
+  const a = Math.abs(exp)
+  return mantissa + 'e' + (exp < 0 ? '-' : '+') + (a < 10 ? '0' : '') + a
+}
+
+/**
+ * C's `%f`.
+ *
+ * @param   {number}  n
+ * @param   {number}  precision
+ * @param   {boolean} [alt]
+ * @returns {string}  of the magnitude, no sign
+ */
+export function formatF(n, precision, alt) {
+  let s
+  if (n >= 1e21) {
+    // toFixed gives up on these; spell the integer out from its exponent form
+    const { digits, exp } = significant(n, 21)
+    s = digits + zeros(exp - 20)
+    if (precision > 0) s += '.' + zeros(precision)
+  } else s = fixed(n, Math.min(precision, 70))
+  if (alt && precision === 0) s += '.'
+  return s
+}
+
+/**
+ * C's `%g`.
+ *
+ * @param   {number}  n
+ * @param   {number}  precision  significant digits; 0 counts as 1
+ * @param   {boolean} [alt]  keep trailing zeros
+ * @returns {string}  of the magnitude, no sign
+ */
+export function formatG(n, precision, alt) {
+  const p = precision === 0 ? 1 : precision
+  const { digits, exp } = significant(n, p)
+  if (exp < -4 || exp >= p) {
+    let m = digits.charAt(0) + (p > 1 ? '.' + digits.slice(1) : '')
+    if (!alt) m = trimFraction(m)
+    const a = Math.abs(exp)
+    return m + 'e' + (exp < 0 ? '-' : '+') + (a < 10 ? '0' : '') + a
+  }
+  let s
+  if (exp >= 0) s = digits.slice(0, exp + 1) + (p > exp + 1 ? '.' + digits.slice(exp + 1) : '')
+  else s = '0.' + zeros(-exp - 1) + digits
+  return alt ? s : trimFraction(s)
+}
+
+/**
+ * How `tostring` writes a number, as Luau does: the shortest digits that read
+ * back as the same double, in fixed notation while the decimal point falls
+ * between 5 places left of the digits and 21 places right (`0.00001`,
+ * `1000000000000000`, `9223372036854776000`), else in scientific (`1e+21`,
+ * `1e-07`). `inf`, `-inf` and `nan` are spelled that way.
+ *
+ * @param   {number} n
+ * @returns {string}
+ */
+export function numberToString(n) {
+  if (n !== n) return 'nan'
+  if (n === Infinity) return 'inf'
+  if (n === -Infinity) return '-inf'
+  if (n === 0) return 1 / n < 0 ? '-0' : '0'
+  if (Math.floor(n) === n && Math.abs(n) < 1e15) return String(n)
+  // toExponential() with no argument gives the shortest digits that round-trip
+  const parts = Math.abs(n).toExponential().split('e')
+  const digits = parts[0].replace('.', '')
+  const dot = Number(parts[1]) + 1
+  const sign = n < 0 ? '-' : ''
+  if (dot >= -5 && dot <= 21) {
+    if (dot <= 0) return sign + '0.' + zeros(-dot) + digits
+    if (dot >= digits.length) return sign + digits + zeros(dot - digits.length)
+    return sign + digits.slice(0, dot) + '.' + digits.slice(dot)
+  }
+  const e = Math.abs(dot - 1)
+  return sign + digits[0] + (digits.length > 1 ? '.' + digits.slice(1) : '') + 'e' + (dot - 1 < 0 ? '-' : '+') + (e < 10 ? '0' : '') + e
+}
+
+// Reading
+// ■■■■■■■
+
+const DECIMAL = /^[ \t\n\r\f\v]*[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?[ \t\n\r\f\v]*$/
+const HEX = /^[ \t\n\r\f\v]*([+-]?)0[xX]([0-9a-fA-F]+)[ \t\n\r\f\v]*$/
+
+/**
+ * A string as a number, or undefined when it isn't one: decimal with an
+ * optional fraction and exponent or `0x` hex (not `0b`: only source code has binary), with surrounding
+ * whitespace and a sign.
+ *
+ * @param   {string} s
+ * @returns {number | undefined}
+ */
+export function stringToNumber(s) {
+  if (DECIMAL.test(s)) return Number(s)
+  const m = HEX.exec(s)
+  if (m) return (m[1] === '-' ? -1 : 1) * parseInt(m[2], 16)
+  return undefined
+}
+
+/**
+ * @param   {string} s
+ * @param   {number} base  2 to 36
+ * @returns {number | undefined}
+ */
+export function stringToNumberBase(s, base) {
+  const m = /^[ \t\n\r\f\v]*(-?)([0-9a-zA-Z]+)[ \t\n\r\f\v]*$/.exec(s)
+  if (!m) return undefined
+  let n = 0
+  const body = m[2].toLowerCase()
+  for (let i = 0; i < body.length; i++) {
+    const c = body.charCodeAt(i)
+    const d = c <= 57 ? c - 48 : c - 87
+    if (d >= base) return undefined
+    n = n * base + d
+  }
+  return m[1] === '-' ? -n : n
+}
+
+// Arithmetic
+// ■■■■■■■■■■
+
+/**
+ * Lua's modulo: the remainder takes the divisor's sign.
+ *
+ * @param   {number} a
+ * @param   {number} b
+ * @returns {number}
+ */
+export function mod(a, b) {
+  return a - Math.floor(a / b) * b
+}
+
+/**
+ * @param   {number} n
+ * @returns {number} n cut toward zero
+ */
+export function trunc(n) {
+  return n < 0 ? Math.ceil(n) : Math.floor(n)
+}
+
+/**
+ * @param   {number} n
+ * @returns {number} -1, 0 or 1 (NaN stays 0)
+ */
+export function sign(n) {
+  return n > 0 ? 1 : n < 0 ? -1 : 0
+}
+
+/**
+ * @param   {string} s
+ * @param   {number} n
+ * @returns {string} s repeated n times
+ */
+export function repeat(s, n) {
+  let out = ''
+  let part = s
+  for (let k = n; k > 0; k = Math.floor(k / 2)) {
+    if (k % 2 === 1) out += part
+    part += part
+  }
+  return out
+}