@swf2es/runtime 0.0.0-stage → 0.1.0

package/src/avm2/natives/number.ts

@@ -0,0 +1,194 @@
+// Number, int, uint and Boolean, and Math, whose functions Number has
+// copies of.
+
+import type { Value } from "../descriptors.js";
+import type { ClassHook } from "../hooks.js";
+import { numberToString } from "../number-strings.js";
+import {
+  convertDoubleToString,
+  convertDoubleToStringRadix,
+  DTOSTR_EXPONENTIAL,
+  DTOSTR_FIXED,
+  DTOSTR_PRECISION,
+} from "../numbers.js";
+import type { Runtime } from "../runtime.js";
+import { conversion, type Natives, plain } from "./define.js";
+
+export const numberNatives: Natives = {
+  // As NumberClass::_numberToString: another radix writes the integer part only.
+  "Number.Number::_numberToString": (rt) => (n: number, radix: number) => {
+    if (radix === 10 || !Number.isFinite(n)) {
+      return numberToString(n);
+    }
+
+    if (radix < 2 || radix > 36) {
+      throw rt.error("RangeError", 1003, radix);
+    }
+
+    return convertDoubleToStringRadix(n, radix);
+  },
+  // As NumberClass::_convert: toFixed, toPrecision and toExponential.
+  "Number.Number::_convert": (rt) => (n: number, precision: number, mode: number) => {
+    const [min, max] = mode === DTOSTR_PRECISION ? [1, 21] : [0, 20];
+    if (precision < min || precision > max) {
+      throw rt.error("RangeError", 1002, precision, min, max);
+    }
+
+    switch (mode) {
+      case DTOSTR_FIXED:
+        return numberToFixed(n, precision);
+      case DTOSTR_PRECISION:
+        return numberToPrecision(n, precision);
+      default:
+        return numberToExponential(n, precision);
+    }
+  },
+  "Number.Number::_minValue": plain(() => Number.MIN_VALUE),
+};
+
+// toFixed, toPrecision and toExponential write avmplus' text, which is not
+// JavaScript's, though JavaScript's methods give it for most numbers at a
+// fraction of the cost. avmplus takes the digits D of a number x from its
+// D2A, the shortest within half an ulp of x narrowed by 10^precision, in
+// exact arithmetic. Scaled so that the last place written is 1, x is some y
+// and D is within y * 2^-53 of it. toFixed and toPrecision then round D
+// half up there, as JavaScript rounds x itself; toExponential truncates D,
+// since avmplus rounds only on D2A's fast path, which no 53-bit mantissa
+// takes. So where y is clear of the point where the rounding (or the
+// truncation) changes, both write the same digits. The guards scale x by
+// a power of ten up to 1e22, which doubles hold exactly, so f is within
+// y * 2^-53 of y, and take JavaScript's text only where f is more than
+// f * 2^-50 from those points. Elsewhere avmplus goes its own way: toFixed
+// writes zeros, unrounded, for a number below its last place (0.006 to
+// "0.00"); toPrecision never writes an exponent below 1, and keeps the
+// exponent it had before rounding carried ("10.0" for 9.99 to 2 digits,
+// "0.e+5" for 99999.9); toExponential leaves out "e+0", and writes 0 as
+// "0.00e-16". tests/unit/runtime/numbers.test.ts checks every precision.
+
+const powersOfTen = Array.from({ length: 23 }, (_, i) => Number(`1e${i}`));
+
+/** x * 10^k, rounded once, for k from -22 to 22. */
+function scaled(x: number, k: number): number {
+  return k >= 0 ? x * powersOfTen[k] : x / powersOfTen[-k];
+}
+
+/** As Number.toFixed. */
+export function numberToFixed(n: number, digits: number): string {
+  // NaN, infinities and f past 2^49, where the tolerance reaches 0.5, fail every test.
+  const f = (n < 0 ? -n : n) * powersOfTen[digits];
+  const tolerance = f / 2 ** 50;
+  const half = f - Math.floor(f) - 0.5;
+  if ((half > tolerance || half < -tolerance) && (f < 0.5 || f > 1 + tolerance)) {
+    return n.toFixed(digits);
+  }
+
+  return convertDoubleToString(n, DTOSTR_FIXED, digits);
+}
+
+/** As Number.toPrecision. */
+export function numberToPrecision(n: number, digits: number): string {
+  // log10 may be one off next to a power of ten: the bounds on f catch that.
+  const x = n < 0 ? -n : n;
+  const exponent = Math.floor(Math.log10(x));
+  const k = digits - 1 - exponent;
+  if (exponent >= -6 && k >= -22 && k <= 22) {
+    const f = scaled(x, k);
+    const tolerance = f / 2 ** 50;
+    const half = f - Math.floor(f) - 0.5;
+    const clear = half > tolerance || half < -tolerance;
+    if (clear && f >= powersOfTen[digits - 1] + tolerance && f < powersOfTen[digits] - 0.5) {
+      return n.toPrecision(digits);
+    }
+  }
+
+  return convertDoubleToString(n, DTOSTR_PRECISION, digits);
+}
+
+/**
+ * As Number.toExponential: JavaScript's digits to one place more, the last
+ * dropped, which truncates as avmplus does where rounding that place does
+ * not carry.
+ */
+export function numberToExponential(n: number, digits: number): string {
+  const x = n < 0 ? -n : n;
+  const exponent = Math.floor(Math.log10(x));
+  const k = digits - exponent;
+  if (k >= -22 && k <= 22) {
+    const f = scaled(x, k);
+    const fraction = f - Math.floor(f);
+    const inRange = f >= powersOfTen[digits] && f < powersOfTen[digits + 1];
+    if (fraction > f / 2 ** 50 && fraction < 0.9 && inRange) {
+      const text = x.toExponential(digits + 1);
+      const e = text.indexOf("e");
+      const mantissa = text.slice(0, digits === 0 ? 1 : e - 1);
+      const written = exponent === 0 ? mantissa : mantissa + text.slice(e);
+      return n < 0 ? `-${written}` : written;
+    }
+  }
+
+  return convertDoubleToString(n, DTOSTR_EXPONENTIAL, digits);
+}
+
+// Math, and Number's copies of it.
+for (const name of [
+  "abs",
+  "acos",
+  "asin",
+  "atan",
+  "ceil",
+  "cos",
+  "exp",
+  "floor",
+  "log",
+  "sin",
+  "sqrt",
+  "tan",
+]) {
+  const f = (Math as unknown as Record<string, (x: number) => number>)[name];
+  const native = (rt: Runtime) => (x: Value) => f(rt.toNumber(x));
+  numberNatives[`Math.${name}`] = native;
+  numberNatives[`Number.${name}`] = native;
+}
+
+for (const prefix of ["Math", "Number"]) {
+  // As MathUtils::round, floor(x + 0.5): never -0, as JavaScript's is for -0.5 to -0.
+  numberNatives[`${prefix}.round`] = (rt) => (x: Value) => {
+    const r = Math.round(rt.toNumber(x));
+    return r === 0 ? 0 : r;
+  };
+  numberNatives[`${prefix}.atan2`] = (rt) => (y: Value, x: Value) =>
+    Math.atan2(rt.toNumber(y), rt.toNumber(x));
+  numberNatives[`${prefix}.pow`] = (rt) => (x: Value, y: Value) => rt.toNumber(x) ** rt.toNumber(y);
+  numberNatives[`${prefix}.random`] = plain(() => Math.random());
+  // Of two declared parameters, and any more, so that their length is 2.
+  numberNatives[`${prefix}.max`] = (rt) =>
+    function (x: Value, y: Value) {
+      // biome-ignore lint/complexity/noArguments: all of them, however many
+      const args = arguments;
+      if (args.length === 2) {
+        return Math.max(rt.toNumber(x), rt.toNumber(y));
+      }
+
+      return Math.max(...Array.from(args, (a: Value) => rt.toNumber(a)));
+    };
+  numberNatives[`${prefix}.min`] = (rt) =>
+    function (x: Value, y: Value) {
+      // biome-ignore lint/complexity/noArguments: all of them, however many
+      const args = arguments;
+      if (args.length === 2) {
+        return Math.min(rt.toNumber(x), rt.toNumber(y));
+      }
+
+      return Math.min(...Array.from(args, (a: Value) => rt.toNumber(a)));
+    };
+}
+
+numberNatives["Math.Math::_max"] = plain((x: number, y: number) => Math.max(x, y));
+numberNatives["Math.Math::_min"] = plain((x: number, y: number) => Math.min(x, y));
+
+export const numberHooks: Record<string, ClassHook> = {
+  int: conversion((rt, args) => (args.length ? rt.toInt(args[0]) : 0)),
+  uint: conversion((rt, args) => (args.length ? rt.toUint(args[0]) : 0)),
+  Number: conversion((rt, args) => (args.length ? rt.toNumber(args[0]) : 0)),
+  Boolean: conversion((rt, args) => rt.toBoolean(args[0])),
+};

