swf-toolkit 0.0.0-stage → 0.1.0

package/dist/decompiler/cfg.js

@@ -0,0 +1,231 @@
+import { stackEffect } from '../abc/analysis.js';
+import { opInfo } from '../abc/opcodes.js';
+export function buildCfg(abc, items, exceptions) {
+    const blocks = [];
+    const labelBlock = new Map();
+    let cur = null;
+    const newBlock = () => {
+        const b = { id: blocks.length, insns: [], labels: [], kind: 'fall', succs: [], preds: [], entryHeight: -1 };
+        blocks.push(b);
+        return b;
+    };
+    for (const it of items) {
+        if (it.type === 'label') {
+            if (!cur || cur.insns.length > 0)
+                cur = newBlock();
+            cur.labels.push(it.id);
+            labelBlock.set(it.id, cur.id);
+            continue;
+        }
+        if (!cur)
+            cur = newBlock();
+        if (it.type === 'bytes') {
+            if (cur.insns.length > 0)
+                cur = newBlock();
+            cur.kind = 'raw';
+            cur = null;
+            continue;
+        }
+        cur.insns.push(it);
+        const flow = opInfo(it.op)?.flow;
+        if (flow) {
+            cur.kind = flow === 'return' ? 'return' : flow === 'throw' ? 'throw' : flow;
+            cur = null;
+        }
+    }
+    if (blocks.length === 0)
+        newBlock().kind = 'end';
+    // Successors
+    for (let i = 0; i < blocks.length; i++) {
+        const b = blocks[i];
+        const last = b.insns[b.insns.length - 1];
+        const next = i + 1 < blocks.length ? i + 1 : -1;
+        switch (b.kind) {
+            case 'fall':
+                if (next >= 0)
+                    b.succs = [next];
+                else
+                    b.kind = 'end';
+                break;
+            case 'jump':
+                b.succs = [labelBlock.get(last.targets[0])];
+                break;
+            case 'cond':
+                b.succs = [labelBlock.get(last.targets[0]), ...(next >= 0 ? [next] : [])];
+                if (b.succs.length < 2)
+                    b.succs.push(b.succs[0]);
+                break;
+            case 'switch':
+                b.succs = last.targets.map((t) => labelBlock.get(t));
+                break;
+            default:
+                break;
+        }
+    }
+    for (const b of blocks)
+        for (const s of new Set(b.succs))
+            blocks[s].preds.push(b.id);
+    // Stack heights
+    const handlerBlocks = exceptions.map((e) => labelBlock.get(e.target)).filter((x) => x !== undefined);
+    const work = [[0, 0], ...handlerBlocks.map((h) => [h, 1])];
+    while (work.length) {
+        const [id, h] = work.pop();
+        const b = blocks[id];
+        if (b.entryHeight >= 0)
+            continue;
+        b.entryHeight = h;
+        let height = h;
+        for (const ins of b.insns) {
+            const { pop, push } = stackEffect(abc, ins);
+            height = Math.max(0, height - pop) + push;
+        }
+        for (const s of b.succs)
+            work.push([s, height]);
+    }
+    // Drop edges from unreachable (dead) blocks so they do not disturb structuring.
+    const handlerSet = new Set(handlerBlocks);
+    for (const b of blocks) {
+        if (b.entryHeight >= 0 || handlerSet.has(b.id))
+            continue;
+        for (const s of b.succs) {
+            const t = blocks[s];
+            t.preds = t.preds.filter((p) => p !== b.id);
+        }
+        b.succs = [];
+    }
+    // Dominators (Cooper, Harvey & Kennedy) with exception edges from try starts.
+    const extraSuccs = new Map();
+    for (const e of exceptions) {
+        const from = labelBlock.get(e.from);
+        const target = labelBlock.get(e.target);
+        if (from === undefined || target === undefined)
+            continue;
+        // Every block inside the try range may throw; using the first one is
+        // enough for reachability and keeps handlers dominated by the try start.
+        extraSuccs.set(from, [...(extraSuccs.get(from) ?? []), target]);
+    }
+    const succsOf = (id) => [...blocks[id].succs, ...(extraSuccs.get(id) ?? [])];
+    const predsOf = blocks.map(() => []);
+    for (const b of blocks)
+        for (const s of new Set(succsOf(b.id)))
+            predsOf[s].push(b.id);
+    const order = rpo(blocks.length, [0], succsOf);
+    const idom = dominators(blocks.length, 0, order, (id) => predsOf[id]);
+    // Post-dominators: reverse graph with a virtual exit node (index n).
+    const n = blocks.length;
+    const exitPreds = [];
+    for (const b of blocks)
+        if (b.succs.length === 0)
+            exitPreds.push(b.id);
+    const rsuccs = (id) => (id === n ? exitPreds : blocks[id].preds);
+    const rpreds = (id) => {
+        if (id === n)
+            return [];
+        const b = blocks[id];
+        return b.succs.length === 0 ? [n] : [...new Set(b.succs)];
+    };
+    const rorder = rpo(n + 1, [n], rsuccs);
+    const pdom = dominators(n + 1, n, rorder, rpreds);
+    const ipdom = blocks.map((b) => {
+        const p = pdom[b.id];
+        return p === n || p === undefined ? -1 : p;
+    });
+    return { blocks, labelBlock, exceptions: [...exceptions], idom, ipdom, order };
+}
+function rpo(n, roots, succs) {
+    const order = new Array(n).fill(-1);
+    const visited = new Uint8Array(n);
+    const post = [];
+    for (const root of roots) {
+        const stack = [[root, 0]];
+        visited[root] = 1;
+        while (stack.length) {
+            const top = stack[stack.length - 1];
+            const ss = succs(top[0]);
+            if (top[1] < ss.length) {
+                const s = ss[top[1]++];
+                if (!visited[s]) {
+                    visited[s] = 1;
+                    stack.push([s, 0]);
+                }
+            }
+            else {
+                post.push(top[0]);
+                stack.pop();
+            }
+        }
+    }
+    post.reverse().forEach((id, i) => (order[id] = i));
+    return order;
+}
+function dominators(n, root, order, preds) {
+    const idom = new Array(n).fill(-1);
+    idom[root] = root;
+    const nodes = [...Array(n).keys()].filter((i) => order[i] >= 0).sort((a, b) => order[a] - order[b]);
+    const intersect = (a, b) => {
+        while (a !== b) {
+            while (order[a] > order[b])
+                a = idom[a];
+            while (order[b] > order[a])
+                b = idom[b];
+        }
+        return a;
+    };
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const b of nodes) {
+            if (b === root)
+                continue;
+            let nd = -1;
+            for (const p of preds(b)) {
+                if (idom[p] === -1 || order[p] < 0)
+                    continue;
+                nd = nd === -1 ? p : intersect(p, nd);
+            }
+            if (nd !== -1 && idom[b] !== nd) {
+                idom[b] = nd;
+                changed = true;
+            }
+        }
+    }
+    idom[root] = -1;
+    return idom;
+}
+/** True if `a` dominates `b`. */
+export function dominates(cfg, a, b) {
+    let x = b;
+    for (let guard = 0; x !== -1 && guard < 100000; guard++) {
+        if (x === a)
+            return true;
+        x = cfg.idom[x];
+    }
+    return false;
+}
+/** Natural loops keyed by header block. */
+export function findLoops(cfg) {
+    const loops = new Map();
+    for (const b of cfg.blocks) {
+        for (const s of b.succs) {
+            if (!dominates(cfg, s, b.id))
+                continue;
+            let loop = loops.get(s);
+            if (!loop) {
+                loop = { header: s, body: new Set([s]), latches: [] };
+                loops.set(s, loop);
+            }
+            if (!loop.latches.includes(b.id))
+                loop.latches.push(b.id);
+            const stack = [b.id];
+            while (stack.length) {
+                const x = stack.pop();
+                if (loop.body.has(x))
+                    continue;
+                loop.body.add(x);
+                for (const p of cfg.blocks[x].preds)
+                    stack.push(p);
+            }
+        }
+    }
+    return loops;
+}

