@swf2es/runtime 0.0.0-stage → 0.1.0

package/src/avm2/natives/float-vector.ts

@@ -0,0 +1,99 @@
+import type { AsObject } from "../descriptors.js";
+import type { Runtime } from "../runtime.js";
+
+/** Float identity belongs to the vector; only values leaving it need a tag. */
+export class FloatVector {
+  data: Float32Array;
+  private count: number;
+
+  constructor(length = 0) {
+    this.data = new Float32Array(length);
+    this.count = length;
+  }
+
+  get length(): number {
+    return this.count;
+  }
+
+  set length(length: number) {
+    if (length === 0) {
+      this.data = new Float32Array(0);
+    } else if (length > this.count) {
+      this.reserve(length);
+      this.data.fill(0, this.count, length);
+    }
+
+    this.count = length;
+  }
+
+  private reserve(length: number): void {
+    if (length <= this.data.length) {
+      return;
+    }
+
+    const data = new Float32Array(
+      Math.max(length, this.data.length + Math.max(this.data.length >>> 1, 8)),
+    );
+    data.set(this.data.subarray(0, this.count));
+    this.data = data;
+  }
+
+  push(value: number): number {
+    this.reserve(this.count + 1);
+    this.data[this.count++] = value;
+    return this.count;
+  }
+
+  pop(): number | undefined {
+    return this.count ? this.data[--this.count] : undefined;
+  }
+
+  shift(): number | undefined {
+    if (!this.count) {
+      return undefined;
+    }
+
+    const value = this.data[0];
+    this.data.copyWithin(0, 1, this.count--);
+    return value;
+  }
+
+  unshift(...items: number[]): number {
+    const count = items.length;
+    this.reserve(this.count + count);
+    this.data.copyWithin(count, 0, this.count);
+    this.data.set(items);
+    this.count += count;
+    return this.count;
+  }
+
+  splice(start: number, remove: number, ...items: number[]): number[] {
+    const at = start < 0 ? Math.max(0, this.count + start) : Math.min(start, this.count);
+    const deleted = Math.min(Math.max(remove, 0), this.count - at);
+    const result = Array.from(this.data.subarray(at, at + deleted));
+    const length = this.count - deleted + items.length;
+    this.reserve(length);
+    this.data.copyWithin(at + items.length, at + deleted, this.count);
+    this.data.set(items, at);
+    this.count = length;
+    return result;
+  }
+
+  reverse(): void {
+    this.data.subarray(0, this.count).reverse();
+  }
+}
+
+/** Conversion precedes this check: valueOf may change the vector's size or fixedness. */
+export function setFloatElement(rt: Runtime, o: AsObject, i: number, value: number): void {
+  const a: FloatVector = o.$a;
+  if (i >>> 0 !== i || i > a.length || (i === a.length && o.$fixed)) {
+    throw rt.error("RangeError", 1125, i, a.length);
+  }
+
+  if (i === a.length) {
+    a.push(value);
+  } else {
+    a.data[i] = value;
+  }
+}

package/src/avm2/natives/float.ts