package/src/avm2/natives/object.ts

@@ -0,0 +1,272 @@
+// Object, Class, Function, Namespace and QName: their natives, and what
+// calling or constructing Object, Namespace, QName or Function does.
+
+import type { AsObject, Value } from "../descriptors.js";
+import type { ClassHook } from "../hooks.js";
+import { formatClassName, Namespace, prefixOf, publicQname } from "../names.js";
+import { NOT_FOUND, type Runtime } from "../runtime.js";
+import { AS3, elements, type Natives, plain } from "./define.js";
+import { constructNamespace, newNamespace } from "./xml/names.js";
+
+export const objectNatives: Natives = {
+  // Object
+  "Object.Object::_hasOwnProperty": (rt) => (o: Value, v: Value) => {
+    const name = rt.toString(v);
+    const traits = rt.traitsOf(o);
+    if (traits.find(publicQname(name, rt.userVersions)) !== 0) {
+      return true;
+    }
+
+    // An index of a class with its own elements, a Vector's: in range or not, no RangeError.
+    if (traits.hasIndex && /^(?:0|[1-9]\d*)$/.test(name) && Number(name) < 0xffffffff) {
+      return traits.hasIndex(o, Number(name));
+    }
+
+    return rt.getOwn(o, name) !== NOT_FOUND;
+  },
+  "Object.Object::_propertyIsEnumerable": (rt) => (o: Value, v: Value) => {
+    const name = rt.toString(v);
+    // E4X 13.2.5: a Namespace's prefix and uri are enumerable.
+    if (o instanceof Namespace) {
+      return name === "uri" || name === "prefix";
+    }
+
+    // A Vector's elements are not enumerable to it, in or out of range, as avmplus has it.
+    if (o?.$traits?.refusesNames) {
+      return false;
+    }
+
+    return rt.getOwn(o, name) !== NOT_FOUND && !o.$dontEnum?.has(name);
+  },
+  "Object.Object::_setPropertyIsEnumerable": (rt) => (o: Value, v: Value, enumerable: boolean) => {
+    if (typeof o !== "object" || o === null) {
+      return;
+    }
+
+    const name = rt.toString(v);
+    if (enumerable) {
+      o.$dontEnum?.delete(name);
+      if (o.$d) {
+        // A name shown: the for-ins that found them all hidden look again.
+        o.$d.allHidden = false;
+      }
+    } else {
+      o.$dontEnum ??= new Set();
+      o.$dontEnum.add(name);
+    }
+  },
+  // A primitive's prototype chain is its class's, as toPrototype gives it.
+  "Object.Object::_isPrototypeOf": (rt) => (o: Value, v: Value) => {
+    if (v === null || v === undefined) {
+      return false;
+    }
+
+    for (let p = rt.protoOf(v); p; p = p.$p) {
+      if (p === o) {
+        return true;
+      }
+    }
+
+    return false;
+  },
+  "Object.Object::_toString": (rt) => (o: Value) => {
+    if (o !== null && typeof o === "object" && o.$it) {
+      return `[class ${shortName(o.$it.name)}]`;
+    }
+
+    // As FunctionObject::implToString: its method's id.
+    if (o !== null && typeof o === "object" && o.$f) {
+      return `[object Function-${o.$id}]`;
+    }
+
+    const traits = rt.traitsOf(o);
+    traits.objectString ??= `[object ${shortName(traits.name)}]`;
+    return traits.objectString;
+  },
+
+  // Class and Function
+  "Class#get:prototype": plain(function (this: AsObject) {
+    return this.$prototype;
+  }),
+  "Function#get:prototype": (rt) =>
+    function (this: AsObject) {
+      return rt.functionPrototype(this);
+    },
+  // As FunctionObject's setter: null and undefined clear it, a primitive is refused.
+  "Function#set:prototype": (rt) =>
+    function (this: AsObject, p: Value) {
+      if (p === null || p === undefined) {
+        this.$prototype = undefined;
+        this.$noPrototype = true;
+        return;
+      }
+
+      if (typeof p !== "object" && typeof p !== "function") {
+        throw rt.error("TypeError", 1049);
+      }
+
+      this.$prototype = p;
+      this.$noPrototype = false;
+    },
+  "Function#get:length": plain(function (this: AsObject) {
+    return this.$length ?? this.$f.length;
+  }),
+  [`Function#${AS3}::call`]: (rt) =>
+    function (this: AsObject, receiver: Value, ...args: Value[]) {
+      // Not a tail call, as the runtime's calls are not (see Runtime.getProperty).
+      // biome-ignore lint/style/useConst: a const is folded into a tail call (see Runtime.getProperty)
+      let r: Value;
+      r = rt.callValue(this, receiver, args, null);
+      return r;
+    },
+  [`Function#${AS3}::apply`]: (rt) =>
+    function (this: AsObject, receiver: Value, args: Value) {
+      // Its arguments an Array, or none, as FunctionObject::AS3_apply has them.
+      if (args !== null && args !== undefined && args.$a === undefined) {
+        throw rt.error("TypeError", 1116);
+      }
+
+      // biome-ignore lint/style/useConst: a const is folded into a tail call (see Runtime.getProperty)
+      let r: Value;
+      r = rt.callValue(this, receiver, elements(args).slice(), null);
+      return r;
+    },
+
+  // Namespace and QName: a QName holds its namespace, null for any, and its
+  // local name, null for any.
+  "Namespace#get:uri": plain(function (this: Value) {
+    return this.uri ?? "";
+  }),
+  "QName#get:localName": plain(function (this: AsObject) {
+    return this.$local ?? "*";
+  }),
+  "QName#get:uri": plain(function (this: AsObject) {
+    return this.$ns ? this.$ns.uri : null;
+  }),
+  "Namespace#get:prefix": plain(function (this: Namespace) {
+    return prefixOf(this);
+  }),
+};
+
+/** As QNameClass::construct: QName(name) or QName(namespace, name). */
+function newQName(rt: Runtime, cls: AsObject, args: Value[]): AsObject {
+  if (args.length === 1 && args[0]?.$local !== undefined) {
+    return args[0];
+  }
+
+  const name = args.length >= 2 ? args[1] : args[0];
+  const o = cls.$it.instance();
+  // With no namespace, a name is in the default XML namespace.
+  let ns: Namespace | null = rt.defaultXmlNamespace.interned;
+  if (args.length >= 2 && args[0] !== undefined) {
+    ns =
+      args[0] === null
+        ? null
+        : args[0] instanceof Namespace
+          ? args[0].interned
+          : newNamespace(rt, args[0]);
+  } else if (name?.$local !== undefined) {
+    ns = name.$ns;
+  }
+
+  const local =
+    name === undefined ? "" : name?.$local !== undefined ? name.$local : rt.toString(name);
+  // With no namespace given, the any name is in any namespace too.
+  if (local === "*" && (args.length < 2 || args[0] === undefined)) {
+    ns = null;
+  }
+
+  o.$ns = ns;
+  o.$local = local === "*" ? null : local;
+  o.$attr = false;
+  return o;
+}
+
+/** A class's name without its package, as its toString has it: a Vector's parameter keeps its own, "Vector.<pkg::T>". */
+function shortName(qualified: string): string {
+  const name = formatClassName(qualified);
+  const i = name.indexOf("::");
+  return i < 0 ? name : name.slice(i + 2);
+}
+
+export function qualifiedClassName(rt: Runtime, v: Value): string {
+  switch (typeof v) {
+    // As TypeDescriber::chooseTraits: an int is one that fits avmplus' 29-bit int atom.
+    case "number":
+      return (v | 0) === v && v >= -(1 << 28) && v < 1 << 28 ? "int" : "Number";
+    case "string":
+      return "String";
+    case "boolean":
+      return "Boolean";
+    case "undefined":
+      return "void";
+    default:
+      if (v === null) {
+        return "null";
+      }
+
+      return formatClassName(v.$it ? v.$it.name : rt.traitsOf(v).name);
+  }
+}
+
+function emptyFunction(rt: Runtime, args: Value[]): AsObject {
+  if (args.length) {
+    throw rt.error("EvalError", 1066);
+  }
+
+  return rt.newFunctionObject(() => undefined, null);
+}
+
+/** A class of static natives only, which cannot be instantiated: construct="none" in its declaration. */
+const notInstantiated = (name: string): ClassHook => ({
+  construct: (rt) => {
+    throw rt.error("ArgumentError", 2012, name);
+  },
+});
+
+export const objectHooks: Record<string, ClassHook> = {
+  JSON: notInstantiated("JSON"),
+  "flash.net::ObjectEncoding": notInstantiated("ObjectEncoding"),
+  "avmplus::System": notInstantiated("System"),
+  "avmplus::File": notInstantiated("File"),
+  // Math is neither a function nor a constructor.
+  Math: {
+    call: (rt) => {
+      throw rt.error("TypeError", 1075);
+    },
+    construct: (rt) => {
+      throw rt.error("TypeError", 1076);
+    },
+  },
+  Object: {
+    call: (rt, _cls, args) =>
+      args[0] === null || args[0] === undefined ? rt.newObject([]) : args[0],
+    construct: (rt, _cls, args) =>
+      args[0] === null || args[0] === undefined ? rt.newObject([]) : args[0],
+  },
+  // As ClassClass::construct: Class itself makes no classes.
+  Class: {
+    construct: (rt) => {
+      throw rt.error("TypeError", 1115, "Class");
+    },
+  },
+  // As NamespaceClass: Namespace(),Namespace(uri) or Namespace(prefix, uri).
+  Namespace: {
+    construct: (rt, _cls, args) => constructNamespace(rt, args),
+    call: (rt, _cls, args) =>
+      args.length === 1 && args[0] instanceof Namespace ? args[0] : constructNamespace(rt, args),
+  },
+  // As QNameClass::construct.
+  QName: {
+    construct: newQName,
+    call: newQName,
+  },
+  // Function() and new Function(): an empty function; with a body, which
+  // would be compiled at run time, EvalError 1066, as FunctionClass has it.
+  Function: {
+    construct: (rt, _cls, args) => emptyFunction(rt, args),
+    call: (rt, _cls, args) => emptyFunction(rt, args),
+    // Function.prototype is a function, that does nothing.
+    prototype: (rt) => rt.newFunctionObject(() => undefined, null),
+  },
+};