package/dist/decompiler/class-printer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Prints a whole AS3 class (package, imports, fields, methods) from ABC.
+ */
+import type { AbcFile } from '../abc/abc-file.js';
+export interface DecompileClassOptions {
+    indentUnit?: string;
+}
+/** Decompiles class `classIndex` to AS3 source text. */
+export declare function decompileClass(abc: AbcFile, classIndex: number, options?: DecompileClassOptions): string;

package/dist/decompiler/class-printer.js

@@ -0,0 +1,170 @@
+import { InstanceFlags, NamespaceKind, TraitAttr, TraitKind } from '../abc/constants.js';
+import { scriptOfClass } from '../abc/model.js';
+import { decompileMethodBody, decompileMethodStatements, formatDefault, formatParams, typeNameOf } from './method.js';
+function modifier(abc, mn, isInterface) {
+    if (isInterface)
+        return '';
+    const m = abc.multinames[mn];
+    const ns = m ? abc.namespaces[m.ns] : undefined;
+    switch (ns?.kind) {
+        case NamespaceKind.PrivateNs:
+            return 'private ';
+        case NamespaceKind.ProtectedNamespace:
+        case NamespaceKind.StaticProtectedNs:
+            return 'protected ';
+        case NamespaceKind.PackageInternalNs:
+            return 'internal ';
+        case NamespaceKind.Namespace: {
+            const uri = abc.strings[ns.name] ?? '';
+            const tail = uri.split(/[/:]/).filter(Boolean).pop() ?? 'ns';
+            return `${/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(tail) ? tail : 'ns'} `;
+        }
+        default:
+            return 'public ';
+    }
+}
+function metadataLines(abc, t, indent) {
+    const out = [];
+    for (const mi of t.metadata) {
+        const md = abc.metadata[mi];
+        if (!md)
+            continue;
+        const items = md.keys.map((k, i) => {
+            const v = JSON.stringify(abc.strings[md.values[i]] ?? '');
+            return k ? `${abc.strings[k]}=${v}` : v;
+        });
+        out.push(`${indent}[${abc.strings[md.name]}${items.length ? `(${items.join(',')})` : ''}]`);
+    }
+    return out;
+}
+function traitLines(env, t, isStatic, isInterface, indent, initText) {
+    const { abc } = env;
+    const name = abc.multinameName(t.name);
+    const mods = `${t.attrs & TraitAttr.Override ? 'override ' : ''}${t.attrs & TraitAttr.Final && !isStatic ? 'final ' : ''}${modifier(abc, t.name, isInterface)}${isStatic ? 'static ' : ''}`;
+    const out = metadataLines(abc, t, indent);
+    switch (t.kind) {
+        case TraitKind.Slot:
+        case TraitKind.Const: {
+            const kw = t.kind === TraitKind.Const ? 'const' : 'var';
+            const init = t.valueIndex ? ` = ${formatDefault(abc, t.valueKind, t.valueIndex)}` : initText !== undefined ? ` = ${initText}` : '';
+            out.push(`${indent}${mods}${kw} ${name}:${typeNameOf(env, t.typeName)}${init};`);
+            return out;
+        }
+        case TraitKind.Method:
+        case TraitKind.Getter:
+        case TraitKind.Setter:
+        case TraitKind.Function: {
+            const accessor = t.kind === TraitKind.Getter ? 'get ' : t.kind === TraitKind.Setter ? 'set ' : '';
+            const m = abc.methods[t.method];
+            const ret = m ? typeNameOf(env, m.returnType) : '*';
+            const sig = `${indent}${mods}function ${accessor}${name}(${formatParams(env, t.method)}):${ret}`;
+            if (isInterface || !abc.methodBody(t.method)) {
+                out.push(`${sig};`);
+                return out;
+            }
+            const body = decompileMethodBody(env, t.method, indent);
+            out.push(sig, `${indent}{`, ...body.lines, `${indent}}`);
+            return out;
+        }
+        case TraitKind.Class:
+            out.push(`${indent}// class ${name}`);
+            return out;
+    }
+    return out;
+}
+/** Decompiles class `classIndex` to AS3 source text. */
+export function decompileClass(abc, classIndex, options = {}) {
+    const unit = options.indentUnit ?? '   ';
+    const inst = abc.instances[classIndex];
+    const cls = abc.classes[classIndex];
+    if (!inst || !cls)
+        throw new Error(`Class index ${classIndex} out of range`);
+    const qualified = abc.className(classIndex);
+    const dot = qualified.lastIndexOf('.');
+    const pkg = dot >= 0 ? qualified.slice(0, dot) : '';
+    const shortName = abc.multinameName(inst.name);
+    const isInterface = (inst.flags & InstanceFlags.Interface) !== 0;
+    const script = scriptOfClass(abc, classIndex);
+    const imports = new Set();
+    const env = {
+        abc,
+        thisTraits: inst.traits,
+        globalTraits: script >= 0 ? abc.scripts[script].traits : [],
+        imports,
+        currentPackage: pkg,
+        indentUnit: unit,
+    };
+    const I1 = unit;
+    const I2 = unit + unit;
+    const body = [];
+    // Fields first (static, then instance), then methods.
+    const slots = (traits) => traits.filter((t) => t.kind === TraitKind.Slot || t.kind === TraitKind.Const);
+    const methods = (traits) => traits.filter((t) => t.kind !== TraitKind.Slot && t.kind !== TraitKind.Const);
+    // Static initialiser: leading `NAME = value` assignments become field initialisers.
+    const staticInits = new Map();
+    let cinitLines = [];
+    if (!isInterface && abc.methodBody(cls.cinit)) {
+        const cenv = { ...env, thisTraits: cls.traits };
+        const r = decompileMethodStatements(cenv, cls.cinit);
+        if ('error' in r) {
+            cinitLines = decompileMethodBody(cenv, cls.cinit, I2).lines;
+        }
+        else {
+            const slotNames = new Set(slots(cls.traits).filter((t) => !t.valueIndex).map((t) => abc.multinameName(t.name)));
+            let k = 0;
+            for (; k < r.stmts.length; k++) {
+                const s = r.stmts[k];
+                if (s.k !== 'expr' || s.e.k !== 'assign' || s.e.op)
+                    break;
+                const tgt = s.e.target;
+                const name = tgt.k === 'name' ? tgt.name : tgt.k === 'member' && (tgt.obj.k === 'this' || tgt.obj.k === 'findprop' || tgt.obj.k === 'global') ? tgt.name : undefined;
+                if (!name || !slotNames.has(name) || staticInits.has(name))
+                    break;
+                staticInits.set(name, r.printer.expr(s.e.v, 1, I2));
+            }
+            cinitLines = r.printer.stmts(r.stmts.slice(k), I2 + unit);
+        }
+    }
+    for (const t of slots(cls.traits))
+        body.push(...traitLines(env, t, true, isInterface, I2, staticInits.get(abc.multinameName(t.name))));
+    if (slots(cls.traits).length)
+        body.push('');
+    for (const t of slots(inst.traits))
+        body.push(...traitLines(env, t, false, isInterface, I2));
+    if (slots(inst.traits).length)
+        body.push('');
+    if (cinitLines.length)
+        body.push(`${I2}{`, ...cinitLines, `${I2}}`, '');
+    // Constructor
+    if (!isInterface) {
+        const ctor = decompileMethodBody(env, inst.iinit, I2);
+        const lines = ctor.lines.filter((l, i, all) => !(all.length === 1 && /^\s*super\(\);$/.test(l)));
+        body.push(`${I2}public function ${shortName}(${formatParams(env, inst.iinit)})`, `${I2}{`, ...lines, `${I2}}`, '');
+    }
+    for (const t of methods(cls.traits))
+        body.push(...traitLines(env, t, true, isInterface, I2), '');
+    for (const t of methods(inst.traits))
+        body.push(...traitLines(env, t, false, isInterface, I2), '');
+    while (body.length && body[body.length - 1] === '')
+        body.pop();
+    // Header (computed after the body so imports are complete).
+    const superName = inst.superName ? typeNameOf(env, inst.superName) : '';
+    const ifaces = inst.interfaces.map((i) => typeNameOf(env, i));
+    imports.delete(qualified);
+    const mods = `${modifier(abc, inst.name, false)}${inst.flags & InstanceFlags.Final ? 'final ' : ''}${!(inst.flags & InstanceFlags.Sealed) && !isInterface ? 'dynamic ' : ''}`;
+    let header;
+    if (isInterface) {
+        header = `${I1}${mods}interface ${shortName}${ifaces.length ? ` extends ${ifaces.join(', ')}` : ''}`;
+    }
+    else {
+        header = `${I1}${mods}class ${shortName}${superName && superName !== 'Object' ? ` extends ${superName}` : ''}${ifaces.length ? ` implements ${ifaces.join(', ')}` : ''}`;
+    }
+    const out = [`package${pkg ? ' ' + pkg : ''}`, '{'];
+    const sortedImports = [...imports].sort();
+    for (const imp of sortedImports)
+        out.push(`${I1}import ${imp};`);
+    if (sortedImports.length)
+        out.push('');
+    out.push(header, `${I1}{`, '', ...body, `${I1}}`, '}', '');
+    return out.join('\n');
+}