@@ -0,0 +1,116 @@
+// AIR's scalar float builtin. The declarations live beside the Flash
+// builtins as a separate ABC; Number's existing native paths stay separate.
+import type { Value } from "../descriptors.js";
+import type { ClassHook } from "../hooks.js";
+import { numberToString } from "../number-strings.js";
+import { convertDoubleToStringRadix } from "../numbers.js";
+import { conversion, type Natives } from "./define.js";
+import { numberToExponential, numberToFixed, numberToPrecision } from "./number.js";
+
+export const floatHooks: Record<string, ClassHook> = {
+  float: {
+    ...conversion((rt, args) => rt.float(args.length ? args[0] : 0)),
+    created: (rt, cls) => {
+      const constants: Record<string, number> = {
+        MAX_VALUE: 3.4028234663852886e38,
+        MIN_VALUE: 1.401298464324817e-45,
+        NaN,
+        POSITIVE_INFINITY: Infinity,
+        NEGATIVE_INFINITY: -Infinity,
+        E: Math.E,
+        LN10: Math.LN10,
+        LN2: Math.LN2,
+        LOG2E: Math.LOG2E,
+        PI: Math.PI,
+        SQRT1_2: Math.SQRT1_2,
+        SQRT2: Math.SQRT2,
+      };
+      for (const [, , name, binding] of cls.$desc.static.bindings) {
+        if (name in constants) {
+          cls[`$${binding >> 3}`] = rt.float(constants[name]);
+        }
+      }
+    },
+  },
+};
+
+export const floatNatives: Natives = {};
+
+floatNatives["float.float::_toString"] = (rt) => (value: Value, radix: Value) => {
+  const n = rt.toNumber(value);
+  const base = rt.toInt(radix);
+  if (base === 10 || !Number.isFinite(n)) {
+    return numberToString(n);
+  }
+
+  if (base < 2 || base > 36) {
+    throw rt.error("RangeError", 1003, base);
+  }
+
+  return convertDoubleToStringRadix(n, base);
+};
+for (const [name, convert] of [
+  ["toFixed", numberToFixed],
+  ["toExponential", numberToExponential],
+  ["toPrecision", numberToPrecision],
+] as const) {
+  floatNatives[`float.float::_${name}`] = (rt) => (value: Value, digits: Value) => {
+    const n = rt.toInt(digits);
+    const min = name === "toPrecision" ? 1 : 0;
+    const max = name === "toPrecision" ? 21 : 20;
+    if (n < min || n > max) {
+      throw rt.error("RangeError", 1002, n, min, max);
+    }
+
+    return convert(rt.toNumber(value), n);
+  };
+}
+
+for (const name of [
+  "abs",
+  "acos",
+  "asin",
+  "atan",
+  "ceil",
+  "cos",
+  "exp",
+  "floor",
+  "log",
+  "sin",
+  "sqrt",
+  "tan",
+]) {
+  const fn = (Math as unknown as Record<string, (value: number) => number>)[name];
+  floatNatives[`float.${name}`] = (rt) => (value: Value) =>
+    rt.float(fn(Math.fround(rt.toNumber(value))));
+}
+
+for (const name of ["atan2", "pow"] as const) {
+  const fn = Math[name];
+  floatNatives[`float.${name}`] = (rt) => (a: Value, b: Value) =>
+    rt.float(fn(Math.fround(rt.toNumber(a)), Math.fround(rt.toNumber(b))));
+}
+
+for (const name of ["max", "min"] as const) {
+  const fn = Math[name];
+  floatNatives[`float.${name}`] =
+    (rt) =>
+    (...args: Value[]) => {
+      let result = name === "max" ? -Infinity : Infinity;
+      for (const arg of args) {
+        result = fn(result, Math.fround(rt.toNumber(arg)));
+      }
+
+      return rt.float(result);
+    };
+}
+
+floatNatives["float.random"] = (rt) => () => rt.float(Math.random());
+floatNatives["float.round"] = (rt) => (value: Value) => {
+  const rounded = Math.round(Math.fround(rt.toNumber(value)));
+  return rt.float(rounded === 0 ? 0 : rounded);
+};
+floatNatives["float.reciprocal"] = (rt) => (value: Value) =>
+  rt.float(1 / Math.fround(rt.toNumber(value)));
+floatNatives["float.rsqrt"] = (rt) => (value: Value) =>
+  rt.float(1 / Math.sqrt(Math.fround(rt.toNumber(value))));

package/src/avm2/natives/index.ts

@@ -0,0 +1,70 @@
+// The builtins' native methods, in TypeScript, bound by the names the
+// compiler gives them: "Class.name" for a static method, "Class#name" for an
+// instance method, the name alone for a script's function, with "get:" and
+// "set:" for accessors and "uri::name" outside the public namespace. And how
+// the builtin classes differ from others: how their instances hold native
+// state, and what calling or constructing them does.
+
+import type { ClassHook } from "../hooks.js";
+import type { Runtime } from "../runtime.js";
+import { aliasesNatives } from "./aliases.js";
+import { arrayHooks, arrayNatives } from "./array.js";
+import { byteArrayHook, byteArrayNatives } from "./bytearray.js";
+import { concurrentNatives } from "./concurrent.js";
+import { dateHook, dateNatives } from "./date.js";
+import type { Natives } from "./define.js";
+import { describeNatives } from "./describe.js";
+import { dictionaryNatives } from "./dictionary.js";
+import { floatHooks, floatNatives } from "./float.js";
+import { jsonNatives } from "./json.js";
+import { numberHooks, numberNatives } from "./number.js";
+import { objectHooks, objectNatives } from "./object.js";
+import { proxyHooks, proxyNatives } from "./proxy.js";
+import { regexpHooks, regexpNatives } from "./regexp.js";
+import { shellHooks, shellNatives } from "./shell.js";
+import { stringHooks, stringNatives } from "./string.js";
+import { errorHooks, toplevelNatives } from "./toplevel.js";
+import { vectorHooks, vectorNatives } from "./vector.js";
+import { xmlHooks, xmlNatives } from "./xml/xml.js";
+
+/** The builtins' natives for `rt`: most are the same for every runtime; a class of natives closes over it. */
+export function builtinNatives(rt: Runtime): Natives {
+  return {
+    ...objectNatives,
+    ...arrayNatives,
+    ...stringNatives,
+    ...regexpNatives(rt),
+    ...numberNatives,
+    ...floatNatives,
+    ...toplevelNatives,
+    ...describeNatives,
+    ...proxyNatives,
+    ...aliasesNatives,
+    ...shellNatives(rt),
+    ...dictionaryNatives,
+    ...vectorNatives,
+    ...byteArrayNatives(rt),
+    ...concurrentNatives(rt),
+    ...dateNatives(),
+    ...jsonNatives(),
+    ...xmlNatives,
+  };
+}
+
+export function builtinHooks(): Record<string, ClassHook> {
+  return {
+    ...objectHooks,
+    ...numberHooks,
+    ...floatHooks,
+    ...stringHooks,
+    ...arrayHooks,
+    ...regexpHooks,
+    "flash.utils::ByteArray": byteArrayHook,
+    Date: dateHook,
+    ...vectorHooks,
+    ...xmlHooks,
+    ...proxyHooks,
+    ...errorHooks,
+    ...shellHooks,
+  };
+}