@swf2es/runtime 0.0.0-stage → 0.1.0

package/src/avm2/natives/case.ts

@@ -0,0 +1,98 @@
+// String case mapping as avmplus does it: unit by unit, from Unicode tables
+// older than JavaScript's, so a unit never maps to more than one and never
+// by context (no final sigma), and a surrogate pair keeps its case.
+
+// Where avmplus' mapping of a unit differs from JavaScript's, as the
+// oracle's avmshell maps each of the 65536: runs of [first unit, count,
+// stride, what to add to each], most of them 0, a unit avmplus leaves as it is.
+const UPPER = [
+  181, 1, 1, 0, 223, 1, 1, 0, 329, 1, 1, 0, 384, 1, 1, 0, 410, 2, 1, 0, 414, 1, 1, 0, 496, 1, 1, 0,
+  572, 1, 1, 0, 575, 2, 1, 0, 578, 1, 1, 0, 583, 5, 2, 0, 592, 3, 1, 0, 604, 1, 1, 0, 609, 1, 1, 0,
+  612, 3, 1, 0, 618, 3, 1, 0, 625, 1, 1, 0, 637, 1, 1, 0, 642, 1, 1, 0, 647, 2, 2, 0, 652, 1, 1, 0,
+  669, 2, 1, 0, 881, 2, 2, 0, 887, 1, 1, 0, 891, 3, 1, 0, 912, 1, 1, 0, 944, 1, 1, 0, 962, 1, 1,
+  -32, 983, 1, 1, 0, 1010, 1, 1, -79, 1011, 1, 1, 0, 1016, 1, 1, 0, 1019, 1, 1, 0, 1222, 1, 1, 0,
+  1226, 1, 1, 0, 1230, 2, 1, 0, 1275, 27, 2, 0, 1415, 1, 1, 0, 4304, 43, 1, 0, 4349, 3, 1, 0, 5112,
+  6, 1, 0, 7296, 9, 1, 0, 7306, 1, 1, 0, 7545, 1, 1, 0, 7549, 1, 1, 0, 7566, 1, 1, 0, 7830, 5, 1, 0,
+  7931, 3, 2, 0, 8016, 4, 2, 0, 8064, 8, 1, 8, 8072, 8, 1, 0, 8080, 8, 1, 8, 8088, 8, 1, 0, 8096, 8,
+  1, 8, 8104, 8, 1, 0, 8114, 1, 1, 0, 8115, 1, 1, 9, 8116, 2, 2, 0, 8119, 1, 1, 0, 8124, 1, 1, 0,
+  8130, 1, 1, 0, 8131, 1, 1, 9, 8132, 2, 2, 0, 8135, 1, 1, 0, 8140, 1, 1, 0, 8146, 2, 1, 0, 8150, 2,
+  1, 0, 8162, 3, 1, 0, 8166, 2, 1, 0, 8178, 1, 1, 0, 8179, 1, 1, 9, 8180, 2, 2, 0, 8183, 1, 1, 0,
+  8188, 1, 1, 0, 8526, 1, 1, 0, 8580, 1, 1, 0, 11312, 48, 1, 0, 11361, 1, 1, 0, 11365, 2, 1, 0,
+  11368, 3, 2, 0, 11379, 1, 1, 0, 11382, 1, 1, 0, 11393, 50, 2, 0, 11500, 2, 2, 0, 11507, 1, 1, 0,
+  11520, 38, 1, 0, 11559, 1, 1, 0, 11565, 1, 1, 0, 42561, 23, 2, 0, 42625, 14, 2, 0, 42787, 7, 2, 0,
+  42803, 31, 2, 0, 42874, 2, 2, 0, 42879, 5, 2, 0, 42892, 1, 1, 0, 42897, 2, 2, 0, 42900, 1, 1, 0,
+  42903, 10, 2, 0, 42933, 8, 2, 0, 42952, 2, 2, 0, 42957, 8, 2, 0, 42998, 1, 1, 0, 43859, 1, 1, 0,
+  43888, 80, 1, 0, 64256, 7, 1, 0, 64275, 5, 1, 0,
+];
+const LOWER = [
+  304, 1, 1, -199, 544, 1, 1, 0, 570, 2, 1, 0, 573, 2, 1, 0, 577, 2, 2, 0, 580, 3, 1, 0, 584, 4, 2,
+  0, 880, 2, 2, 0, 886, 1, 1, 0, 895, 1, 1, 0, 930, 1, 1, 32, 975, 1, 1, 0, 1015, 2, 2, 0, 1018, 1,
+  1, 0, 1021, 3, 1, 0, 1216, 1, 1, 0, 1221, 1, 1, 0, 1225, 1, 1, 0, 1229, 1, 1, 0, 1274, 27, 2, 0,
+  4256, 38, 1, 48, 4295, 1, 1, 0, 4301, 1, 1, 0, 5024, 86, 1, 0, 7305, 1, 1, 0, 7312, 43, 1, 0,
+  7357, 3, 1, 0, 7838, 1, 1, 0, 7930, 3, 2, 0, 8498, 1, 1, 0, 8579, 1, 1, 0, 11264, 48, 1, 0, 11360,
+  2, 2, 0, 11363, 2, 1, 0, 11367, 4, 2, 0, 11374, 3, 1, 0, 11378, 1, 1, 0, 11381, 1, 1, 0, 11390, 3,
+  1, 0, 11394, 49, 2, 0, 11499, 2, 2, 0, 11506, 1, 1, 0, 42560, 23, 2, 0, 42624, 14, 2, 0, 42786, 7,
+  2, 0, 42802, 31, 2, 0, 42873, 3, 2, 0, 42878, 5, 2, 0, 42891, 2, 2, 0, 42896, 2, 2, 0, 42902, 11,
+  2, 0, 42923, 4, 1, 0, 42928, 5, 1, 0, 42934, 8, 2, 0, 42949, 3, 1, 0, 42953, 2, 2, 0, 42956, 9, 2,
+  0, 42997, 1, 1, 0,
+];
+
+// Below the first unit either table names, JavaScript maps a string as avmplus does.
+const PLAIN = /^[\0-\xb4]*$/;
+
+let upper: Map<number, number> | undefined;
+let lower: Map<number, number> | undefined;
+
+function table(runs: number[]): Map<number, number> {
+  const t = new Map<number, number>();
+  for (let i = 0; i < runs.length; i += 4) {
+    for (let k = 0; k < runs[i + 1]; k++) {
+      const c = runs[i] + k * runs[i + 2];
+      t.set(c, c + runs[i + 3]);
+    }
+  }
+
+  return t;
+}
+
+function map(s: string, t: Map<number, number>, js: (c: string) => string): string {
+  const out: number[] = [];
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    const m = t.get(c);
+    if (m !== undefined) {
+      out.push(m);
+    } else if (c >= 0xd800 && c <= 0xdfff) {
+      out.push(c);
+    } else {
+      out.push(js(String.fromCharCode(c)).charCodeAt(0));
+    }
+  }
+
+  const parts: string[] = [];
+  for (let i = 0; i < out.length; i += 0x1000) {
+    parts.push(String.fromCharCode(...out.slice(i, i + 0x1000)));
+  }
+
+  return parts.join("");
+}
+
+/** String::toUpperCase. */
+export function upperCase(s: string): string {
+  if (PLAIN.test(s)) {
+    return s.toUpperCase();
+  }
+
+  upper ??= table(UPPER);
+  return map(s, upper, (c) => c.toUpperCase());
+}
+
+/** String::toLowerCase. */
+export function lowerCase(s: string): string {
+  if (PLAIN.test(s)) {
+    return s.toLowerCase();
+  }
+
+  lower ??= table(LOWER);
+  return map(s, lower, (c) => c.toLowerCase());
+}