package/dist/decompiler/method.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Method-level decompilation: bytecode → structured AS3 statements → text.
+ */
+import type { AbcFile, MethodInfo, Trait } from '../abc/abc-file.js';
+import { Printer, type Stmt } from './ast.js';
+export interface DecompileEnv {
+    abc: AbcFile;
+    /** Instance traits (for getslot on `this`). */
+    thisTraits?: Trait[];
+    /** Script traits (for getglobalslot). */
+    globalTraits?: Trait[];
+    /** Fully qualified names referenced by the code (filled in). */
+    imports?: Set<string>;
+    /** Package of the class being decompiled (no import needed for it). */
+    currentPackage?: string;
+    indentUnit?: string;
+}
+/** Short type name for a multiname; records an import when needed. */
+export declare function typeNameOf(env: DecompileEnv, mn: number): string;
+export declare function useNameOf(env: DecompileEnv, mn: number): void;
+export declare function paramNames(abc: AbcFile, method: MethodInfo): string[];
+/** Parameter list text: `a:int, b:String = "x", ...rest`. */
+export declare function formatParams(env: DecompileEnv, methodIndex: number, printer?: Printer): string;
+/** Default value literal for optional parameters and slots. */
+export declare function formatDefault(abc: AbcFile, kind: number, index: number): string;
+export interface DecompiledMethod {
+    /** Body lines (already indented with `indent + indentUnit`), without braces. */
+    lines: string[];
+    /** Set when decompilation failed and P-code was emitted instead. */
+    error?: string;
+}
+export interface DecompiledStatements {
+    stmts: Stmt[];
+    printer: Printer;
+}
+/** Decompiles a method body into lines of AS3. */
+export declare function decompileMethodBody(env: DecompileEnv, methodIndex: number, indent: string): DecompiledMethod;
+/** Decompiles a method body to statements plus a printer bound to its local names. */
+export declare function decompileMethodStatements(env: DecompileEnv, methodIndex: number): DecompiledStatements | {
+    error: string;
+};