Files
Aidem-Media-DLL-Analysis/ams/render.py
T
Patryk GenschandClaude Opus 5.5 aee8f17417 feat: type_fields in diff and tracker, joined with emulator property reads
The tracker lists each scope's original properties (constructor chain,
or class fields up the chain for Piklib 6.1 and singletons such as
SCENE) and where the emulator reads them: a CNVParser.createVariable
case arm, an attribute read in the type's class or Variable.java, or
other code. The switch-arm parser is shared with the @ statements.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-24 20:30:36 +02:00

181 lines
8.1 KiB
Python

"""Human-readable rendering of a snapshot diff (see diff.compute_diff)."""
from __future__ import annotations
from typing import Any, Callable
def _counts(block: dict[str, Any]) -> str:
return "+{0} -{1} ~{2}".format(
len(block["added"]), len(block["removed"]), len(block["changed"]))
def _fmt_changes(changes: dict[str, list]) -> str:
return "; ".join("{0}: {1} -> {2}".format(f, v[0], v[1]) for f, v in sorted(changes.items()))
def _group_by(items: list[dict], owner_of: Callable[[dict], str]) -> dict[str, list[dict]]:
out: dict[str, list[dict]] = {}
for it in items:
out.setdefault(owner_of(it) or "?", []).append(it)
return out
# --- per-axis item formatting ------------------------------------------------------------------
def _fmt_type(t: dict) -> str:
tag = " [via module iface]" if t.get("via_module_iface") else ""
size = t.get("object_size")
cls = t.get("cpp_class") or "?"
return "{0} -> {1} (size {2}){3}".format(t["script_name"], cls, size, tag)
def _fmt_method(m: dict) -> str:
return "{0} (id {1})".format(m["name"], m.get("id"))
def _fmt_event(e: dict) -> str:
return "{0} (#{1})".format(e["name"], e.get("order"))
def _fmt_field(f: dict) -> str:
return "{0}: {1}".format(f["name"], f.get("type"))
def _fmt_layout(x: dict) -> str:
vt = " vtable" if x.get("is_vtable") else ""
return "@{0:#x} size {1}{2}".format(x["offset"], x.get("size"), vt)
# --- section renderers -------------------------------------------------------------------------
def _section_flat(out: list[str], title: str, block: dict, fmt: Callable[[dict], str],
name_of: Callable[[dict], str]) -> None:
out.append("")
out.append("{0:<16} {1}".format(title, _counts(block)))
for it in sorted(block["added"], key=name_of):
out.append(" + {0}".format(fmt(it)))
for it in sorted(block["removed"], key=name_of):
out.append(" - {0}".format(name_of(it)))
for ch in sorted(block["changed"], key=lambda c: name_of(c["item"])):
out.append(" ~ {0:<22} {1}".format(name_of(ch["item"]), _fmt_changes(ch["changes"])))
def _section_owned(out: list[str], title: str, block: dict, fmt: Callable[[dict], str],
owner_of: Callable[[dict], str], name_of: Callable[[dict], str]) -> None:
out.append("")
out.append("{0:<16} {1}".format(title, _counts(block)))
added = _group_by(block["added"], owner_of)
removed = _group_by(block["removed"], owner_of)
changed = _group_by([c["item"] for c in block["changed"]], owner_of)
change_by_id = {id(c["item"]): c for c in block["changed"]}
for owner in sorted(set(added) | set(removed) | set(changed)):
out.append(" {0}".format(owner))
for it in sorted(added.get(owner, []), key=name_of):
out.append(" + {0}".format(fmt(it)))
for it in sorted(removed.get(owner, []), key=name_of):
out.append(" - {0}".format(name_of(it)))
for it in sorted(changed.get(owner, []), key=name_of):
out.append(" ~ {0:<22} {1}".format(
name_of(it), _fmt_changes(change_by_id[id(it)]["changes"])))
def _dispatch_name(r: dict) -> str:
return r.get("name") or "id {0}".format(r.get("id"))
def _leaves(items: list, cap: int = 4) -> str:
shown = items[:cap]
extra = "…+{0}".format(len(items) - cap) if len(items) > cap else ""
return ", ".join(shown) + extra
def _section_dispatch(out: list[str], block: dict) -> None:
"""Method bodies (per owner+id), normalised. Each changed entry shows a similarity score and
the leaf-level delta (which calls appeared/vanished); a summary line gives the overall drift."""
out.append("")
summ = block.get("summary")
head = "METHOD BODIES"
if summ:
head = "{0} (shared {1}, ~{2} changed, mean {3}% similar)".format(
"METHOD BODIES", summ["shared"], summ["changed"], summ["mean_similarity"])
out.append("{0}".format(head))
out.append("{0:<16} {1}".format("", _counts(block)))
owner_of = lambda r: r["owner"]
added = _group_by(block["added"], owner_of)
removed = _group_by(block["removed"], owner_of)
changed = _group_by([c["item"] for c in block["changed"]], owner_of)
change_by_id = {id(c["item"]): c for c in block["changed"]}
for owner in sorted(set(added) | set(removed) | set(changed)):
out.append(" {0}".format(owner))
for it in sorted(added.get(owner, []), key=_dispatch_name):
out.append(" + {0}".format(_dispatch_name(it)))
for it in sorted(removed.get(owner, []), key=_dispatch_name):
out.append(" - {0}".format(_dispatch_name(it)))
for it in sorted(changed.get(owner, []), key=_dispatch_name):
ch = change_by_id[id(it)]
body = ch.get("body", {})
sim = body.get("similarity")
bits = []
if body.get("added"):
bits.append("+[{0}]".format(_leaves(body["added"])))
if body.get("removed"):
bits.append("-[{0}]".format(_leaves(body["removed"])))
if not bits and "impl" in ch["changes"]:
bits.append("impl {0} -> {1}".format(*ch["changes"]["impl"]))
label = "{0} {1}%".format(_dispatch_name(it), sim) if sim is not None else _dispatch_name(it)
out.append(" ~ {0:<26} {1}".format(label, " ".join(bits)))
_EMPTY = {"added": [], "removed": [], "changed": []}
def _is_empty(block: dict) -> bool:
return not (block["added"] or block["removed"] or block["changed"])
def render_text(diff: dict[str, Any], only: set[str] | None = None) -> str:
b = diff["binary"]
out: list[str] = ["Engine surface diff"]
out.append(" from: {0} [{1}/{2}]".format(
b["from"].get("name", "?"), b["from"].get("engine", "?"), b["from"].get("compiler", "?")))
out.append(" to: {0} [{1}/{2}]".format(
b["to"].get("name", "?"), b["to"].get("engine", "?"), b["to"].get("compiler", "?")))
def want(axis: str) -> bool:
return only is None or axis in only
if want("types") and not _is_empty(diff["types"]):
_section_flat(out, "TYPES", diff["types"], _fmt_type, lambda t: t["script_name"])
if want("methods") and not _is_empty(diff["methods"]):
_section_owned(out, "METHODS", diff["methods"], _fmt_method,
lambda m: m["owner"], lambda m: m["name"])
if want("events") and not _is_empty(diff["events"]):
_section_owned(out, "EVENTS", diff["events"], _fmt_event,
lambda e: e["owner"], lambda e: e["name"])
if want("events") and not _is_empty(diff.get("type_events", _EMPTY)):
_section_owned(out, "TYPE EVENTS", diff["type_events"], _fmt_event,
lambda e: e["type"], lambda e: e["name"])
if want("fields") and not _is_empty(diff["fields"]):
_section_owned(out, "FIELDS", diff["fields"], _fmt_field,
lambda f: f["owner"], lambda f: f["name"])
if want("fields") and not _is_empty(diff.get("type_fields", _EMPTY)):
_section_owned(out, "TYPE FIELDS", diff["type_fields"],
lambda f: "{0}: {1}".format(f["name"], "/".join(f.get("value_types", []))),
lambda f: f["type"], lambda f: f["name"])
if want("layout") and not _is_empty(diff["struct_layout"]):
_section_owned(out, "STRUCT LAYOUT", diff["struct_layout"], _fmt_layout,
lambda x: x["owner"], lambda x: "@{0:#x}".format(x["offset"]))
if want("dispatch") and not _is_empty(diff.get("method_dispatch", _EMPTY)):
_section_dispatch(out, diff["method_dispatch"])
if want("methods") and diff["moved_methods"]:
out.append("")
out.append("MOVED METHODS {0}".format(len(diff["moved_methods"])))
for m in sorted(diff["moved_methods"], key=lambda x: x["name"]):
out.append(" {0}: {1} -> {2}".format(
m["name"], ",".join(m["from_owners"]), ",".join(m["to_owners"])))
if all(_is_empty(diff.get(a, _EMPTY))
for a in ("types", "methods", "events", "fields", "struct_layout", "method_dispatch")):
out.append("")
out.append("(no differences)")
return "\n".join(out)