package/src/avm2/natives/concurrent.ts

@@ -0,0 +1,268 @@
+// flash.concurrent's Mutex and Condition, as avmplus' ConcurrencyGlue, over
+// the memory a primordial's workers share (sync.ts): a Mutex or a Condition
+// is an address in it, the same in every worker, and each VM keeps one
+// object for each, as avmplus interns one for its State. And
+// avm2.intrinsics.memory's compare and swap. Crossbridge uses them all on
+// startup whether or not it starts workers.
+
+import type { AsObject, Value } from "../descriptors.js";
+import type { Runtime } from "../runtime.js";
+import { bytesOf } from "./bytearray.js";
+import { type Natives, plain, registerNativeClass } from "./define.js";
+import { newSyncMemory, Sync, SyncFull, SyncTimeout } from "./sync.js";
+
+interface MutexObject extends AsObject {
+  /** Its address in the shared memory. */
+  $mutex: number;
+}
+
+interface ConditionObject extends AsObject {
+  $condition: number;
+  /** Its Mutex object in this VM, once known. */
+  $mutexObject: MutexObject | null;
+}
+
+interface VmSync {
+  sync: Sync;
+  /** This VM's one object for each Mutex and Condition, by its address. */
+  objects: Map<number, WeakRef<AsObject>>;
+}
+
+const vmSyncs = new WeakMap<Runtime, VmSync>();
+
+function vmSync(rt: Runtime): VmSync {
+  let vm = vmSyncs.get(rt);
+  if (!vm) {
+    const init = rt.syncInit;
+    const sync = init
+      ? new Sync(init.memory, init.thread, init)
+      : rt.workerInit
+        ? // A refused avmshell worker's code ends: its runShell stops.
+          new Sync(rt.workerInit.memory.sync, rt.workerInit.id, { selfEnds: true })
+        : new Sync(newSyncMemory(), 0);
+    vm = { sync, objects: new Map() };
+    vmSyncs.set(rt, vm);
+  }
+
+  return vm;
+}
+
+/** The shared memory as `rt` sees it: its own, or that of the primordial whose worker it runs. */
+export function syncOf(rt: Runtime): Sync {
+  return vmSync(rt).sync;
+}
+
+/** What a Mutex or a Condition crosses to another worker as: its address. */
+export interface SyncRef {
+  kind: "mutex" | "condition";
+  address: number;
+}
+
+/** The address of a Mutex or a Condition; null for anything else. */
+export function syncRef(value: Value): SyncRef | null {
+  if (value === null || typeof value !== "object") {
+    return null;
+  }
+
+  const o = value as AsObject;
+  if (typeof o.$mutex === "number") {
+    return { kind: "mutex", address: o.$mutex };
+  }
+
+  if (typeof o.$condition === "number") {
+    return { kind: "condition", address: o.$condition };
+  }
+
+  return null;
+}
+
+/** This VM's one Mutex or Condition for `ref`, made without running its constructor. */
+export function syncObject(rt: Runtime, ref: SyncRef): AsObject {
+  const { objects } = vmSync(rt);
+  const known = objects.get(ref.address)?.deref();
+  if (known) {
+    return known;
+  }
+
+  const name = ref.kind === "mutex" ? "flash.concurrent::Mutex" : "flash.concurrent::Condition";
+  const o = rt.classNamed(name).$it.instance() as AsObject;
+  if (ref.kind === "mutex") {
+    o.$mutex = ref.address;
+  } else {
+    o.$condition = ref.address;
+    o.$mutexObject = null;
+  }
+
+  objects.set(ref.address, new WeakRef(o));
+  return o;
+}
+
+/** An error of class `name`, or a plain Error where the VM has no such class, as avmshell has none of flash.errors'. */
+function errorOf(rt: Runtime, name: string, id: number): Value {
+  let cls: AsObject | undefined;
+  try {
+    cls = rt.classNamed(name);
+  } catch {
+    cls = undefined;
+  }
+
+  return rt.error(cls ? name : "Error", id);
+}
+
+/**
+ * What a script gets for what the sync memory threw: Flash's script
+ * timeout (1502) for a lock or wait that spun too long on the primordial,
+ * MemoryError 1000 where the memory is full; anything else as it is, as a
+ * terminated worker's SyncTerminated, which no script catches.
+ */
+export function syncError(rt: Runtime, e: unknown): unknown {
+  if (e instanceof SyncTimeout) {
+    return errorOf(rt, "flash.errors::ScriptTimeoutError", 1502);
+  }
+
+  if (e instanceof SyncFull) {
+    return errorOf(rt, "flash.errors::MemoryError", 1000);
+  }
+
+  return e;
+}
+
+export function concurrentNatives(rt: Runtime): Natives {
+  const natives: Natives = {};
+
+  const blocking = <T>(f: () => T): T => {
+    try {
+      return f();
+    } catch (e) {
+      throw syncError(rt, e);
+    }
+  };
+
+  class MutexNatives {
+    static get isSupported(): boolean {
+      return true;
+    }
+
+    "flash.concurrent:Mutex::ctor"(this: MutexObject): void {
+      const vm = vmSync(rt);
+      this.$mutex = blocking(() => vm.sync.newMutex());
+      vm.objects.set(this.$mutex, new WeakRef(this));
+    }
+
+    lock(this: MutexObject): void {
+      blocking(() => syncOf(rt).lock(this.$mutex));
+    }
+
+    tryLock(this: MutexObject): boolean {
+      return blocking(() => syncOf(rt).tryLock(this.$mutex));
+    }
+
+    unlock(this: MutexObject): void {
+      if (!syncOf(rt).unlock(this.$mutex)) {
+        throw rt.error("flash.errors::IllegalOperationError", 1514);
+      }
+    }
+  }
+
+  class ConditionNatives {
+    static get isSupported(): boolean {
+      return true;
+    }
+
+    "flash.concurrent:Condition::ctor"(this: ConditionObject, mutex: Value): void {
+      if (mutex === null || mutex === undefined) {
+        throw rt.error("ArgumentError", 2007, "mutex");
+      }
+
+      const vm = vmSync(rt);
+      this.$mutexObject = mutex as MutexObject;
+      this.$condition = blocking(() => vm.sync.newCondition((mutex as MutexObject).$mutex));
+      vm.objects.set(this.$condition, new WeakRef(this));
+    }
+
+    // As ConditionObject::get_mutex: one that crossed from another worker
+    // finds its Mutex in this VM, or makes it.
+    get mutex(): Value {
+      const self = this as unknown as ConditionObject;
+      if (!self.$mutexObject) {
+        const address = syncOf(rt).conditionMutex(self.$condition);
+        self.$mutexObject = syncObject(rt, { kind: "mutex", address }) as MutexObject;
+      }
+
+      return self.$mutexObject;
+    }
+
+    // As ConditionObject::wait: true when the time ran out, false when
+    // notified, and false for a wait without a timeout (-1), which only a
+    // notify ends.
+    wait(this: ConditionObject, timeout: Value): boolean {
+      // Left out, it is the declared -1, which a native is not given.
+      const t = timeout === undefined ? -1 : rt.toNumber(timeout);
+      if (t < 0 && t !== -1) {
+        throw rt.error("ArgumentError", 1515);
+      }
+
+      const sync = syncOf(rt);
+      if (!sync.holds(sync.conditionMutex(this.$condition))) {
+        throw rt.error("flash.errors::IllegalOperationError", 1518);
+      }
+
+      const ms = t === -1 ? -1 : Number.isNaN(t) ? 0 : Math.min(Math.ceil(t), 0x7fffffff);
+      return blocking(() => sync.wait(this.$condition, ms));
+    }
+
+    notify(this: ConditionObject): void {
+      const sync = syncOf(rt);
+      if (!sync.holds(sync.conditionMutex(this.$condition))) {
+        throw rt.error("flash.errors::IllegalOperationError", 1516);
+      }
+
+      blocking(() => sync.notify(this.$condition, false));
+    }
+
+    notifyAll(this: ConditionObject): void {
+      const sync = syncOf(rt);
+      if (!sync.holds(sync.conditionMutex(this.$condition))) {
+        throw rt.error("flash.errors::IllegalOperationError", 1517);
+      }
+
+      blocking(() => sync.notify(this.$condition, true));
+    }
+  }
+
+  // As ConcurrentMemory::casi32: the domain memory's int at a word-aligned
+  // address replaced by `next` if it is `expected`; the int there before.
+  // Atomic where another worker shares the memory.
+  natives["avm2.intrinsics.memory::casi32"] = plain(
+    (address: Value, expected: Value, next: Value) => {
+      const at = rt.toInt(address);
+      const outside = () => at % 4 !== 0 || rt.memoryLength < 4 || at >>> 0 > rt.memoryLength - 4;
+      if (outside()) {
+        rt.refreshMemory?.();
+        if (outside()) {
+          throw rt.error("RangeError", 1506);
+        }
+      }
+
+      if (rt.refreshMemory && rt.memoryProvider) {
+        return bytesOf(rt, rt.memoryProvider).compareAndSwapInt(
+          at,
+          rt.toInt(expected),
+          rt.toInt(next),
+        );
+      }
+
+      const previous = rt.memory.getInt32(at, true);
+      if (previous === rt.toInt(expected)) {
+        rt.memory.setInt32(at, rt.toInt(next), true);
+      }
+
+      return previous;
+    },
+  );
+  natives["avm2.intrinsics.memory::mfence"] = plain(() => {});
+
+  registerNativeClass(natives, "flash.concurrent::Mutex", MutexNatives);
+  registerNativeClass(natives, "flash.concurrent::Condition", ConditionNatives);
+  return natives;
+}