#!/usr/bin/env python3

"""Check the generated opcode tables against the published 65C02 spec.

ProcessorTests measures what the hardware does, across tens of thousands of

randomised cases. This checks something different and much smaller: that the

sizes and cycle counts in src/cpu/tables.h still agree with the documentation.

The two have disagreed once already, over $5C, where both WDC datasheets and

the 6502.org list say eight cycles and the test suite says four. Divergences

like that are listed below rather than hidden, so changing one is a deliberate

act.

"""

import pathlib

import re

import sys

ROOT = pathlib.Path(__file__).resolve().parent.parent

# Bytes consumed by each addressing mode, including the opcode.

MODE_BYTES = {

    "imp": 1, "acc": 1, "imp8": 1,

    "imm8": 2, "immm": 2, "immx": 2,

    "zp": 2, "zpx": 2, "zpy": 2, "rel": 2,

    "ind0": 2, "indx": 2, "indy": 2,

    "abso": 3, "absx": 3, "absy": 3, "ind": 3, "ainx": 3, "zprel": 3,

}

# Where this emulator knowingly differs from the published 65C02 spec. The

# value is what the emulator is expected to be, so a drift away from the

# recorded difference fails rather than being waved through.

KNOWN = {

    0xDB: ((1, 1), "the X16 maps $DB to a debugger trap rather than STP"),

}

# The spec file is data, and data can be quietly emptied. A truncated file would

# otherwise report zero failures out of zero opcodes and pass.

MIN_ROWS = 120

def read_table(path, decl):

    text = (ROOT / path).read_text(encoding="utf-8")

    start = text.index(decl) + len(decl)

    body = text[start:text.index("};", start)]

    body = re.sub(r"/\*.*?\*/", "", body, flags=re.S)

    return [x.strip() for x in body.replace("\n", " ").split(",") if x.strip()]

def read_spec():

    rows = {}

    path = ROOT / "tests" / "spec_65c02.txt"

    for line in path.read_text(encoding="utf-8").splitlines():

        if not line.strip() or line.startswith("#"):

            continue

        op, size, cycles, note = line.split()

        rows[int(op, 16)] = (int(size), int(cycles), note)

    return rows

def main() -> int:

    modes = read_table("src/cpu/tables.h", "addrtable_c02[256])() = {")

    ticks = [int(x) for x in read_table("src/cpu/tables.h", "ticktable_c02[256] = {")]

    spec = read_spec()

    if len(modes) != 256 or len(ticks) != 256:

        print("FAIL: parsed %d modes and %d cycle counts, expected 256 of each"

              % (len(modes), len(ticks)))

        return 1

    failures = 0

    if len(spec) < MIN_ROWS:

        print("FAIL: spec_65c02.txt holds %d opcodes, expected at least %d"

              % (len(spec), MIN_ROWS))

        failures += 1

    for op in sorted(spec):

        want_size, want_cycles, _note = spec[op]

        mode = modes[op]

        if mode not in MODE_BYTES:

            print("FAIL: $%02X uses addressing mode %s, which has no size here"

                  % (op, mode))

            failures += 1

            continue

        got = (MODE_BYTES[mode], ticks[op])

        if got == (want_size, want_cycles):

            if op in KNOWN:

                print("FAIL: $%02X now matches the spec; drop it from KNOWN (%s)"

                      % (op, KNOWN[op][1]))

                failures += 1

            continue

        if op in KNOWN:

            expected, why = KNOWN[op]

            if got == expected:

                print("ok   : $%02X is %d bytes and %d cycles rather than %d and "

                      "%d -- %s" % (op, got[0], got[1], want_size, want_cycles, why))

            else:

                print("FAIL: $%02X is %d bytes and %d cycles; the spec says %d and "

                      "%d and the recorded difference is %d and %d"

                      % (op, got[0], got[1], want_size, want_cycles,

                         expected[0], expected[1]))

                failures += 1

            continue

        print("FAIL: $%02X is %d bytes and %d cycles, spec says %d and %d"

              % (op, got[0], got[1], want_size, want_cycles))

        failures += 1

    print("%s: %d opcodes checked against the published spec, %d failed"

          % ("opcode_spec", len(spec), failures))

    return 1 if failures else 0

if __name__ == "__main__":

    sys.exit(main())