package/src/avm2/natives/proxy.ts

@@ -0,0 +1,98 @@
+// flash.utils.Proxy: an instance's names its traits do not bind go to its
+// flash_proxy methods, as avmplus' ProxyObject (core/ProxyGlue.cpp) sends
+// them: a name the code wrote, a multiname, as a QName object; a name made
+// at run time, as proxy[name], as the value it was, a string or a QName.
+// callProperty gets the QName and the arguments; for-in asks
+// nextNameIndex, nextName and nextValue.
+
+import type { AsObject, Value } from "../descriptors.js";
+import type { ClassHook, PropertyHook } from "../hooks.js";
+import { type Multiname, NS_Public, namespace, publicNs, publicQname, qname } from "../names.js";
+import type { Runtime } from "../runtime.js";
+import type { Natives } from "./define.js";
+
+const FLASH_PROXY = namespace(NS_Public, "http://www.adobe.com/2006/actionscript/flash/proxy");
+
+/**
+ * The name a flash_proxy method gets for `mn`: a QName that was the name
+ * stays one, an index comes as its string, as avmplus' getUintProperty
+ * interns it, and any other name as a QName in its namespace.
+ */
+function nameFor(rt: Runtime, mn: Multiname): Value {
+  if (mn.key !== undefined && (mn.key as AsObject)?.$local !== undefined) {
+    return mn.key as Value;
+  }
+
+  const name = mn.name;
+  if (name !== null && !mn.attribute && isIndex(name)) {
+    return name;
+  }
+
+  // A QName keeps the whole multiname in avmplus; of a set of several it
+  // reports the empty URI, and still names all of them as a lookup's name.
+  const ns = mn.namespaces.length > 1 ? publicNs : mn.namespaces.length ? mn.namespaces[0] : null;
+  const q = rt.builtinClass("QName").$it.instance();
+  q.$ns = ns;
+  q.$local = name;
+  q.$attr = mn.attribute;
+  if (mn.namespaces.length > 1) {
+    q.$mn = mn;
+  }
+
+  return q;
+}
+
+function isIndex(name: string): boolean {
+  return /^(?:0|[1-9]\d*)$/.test(name) && Number(name) < 0xffffffff;
+}
+
+function call(rt: Runtime, o: AsObject, method: string, ...args: Value[]): Value {
+  // Not a tail call, as the runtime's calls are not (see Runtime.getProperty).
+  // biome-ignore lint/style/useConst: a const is folded into a tail call (see Runtime.getProperty)
+  let r: Value;
+  r = rt.callProperty(o, qname(FLASH_PROXY, method), ...args);
+  return r;
+}
+
+const proxyHook: PropertyHook = {
+  // A method the traits bind is the method, as for any object; only unbound names reach the proxy.
+  hidesMethods: false,
+  get: (rt, o, mn) => call(rt, o, "getProperty", nameFor(rt, mn)),
+  set: (rt, o, mn, v) => {
+    call(rt, o, "setProperty", nameFor(rt, mn), v);
+  },
+  // The flash_proxy methods declare Boolean results, coerced on their way out.
+  delete: (rt, o, mn) => call(rt, o, "deleteProperty", nameFor(rt, mn)) === true,
+  // `in` asks with the name's string, as hasAtomProperty gets it.
+  has: (rt, o, mn) =>
+    call(rt, o, "hasProperty", mn.key !== undefined ? (mn.key as Value) : mn.name) === true,
+  callee: (rt, o, mn) => {
+    const name = nameFor(rt, mn);
+    return rt.newFunctionObject(
+      (...args: Value[]) => call(rt, o, "callProperty", name, ...args),
+      null,
+    );
+  },
+  descendants: (rt, o, mn) => call(rt, o, "getDescendants", nameFor(rt, mn)),
+  nextIndex: (rt, o, index) => rt.toInt(call(rt, o, "nextNameIndex", index)),
+  nextName: (rt, o, index) => call(rt, o, "nextName", index),
+  nextValue: (rt, o, index) => call(rt, o, "nextValue", index),
+  equals: () => undefined,
+  add: () => undefined,
+  // toString is a call like any other the traits do not bind: callProperty answers it.
+  toString: (rt, o) =>
+    rt.toString(call(rt, o, "callProperty", nameFor(rt, publicQname("toString", rt.userVersions)))),
+  toXMLString: (rt, o) =>
+    rt.toString(call(rt, o, "callProperty", nameFor(rt, publicQname("toString", rt.userVersions)))),
+};
+
+export const proxyHooks: Record<string, ClassHook> = {
+  "flash.utils::Proxy": { properties: proxyHook },
+};
+
+export const proxyNatives: Natives = {
+  // As ProxyObject::flash_proxy_isAttribute: whether the name is a QName of an attribute.
+  "flash.utils::Proxy#http://www.adobe.com/2006/actionscript/flash/proxy::isAttribute":
+    () => (name: Value) =>
+      name !== null && typeof name === "object" && name.$local !== undefined && name.$attr === true,
+};