TP3/shell/tests/nonvacuity.sh

#!/bin/sh
# The layout cases below rewrite tests/comimage.py and restore it within the
# same second.  A .pyc names the source by (mtime, size), and two versions of
# this file can have both in common, so Python would keep executing the
# MUTATED module after the restore.  That made later cases report the mutation
# as if it were the baseline.  Do not write bytecode here.
PYTHONDONTWRITEBYTECODE=1
export PYTHONDONTWRITEBYTECODE
# nonvacuity.sh -- prove the runtime checks can actually fail.
#
# A test that has never been seen red is not a test.  This script breaks the
# runtime on purpose, once per check, and asserts that the check goes red and
# says something useful about the breakage.  Then it restores the source and
# asserts everything is green again.
#
# Each mutation below is a real bug that was in this file at some point, not an
# invented one.  That is the point: these are the mistakes we actually make
# with 16-bit ModRM, so these are the ones the checks have to catch.
#
#   audit_helpers.py   name-versus-decode: catches a wrong ModRM that still
#                      decodes cleanly, and both halves of a name that admits
#                      an operand at all - `34 02' where the name promises
#                      `34 01', and `35 01' where the row's opcode gate admits
#                      only 34h.  Both rows are new, and a row nobody has seen
#                      reject anything accepts whatever it is shown.
#   audit_helpers.py   coverage:           catches a helper that has silently
#                      dropped OUT of the audit, which is a green report about
#                      a subject nobody looked at
#   run_com_tests.sh   the .COM layout:    catches a header that cannot be
#                      located, a runtime size that disagrees with the image,
#                      and an entry jump that starts in the wrong place
#   check_runtime.py   golden:            catches the same thing in the built
#                                           image
#   check_runtime.py   decode sweep:      catches a wrong instruction LENGTH
#   check_runtime.py   branch targets:    catches a wrong fixup
#   check_runtime.py   entry goldens:     catches a broken prologue
#   probe/modrm11.py   the mod=11 table:   catches the ModRM column itself
#                      going wrong, which no amount of decoding will show
#   check_framedisp.py the BP disp rule:   catches a displacement that reads
#                      a different address than the symbol table named
#   tests/comimage.py the image layout:     catches a sweep region built from a
#                      literal instead of from two independent readings of the
#                      file - the old RT_SZ went on reporting PASS while its
#                      region began inside the runtime - and the layout itself
#                      being written down a second time, now that one file
#                      defines it and all three readers import it
#   rt_exec.py        the BP contract:      catches an entry that borrows BP to
#                      reach its argument and does not hand it back.  The bytes
#                      are well formed, the golden is satisfied, the audit says
#                      every helper emits what its name says, and the machine
#                      triple-faults on the second call - so nothing short of
#                      running it, or of stating the register contract
#                      explicitly, can see it.
#   rt_exec.py        the string entries: catches rdstr storing its first
#                      character where the length byte belongs (a missing IncSi
#                      puts `hello' back as 05 65 6c 6c 6f), and strstore
#                      running LOOP with CX = 0 when the source is empty - 65536
#                      iterations that wrap the segment and walk through the
#                      driver's own case record.  Both are same-size,
#                      matrix-green slips that only a byte dump can see.
#   run_com_exec.py   the frame rule:     catches a local STRING packed with the
#                      INTEGER rule, so its characters grow up over the saved BP
#                      and the return address; readln into such a local then
#                      runs the string's own bytes as an address.  The fix moves
#                      no well-formed instruction, so only execution - or the
#                      size it pins in the compile matrix - can tell.
#   run_com_exec.py   the string arms:    catches the destination limit loaded
#                      into AX instead of CX, the assignment pushes swapped so
#                      the destination is read as its own source, and a string
#                      read dispatched to the integer reader.  Every one is the
#                      right shape reading the wrong thing, and the MovCxi
#                      helper is COMP in the audit, so no byte check can see it.
#   check_8086.py    the 8086 opcodes:    catches a conditional branch or a
#                      SETcc emitted as `0F 8x'/`0F 9x', which are 386-only.
#                      Nothing else here can: qemu-system-i386's lowest CPU
#                      model is 486, where both are ordinary instructions, and
#                      FCML's -m16 mode is a 386 too.  Clause H additionally
#                      catches the branch polarity being inverted, which is
#                      still a legal opcode and therefore invisible to every
#                      shape-based check.
#   run_com_exec.py   behaviour:            catches a*b that emits an ADD, `>'
#                      and `>=' swapped, REPEAT..UNTIL that stops after one
#                      pass, two procedures whose parameters collide, a left
#                      operand overwritten by the right one's code (SaveLeft),
#                      and a boolean `not' lowered as the integer one.  Every
#                      one of them sat in a fixture that COMPILED and was
#                      never RUN, with every byte-level check green.
#   run_compile_tests.sh   refusal:     catches a boolean READ slipping
#                      through to the runtime.  TP3 refuses it with error 66
#                      (TPSRC8 prderrtp; its runtime has no xrdbool), and
#                      this compiler used to accept it and let rdbool store
#                      a WORD into the one-byte variable.  The mutation is
#                      the one arm of IoCall's type dispatch that refuses it,
#                      and only the COMPILE MATRIX can see a refusal: an ERR
#                      fixture is never executed, so nothing that runs
#                      programs on it can fail the check.
#   run_exec86.py     behaviour (Exec86):   catches the interpreter's OWN
#                      reading of the machine: JE inverted in Exec86's Cond,
#                      which swaps the two arms of every `=' in every program
#                      while the emitted bytes, the sizes and every
#                      byte-level check stay green.  The image is fine; only
#                      the thing reading it is wrong, so nothing that looks at
#                      the image can fail this one.
#   runtest.py        the R key:            catches CmdRun poking nothing into
#                      the interpreter at all, which faults on the first step
#                      and prints "interpreter fault" instead of the guest's
#                      answer.  It is the only case here that needs a rebuilt
#                      SHELL rather than a rebuilt compiler or runtime.
#
# The mod=11 cases do not need a rebuild -- they read the probe sources
# directly -- so they are cheap, and they are the ones that matter most: the
# table they guard is the one thing in this project that was wrong in the
# documentation while the code was right, and a table that is wrong in the
# code produces bytes that decode perfectly.
#
# Usage: tests/nonvacuity.sh        (from shell/; leaves Runtime.mod restored)

set -u
cd "$(dirname "$0")/.." || exit 1

GM2=/home/eric/bin/Modula2/Gm2/bin/gm2
SAVED=../tmp/nonvacuity.Runtime.mod
PROBE=../tmp/nonvacuity.rtprobe
DUMP=../tmp/nonvacuity.dump
# Exec86.mod is UNTRACKED, so unlike Runtime.mod git cannot put a botched
# mutation back: the copy taken here is the only correct one in existence.
# Shell.mod is tracked but is mutated by the R-key case below, and a trap that
# restored only the sources would leave tpshell BUILT FROM the mutation - so
# the trap rebuilds too.  All three copies live in the project's own tmp/ and
# are taken here, before the first mutation, rather than beside each case.
#
# comimage.py and comtest.py are the image layout and one of its three readers;
# both are mutated by cases further down, and neither is recoverable from git
# once the mutation is staged over - so they join the trap here for the same
# reason, and an interrupted run cannot leave the layout half-written.
#
# Compiler.mod is the file mutated by the most cases, and it used to be saved
# BESIDE the first case that needed it - the BP displacement section halfway
# down this file, which is well AFTER this trap is set.  An interrupted run
# therefore left Compiler.mod half-mutated, with `git status` showing a source
# that no case had finished with.  It joins the copies above, taken before the
# first mutation and covered by the same trap.
#
# tests/probe/modrm11.{py,s} are the last two: the mod=11 table section mutates
# them and puts them back after each case, so a run that died between the two
# left them edited.  They move here for the same reason.  restore_all copies
# them directly instead of calling restore_probe, which is defined halfway down
# this file: a trap firing before that definition would abort the rest of the
# restore with "command not found".
mkdir -p ../tmp
SAVED_E=../tmp/nonvacuity.Exec86.mod
SAVED_SH=../tmp/nonvacuity.Shell.mod
SAVED_CI=../tmp/nonvacuity.comimage.py
SAVED_T=../tmp/nonvacuity.comtest.py
SAVED_C=../tmp/nonvacuity.Compiler.mod
SAVED_PY=../tmp/nonvacuity.modrm11.py
SAVED_S=../tmp/nonvacuity.modrm11.s

cp Runtime.mod "$SAVED" || exit 1
cp Exec86.mod "$SAVED_E" || exit 1
cp Shell.mod "$SAVED_SH" || exit 1
cp tests/comimage.py "$SAVED_CI" || exit 1
cp tests/comtest.py "$SAVED_T" || exit 1
cp Compiler.mod "$SAVED_C" || exit 1
cp tests/probe/modrm11.py "$SAVED_PY" || exit 1
cp tests/probe/modrm11.s "$SAVED_S" || exit 1

restore_all () {
    cp "$SAVED" Runtime.mod
    cp "$SAVED_E" Exec86.mod
    cp "$SAVED_SH" Shell.mod
    cp "$SAVED_CI" tests/comimage.py
    cp "$SAVED_T" tests/comtest.py
    cp "$SAVED_C" Compiler.mod
    cp "$SAVED_PY" tests/probe/modrm11.py
    cp "$SAVED_S" tests/probe/modrm11.s
    "$GM2" -fiso -c Runtime.mod >/dev/null 2>&1
    "$GM2" -fiso -c Exec86.mod >/dev/null 2>&1
    # The shell is rebuilt as well: a test that runs against a binary built
    # from a half-restored tree is reporting on the mutation, not on the code.
    # make rebuilds Compiler.o out of the Compiler.mod restored just above.
    make >/dev/null 2>&1
}
trap restore_all EXIT
#
# An unhandled signal does NOT run an EXIT trap: bash dies on the spot.  That is
# what the comment above promises ("an interrupted run cannot leave the layout
# half-written") and what this file did not actually do.  A handler that only
# `exit's is enough, because `exit' from a trap DOES fire the EXIT trap -- and
# it has to exit, or the run would go on using a tree it has just put back.
#
# Measured on bash 5.2: TERM and HUP fire these and restore everything, so
# `kill' and a session teardown are covered.  INT is trapped too, but in the
# usual case it never reaches this script: a foreground child that dies of
# SIGINT makes bash treat the signal as the CHILD's and continue the script
# instead.  So Ctrl-C does not abort this run at all -- it kills the current
# case's child and the next case starts -- and SIGTERM is what actually stops
# it.  129/130/143 = 128+SIGHUP/INT/TERM.
trap 'exit 129' HUP
trap 'exit 130' INT
trap 'exit 143' TERM

pass=0
fail=0

# mutate <file> <sed-expr> -- apply a deliberate breakage and INSIST it landed.
#
# Four cases in this file were already dead when first run, all the same way:
# the helper they name had been renamed or reformatted since the case was
# written, the sed matched nothing, the source was unchanged, and the check
# correctly passed - so the harness reported "NOT NON-VACUOUS" and, worse, a
# reader skimming the output could take "the check still passed" for a passing
# test.  A case that cannot fire is worse than no case: it is a claim of
# coverage that was never tested.
#
# So the mutation is verified, not assumed.  If the file is byte-identical
# afterwards, that is reported as a FAILURE of the harness, naming the sed, and
# the case is not run - because running it would only produce a meaningless
# green.  The message says what to do (fix the sed) rather than what it found.
mutate () {
    mf=$1
    msed=$2
    cp "$mf" ../tmp/nonvacuity.mut.bak
    sed -i "$msed" "$mf"
    if cmp -s "$mf" ../tmp/nonvacuity.mut.bak; then
        echo "  BROKEN CASE: the mutation did not change $mf"
        echo "       sed: $msed"
        echo "       the named code has probably been renamed or reformatted -"
        echo "       fix this case, it is asserting nothing"
        fail=$((fail + 1))
        return 1
    fi
    return 0
}

# rebuild <label> -- re-emit the runtime and dump it
rebuild () {
    "$GM2" -fiso -c Runtime.mod >/dev/null 2>&1 || return 1
    "$GM2" -fiso -o "$PROBE" tests/RtProbe.mod Runtime.o Posix.o \
        >/dev/null 2>&1 || return 1
    "$PROBE" > "$DUMP" || return 1
    return 0
}

# expect_red <label> <pattern> <checker-cmd...>
#   <pattern> is a grep the failure output must match, so a check cannot
#   "pass" by failing for some unrelated reason.
expect_red () {
    label=$1
    want=$2
    shift 2
    if out=$("$@" 2>&1); then
        echo "NOT NON-VACUOUS: $label -- the check still passed"
        fail=$((fail + 1))
    elif ! printf '%s\n' "$out" | grep -qi "$want"; then
        echo "WRONG FAILURE: $label -- went red, but not for the stated reason"
        printf '%s\n' "$out" | sed 's/^/       /'
        fail=$((fail + 1))
    else
        echo "  ok: $label"
        printf '%s\n' "$out" | grep -im1 "$want" | sed 's/^/       /'
        pass=$((pass + 1))
    fi
}

echo "== each mutation must turn the named check red"
echo

# --- 1. name-versus-decode -------------------------------------------
# MovSiBx was `89 DC`, which is MOV SP,BX.  Two bytes either way, decodes
# cleanly, and no structural check can see it.
cp "$SAVED" Runtime.mod
mutate Runtime.mod 's|B (0DEH) END MovSiBx|B (0DCH) END MovSiBx|'
expect_red "audit_helpers catches MovSiBx emitting MOV SP,BX" \
    "MovSiBx" python3 tests/audit_helpers.py

# CmpSiBx had the identical mistake, which is how you know a single fix is
# not enough -- the same misreading was written twice.
cp "$SAVED" Runtime.mod
mutate Runtime.mod 's|B (39H) ; B (0DEH) END CmpSiBx|B (39H) ; B (0DCH) END CmpSiBx|'
expect_red "audit_helpers catches CmpSiBx emitting CMP SP,BX" \
    "CmpSiBx" python3 tests/audit_helpers.py

# --- 2. golden, and entry goldens ------------------------------------
# MovDlAl was `88 C0` = MOV AL,AL instead of MOV DL,AL.  This is the case that
# motivated runtime.golden: the sweep stayed in sync, every branch target
# stayed on a boundary, no entry's first bytes moved, and the size did not
# change.  The target helper was MovAlDh when this case was written, which is
# the fourth way a case here can rot - see the note on `mutate` below.
cp "$SAVED" Runtime.mod
mutate Runtime.mod 's|PROCEDURE MovDlAl  ; BEGIN B (88H) ; B (0C2H)|PROCEDURE MovDlAl  ; BEGIN B (88H) ; B (0C0H)|'
rebuild
expect_red "runtime.golden catches MOV AL,AL" \
    "mov al,al" python3 tests/check_runtime.py "$DUMP"

# initmem opened with the mis-emitted MovSiAx, so its entry golden was the
# thing that noticed the prologue was a no-op.
cp "$SAVED" Runtime.mod
mutate Runtime.mod 's|B (0F0H) END MovSiAx|B (0C0H) END MovSiAx|'
rebuild
expect_red "check_runtime catches a broken initmem prologue" \
    "mov ax,ax" python3 tests/check_runtime.py "$DUMP"

# --- 3. decode sweep / length ----------------------------------------
# StDiDl was `88 97` = [BX+disp16],DL: mod=10, so the instruction needs a
# disp16 it was not given, and the sweep loses sync two bytes later.
cp "$SAVED" Runtime.mod
mutate Runtime.mod 's|PROCEDURE StDiDl   ; BEGIN B (88H) ; B (15H)|PROCEDURE StDiDl   ; BEGIN B (88H) ; B (97H)|'
rebuild
expect_red "decode sweep catches a mod=10 byte move with no displacement" \
    "mov byte ptr \[bx+5b5fh\],dl" python3 tests/check_runtime.py "$DUMP"

# --- 4. branch targets ------------------------------------------------
# FixUp measures a rel8 from the end of the instruction, one byte past the
# displacement field.  Drop the +1 and every short branch lands one byte into
# its target, which for a 3-byte instruction means the middle of it.  The
# bytes themselves are all perfectly well formed -- only the fixups are
# wrong -- so this is the one failure mode the golden cannot be expected to
# catch on its own.
cp "$SAVED" Runtime.mod
mutate Runtime.mod 's|rel := (t + 100H - (fix \[i\].place + 1)) MOD 100H|rel := (t + 100H - fix [i].place) MOD 100H|'
rebuild
expect_red "branch check catches rel8 fixups measured from the wrong byte" \
    "not an instruction boundary" \
    python3 tests/check_runtime.py "$DUMP"

echo
echo "== everything restored and green again"
cp "$SAVED" Runtime.mod
if rebuild; then
    if python3 tests/audit_helpers.py >/dev/null 2>&1 &&
       python3 tests/check_runtime.py "$DUMP" >/dev/null 2>&1; then
        echo "  ok: both checks pass on the restored source"
        pass=$((pass + 1))
    else
        echo "NOT RESTORED: a check is red after restoring Runtime.mod"
        fail=$((fail + 1))
    fi
else
    echo "NOT RESTORED: the runtime would not rebuild"
    fail=$((fail + 1))
fi

echo
echo "== the mod=11 table (probe/modrm11.py)"
# These mutate the probe's own sources, not the runtime, so there is no
# rebuild in the loop.  SAVED_PY / SAVED_S are taken at the top of this file,
# beside the EXIT trap, so an interrupted run restores them too; each case
# still puts them back here so the next one starts from the real table.

M11="python3 tests/probe/modrm11.py"
restore_probe () {
    cp "$SAVED_PY" tests/probe/modrm11.py
    cp "$SAVED_S" tests/probe/modrm11.s
}

# 1. one cell of the table moved
mutate tests/probe/modrm11.py 's|"Si", "Di"\]$|"Bp", "Di"]|'
expect_red "anchor pins a moved table cell" \
    "anchor ADD SI, 2" $M11
restore_probe

# 2. the table this project actually shipped: AX dropped off the front and a
#    duplicate BX invented at the end, which shifts every code down by one
mutate tests/probe/modrm11.py 's|^REG = .*$|REG = ["Cx", "Dx", "Bx", "Sp", "Bp", "Si", "Di", "Bx"]|'
expect_red "the table shifted by one (AX dropped, BX duplicated)" \
    "anchor MOV SP, BP" $M11
restore_probe

# 3. the .s edited to contradict the table.  This is the case that shows why
#    the hard-coded EXPECT bytes exist: the assembler encodes the new claim
#    correctly, so comparing the .s against `as` alone can never fail here.
mutate tests/probe/modrm11.s 's|movw    %sp, %di         # reg 100|movw    %bp, %di         # reg 100|'
expect_red "probe source edited away from the recorded bytes" \
    "expected 89 E7" $M11
restore_probe

# 4. the 8-bit list edited, which is a different table from the word one
mutate tests/probe/modrm11.s 's|movb    %al, %dl         # 88 C2  ->  DL := AL|movb    %al, %bl         # was DL|'
expect_red "the 8-bit register list edited" \
    "expected 88 C2" $M11
restore_probe

# 5. an anchor's recorded byte corrupted, so the anchor can no longer
#    corroborate itself
mutate tests/probe/modrm11.py 's|"8B EC", "8B E5"|"8B ED", "8B E5"|'
expect_red "anchor byte no longer matches the emitted code" \
    "expected 8B ED" $M11
restore_probe

if $M11 >/dev/null 2>&1; then
    echo "  ok: modrm11.py passes on the restored probe sources"
    pass=$((pass + 1))
else
    echo "NOT RESTORED: modrm11.py is red after restoring its sources"
    $M11 2>&1 | sed 's/^/       /'
    fail=$((fail + 1))
fi

echo
echo "== the BP displacement rule (check_framedisp.py)"
# This one is about Compiler.mod rather than the runtime, and it needs the
# whole toolchain rebuilt (comtest, not rtprobe), so it gets its own rebuild.
# SAVED_C itself is taken at the top of this file, beside the EXIT trap, so an
# interrupted run restores Compiler.mod as well.

rebuild_compiler () {
    $GM2 -fiso -c Compiler.mod >/dev/null 2>&1 || return 1
    $GM2 -fiso -fgen-module-list=tests/ct.lst -o /dev/null \
        tests/ComTest.mod TextBuf.o Posix.o Compiler.o Runtime.o Linker.o \
        >/dev/null 2>&1
    $GM2 -fiso -fuse-list=tests/ct.lst -o comtest \
        tests/ComTest.mod TextBuf.o Posix.o Compiler.o Runtime.o Linker.o \
        >/dev/null 2>&1 || return 1
    return 0
}

# 1. the original bug: `off MOD 100H`, always disp8.  Restores the code that
#    was there before EmBpDisp existed.  t28's [BP+128] read becomes [BP-128],
#    which is the failure this whole check is named after.
#
#    regf is KEPT.  It is the other half of EmBpDisp's job - the ModR/M reg
#    field, which the DI forms (regf 7) need - and it was added after this
#    case was written.  Hard-coding 46H here again would break the DI forms at
#    the same time and turn one mutation into two faults; the check would
#    still go red, but for a reason the label does not name.
python3 - "$SAVED_C" <<'PYEOF'
import sys
p = 'Compiler.mod'
s = open(p).read()
old = """   IF off <= 127 THEN
      Ebyte (VAL (BYTE, 40H + regf * 8 + 6H)) ; Ebyte (VAL (BYTE, off))
   ELSE
      Ebyte (VAL (BYTE, 80H + regf * 8 + 6H)) ; Eword (off)
   END
END EmBpDisp ;"""
new = """   Ebyte (VAL (BYTE, 40H + regf * 8 + 6H)) ; Ebyte (VAL (BYTE, off MOD 100H))
END EmBpDisp ;"""
assert old in s, "EmBpDisp body not found -- update this mutation"
open(p, 'w').write(s.replace(old, new))
PYEOF
if rebuild_compiler; then
    expect_red "displacement truncation reads a different address" \
        "no 8B access at \[BP+128\]" python3 tests/check_framedisp.py
else
    echo "  FAIL: the compiler would not rebuild with the truncation"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# 2. the other half of the rule: always use the 4-byte form, ignoring the
#    <= 127 case.  This is over-cautious rather than wrong, so the checker must
#    still be happy -- which is worth asserting, because a check that only
#    ever fails on a smaller encoding is a check that pins one answer instead
#    of the rule.
python3 - <<'PYEOF'
p = 'Compiler.mod'
s = open(p).read()
old = """   IF off <= 127 THEN
      Ebyte (VAL (BYTE, 40H + regf * 8 + 6H)) ; Ebyte (VAL (BYTE, off))
   ELSE
      Ebyte (VAL (BYTE, 80H + regf * 8 + 6H)) ; Eword (off)
   END"""
new = """   Ebyte (VAL (BYTE, 80H + regf * 8 + 6H)) ; Eword (off)"""
assert old in s, "EmBpDisp branch not found -- update this mutation"
open(p, 'w').write(s.replace(old, new))
PYEOF
if rebuild_compiler; then
    if python3 tests/check_framedisp.py >/dev/null 2>&1; then
        echo "  ok: always-disp16 is accepted, so the check pins the rule"
        echo "       and not one particular encoding"
        pass=$((pass + 1))
    else
        echo "  FAIL: check_framedisp rejects a safe, over-long encoding"
        python3 tests/check_framedisp.py 2>&1 | sed 's/^/       /'
        fail=$((fail + 1))
    fi
else
    echo "  FAIL: the compiler would not rebuild with always-disp16"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

if rebuild_compiler; then
    if python3 tests/check_framedisp.py >/dev/null 2>&1; then
        echo "  ok: check_framedisp passes on the restored source"
        pass=$((pass + 1))
    else
        echo "NOT RESTORED: check_framedisp is red after restoring Compiler.mod"
        python3 tests/check_framedisp.py 2>&1 | sed 's/^/       /'
        fail=$((fail + 1))
    fi
else
    echo "NOT RESTORED: the compiler would not rebuild"
    fail=$((fail + 1))
fi

# --- the region check_framedisp sweeps, and the one file it comes from -----
echo
echo "== the image layout, measured once (tests/comimage.py)"
# check_framedisp.py decodes instructions over a REGION of the image, and a
# wrong region does not stop it: the byte patterns it searches for are in the
# image wherever they happen to be, and a decode that starts mid-instruction
# reached the same offsets anyway.  That is how RT_SZ = 391 - a literal that had
# drifted from the runtime it described - went on reporting PASS while its sweep
# began inside the runtime, part way through an instruction.  Nothing in the
# check could see where its own region began.
#
# So the region is two independent readings of the file - where the entry jump
# says execution starts, and where the program header says the runtime ends -
# and the two must AGREE or the region is undetermined.  Both readings, and the
# layout itself, live in tests/comimage.py, which is also where comtest.py and
# the independent checker in run_com_tests.sh now get the copy each of them
# used to keep: a duplicated constant that has silently drifted is not an
# independent check, it is a second source of truth that lies, and it lies in
# the direction of looking like the code under test is broken.
#
# None of this needs a rebuild - comimage.py is Python the checkers import -
# so these cases are cheap, and they turn the READERS red one at a time.

# 1. entry_target answers with the literal the region used to be built from.
#    The two readings now disagree, and there is no measured region to sweep.
python3 - <<'PYEOF'
p = 'tests/comimage.py'
s = open(p).read()
old = '    return ENT_SZ + int.from_bytes(d[1:ENT_SZ], "little", signed=True)'
new = '    return ENT_SZ + 391                        # the literal RT_SZ was'
assert s.count(old) == 1, "entry_target's return not found -- update this mutation"
open(p, 'w').write(s.replace(old, new))
PYEOF
expect_red "a sweep region that is not where execution starts is rejected" \
    "neither region is swept" python3 tests/check_framedisp.py
cp "$SAVED_CI" tests/comimage.py

# 2 and 3. The header's own equation, one byte out, so the header cannot be
#    located at all - the case where a checker that fell back on a remembered
#    offset would report a confident number instead.  Two readers, two
#    different sentences: each must say in its own words that it does not know
#    where the program's code begins.
python3 - <<'PYEOF'
p = 'tests/comimage.py'
s = open(p).read()
old = '    if w(HDR_DS_WORD) != DATA_IMAGE + LOAD_BIAS:         # hdrDS'
new = '    if w(HDR_DS_WORD) != DATA_IMAGE + LOAD_BIAS + 1:     # hdrDS'
assert s.count(old) == 1, "the hdrDS equation not found -- update this mutation"
open(p, 'w').write(s.replace(old, new))
PYEOF
expect_red "check_framedisp reports a header it cannot locate" \
    "no program header found" python3 tests/check_framedisp.py
expect_red "check_8086 reports the same unlocatable header" \
    "could not locate the code region" python3 tests/check_8086.py
cp "$SAVED_CI" tests/comimage.py

# 4-7. The single copy itself, now that there is one.  A second find_header,
#      a second HDR_SZ, a caller that reaches the helper through another
#      consumer instead of through comimage, and - the case that exists
#      because of rt_exec.py's "matched nothing" lesson - the definition the
#      audit counts.  A rule that matches nothing looks exactly like a rule
#      that passes, so a deleted definition must be a red report rather than a
#      silent green one.
python3 - <<'PYEOF'
p = 'tests/comtest.py'
s = open(p).read()
old = 'def check_com(path, expected_src_len):'
new = ('def find_header(d):\n'
       '    return None                    # a second copy of the helper\n'
       '\n\n'
       'def check_com(path, expected_src_len):')
assert s.count(old) == 1, "check_com not found -- update this mutation"
open(p, 'w').write(s.replace(old, new))
PYEOF
expect_red "the audit reports a find_header copied out of comimage" \
    "comtest.py defines its own find_header" python3 tests/check_comimage.py
cp "$SAVED_T" tests/comtest.py

python3 - <<'PYEOF'
p = 'tests/comtest.py'
s = open(p).read()
old = 'from comimage import (ENT_SZ, HDR_SZ, LOAD_BIAS, DATA_IMAGE, HEAD,'
new = ('HDR_SZ = 16                   # a second copy of the layout\n'
       'from comimage import (ENT_SZ, HDR_SZ, LOAD_BIAS, DATA_IMAGE, HEAD,')
assert s.count(old) == 1, "the comimage import not found -- update this mutation"
open(p, 'w').write(s.replace(old, new))
PYEOF
expect_red "the audit reports a layout constant defined elsewhere" \
    "comtest.py defines its own HDR_SZ" python3 tests/check_comimage.py
cp "$SAVED_T" tests/comtest.py

python3 - <<'PYEOF'
p = 'tests/comimage.py'
s = open(p).read()
old = 'def find_header(d):'
new = 'def _find_header(d):                # the definition is gone'
assert s.count(old) == 1, "def find_header not found -- update this mutation"
open(p, 'w').write(s.replace(old, new))
PYEOF
expect_red "the audit counts its own subject rather than matching nothing" \
    "defines find_header 0 times" python3 tests/check_comimage.py
cp "$SAVED_CI" tests/comimage.py

# 7. The import dropped while the CALLS stay - the shape a refactor makes when
#    one reader starts taking the helper from another reader instead.  It would
#    NameError the moment comtest ran, but the audit says so first, and in the
#    vocabulary of the layout rather than in the vocabulary of Python: the
#    failure this is guarding is "two sources of truth", not "undefined name".
python3 - <<'PYEOF'
p = 'tests/comtest.py'
s = open(p).read()
old = ('from comimage import (ENT_SZ, HDR_SZ, LOAD_BIAS, DATA_IMAGE, HEAD,\n'
       '                      HDR_DS_WORD, HDR_HEAP_WORD, find_header)')
new = '# MUTATION: the shared import is gone, but the calls remain\n'
assert s.count(old) == 1, "the comimage import not found -- update this mutation"
open(p, 'w').write(s.replace(old, new))
PYEOF
expect_red "the audit reports a caller that does not take it from comimage" \
    "comtest.py calls find_header without importing it from comimage" \
    python3 tests/check_comimage.py
cp "$SAVED_T" tests/comtest.py

# Green again, on all three readers at once: the case above mutated the one
# file all of them import, so restoring it has to satisfy each of them, not
# just the one that was last run.
for c in tests/check_framedisp.py tests/check_comimage.py tests/check_8086.py; do
    if python3 "$c" >/dev/null 2>&1; then
        echo "  ok: $c passes on the restored sources"
        pass=$((pass + 1))
    else
        echo "NOT RESTORED: $c is red after restoring comimage.py and comtest.py"
        python3 "$c" 2>&1 | tail -3 | sed 's/^/       /'
        fail=$((fail + 1))
    fi
done

# --- 3. the operator bugs the nine dead fixtures were hiding ------------
echo
echo "== the bugs the never-executed fixtures were hiding"
echo
# A different KIND of case from everything above.  The others break the code
# and assert a byte-level check notices; these break the code and assert a
# BEHAVIOURAL check notices, which is the only kind that could have found them.
# Each of the original four shipped with a green compile matrix, a passing .COM
# layout check, a passing golden and a passing emitter audit:
#
#   OpMul = 1        `a * b` emitted ADD AX,CX.  `*' and `+' both numbered
#                    their operator 1, and BinOpEmit cannot see which
#                    precedence level called it, so every multiplication
#                    dispatched to the addition.  The constant-folding arm was
#                    correct, which is why `n * n' with n a CONST was right and
#                    `a * a' with a a variable was not -- and t08_const is the
#                    only fixture that ever multiplied.
#   9Dh / 9FH        `>' got SETGE and `>=' got SETG: swapped, one letter
#                    apart in the mnemonic.  Only a==b could see it.
#   JNZ -> body      REPEAT..UNTIL looped back while the condition was TRUE,
#                    which is WHILE, so the body ran once and stopped.
#
# They are mutated back to the original defect and run_com_exec.py must go red
# on the exact fixture that pins the behaviour.  The fourth (HideLocals) is a
# scoping bug rather than an operator bug; it was hiding in the same place.
#
# Two joined them when the operand-lifetime and `not' fixes landed, each run
# red by hand before it was written down here, and each with the same property
# as the four above -- green everywhere except execution:
#
#   SaveLeft's park `(p > q) or (q > p)' evaluated `(q > p) or (q > p)'.  A
#                    kind-2 value exists only in AX, and the right operand's
#                    code is emitted before the two are ever brought together,
#                    so without the push the left one is simply gone.
#   neglevel's split `not' on a boolean emitted the INTEGER `not', which left
#                    0FFFEh where a boolean belongs, and wrbool reads anything
#                    non-zero as TRUE -- so `not (a = a)' answered TRUE and so
#                    did every other `not'.
mutate_compiler () {   # reuse mutate's verified-change discipline on Compiler.mod
    mf=Compiler.mod
    msed=$1
    cp "$SAVED_C" ../tmp/nonvacuity.mut2.bak
    sed -i "$msed" "$mf"
    if cmp -s "$mf" ../tmp/nonvacuity.mut2.bak; then
        echo "  BROKEN CASE: the mutation did not change Compiler.mod"
        echo "       sed: $msed"
        echo "       the named code has probably been renamed or reformatted -"
        echo "       fix this case, it is asserting nothing"
        fail=$((fail + 1))
        return 1
    fi
    return 0
}

# The SETcc swap and the HideLocals removal are done in python rather than
# with sed: both need to match source text containing `*` and `(` in a way that
# is tedious and fragile as a regex, and a case whose only failure mode is a
# malformed sed is a case that silently asserts nothing.
#
# And a python helper fails in a way sed does not: a syntax error in the helper
# is a non-zero exit, `if mutate_foo; then` is simply false, and the case is
# SKIPPED -- with no failure counted and nothing on stdout but whatever python
# printed.  That is how the SETcc case spent its first run: an apostrophe in an
# assert message ("the `>' arm") closed the string early, python died, the
# compiler was never broken, and the suite still reported 0 failed.  A skipped
# case and a passing case look the same in the total.  So each helper below
# fails LOUDLY: a non-zero exit from python is reported as a BROKEN CASE and
# counted, never swallowed.
#
# Each one also counts its targets before replacing.  `assert s != before' only
# says the file changed; with two edits it would pass if just one of them
# landed, and with two identical HideLocals call sites it would happily delete
# the wrong one -- still a changed file, still a working compiler, still green
# for the wrong reason.
mutate_cc_swap () {
    if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
GT = 'EmSetcc (9FH) ;          (* >  SETG  *)'    # the greater-than arm
GE = 'EmSetcc (9DH) ;          (* >= SETGE *)'    # the greater-equal arm
assert s.count(GT) == 1, 'expected 1 greater-than arm, found %d' % s.count(GT)
assert s.count(GE) == 1, 'expected 1 greater-equal arm, found %d' % s.count(GE)
s = s.replace(GT, GT.replace('9FH', '9DH'))
s = s.replace(GE, GE.replace('9DH', '9FH'))
open(p, 'w').write(s)
PYX
    then
        return 0
    fi
    echo "  BROKEN CASE: the SETcc swap did not apply"
    echo "       the two EmSetcc arms are probably renamed or reformatted -"
    echo "       fix this case, it is asserting nothing"
    fail=$((fail + 1))
    return 1
}

mutate_no_hidelocals () {
    if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
# Two HideLocals calls exist.  Only the body-exit one may go: deleting the
# FORWARD one instead would still change the file, still rebuild, and still
# leave t13_proc compiling, so the case would go green for the wrong reason.
HL = '   HideLocals (nestMark) ;         (* parameters and locals stop here *)\n'
assert s.count(HL) == 1, 'expected 1 body-exit HideLocals, found %d' % s.count(HL)
open(p, 'w').write(s.replace(HL, ''))
PYX
    then
        return 0
    fi
    echo "  BROKEN CASE: HideLocals was not removed"
    echo "       the call or its comment has probably been reformatted -"
    echo "       fix this case, it is asserting nothing"
    fail=$((fail + 1))
    return 1
}

cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|^         op := OpMul ; DropCh|         op := OpAdd ; DropCh|'; then
    if rebuild_compiler; then
        expect_red "execution catches '*' emitting an ADD (t08_const, n*n)" \
            "t08_const" python3 tests/run_com_exec.py t08_const
        # t08 only ever multiplied two CONSTANTS, which is the one path that was
        # never wrong, because BinOpEmit folds it.  So the case above is close
        # to vacuous: it proves the mutation changed the binary, not that the
        # emitted multiply is covered.  The check that matters needs a
        # VARIABLE operand, and no shipped fixture has one -- which is why the
        # bug survived at all.  So this writes a throwaway fixture that
        # multiplies a variable, runs it, and asserts the multiply is right.
        # The fixture is deleted afterwards; it is here to close the coverage
        # hole, not to become a permanent test (that is what a real fixture
        # with a `*' in it would be for).
        cat > tests/fixtures/zzmul.pas <<'ZZEOF'
program zzmul;
var a : integer ;
begin
  a := 7 ;
  writeln (a * 6)
end.
ZZEOF
        printf '42\r\n' > tests/fixtures/zzmul.out
        expect_red "execution catches '*' on a VARIABLE (the unfolded path)" \
            "zzmul" python3 tests/run_com_exec.py zzmul
        rm -f tests/fixtures/zzmul.pas tests/fixtures/zzmul.out
    else
        echo "  FAIL: the compiler would not rebuild with OpAdd for '*'"
        fail=$((fail + 1))
    fi
fi
cp "$SAVED_C" Compiler.mod

cp "$SAVED_C" Compiler.mod
if mutate_cc_swap; then
    if rebuild_compiler; then
        expect_red "execution catches '>' and '>=' swapped (t09_if)" \
            "t09_if" python3 tests/run_com_exec.py t09_if
    else
        echo "  FAIL: the compiler would not rebuild with the SETcc swap"
        fail=$((fail + 1))
    fi
fi
cp "$SAVED_C" Compiler.mod

cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|      DropC (EmJcc (84H, L1)) ;        (\* JZ -> body again \*)|      zj := EmJcc (85H, L1) ;|'; then
    if rebuild_compiler; then
        expect_red "execution catches REPEAT..UNTIL exiting after one pass (t12)" \
            "t12_repeat" python3 tests/run_com_exec.py t12_repeat
    else
        echo "  FAIL: the compiler would not rebuild with the JNZ repeat"
        fail=$((fail + 1))
    fi
fi
cp "$SAVED_C" Compiler.mod

# The fourth: sibling procedures shared one parameter namespace, because a
# finished procedure's symbols were left at a level Search still accepts.
# Removing HideLocals puts two procedures' `a : integer' back in collision.
cp "$SAVED_C" Compiler.mod
if mutate_no_hidelocals; then
    if rebuild_compiler; then
        expect_red "a duplicate parameter in two procedures is a compile error again" \
            "ERROR 41" python3 tests/run_com_exec.py t13_proc
    else
        echo "  FAIL: the compiler would not rebuild without HideLocals"
        fail=$((fail + 1))
    fi
else
    echo "  FAIL: could not remove HideLocals to test the scoping fix"
    fail=$((fail + 1))
fi
# M6: the LEFT operand, parked for the right one.  kind 2 means "this value
# exists in AX and nowhere else", and the right-hand operand's code is emitted
# between recognizing the operator and using both operands - so without
# SaveLeft's push the left value is overwritten before it is ever read, and
# LoadPair's kind-4 shape can never trigger.  `(p > q) or (q > p)' then
# evaluates `(q > p) or (q > p)'.  Every byte, every size and the whole compile
# matrix stay green: nothing is malformed, the value is simply the wrong one.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
# Both guards are matched, and each must be unique.  `IF left.kind = 2 THEN'
# reads like it can only be SaveLeft's, but LoadAtom and friends also branch
# on kind, so an unasserted replace could disable one of THEM instead and the
# case would still go red - for a reason the label does not name.
#
# The kind-5 ("a string element whose address is in DI") guard did not exist
# when this case was written; it arrived with `s[i]`.  Making only the kind-2
# park unreachable would leave that one alive, so the mutation would no longer
# be "SaveLeft parks nothing" - it would be a half-disabled SaveLeft, and the
# case would be testing something narrower than it says.
g2 = '   IF left.kind = 2 THEN\n'
g5 = '   ELSIF left.kind = 5 THEN\n'
assert s.count(g2) == 1, 'the kind-2 guard found %d times -- update this mutation' % s.count(g2)
assert s.count(g5) == 1, 'the kind-5 guard found %d times -- update this mutation' % s.count(g5)
s = s.replace(g2, '   IF left.kind = 99 THEN\n')
s = s.replace(g5, '   ELSIF left.kind = 99 THEN\n')
open(p, 'w').write(s)
PYX
then
    if rebuild_compiler; then
        expect_red "execution catches a left operand clobbered by the right one" \
            "t34_arith" python3 tests/run_com_exec.py t34_arith
    else
        echo "  FAIL: the compiler would not rebuild without SaveLeft's push"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the SaveLeft mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# M7: the type split in TPSRC9's neglevel, wrong half.  A boolean NOT lowered
# as the INTEGER one leaves 0FFFEh/0FFFFh, and wrbool tests [BP+4] <> 0 - so
# `not (a = a)' answers TRUE, and so does every other `not'.  One instruction,
# same length, same sizes, and the compile matrix cannot see it because both
# halves emit well-formed code for a type the parser already accepted.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = """      IF r.cls = TBool THEN
         LoadAtom (r) ;
         EmXorAl01 () ;"""
new = """      IF r.cls = TBool THEN
         LoadAtom (r) ;
         EmNotAx () ;                      (* MUTATION: integer NOT on a boolean *)"""
assert s.count(old) == 1, 'the TBool arm of ParseNeg found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, new))
PYX
then
    if rebuild_compiler; then
        expect_red "execution catches a boolean NOT lowered as an integer one" \
            "t35_not" python3 tests/run_com_exec.py t35_not
    else
        echo "  FAIL: the compiler would not rebuild with EmNotAx for a boolean"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the neglevel type-split mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# Bug 36, argument order: the fix has FOUR independent halves - three parsers
# that push each argument the moment it is parsed instead of after the whole
# list, and the callee that reads its parameters backwards from BP+4 - and
# t36_argclobber is the one fixture that tells them apart.  Before these four
# cases existed, its only proof was the pre-fix run quoted in the commit
# message, which is a fact about the past rather than a check: it cannot be
# re-derived, and nothing stops the four halves from drifting apart.
#
# Each revert below was run to a red BEFORE it was written here, and the four
# fail on four DIFFERENT rows, which is what makes them four cases and not one
# wearing four hats: the callee revert turns `5 3 7' into `7 3 5' (every
# argument lands on its neighbour's parameter), the deferred ParseCallArgs
# zeroes the rows built from computed arguments, ParseCall changes the
# function call's result (19 -> 10) and IoCall changes the last write
# (`FALSE 1' -> `TRUE 544', the first argument printed as the second
# argument's value).  A revert that left t36 green is reported by expect_red
# as NOT NON-VACUOUS; a revert that did not land is a BROKEN CASE.

# revert_procedure <name> -- put <name> back the way it was before bug 36 was
# fixed, spliced out of the tree the fix landed on top of.  The old code's
# source of truth is the old code: quoting a copy of it in this file is a copy
# that can drift from the tag it claims to reproduce, and a revert that
# reproduces nothing is a case asserting nothing.
revert_procedure () {
    python3 - "$1" <<'PYX'
import subprocess, sys
name = sys.argv[1]
cur = open('Compiler.mod').read()
r = subprocess.run(['git', 'show', 'v-TP3-IMAGELAYOUT:shell/Compiler.mod'],
                   capture_output=True)
assert r.returncode == 0, 'cannot read the pre-fix tree: %s' % r.stderr.decode()[:200]
pre = r.stdout.decode()

def span(text, where):
    # The DEFINITION, not the FORWARD declaration a few screens earlier: the
    # anchor runs to the end of the line, and a FORWARD line ends `FORWARD ;'
    # instead of nothing.
    a, b = 'PROCEDURE %s (idx : CARDINAL) ;\n' % name, 'END %s ;' % name
    na, nb = text.count(a), text.count(b)
    assert na == 1 and nb == 1, \
        '%s: %d definitions, %d ends in %s -- update this case' % (name, na, nb, where)
    i = text.index(a)
    j = text.index(b, i) + len(b)
    return text[i:j], i, j

new, i, j = span(cur, 'Compiler.mod')
old, _, _ = span(pre, 'the pre-fix tree')
assert old != new, 'the pre-fix %s is identical to the current one' % name
open('Compiler.mod', 'w').write(cur[:i] + old + cur[j:])
PYX
}

# The callee half: no remap, so parameters are read in declaration order from
# BP+4 while the arguments are pushed in parse order - the FIRST argument ends
# up in the LAST parameter's slot, and one-argument calls (all of
# Runtime.mod's own cases) cannot tell the two layouts apart.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = """   i := nestMark ;
   WHILE i < symTop DO
      symtab [i].off := 8 + (parmOff - 4) - symtab [i].off
                        - ParamSlotBytes (symtab [i]) ;
      INC (i)
   END ;
"""
assert s.count(old) == 1, 'the ProcFunc parameter remap found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, ''))
PYX
then
    if rebuild_compiler; then
        expect_red "t36 catches the callee laid out in declaration order (no remap)" \
            "t36_argclobber" python3 tests/run_com_exec.py t36_argclobber
    else
        echo "  FAIL: the compiler would not rebuild without the parameter remap"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the ProcFunc remap mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# The caller half, site 1 of 3: a call used as a statement.  The old code
# read the whole list into args[] and pushed it backwards afterwards, so a
# computed argument (which exists only in AX) was gone before the push loop
# reached it.
cp "$SAVED_C" Compiler.mod
if revert_procedure ParseCallArgs; then
    if rebuild_compiler; then
        expect_red "t36 catches ParseCallArgs pushing after the whole list" \
            "t36_argclobber" python3 tests/run_com_exec.py t36_argclobber
    else
        echo "  FAIL: the compiler would not rebuild with ParseCallArgs deferred"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the ParseCallArgs revert did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# Site 2 of 3: the same call reached from ParseAtom, when a FUNCTION is
# called inside an expression.  A separate site, because it is a separate
# procedure - and t36's `19' row is the only thing that notices this one.
cp "$SAVED_C" Compiler.mod
if revert_procedure ParseCall; then
    if rebuild_compiler; then
        expect_red "t36 catches ParseCall pushing after the whole list" \
            "t36_argclobber" python3 tests/run_com_exec.py t36_argclobber
    else
        echo "  FAIL: the compiler would not rebuild with ParseCall deferred"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the ParseCall revert did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# Site 3 of 3: write/writeln/read/readln, where the argument list is also
# where an inline string literal gets its call.  Reverting this procedure
# also reverts the per-argument dispatch inside it (the BYTE read landed
# here), which is harmless for t36 and is why the splice is the whole
# procedure rather than the push alone: half a revert is a state the tree
# was never in.
cp "$SAVED_C" Compiler.mod
if revert_procedure IoCall; then
    if rebuild_compiler; then
        expect_red "t36 catches IoCall printing the last argument's value" \
            "t36_argclobber" python3 tests/run_com_exec.py t36_argclobber
    else
        echo "  FAIL: the compiler would not rebuild with IoCall's loops split"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the IoCall revert did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# The boolean read (t38): TP3 refuses `readln (b)' with error 66 - prderrtp
# rejects the whole class and the runtime has no xrdbool - and this compiler
# used to accept it and dispatch to rdbool, which stores a WORD into the
# one-byte variable, its second byte landing on the variable AFTER b (t37's
# overflow, unobserved only because no fixture read a boolean).  The fix is
# one arm of IoCall's type dispatch, so the mutation restores exactly that
# arm.  The check is the COMPILE MATRIX rather than any run: an ERR fixture
# is never executed, so nothing that runs programs on it can see a refusal.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = """               ELSIF acls = TBool THEN
                  (* TP3 refuses boolean I/O: TPSRC8 prderrtp is error 66,
                     "I/O not allowed here", and the runtime has no xrdbool
                     at all.  rdbool stores a WORD, so one byte of an
                     accepted read would land on the variable AFTER b - the
                     exact overflow t37_readbyte pins for a byte.  TP3's
                     answer to the whole class is the error; so is ours. *)
                  Err (EIoHere) ;
                  RETURN"""
assert s.count(old) == 1, 'the boolean-read error arm found %d times -- update this mutation' % s.count(old)
rep = """               ELSIF acls = TBool THEN
                  ent := TU_RdBool"""
open(p, 'w').write(s.replace(old, rep))
PYX
then
    if rebuild_compiler; then
        expect_red "t38 red when a boolean read dispatches to TU_RdBool" \
            "t38_readbool" tests/run_compile_tests.sh
    else
        echo "  FAIL: the compiler would not rebuild with the boolean read accepted"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the boolean-read mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# The string variable (t39).  A STRING is the first declared type bigger than
# a word that this compiler accepts, and it is accepted in two places: DefVar
# exempts TString from its `size > 2' catch-all so `var s : string [10]' can
# exist at all, and the two arms below USE it once it does.  The three
# mutations are the three places the feature lives, each restored to the
# exact pre-fix state (all three used to be ENoLib, or never existed):
#
#   1. the DEPARSE of assignment: before the fix, `s := 'hello'' fell out of
#      Assignment's size check.  Removing the string arm puts it back there.
#   2. the WRITE: before the fix, `writeln (s)' was refused by IoCall's
#      type dispatch.  Restoring the refusal arm is removing the feature.
#   3. the RUNTIME: wrstr's print loop is only as good as its length byte,
#      and only rt_exec.py can see a wrstr that reads no length at all.

# 1. Assignment's string arm is gone, so `s := 'hello'' trips the old
#    `size > 2' refusal again.  The arm is spliced between its guard and the
#    `size > 2' check that follows it, so a comment inside cannot break the
#    match - but the GUARD is matched by text, and it has to be the whole
#    guard.  It grew an `AND (r.cls = TString)' when `s[i] := c' made a
#    TString destination reach a second arm, and ParseSub grew a look-alike
#    `IF symtab [r.idx].cls = TString THEN' for `s[i]'.  The shorter anchor
#    therefore now finds ParseSub's, some 800 lines earlier, and the splice
#    below deletes everything between the two - which does not test the
#    refusal, it tests whether the compiler still compiles.  Hence the assert
#    and the spelled-out guard.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
g = '   IF (r.cls = TString) AND (VarSize (r) > 1) THEN\n'
assert s.count(g) == 1, 'the string-assignment guard found %d times' % s.count(g)
a = s.index(g)
m = '      RETURN\n   END ;\n   IF (r.kind = 5) OR (VarSize (r) > 2) THEN\n'
i = s.index(m, a)
new = g + '      Err (ENoLib) ;              (* MUTATION: the arm is refused *)\n      RETURN\n'
open(p, 'w').write(s[:a] + new + s[i + len('      RETURN\n'):])
PYX
then
    if rebuild_compiler; then
        expect_red "t39 red when the string-assignment arm is refused" \
            "t39_strvar" tests/run_compile_tests.sh
    else
        echo "  FAIL: the compiler would not rebuild with the string assignment refused"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the string-assignment mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# 2. The write arm of IoCall, restored to its pre-fix refusal.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = """                     IF arg.kind = 5 THEN
                        EmPushDi ()
                     ELSE
                        EmPushVarAddr (symtab [arg.idx].local,
                                       (symtab [arg.idx].off + arg.boff) MOD 10000H)
                     END ;
                     ent := TU_WrStr"""
assert s.count(old) == 1, 'the string-write arm found %d times -- update this mutation' % s.count(old)
rep = """                     Err (ENoLib) ;
                     RETURN"""
open(p, 'w').write(s.replace(old, rep))
PYX
then
    if rebuild_compiler; then
        expect_red "t39 red when a string write is refused again (ENoLib)" \
            "t39_strvar" tests/run_compile_tests.sh
    else
        echo "  FAIL: the compiler would not rebuild with the string write refused"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the string-write mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# 3. The runtime half: wrstr never reads the length byte, so every string -
#    "hello" and the empty one alike - prints nothing.  The compiler, the
#    golden and the audit all stay green; only executing the entry finds it.
cp "$SAVED" Runtime.mod
if python3 - <<'PYX'
p = 'Runtime.mod'
s = open(p).read()
old = """   MovBxBp4 ;                        (* BX := the caller's string address *)
   XorCxCx ;
   MovClBx ;                         (* CX := the length byte at [BX] *)"""
assert s.count(old) == 1, 'the wrstr length load found %d times -- update this mutation' % s.count(old)
rep = """   MovBxBp4 ;                        (* BX := the caller's string address *)
   XorCxCx ;                         (* CX is never loaded: prints nothing *)"""
open(p, 'w').write(s.replace(old, rep))
PYX
then
    if rebuild; then
        expect_red "the runtime cases catch a wrstr that reads no length" \
            "wrstr" python3 tests/rt_exec.py
    else
        echo "  FAIL: the runtime would not rebuild with the length load dropped"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the wrstr length-load mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED" Runtime.mod
# Re-emit the object: the `rebuild` above compiled Runtime.o from the MUTATED
# source, and the restored-compiler check next links that object - without
# this recompile it would report on the mutation, not on the restored code.
"$GM2" -fiso -c Runtime.mod >/dev/null 2>&1 || {
    echo "  FAIL: Runtime.mod would not recompile after the restore"
    fail=$((fail + 1))
}

if rebuild_compiler; then
    if python3 tests/run_com_exec.py >/dev/null 2>&1; then
        # No count: the matrix grows every time a fixture is added, and a
        # number here would be right only until the next one.
        echo "  ok: every executed fixture passes on the restored compiler"
        pass=$((pass + 1))
    else
        echo "NOT RESTORED: run_com_exec.py is red after restoring Compiler.mod"
        python3 tests/run_com_exec.py 2>&1 | grep -i fail | head -3 | sed 's/^/       /'
        fail=$((fail + 1))
    fi
else
    echo "NOT RESTORED: the compiler would not rebuild"
    fail=$((fail + 1))
fi

echo
echo "== the string READ and ASSIGNMENT entries (t40, t41)"
# t39 above gave a STRING variable a frame and printed it.  This milestone puts
# one on the RECEIVING end of the two operations that move data into a string
# and between two strings - readln(s)/read(s), and s := t - and each one is
# three things at once: a compiler arm that chooses a runtime entry, the
# convention that carries the limit, and the entry itself.  The cases below
# break each of the six in turn.  Every mutation is a fault, or a plausible
# neighbour of one, that was run to a red BY HAND before it was written here.
#
# The frame rule is the odd one out: it is not a new entry at all, but a
# pre-existing compiler bug that only this milestone could reach.  A local
# STRING was packed with the INTEGER rule - the symbol took the pre-decrement
# locFree, so a string[5] local sat at BP-2 and its characters grew UP into
# BP+3, over the saved BP at [BP] and the return address at [BP+2].  `readln(s)'
# into such a local stored 'hello' over its own return address, and t40 then ran
# the string's own bytes as an address: Exec86 said `fault at IP=0x6F6C', which
# is 'l','o'.  The fix packs locals top-anchored, so the first INTEGER (size 2)
# is still at -2 - byte for byte what the old rule produced - while a string[5]
# (size 6) goes to -6..-1, inside the frame.  t39's size (217) and t40's
# behaviour are the two independent things that pin it.

# --- the two runtime entries ---------------------------------------------
# rdstr stored the first character where the length byte belongs, because the
# IncSi that steps SI past dest[0] was missing.  The length byte then
# overwrote it: `hello' read back as 05 65 6c 6c 6f.  Same length, same sizes,
# and the whole compile matrix stays green - only rt_exec.py's byte dump can
# see it.
cp "$SAVED" Runtime.mod
if python3 - <<'PYX'
p = 'Runtime.mod'
lines = open(p).read().split('\n')
out, i, n = [], 0, 0
while i < len(lines):
    if lines[i].startswith('   IncSi ;') and 'dest + 1' in lines[i]:
        out.append('   (* MUTATION: the IncSi that puts chars at dest+1 is gone *)')
        i += 1
        while i < len(lines) and not lines[i].rstrip().endswith('*)'):
            i += 1
        i += 1
        n += 1
        continue
    out.append(lines[i])
    i += 1
assert n == 1, 'the rdstr IncSi found %d times -- update this mutation' % n
open(p, 'w').write('\n'.join(out))
PYX
then
    if rebuild; then
        expect_red "rt_exec catches rdstr storing its first character at dest[0]" \
            "rdstr reads a line into a string" python3 tests/rt_exec.py
    else
        echo "  FAIL: the runtime would not rebuild with rdstr's IncSi removed"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the rdstr IncSi mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED" Runtime.mod

# strstore's empty-source guard.  A source of length 0 sets CX := 0, and LOOP
# with CX = 0 runs 65536 times rather than zero - so `s := ''' copied 64K,
# wrapped the segment, and walked through the driver's own case record.  That is
# why the pattern below matches the CASE, not a byte count: rt_exec.py reports
# this one as a malformed record, which is the honest shape of "the entry wrote
# where it had no business writing".
if python3 - <<'PYX'
p = 'Runtime.mod'
lines = open(p).read().split('\n')
out, i, n = [], 0, 0
while i < len(lines):
    if lines[i].startswith('   Jcxz8 ("ss_done")'):
        out.append('   (* MUTATION: the empty-source guard is gone *)')
        i += 1
        while i < len(lines) and not lines[i].rstrip().endswith('*)'):
            i += 1
        i += 1
        n += 1
        continue
    out.append(lines[i])
    i += 1
assert n == 1, 'the strstore Jcxz8 found %d times -- update this mutation' % n
open(p, 'w').write('\n'.join(out))
PYX
then
    if rebuild; then
        expect_red "rt_exec catches a strstore that runs LOOP with CX=0" \
            "strstore copies an empty string" python3 tests/rt_exec.py
    else
        echo "  FAIL: the runtime would not rebuild with the empty-source guard removed"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the strstore empty-source guard mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED" Runtime.mod
# Re-emit the object: `rebuild` above compiled Runtime.o from the MUTATED
# source, and the compiler rebuild below links that object - without this
# recompile the restored-compiler check at the end would report on the mutation.
"$GM2" -fiso -c Runtime.mod >/dev/null 2>&1 || {
    echo "  FAIL: Runtime.mod would not recompile after the restore"
    fail=$((fail + 1))
}

# --- the frame rule -------------------------------------------------------
# The pre-fix layout, exactly: the symbol took locFree itself instead of its
# top, and the frame began at 0FFFEh.  For INTEGER locals that is byte-for-byte
# the same -2, -4, ... the new rule produces, which is why the old rule survived
# so long unnoticed; for a STRING it puts characters where the return address
# is.  Two independent readers go red together, so both are asserted: the
# compile matrix pins the LAYOUT (t39's code size drops 217 -> 215), and t40
# pins that the program RUNS (with the overlap its readln never sees the line
# terminator and the machine hangs).
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
a = '(locFree - size + 1) MOD 10000H'
assert s.count(a) == 2, 'the top-anchored base found %d times -- update this mutation' % s.count(a)
s = s.replace(a, 'locFree')                     # the old pre-decrement base
b = 'locFree := 0FFFFH ;'
assert s.count(b) == 2, 'the frame top found %d times -- update this mutation' % s.count(b)
s = s.replace(b, 'locFree := 0FFFEH ;')         # the old starting point
open(p, 'w').write(s)
PYX
then
    if rebuild_compiler; then
        expect_red "the compile matrix catches a local string packed over the frame" \
            "expected: OK 222" tests/run_compile_tests.sh
        expect_red "t40 red when readln into a local string overwrites its return address" \
            "never halted" python3 tests/run_com_exec.py t40_readln
    else
        echo "  FAIL: the compiler would not rebuild with the old frame layout"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the frame-layout revert did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- the MBF integer conversion's exponent base ---------------------------
# intreal starts with exponent 90h for a value whose top byte is set; one less
# and every real_from_int result carries the wrong exponent.  rt_exec compares
# the six emitted bytes against CALC-PORT.md's measured table, so this is a
# behavioural case, not a byte-golden one.
cp "$SAVED" Runtime.mod
if mutate Runtime.mod 's|   MovAxImm (0090H)|   MovAxImm (008FH)|'; then
    if "$GM2" -fiso -c Runtime.mod >/dev/null 2>&1; then
        expect_red "real_from_int red when the exponent base is 8Fh" \
            "real_from_int" python3 tests/rt_exec.py
    else
        echo "  FAIL: the runtime would not rebuild with the wrong base"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the MBF exponent-base mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED" Runtime.mod
"$GM2" -fiso -c Runtime.mod >/dev/null 2>&1

# --- the MBF sign is stored, not XORed into DH --------------------------
# XorDataDh is `30 36' (memory destination).  Encoding it as `32 36' makes it
# XOR DH with the saved sign instead, which leaves the result with the
# operand's fraction bits (the bug found while transcribing readd).  The
# real_add/real_sub cases compare exact bytes.
cp "$SAVED" Runtime.mod
if mutate Runtime.mod 's|BEGIN B (30H) ; B (36H) ; Dd (delta) END XorDataDh|BEGIN B (32H) ; B (36H) ; Dd (delta) END XorDataDh|'; then
    if "$GM2" -fiso -c Runtime.mod >/dev/null 2>&1; then
        expect_red "real_add red when the sign is XORed into DH, not memory" \
            "real_add" python3 tests/rt_exec.py
    else
        echo "  FAIL: the runtime would not rebuild with the XOR direction wrong"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the MBF XOR-direction mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED" Runtime.mod
"$GM2" -fiso -c Runtime.mod >/dev/null 2>&1

# --- JccNear jumps when the condition HOLDS ------------------------------
# The near form is an INVERSE Jcc over an E9.  Putting the condition back
# unchanged makes remult's `b = 0 ?' test jump when b is NON-zero, so every
# product becomes zero.  The rt_exec real_mul cases compare exact bytes.
cp "$SAVED" Runtime.mod
if python3 - <<'PYX'
p = 'Runtime.mod'
s = open(p).read()
old = """   IF (code MOD 2) = 0 THEN
      B (code + 1)
   ELSE
      B (code - 1)
   END ;"""
assert s.count(old) == 1, 'the JccNear inverse found %d times' % s.count(old)
open(p, 'w').write(s.replace(old, '   B (code) ;'))
PYX
then
    if "$GM2" -fiso -c Runtime.mod >/dev/null 2>&1; then
        expect_red "real_mul red when JccNear uses the raw condition" \
            "real_mul" python3 tests/rt_exec.py
    else
        echo "  FAIL: the runtime would not rebuild with the raw JccNear"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the JccNear-inverse mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED" Runtime.mod
"$GM2" -fiso -c Runtime.mod >/dev/null 2>&1

# --- rediv's first subtraction is SUB, not SBB ---------------------------
# TPSRC's `SUB.B AH,remul21a' ignores the carry; `SBB' would subtract the
# carry-out of the shifted numerator as well.  In the ordinary compare path
# CF is 0, so the two agree and a casual transcription passes most divisions;
# only 42/6 - the one quotient below 1, where the loop subtracts on equality -
# comes out two ulps low.  Encoding the AH subtraction as SBB must turn the
# exact-byte real_div cases red.
if mutate Runtime.mod 's|BEGIN B (2AH) ; B (26H) ; Dd (delta) END SubAhData|BEGIN B (1AH) ; B (26H) ; Dd (delta) END SubAhData|'; then
    if "$GM2" -fiso -c Runtime.mod >/dev/null 2>&1; then
        expect_red "real_div red when the mantissa subtraction uses SBB instead of SUB" \
            "real_div" python3 tests/rt_exec.py
    else
        echo "  FAIL: the runtime would not rebuild with SubAhData as SBB"
        fail=$((fail + 1))
    fi
fi
cp "$SAVED" Runtime.mod
"$GM2" -fiso -c Runtime.mod >/dev/null 2>&1

# --- recmp compares b's SIGN, not its middle word -----------------------
# The different-sign path is decided by RCL on a's high word, but WHICH pair is
# different is decided by XOR DX,DI.  XORing with SI (b's middle mantissa word)
# still sees a's sign, so two negatives are taken as different signs: -3.7 and
# -3.9 then compare backwards.  The fractional real_cmp cases catch it.
if mutate Runtime.mod 's|BEGIN B (31H) ; B (0FAH) END XorDxDi|BEGIN B (31H) ; B (0F2H) END XorDxDi|'; then
    if "$GM2" -fiso -c Runtime.mod >/dev/null 2>&1; then
        expect_red "real_cmp red when the sign XOR uses SI instead of DI" \
            "real_cmp" python3 tests/rt_exec.py
    else
        echo "  FAIL: the runtime would not rebuild with the XorDxDi mutation"
        fail=$((fail + 1))
    fi
fi
cp "$SAVED" Runtime.mod
"$GM2" -fiso -c Runtime.mod >/dev/null 2>&1

# --- reint must not skip the mask for ordinary large reals ---------------
# 0A8h is 2^39, above which every representable value is already integral.
# Lowering it to 088h (256) makes 12345.75 come back unchanged instead of
# 12345: the fraction survives, and the exact-byte real_int case says so.
if mutate Runtime.mod 's|CmpAl (0A8H)|CmpAl (088H)|'; then
    if "$GM2" -fiso -c Runtime.mod >/dev/null 2>&1; then
        expect_red "real_int red when the integral short-circuit starts too low" \
            "real_int" python3 tests/rt_exec.py
    else
        echo "  FAIL: the runtime would not rebuild with the CmpAl mutation"
        fail=$((fail + 1))
    fi
fi
cp "$SAVED" Runtime.mod
"$GM2" -fiso -c Runtime.mod >/dev/null 2>&1

# --- fmtreal reads the real through DI, not BX ---------------------------
# LdBxDiOff is `8B 5D off' = MOV BX,[DI+off].  8B 5F is [BX+off], and the
# formatter would then read its own card scratch as the real's mantissa.  The
# exact-output real_fmt cases catch it.
if mutate Runtime.mod 's|BEGIN B (8BH) ; B (5DH) ; B (off MOD 256) END LdBxDiOff|BEGIN B (8BH) ; B (5FH) ; B (off MOD 256) END LdBxDiOff|'; then
    if "$GM2" -fiso -c Runtime.mod >/dev/null 2>&1; then
        expect_red "real_fmt red when the real is loaded through BX, not DI" \
            "real_fmt" python3 tests/rt_exec.py
    else
        echo "  FAIL: the runtime would not rebuild with the LdBxDiOff mutation"
        fail=$((fail + 1))
    fi
fi
cp "$SAVED" Runtime.mod
"$GM2" -fiso -c Runtime.mod >/dev/null 2>&1

# --- ascreal's digit add is an ADD, not a SUB ----------------------------
# rd_core is the post-testexp core; its caller must set resign.  The parser
# adds each digit, so resign must be 0.  8000h makes it a subtraction with the
# sign XORed into the second operand: 12341 comes out 12339-ish, while the
# offset tests (which do not look at the value) still pass.
if python3 - <<'PYX'
p = 'Runtime.mod'
s = open(p).read()
old = """   PopAx ; PopBx ; PopDx ;
   StDataImm (D_RSIGN, 0) ;          (* readd, not resub: resign := 0 *)"""
assert s.count(old) == 1, 'the parser resign found %d times' % s.count(old)
open(p, 'w').write(s.replace(old, """   PopAx ; PopBx ; PopDx ;
   StDataImm (D_RSIGN, 8000H) ;"""))
PYX
then
    if "$GM2" -fiso -c Runtime.mod >/dev/null 2>&1; then
        expect_red "real_val value red when the digit add uses resign=8000h" \
            "real_val" python3 tests/rt_exec.py
    else
        echo "  FAIL: the runtime would not rebuild with the parser resign mutation"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the parser resign mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED" Runtime.mod
"$GM2" -fiso -c Runtime.mod >/dev/null 2>&1

# --- the compiler's arms --------------------------------------------------
# The limit both entries read is MOV CX,imm16.  MOV AX,imm16 is one opcode away,
# the same length, and the audit's MovCxi row is COMP - "no single sequence to
# disassemble" - so nothing in the byte-level checks can tell them apart.  Only
# execution can: t41's `s := t' truncates to 4 under CX and does not under AX.
# (t40 passes either way, because its CX happens to survive large enough for the
# five characters it reads - exactly the kind of luck a behavioural case is for.)
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|   Ebyte (0B9H) ; Eword (imm)|   Ebyte (0B8H) ; Eword (imm)|'; then
    if rebuild_compiler; then
        expect_red "t41 red when the destination limit is loaded into AX, not CX" \
            "t41_strassign" python3 tests/run_com_exec.py t41_strassign
    else
        echo "  FAIL: the compiler would not rebuild with MovCxi emitting MOV AX"
        fail=$((fail + 1))
    fi
fi
cp "$SAVED_C" Compiler.mod

# Assignment pushes the source first, then the destination, so the source sits
# at [BP+6] and the destination at [BP+4].  Swapped, strstore takes the
# destination as its own source - t41's `worl' rows become copies of what was
# already in the destination, which looks like it works and prints the wrong
# bytes.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
src = ('         EmPushVarAddr (symtab [src.idx].local,\n'
       '                        (symtab [src.idx].off + src.boff) MOD 10000H) ;\n'
       '         EmPushVarAddr (symtab [r.idx].local,\n'
       '                        (symtab [r.idx].off + r.boff) MOD 10000H) ;')
dst = ('         EmPushVarAddr (symtab [r.idx].local,\n'
       '                        (symtab [r.idx].off + r.boff) MOD 10000H) ;\n'
       '         EmPushVarAddr (symtab [src.idx].local,\n'
       '                        (symtab [src.idx].off + src.boff) MOD 10000H) ;')
assert s.count(src) == 1, 'the assignment pushes found %d times -- update this mutation' % s.count(src)
open(p, 'w').write(s.replace(src, dst))
PYX
then
    if rebuild_compiler; then
        expect_red "t41 red when the assignment pushes are swapped" \
            "t41_strassign" python3 tests/run_com_exec.py t41_strassign
    else
        echo "  FAIL: the compiler would not rebuild with the pushes swapped"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the assignment push-order mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# The read dispatch's string arm.  TU_RdStr and TU_RdInt sit next to each other
# in the same table and both take one address; TU_RdInt parses the line as a
# number, which stores nothing on `world', so readln(s) leaves s empty and the
# program prints a blank line.  A refusal would at least say so; this arm looks
# like it worked and answers with the wrong bytes.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = ('                  EmMovCxi ((VarSize (arg) - 1) MOD 10000H) ;\n'
       '                  ent := TU_RdStr')
assert s.count(old) == 1, 'the string-read arm found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, old.replace('TU_RdStr', 'TU_RdInt')))
PYX
then
    if rebuild_compiler; then
        expect_red "t40 red when a string read dispatches to TU_RdInt" \
            "t40_readln" python3 tests/run_com_exec.py t40_readln
    else
        echo "  FAIL: the compiler would not rebuild with the read dispatch on TU_RdInt"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the string-read dispatch mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- the include pre-pass -------------------------------------------------
# ExpandIncludes is the only thing that turns {$I name} into the named file;
# forced off, it is exactly the old bug - the directive is a comment and the
# include's own symbols do not exist.  t56_include's `FromInclude' lives only in
# the .inc, so the compile matrix demands OK 56 4 and gets ERR 41 instead.  That
# pins the fixture to the include ACTUALLY happening, not merely to the buffer
# being well formed; t57/t58 pin the two refusals (90 and 96) separately.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = 'isInc := TRUE'
assert s.count(old) == 1, 'the include flag found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, 'isInc := FALSE'))
PYX
then
    if rebuild_compiler; then
        expect_red "t56 red when the include is swallowed, not expanded" \
            "expected: OK 61 5" tests/run_compile_tests.sh
    else
        echo "  FAIL: the compiler would not rebuild with the include forced off"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the include-flag mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- typed constants, and the caret/decimal character constants -----------
# A scalar typed constant's whole point is the CLASS its declaration gives the
# symbol: the value folds to an immediate either way, so the code size does not
# move when the class is dropped - `cls := typCls' -> `cls := cls' turns
# t59's `write (FXMax)' from the char writer to the integer one and the program
# prints 71 for 'G'.  The compile matrix stays GREEN (same OK 65 4); only
# execution can see it, which is why this case runs the .COM and not the matrix.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = '               cls := typCls'
assert s.count(old) == 1, 'the declared-type assignment found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, '               cls := cls'))
PYX
then
    if rebuild_compiler; then
        expect_red "t59 red when a typed constant's declared class is thrown away" \
            "t59_typedconst" python3 tests/run_com_exec.py t59_typedconst
    else
        echo "  FAIL: the compiler would not rebuild with the typed-const class dropped"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the typed-const class mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# ^M and #27 are CHARACTER constants, and ParseAtom must accept them as
# literals - RdConst alone only helps in a declaration.  Drop them from the
# literal test and `write (^M)' is a syntax error, so the MATRIX goes red here
# (unlike the class case above, this one is visible at compile time).
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = " OR (CurCh () = '^') OR (CurCh () = '#') THEN"
assert s.count(old) == 1, 'the caret/decimal literal test found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, ' THEN'))
PYX
then
    if rebuild_compiler; then
        expect_red "t60 red when ^M / #nn are not character literals" \
            "expected: OK 80 5" tests/run_compile_tests.sh
    else
        echo "  FAIL: the compiler would not rebuild with the caret literal test removed"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the caret-literal mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- the set membership bit -----------------------------------------------
# Compile-time `in' reads a byte out of the emitted set and tests one bit.  Flip
# the test and every answer is wrong while the sizes are untouched, so the
# compile matrix stays GREEN (same OK 183 4) and only execution sees it - the
# same shape as the typed-constant class case above, and the reason t61 has a
# .out rather than just a row.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = 'isIn := (o DIV m) MOD 2 # 0'
assert s.count(old) == 1, 'the set membership bit test found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, 'isIn := (o DIV m) MOD 2 = 0'))
PYX
then
    if rebuild_compiler; then
        expect_red "t61 red when the set membership bit test is inverted" \
            "t61_setconst" python3 tests/run_com_exec.py t61_setconst
    else
        echo "  FAIL: the compiler would not rebuild with the set bit test inverted"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the set-bit mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- an enumerator's ordinal ----------------------------------------------
# Every enumerator must get its own ordinal (0,1,2,..).  Give them all 0 and
# every `a = SomeEnumerator' is TRUE, while the sizes do not move: the compile
# matrix stays green (OK 187 5) and only execution sees it.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = 'KConst, TScalar, 1, 1, 0, hi + 1, FALSE'
assert s.count(old) == 1, 'the enumerator ordinal found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, 'KConst, TScalar, 1, 1, 0, 0, FALSE'))
PYX
then
    if rebuild_compiler; then
        expect_red "t62 red when every enumerator gets ordinal 0" \
            "t62_enum" python3 tests/run_com_exec.py t62_enum
    else
        echo "  FAIL: the compiler would not rebuild with the enumerator ordinals flattened"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the enumerator-ordinal mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- subrange sizing ------------------------------------------------------
# TP3 sizes a subrange by its bounds: one byte when both are inside 0..255.
# Force two bytes and CellRec grows from 80 to 82, so the compile matrix's
# `data=84' becomes `data=86' - this one is visible at compile time, unlike the
# set/class cases above.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = 'IF (lo >= 0) AND (hi <= 255) AND (lo <= hi) THEN\n            size := 1'
assert s.count(old) == 1, 'the subrange size test found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, old.replace('size := 1', 'size := 2')))
PYX
then
    if rebuild_compiler; then
        expect_red "t63 red when a small subrange is sized two bytes" \
            "expected: OK 62 85" tests/run_compile_tests.sh
    else
        echo "  FAIL: the compiler would not rebuild with subranges forced to two bytes"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the subrange-size mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- an element's width ---------------------------------------------------
# A constant array subscript must hand the ELEMENT's size to the store, or the
# array's own size is used and `v[1] := 11' writes the whole array.  Drop the
# width and the compile matrix stays green (same OK 101 16) while execution
# sees 0s and a corrupted neighbour - the shape the width exists to prevent.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
# The element width is set once after the subscript list, for constant and
# run-time indices alike; dropping it makes the whole array's width win.
old = 'r.sz := arrs [ai].elem'
new = 'r.sz := 0'
assert s.count(old) == 1, 'the element width assignment found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, new))
PYX
then
    if rebuild_compiler; then
        expect_red "t65 red when a subscripted element keeps the array's width" \
            "t65_array_access" python3 tests/run_com_exec.py t65_array_access
    else
        echo "  FAIL: the compiler would not rebuild with the element width dropped"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the element-width mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- the file variable's size ---------------------------------------------
# Our file control block is FileVarSize bytes; shrink it and every file
# variable's slot moves, so t66's `data=269' becomes `data=265'.  Visible at
# compile time, so the matrix carries it.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = 'FileVarSize = 132 ;'
assert s.count(old) == 1, 'the file variable size found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, 'FileVarSize = 130 ;'))
PYX
then
    if rebuild_compiler; then
        expect_red "t66 red when the file variable is the wrong size" \
            "expected: OK 55 269" tests/run_compile_tests.sh
    else
        echo "  FAIL: the compiler would not rebuild with the file size changed"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the file-size mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- a string parameter's slot --------------------------------------------
# A string VALUE parameter's slot is its size (n+1 bytes).  Collapse SlotSize
# to 2 for it and BOTH sides agree on 2 - so the compiler still compiles and
# the matrix stays green - but the callee's "string" is just a length byte and
# garbage; t67 prints something other than `hello'.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = '   RETURN size\nEND SlotSize ;'
assert s.count(old) == 1, 'the SlotSize fallthrough found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, '   RETURN 2\nEND SlotSize ;'))
PYX
then
    if rebuild_compiler; then
        expect_red "t67 red when a string parameter's slot collapses to a word" \
            "t67_strparam" python3 tests/run_com_exec.py t67_strparam
    else
        echo "  FAIL: the compiler would not rebuild with SlotSize collapsed"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the string-slot mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- a string builtin is registered ---------------------------------------
# LENGTH has to be in the symbol table, or the name is simply unknown.  Remove
# its registration and t68 stops compiling (ERR 41), so the compile matrix
# carries this one.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = ('   i := NewSym ("LENGTH" , KBuiltin, BI_Length , 0, 0, 0, 0, FALSE) ;\n'
       '   symtab [i].defnd := TRUE ;\n'
       '   symtab [i].goPos := 0 ;          (* inline: the length byte, no entry *)\n')
assert s.count(old) == 1, 'the LENGTH registration found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, ''))
PYX
then
    if rebuild_compiler; then
        expect_red "t68 red when LENGTH is not registered" \
            "expected: OK 127 26" tests/run_compile_tests.sh
    else
        echo "  FAIL: the compiler would not rebuild without the LENGTH builtin"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the LENGTH-registration mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- a CRT builtin is registered ------------------------------------------
# ClrScr must be in the symbol table for t69 to compile.  Remove it and the
# fixture stops at ERR 41 against its expected OK 102 4.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = '   i := NewSym ("CLRSCR"  , KBuiltin, BI_ClrScr  , 0, 0, 0, 0, FALSE) ;\n   symtab [i].defnd := TRUE ;\n'
assert s.count(old) == 1, 'the CLRSCR registration found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, ''))
PYX
then
    if rebuild_compiler; then
        expect_red "t69 red when CLRSCR is not registered" \
            "expected: OK 158 5" tests/run_compile_tests.sh
    else
        echo "  FAIL: the compiler would not rebuild without the CLRSCR builtin"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the CLRSCR-registration mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- KBD is registered ----------------------------------------------------
# Without the predefined KBD file, `Read(Kbd, Ch)' is an unknown identifier and
# t70 stops compiling against its expected OK 55 5.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = ('   i := NewSym ("KBD", KVar, TText, FileVarSize, 1, 0, 0, FALSE) ;\n'
       '   symtab [i].isKbd := TRUE\n')
assert s.count(old) == 1, 'the KBD registration found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, ''))
PYX
then
    if rebuild_compiler; then
        expect_red "t70 red when KBD is not registered" \
            "expected: OK 60 6" tests/run_compile_tests.sh
    else
        echo "  FAIL: the compiler would not rebuild without the KBD file"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the KBD-registration mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- KEYPRESSED is registered ---------------------------------------------
# It is a FUNCTION, not a statement builtin, so it is registered like LENGTH
# and parsed in ParseAtom.  Remove it and t72 stops at ERR 41.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = ('   i := NewSym ("KEYPRESSED", KBuiltin, BI_KeyPressed, 0, 0, 0, 0, FALSE) ;\n'
       '   symtab [i].defnd := TRUE ;\n')
assert s.count(old) == 1, 'the KEYPRESSED registration found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, ''))
PYX
then
    if rebuild_compiler; then
        expect_red "t72 red when KEYPRESSED is not registered"             "expected: OK 138 6" tests/run_compile_tests.sh
    else
        echo "  FAIL: the compiler would not rebuild without the KEYPRESSED builtin"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the KEYPRESSED-registration mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- KeyPressed masks AL, not AX ------------------------------------------
# AH is still 0Bh after INT 21h, so `AND AL,1' leaves AX = 0B00h and the
# boolean test `CMP AX,0' calls the NO-KEY answer TRUE.  bootcom's handler
# happens to IRET the whole AX and returns AH=0, so qemu cannot see this;
# only the Exec86 oracle can, which is why t72 runs under both.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|   Ebyte (25H) ; Ebyte (01H) ; Ebyte (00H)|   Ebyte (24H) ; Ebyte (01H)|'; then
    if rebuild_compiler; then
        expect_red "t72 red when KeyPressed masks AL instead of AX"             "more" python3 tests/run_exec86.py t72_keypress
    else
        echo "  FAIL: the compiler would not rebuild with AND AL,1"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the AND AX,1 mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- a parameter may shadow a global --------------------------------------
# DupTest used to reject any name Search could see, so CALC's
# `IBMCh(var Ch: Char)' collided with the global `Ch'.  Make the level test
# unconditional and t73 is ERR 41 at the parameter name again.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|      IF symtab \[i\].level = lexnest THEN|      IF TRUE THEN|'; then
    if rebuild_compiler; then
        expect_red "t73 red when a parameter may not shadow a global"             "expected: OK 334 8" tests/run_compile_tests.sh
    else
        echo "  FAIL: the compiler would not rebuild with the old DupTest"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the DupTest level-test mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- a VAR parameter is not a value parameter -----------------------------
# Record the formal as a value parameter again (the exact old behaviour):
# the caller pushes a copy and IBMCh/Bump update that copy.  This compiles and
# runs, and prints H,H,41,a - which is why it is the execution, not the
# compile, that must catch it.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|               symtab \[i\].isVar := groupVar ;|               symtab \[i\].isVar := FALSE ;|'; then
    if rebuild_compiler; then
        expect_red "t73 red when a VAR parameter is recorded as value"             "FAIL" python3 tests/run_com_exec.py t73_varparam
    else
        echo "  FAIL: the compiler would not rebuild with VAR as value"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the VAR-as-value mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- a CASE range is a range ----------------------------------------------
# The old emitter compared the selector with lo and then with hi, both
# demanding equality, so `1..5' matched nothing.  Invert only the high test:
# i=5 in t74's `1..5' arm then falls through to ELSE, and the .out says
# `range'.  This is an execution failure, not a compile failure - the range
# compiled and ran, and answered wrongly.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|EmJcc (8FH, 0)|EmJcc (84H, 0)|'; then
    if rebuild_compiler; then
        expect_red "t74 red when a CASE range requires equality"             "FAIL" python3 tests/run_com_exec.py t74_caselist
    else
        echo "  FAIL: the compiler would not rebuild with the broken range test"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the CASE-range mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- an array subscript scales by the element size ------------------------
# Skip the multiply: for an Integer array a[i] is then base + (i - lo) BYTES,
# so a[2] reads the second byte of a[1].  Compiles, runs, wrong - an execution
# failure, which is what t75 is executed for.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|                  IF st # 1 THEN|                  IF FALSE THEN|'; then
    if rebuild_compiler; then
        expect_red "t75 red when an array subscript is not scaled"             "FAIL" python3 tests/run_com_exec.py t75_arrvar
    else
        echo "  FAIL: the compiler would not rebuild without the element scale"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the element-scale mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- a field width reaches the width-aware writer -------------------------
# Call wrint instead of wrintw.  The caller still pushes the value and the
# width and still cleans up four bytes, so wrint reads the WIDTH as its value
# and the stack stays balanced: t76 prints the widths, not the numbers.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|ent := TU_WrIntW ;|ent := TU_WrInt ;|'; then
    if rebuild_compiler; then
        expect_red "t76 red when a width calls the plain integer writer"             "FAIL" python3 tests/run_com_exec.py t76_width
    else
        echo "  FAIL: the compiler would not rebuild with the plain writer"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the width-entry mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- a 2-D subscript uses the row stride ----------------------------------
# Let every dimension use the ELEMENT size: `g[i,j]' then adds (i-lo0)*elem
# and (j-lo1)*elem instead of scaling the first by the second dimension's
# count.  1-D is unchanged, so t75 stays green; t77's 2-D element moves.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|               k := nd + 1 ;|               k := arrs \[ai\].n ;|'; then
    if rebuild_compiler; then
        expect_red "t77 red when the 2-D row stride is dropped"             "FAIL" python3 tests/run_com_exec.py t77_with
    else
        echo "  FAIL: the compiler would not rebuild without the row stride"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the row-stride mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- a WITH over an element keeps the element's offset ---------------------
# `with g[1,2]' must remember boff (2,3's predecessor); dropping it makes the
# body address g[1,1].  t77 sets g[1,2].a := 7 and reads it back.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|            withBoff \[withN\] := t.boff|            withBoff \[withN\] := 0|'; then
    if rebuild_compiler; then
        expect_red "t77 red when WITH forgets the element offset"             "FAIL" python3 tests/run_com_exec.py t77_with
    else
        echo "  FAIL: the compiler would not rebuild without the WITH offset"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the WITH-offset mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- a set field's constructor is sized by the TARGET ---------------------
# Write the default 32-byte set-of-Char length instead of the field's one
# byte: the store runs past Status into N and the neighbours.  t78 reads N
# back, so the overrun is visible.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|         WHILE k < r.setsize DO|         WHILE k < 32 DO|'; then
    if rebuild_compiler; then
        expect_red "t78 red when a set field stores 32 bytes, not its size"             "FAIL" python3 tests/run_com_exec.py t78_setfield
    else
        echo "  FAIL: the compiler would not rebuild with the 32-byte store"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the set-size mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- a field's set base offset is the ARRAY/RECORD's ----------------------
# `in' reads setoff + boff.  Forgetting the symbol's base (setoff := 0) makes
# sh[2,3].Status read absolute address 15 instead of sh+15.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|            r.setoff := symtab \[r.idx\].off ;|            r.setoff := 0 ;|'; then
    if rebuild_compiler; then
        expect_red "t78 red when a field's set base offset is dropped"             "FAIL" python3 tests/run_com_exec.py t78_setfield
    else
        echo "  FAIL: the compiler would not rebuild without the set base"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the set-base mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- a short literal sets the SOURCE length ---------------------------------
# Skip the min(source length, capacity): n stays at the field's capacity and
# the copy reads past the literal into the string pool, so 'abc' prints five
# characters.  t79's first line is 'abc'.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|         IF strLen \[src.strx\] < n THEN|         IF FALSE THEN|'; then
    if rebuild_compiler; then
        expect_red "t79 red when a short string literal keeps the capacity"             "FAIL" python3 tests/run_com_exec.py t79_strfield
    else
        echo "  FAIL: the compiler would not rebuild without the length min"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the literal-length mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- a DI-addressed string field stores its length --------------------------
# Store a zero length byte: the characters go to the field but every reader
# sees an empty string.  t79 writes 'xy' through WITH and prints it back.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|         EmStDiImm (0, n) ;|         EmStDiImm (0, 0) ;|'; then
    if rebuild_compiler; then
        expect_red "t79 red when a string field's length byte is zero"             "FAIL" python3 tests/run_com_exec.py t79_strfield
    else
        echo "  FAIL: the compiler would not rebuild with a zero length"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the string length-byte mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- the Real exponent bias is 129, not 128 -------------------------------
# byte 0 is E + 129 in CALC-PORT.md's measured table.  One less and every
# constant's exponent is wrong; the byte check reads the emitted code.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|   e := 129 + k ;|   e := 128 + k ;|'; then
    if rebuild_compiler; then
        if ./tests/run_compile_tests.sh --build-only >/dev/null 2>&1; then
            expect_red "the Real bytes red when the exponent bias is 128"                 "FAIL" python3 tests/check_realconst.py
        else
            echo "  FAIL: compiletest would not rebuild with the wrong bias"
            fail=$((fail + 1))
        fi
    else
        echo "  FAIL: the compiler would not rebuild with the wrong bias"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the Real-bias mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- the fraction is (a - 2^k), not a ------------------------------------
# Dropping the implicit 1 from the mantissa: 1.0 becomes 2.0, 3.0's bytes are
# wrong, and the measured table no longer appears.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|   n := a - p ;|   n := a ;|'; then
    if rebuild_compiler; then
        if ./tests/run_compile_tests.sh --build-only >/dev/null 2>&1; then
            expect_red "the Real bytes red when the implicit 1 is missing"                 "FAIL" python3 tests/check_realconst.py
        else
            echo "  FAIL: compiletest would not rebuild without the implicit 1"
            fail=$((fail + 1))
        fi
    else
        echo "  FAIL: the compiler would not rebuild without the implicit 1"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the implicit-1 mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- UpCase subtracts 32, not 33 ------------------------------------------
# The run-time fold; 'a' becomes '@'.  t81 prints A for 'a'.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|      EmSubAlImm (32) ;|      EmSubAlImm (33) ;|'; then
    if rebuild_compiler; then
        expect_red "t81 red when UpCase subtracts 33"             "FAIL" python3 tests/run_com_exec.py t81_upcase
    else
        echo "  FAIL: the compiler would not rebuild with a 33 fold"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the UpCase-fold mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- a set membership indexes bytes with DIV 8 ----------------------------
# Two SHRs instead of three divide by 4: 'Y' (89) picks byte 22 of a 32-byte
# literal, whose bits are clear.  t82 expects the first line to be 'yes'.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|      EmShrAx1 () ; EmShrAx1 () ; EmShrAx1 () ;|      EmShrAx1 () ; EmShrAx1 () ;|'; then
    if rebuild_compiler; then
        expect_red "t82 red when set membership divides by 4, not 8"             "FAIL" python3 tests/run_com_exec.py t82_setin
    else
        echo "  FAIL: the compiler would not rebuild with two shifts"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the set-index shift mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- real output goes through real_write, not the placeholder ----------
# TU_WrReal is still the "?REAL?" marker; the compiler's new real arm must
# select TU_RealWrite.  t84 prints a real field with variable width/decimals.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|                        ent := TU_RealWrite ;|                        ent := TU_WrReal ;|'; then
    if rebuild_compiler; then
        expect_red "t84 red when real output falls back to the placeholder" \
            "t84_realwrite" python3 tests/run_com_exec.py t84_realwrite
    else
        echo "  FAIL: the compiler would not rebuild with the placeholder"
        fail=$((fail + 1))
    fi
fi
cp "$SAVED_C" Compiler.mod

# --- a DI-addressed string field is an address, not a scalar ------------
# `if A[I].Contents <> '' then' must push DI; the old EmPushStrAddr refused
# kind 5 (ENoLib) and SaveLeft would try to load the whole string.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = """   IF r.kind = 5 THEN
      (* a string element/field computed through DI - `Sheet[X,Y].Contents'"""
assert s.count(old) == 1, 'the kind-5 string branch found %d times' % s.count(old)
open(p, 'w').write(s.replace(old, """   IF r.kind = 4 THEN
      (* a string element/field computed through DI - `Sheet[X,Y].Contents'"""))
PYX
then
    if rebuild_compiler; then
        expect_red "t83 red when a string field address is refused" \
            "t83_strfield_cmp" python3 tests/run_com_exec.py t83_strfield_cmp
    else
        echo "  FAIL: the compiler would not rebuild without the kind-5 push"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the kind-5 string-field mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# --- real_write pads from the WIDTH, not from the length ----------------
# The pad is width - length; using the length for both makes it zero, so every
# right-justified field loses its leading spaces.  rt_exec checks exact output.
cp "$SAVED" Runtime.mod
if mutate Runtime.mod 's|   MovAxData (D_FMTW) ;|   MovAxData (D_FMTLEN) ;|'; then
    if "$GM2" -fiso -c Runtime.mod >/dev/null 2>&1; then
        expect_red "real_write red when the pad uses the length" \
            "real_write" python3 tests/rt_exec.py
    else
        echo "  FAIL: the runtime would not rebuild with the pad mutation"
        fail=$((fail + 1))
    fi
fi
cp "$SAVED" Runtime.mod
"$GM2" -fiso -c Runtime.mod >/dev/null 2>&1

# --- set_op's intersection really ANDs the two bytes ---------------------
# 20 D0 is AND AL,DL; 20 C2 is AND DL,AL and leaves AL (the left byte), which
# is exactly the bug this rung fixed.  The exact-byte set_op cases catch it.
cp "$SAVED" Runtime.mod
if mutate Runtime.mod 's|PROCEDURE AndAlDl ; BEGIN B (20H) ; B (0D0H)|PROCEDURE AndAlDl ; BEGIN B (20H) ; B (0C2H)|'; then
    if "$GM2" -fiso -c Runtime.mod >/dev/null 2>&1; then
        expect_red "set_op red when intersection uses the wrong AND operand" \
            "set_op" python3 tests/rt_exec.py
    else
        echo "  FAIL: the runtime would not rebuild with the AND mutation"
        fail=$((fail + 1))
    fi
fi
cp "$SAVED" Runtime.mod
"$GM2" -fiso -c Runtime.mod >/dev/null 2>&1

# --- set union is OR, not intersection -----------------------------------
# t85's `union' line is `Status := Status + [C]'; choosing intersection there
# loses C (and the later difference line too).  This pins the compiler's
# operator-to-runtime mapping, not just the runtime core.
cp "$SAVED_C" Compiler.mod
if mutate_compiler 's|               SetBinEmit (1, left, right, r)|               SetBinEmit (0, left, right, r)|'; then
    if rebuild_compiler; then
        expect_red "t85 red when set addition becomes intersection" \
            "t85_setops" python3 tests/run_com_exec.py t85_setops
    else
        echo "  FAIL: the compiler would not rebuild with set + as *"
        fail=$((fail + 1))
    fi
fi
cp "$SAVED_C" Compiler.mod

# --- Succ increments, Pred decrements ------------------------------------
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = """         IF symtab [idx].cls = BI_Succ THEN
            EmIncAx ()
         ELSE
            EmDecAx ()"""
assert s.count(old) == 1, 'the Succ branch found %d times' % s.count(old)
open(p, 'w').write(s.replace(old, """         IF symtab [idx].cls = BI_Succ THEN
            EmDecAx ()
         ELSE
            EmDecAx ()"""))
PYX
then
    if rebuild_compiler; then
        expect_red "t86 red when Succ decrements" \
            "t86_succ" python3 tests/run_com_exec.py t86_succ
    else
        echo "  FAIL: the compiler would not rebuild with Succ as Pred"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the Succ mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

if rebuild_compiler; then
    if python3 tests/run_com_exec.py >/dev/null 2>&1; then
        echo "  ok: every executed fixture passes on the restored sources"
        pass=$((pass + 1))
    else
        echo "NOT RESTORED: run_com_exec.py is red after restoring the sources"
        python3 tests/run_com_exec.py 2>&1 | grep -i fail | head -3 | sed 's/^/       /'
        fail=$((fail + 1))
    fi
else
    echo "NOT RESTORED: the compiler would not rebuild"
    fail=$((fail + 1))
fi

echo
echo "== the second execution oracle (run_exec86.py)"
# Everything above runs the image under qemu-system-i386.  This one runs the
# SAME image inside shell/Exec86.mod, this project's own in-process 8086
# interpreter, and requires its output to agree with BOTH the hand-derived .out
# and qemu, byte for byte.  Two execution checks that could only ever agree
# with each other would be one check: the point of this one is that it was
# written against the 8086's own reference rather than against qemu, whose
# lowest CPU model is a 486 and whose `0F 84' is an ordinary JZ.
#
# So the only mutation worth writing here is one qemu cannot make at all - the
# interpreter's own reading of the machine.  Cond is that reading: nibble 4 is
# JE, and inverting it swaps the two arms of every `=' in every program.  The
# emitted bytes, the sizes and the compile matrix are untouched, because
# nothing is emitted here - the fault is in who interprets it.
#
# Exec86.mod is recompiled explicitly rather than left to the harness:
# ensure_exec86run() notices the source changed and RELINKS, but does not
# recompile it, so a mutated source with a stale object would link the good
# interpreter straight back in and stay green - which is the trap its own
# docstring records, and the reason this case compiles first.
#
# SAVED_E itself was taken at the top of this file, next to the EXIT trap that
# puts it back.

if python3 - <<'PYX'
p = 'Exec86.mod'
s = open(p).read()
old = "| 4H  : r := ZF"
new = "| 4H  : r := NOT ZF                    (* MUTATION: JE inverted *)"
assert s.count(old) == 1, 'the JE arm of Cond found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, new))
PYX
then
    if $GM2 -fiso -c Exec86.mod >/dev/null 2>&1; then
        expect_red "the interpreter's own oracle catches JE inverted" \
            "t33_cmpops" python3 tests/run_exec86.py t33_cmpops
    else
        echo "  FAIL: Exec86.mod would not compile with JE inverted"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the Cond JE mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_E" Exec86.mod

# And the check on the RESTORED interpreter, because a green above could also
# come from a mutation that never took and an object left mutated by a run
# that died in between.
if $GM2 -fiso -c Exec86.mod >/dev/null 2>&1; then
    if python3 tests/run_exec86.py >/dev/null 2>&1; then
        echo "  ok: run_exec86 green on the restored interpreter"
        pass=$((pass + 1))
    else
        echo "NOT RESTORED: run_exec86.py is red after restoring Exec86.mod"
        python3 tests/run_exec86.py 2>&1 | grep -i "fail" | head -3 | sed 's/^/       /'
        fail=$((fail + 1))
    fi
else
    echo "NOT RESTORED: Exec86.mod would not recompile"
    fail=$((fail + 1))
fi

echo
echo "== the R key: compile, poke, run, report (runtest.py)"
# The only check in the project that exercises CmdRun.  Everything above looks
# at bytes, or at what qemu says the image does; this one drives the shell
# through a pty the way a person would, presses R, and compares the GUEST's
# output against the fixture's hand-derived .out - so it fails on things no
# byte check can see and no file records either, because R writes no file at
# all (which is itself asserted).
#
# The mutation is the poke loop's count.  With n = 0 nothing is copied into
# the interpreter, loadHi stays where Clear86 left it - 0100h - and Run86
# faults on its very first step, "execution left the loaded image", before the
# guest has executed a single instruction.  That is fast and deterministic, which
# matters: the obvious alternative (poking the image somewhere else) leaves the
# machine executing zeros and buys a step-limit timeout instead of a finding.
cp "$SAVED_SH" Shell.mod
if python3 - <<'PYX'
p = 'Shell.mod'
s = open(p).read()
old = "   n := LinkSize () ;"
new = "   n := 0 ;                           (* MUTATION: nothing is poked *)"
assert s.count(old) == 1, 'the poke count in CmdRun found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, new))
PYX
then
    if make > ../tmp/nonvacuity.make.log 2>&1; then
        expect_red "the R check catches an image that was never poked" \
            "AH=4Ch exit" python3 tests/runtest.py
    else
        echo "  FAIL: the shell would not rebuild with the poke loop neutered"
        tail -5 ../tmp/nonvacuity.make.log | sed 's/^/       /'
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the CmdRun poke mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_SH" Shell.mod

if make > ../tmp/nonvacuity.make.log 2>&1; then
    if python3 tests/runtest.py >/dev/null 2>&1; then
        echo "  ok: runtest green on the restored shell"
        pass=$((pass + 1))
    else
        echo "NOT RESTORED: runtest.py is red after restoring Shell.mod"
        python3 tests/runtest.py 2>&1 | grep -i "fail" | head -3 | sed 's/^/       /'
        fail=$((fail + 1))
    fi
else
    echo "NOT RESTORED: the shell would not rebuild"
    tail -5 ../tmp/nonvacuity.make.log | sed 's/^/       /'
    fail=$((fail + 1))
fi

echo
echo "== 8086 legality of the conditional lowering (check_8086.py)"
# This whole section exists because of a fault that every other check in the
# project was blind to, and being blunt about WHY is the point of listing it.
#
# EmJcc and EmSetcc emitted `0F 8x rel16' and `0F 9x rel8'.  `0F' is a
# 386-and-later opcode prefix; the 8086 has none.  So EVERY conditional branch
# and EVERY comparison in EVERY compiled program was an illegal instruction on
# the machine this compiler targets.  And all of the following were green while
# it was: the compile matrix, the .COM layout checker, the runtime golden, the
# emitter audit, and the whole execution suite answering correctly under qemu.
#
# Two reasons, and the second is the one worth keeping:
#   1. qemu-system-i386 has no 8086 model.  Its lowest is 486, where `0F 84' is
#      a perfectly ordinary JZ.  So the execution oracle CANNOT see this class
#      of fault, ever.
#   2. FCML is this project's INDEPENDENT disassembler, and FCML's -m16 mode is
#      a 386.  The one tool whose job is to say "this is not a real instruction"
#      was architecturally guaranteed to agree with the bug.
#
# So a check was needed that asks the question nothing else was asking.  The
# five mutations below are the mutations that check has to catch, and each was
# run by hand and confirmed red BEFORE this section existed.
#
# M4 and M5 are the interesting pair.  M4 is a fault this project actually
# introduced while fixing the above: EmJcc jumps TO its target, but the 8086
# shape steps OVER a 3-byte EJMP, so the naive port inverts every conditional
# in every program.  It was caught by execution, not by any byte check.  M5 is
# the partial version -- the inversion dropped for the IF and CASE sites only,
# kept for FOR -- and MEASURING that is what produced clause H, because the
# check was blind to M5 as first written: IF declares nibble 4, CASE declares
# 5, they negate into each other, and both are declared, so nothing complained
# while every conditional in every program took the wrong path.  FOR declares
# C and F, whose negations D and E are declared for nothing at all, so the
# whole-suite version was caught by luck.
#
# Note these need `rebuild_compiler' only to refresh comtest; check_8086.py
# relinks the fixtures itself.  Getting that wrong is how this section's first
# draft reported a mutation as VACUOUS: the build was skipped, a stale comtest
# ran the GOOD compiler, and the check passed.  A helper that exits non-zero
# makes `if mutate_x; then' false and the case is silently skipped, which looks
# exactly like a pass -- so rebuild_compiler is checked, not assumed.

# M1: the original defect, restored verbatim.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = """   Ebyte (JccShortInv (cc)) ;        (* Jcc_s, taken when cc does NOT hold *)
   Ebyte (03H) ;                     (* rel8: step over the 3-byte EJMP *)
   RETURN EmJmpNear (target)         (* target = 0 => forward, see above *)"""
new = """   Ebyte (0FH) ; Ebyte (cc) ; Eword (0) ;
   IF target = 0 THEN
      RETURN nPatch
   END ;
   RETURN 0"""
assert s.count(old) == 1, 'EmJcc body found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, new))
PYX
then
    if rebuild_compiler; then
        expect_red "check_8086 catches a 0F 8x branch (the original bug)" \
            "0F 84" python3 tests/check_8086.py
    else
        echo "  FAIL: the compiler would not rebuild with the 0F branch"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the 0F branch mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# M2: the other original defect, SETcc plus the MOV AH,0 it needed.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = """   Ebyte (0B8H) ; Eword (1) ;                           (* MOV AX,#0001 *)
   Ebyte (JccShort (cc)) ;            (* taken when the comparison HOLDS *)
   Ebyte (01H) ;                     (* rel8: step over the DEC AX *)
   Ebyte (48H)                                          (* DEC AX *)"""
new = """   Ebyte (0FH) ; Ebyte (cc) ; Ebyte (0C0H) ;
   EmMovAh0 ()"""
assert s.count(old) == 1, 'EmSetcc body found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, new))
PYX
then
    if rebuild_compiler; then
        expect_red "check_8086 catches a 0F 9x SETcc (the original bug)" \
            "0F 9F C0" python3 tests/check_8086.py
    else
        echo "  FAIL: the compiler would not rebuild with the 0F SETcc"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the 0F SETcc mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# M4: the polarity inversion, everywhere.  Note the expected text is clause H's,
# not a shape complaint: every byte here is a legal 8086 shape, which is the
# entire reason a separate clause had to be written.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = '   Ebyte (JccShortInv (cc)) ;        (* Jcc_s, taken when cc does NOT hold *)'
new = '   Ebyte (JccShort (cc)) ;           (* MUTATION: inversion dropped *)'
assert s.count(old) == 1, 'EmJcc Ebyte found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, new))
PYX
then
    if rebuild_compiler; then
        expect_red "clause H catches the branch polarity inverted everywhere" \
            "but reading the source says" python3 tests/check_8086.py
    else
        echo "  FAIL: the compiler would not rebuild with the inversion dropped"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the polarity mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# M5: the same inversion dropped for the IF and CASE sites ONLY.  This one is
# the reason clause H exists: it was run by hand and the check stayed GREEN,
# and FOR's C/F nibbles were the only reason the whole-suite version (M4)
# happened to be caught.
cp "$SAVED_C" Compiler.mod
if python3 - <<'PYX'
p = 'Compiler.mod'
s = open(p).read()
old = '   Ebyte (JccShortInv (cc)) ;        (* Jcc_s, taken when cc does NOT hold *)'
new = """   IF (cc = 84H) OR (cc = 85H) THEN
      Ebyte (JccShort (cc))            (* MUTATION: no inversion here *)
   ELSE
      Ebyte (JccShortInv (cc))
   END ;"""
assert s.count(old) == 1, 'EmJcc Ebyte found %d times -- update this mutation' % s.count(old)
open(p, 'w').write(s.replace(old, new))
PYX
then
    if rebuild_compiler; then
        expect_red "clause H catches the inversion dropped for IF and CASE only" \
            "t22_case" python3 tests/check_8086.py
    else
        echo "  FAIL: the compiler would not rebuild with the partial inversion"
        fail=$((fail + 1))
    fi
else
    echo "  BROKEN CASE: the partial-inversion mutation did not apply"
    fail=$((fail + 1))
fi
cp "$SAVED_C" Compiler.mod

# And the check on the RESTORED compiler, so a green above cannot come from a
# mutation that failed to take and left the real defect in place.
if rebuild_compiler; then
    if python3 tests/check_8086.py >/dev/null 2>&1; then
        echo "  ok: check_8086 green on the restored compiler"
        pass=$((pass + 1))
    else
        echo "NOT RESTORED: check_8086.py is red after restoring Compiler.mod"
        python3 tests/check_8086.py 2>&1 | grep -m3 -- '  - ' | sed 's/^/       /'
        fail=$((fail + 1))
    fi
else
    echo "NOT RESTORED: the compiler would not rebuild"
    fail=$((fail + 1))
fi

echo
echo "== the emitter-name audit of Compiler.mod (audit_helpers.py)"
# These need no rebuild: the audit reads the SOURCE, not the built object, so
# they are the cheapest cases here and they cover the module the audit used
# not to look at at all.  That is the point of the section: the audit reported
# "every helper agrees with its name" for a module it had never examined, and
# EmXchgAxCx was `93` (XCHG BX,AX) under a name that says XCHG AX,CX for the
# whole life of the project.  Two of these five are for faults that were real.
SAVED_C2=../tmp/nonvacuity.Compiler.mod.2
SAVED_R2=../tmp/nonvacuity.Runtime.mod.2
cp Compiler.mod "$SAVED_C2" || exit 1
cp Runtime.mod "$SAVED_R2" || exit 1
restore_audit_sources () {
    cp "$SAVED_C2" Compiler.mod
    cp "$SAVED_R2" Runtime.mod
}

AUD="python3 tests/audit_helpers.py"

# 1. THE fault.  91h is XCHG AX,CX; 93h is XCHG BX,AX.  Both are one byte, so
#    the compile matrix never moved and the byte counts never moved.
cp "$SAVED_C2" Compiler.mod
mutate Compiler.mod 's|^   Ebyte (91H)$|   Ebyte (93H)|'
expect_red "audit catches XchgAxCx emitting XCHG BX,AX" \
    "exchanges Ax and Bx" $AUD
restore_audit_sources

# 2. the coverage check itself.  A parameter list that find_helpers does not
#    accept is exactly how the real emitter was missed, and the inventory is
#    scanned separately on purpose so this can be caught.  Without the
#    independent scan this case is silent, because both lists would come from
#    the same parser and agree that the helper does not exist.
cp "$SAVED_C2" Compiler.mod
mutate Compiler.mod 's|^PROCEDURE EmXchgAxCx () ;$|PROCEDURE EmXchgAxCx (why : CARDINAL) ;|'
expect_red "audit reports an emitter it cannot reach, rather than skipping it" \
    "never examined it" $AUD
restore_audit_sources

# 3. EmXchgAxDx was named EmMoveAxDx, which said MOV where the bytes say XCHG.
#    93h here is XCHG AX,BX - one letter away, the exact class of mistake the
#    name is supposed to make impossible.
cp "$SAVED_C2" Compiler.mod
mutate Compiler.mod 's|^   Ebyte (92H)$|   Ebyte (93H)|'
expect_red "audit catches XchgAxDx emitting XCHG BX,AX" \
    "XchgAxDx" $AUD
restore_audit_sources

# 4. CmpArgW0's [BP+2] written as the 386 SIB form, which decodes on a 8086 as
#    [SI+24h].  A real bug: the runtime was clearing the wrong memory.
cp "$SAVED_R2" Runtime.mod
mutate Runtime.mod 's|   B (83H) ; B (7EH) ; B (2) ; B (0) ;|   B (83H) ; B (7CH) ; B (24) ; B (0) ; B (0) ;|'
expect_red "audit catches the [SI+24h] encoding of [BP+2]" \
    "memory base is 'si" $AUD
restore_audit_sources

# 5. MovAxSp is POP then PUSH, because MOV AX,[SP] does not exist on an 8086.
#    Dropping the POP leaves the stack one word short - a fault in the shape,
#    not in a byte value.
cp "$SAVED_C2" Compiler.mod
python3 - <<'PYEOF'
p='Compiler.mod'; s=open(p).read()
a="   Ebyte (58H) ;                     (* POP AX  *)\n"
assert s.count(a)==1, "EmMovAxSp POP line not found -- update this mutation"
open(p,'w').write(s.replace(a, ""))
PYEOF
expect_red "audit catches MovAxSp with its POP missing" \
    "MovAxSp" $AUD
restore_audit_sources

# 6. The two-instruction shape: IDIV is CWD then IDIV, and dropping the CWD
#    leaves an un-sign-extended dividend in DX:AX.  Both are still present as
#    a two-step spec, so a missing step has to be visible.
cp "$SAVED_C2" Compiler.mod
mutate Compiler.mod 's|   Ebyte (99H) ; Ebyte (0F7H) ; Ebyte (0F9H)|   Ebyte (0F7H) ; Ebyte (0F9H)|'
expect_red "audit catches IDiv without the CWD that extends the dividend" \
    "IDivAxCx" $AUD
restore_audit_sources

# 7. The byte under EmXorAl01's name, and the row in PATTERNS that was added
#    to admit it.  `34 01' is XOR AL,#01 - the boolean NOT, and the one emitter
#    in Compiler.mod with no ModRM byte at all.  A grammar row nobody has ever
#    seen reject anything cannot be trusted to accept only the truth, so here
#    is the rejection: `34 02' is the same length, decodes just as cleanly, and
#    `not x' would flip bit 1 instead of bit 0.
cp "$SAVED_C2" Compiler.mod
mutate Compiler.mod 's|^   Ebyte (34H) ; Ebyte (01H)|   Ebyte (34H) ; Ebyte (02H)|'
expect_red "audit catches EmXorAl01 emitting xor al,#2 under a name saying #1" \
    "XorAl01" $AUD
restore_audit_sources

# 7b. The other half of that row: the opcode gate.  34h is XOR AL,#imm and
#     35h is XOR AX,#imm - a word, not a byte, under a name that says AL.  The
#     row is pinned to {034h} on purpose, and a pin that has never been asked
#     to hold is a pin.  The report is the one thing the row above cannot
#     produce: with no reading at all, the helper falls out of the grammar.
cp "$SAVED_C2" Compiler.mod
mutate Compiler.mod 's|^   Ebyte (34H) ; Ebyte (01H)|   Ebyte (35H) ; Ebyte (01H)|'
expect_red "the opcode gate rejects XOR AX under an XOR AL name" \
    "no name pattern accepts it" $AUD
restore_audit_sources

if $AUD >/dev/null 2>&1; then
    echo "  ok: the audit passes on both restored sources"
    pass=$((pass + 1))
else
    echo "NOT RESTORED: the audit is red after restoring the sources"
    $AUD 2>&1 | sed 's/^/       /'
    fail=$((fail + 1))
fi

echo
echo "== the BP contract rt_exec.py checks before it starts a machine"
# wrchar and wrbool both borrowed BP to reach their argument -- [SP] is not
# encodable in 16-bit mode -- and neither saved it.  The driver's cursor into
# the case record lives in BP precisely because BP is the one register an entry
# may keep, so "wrchar borrowed it and did not give it back" sent the second
# call to a garbage address, the machine triple-faulted, and the run printed the
# record header twice and hung.  Both the golden and the audit call that shape
# CORRECT: the bytes are well formed, every branch is on a boundary, the size
# is unchanged, and the decode says exactly what it says.  So the rule is now
# checked directly, and these two cases are what make that check more than a
# claim.
#
# rt_exec.py needs the whole runtime rebuilt and then boots 36 machines, so this
# section is the slow one.  The baseline comes first and is asserted: a case
# that mutates a red tree proves nothing.
SAVED_R3=../tmp/nonvacuity.Runtime.mod.3
cp Runtime.mod "$SAVED_R3" || exit 1

if rebuild; then
    if python3 tests/rt_exec.py >/dev/null 2>&1; then
        echo "  ok: baseline - rt_exec.py passes on the unmutated runtime"
        pass=$((pass + 1))
    else
        echo "  FAIL: the baseline is already red, so the cases below prove"
        echo "        nothing - fix the baseline before reading them"
        python3 tests/rt_exec.py 2>&1 | tail -3 | sed 's/^/       /'
        fail=$((fail + 1))
    fi
else
    echo "  FAIL: could not rebuild the runtime for the baseline"
    fail=$((fail + 1))
fi

# 1. THE fault: drop the PUSH, exactly as EmitWrChar was written.  This is the
#    shape the behavioural case found, so the byte-level check must find it too
#    -- a check that only the expensive test can trip is a check that has not
#    been made to earn its place.
cp "$SAVED_R3" Runtime.mod
python3 - <<'PYEOF'
p = 'Runtime.mod'
s = open(p).read()
a = '   M ("wrchar") ;\n   PushBp ; MovBpSp ;\n'
assert s.count(a) == 1, "EmitWrChar prologue not found exactly once"
open(p, 'w').write(s.replace(a, '   M ("wrchar") ;\n   MovBpSp ;\n'))
PYEOF
if rebuild; then
    expect_red "the BP contract catches wrchar borrowing BP unsaved" \
        "borrows BP but does not open with" python3 tests/rt_exec.py
else
    echo "  FAIL: the runtime would not rebuild with the PUSH removed"
    fail=$((fail + 1))
fi
cp "$SAVED_R3" Runtime.mod

# 2. The mirror image: push it and never pop it.  A different one-instruction
#    omission with the same consequence for a caller, and the reason the rule
#    asks for the 5D and not just the 55.
cp "$SAVED_R3" Runtime.mod
mutate Runtime.mod 's|^   MovSpBp ; PopBp ;$|   MovSpBp ;|'
if rebuild; then
    expect_red "the BP contract catches a BP that is pushed and never popped" \
        "pushes BP but never pops it" python3 tests/rt_exec.py
else
    echo "  FAIL: the runtime would not rebuild with the POP removed"
    fail=$((fail + 1))
fi
cp "$SAVED_R3" Runtime.mod

# 3. The scan's other silent failure: a rule that matches nothing looks exactly
#    like a rule that passes.  The pattern the check looks for is changed to one
#    the blob does not contain -- MOV BP,DI, which the runtime has no reason to
#    emit -- so the check has examined thirteen entries and matched nothing and
#    MUST say so rather than report a clean sweep.  This is the general shape of
#    the fault this project keeps making: a check whose SUBJECT has drifted
#    reports a confident answer about the wrong thing.
cp "$SAVED_R3" Runtime.mod
SAVED_X=../tmp/nonvacuity.rt_exec.py
cp tests/rt_exec.py "$SAVED_X" || exit 1
mutate tests/rt_exec.py 's|^MOV_BP_SP = b"\\x8b\\xec" .*$|MOV_BP_SP = b"\\x8b\\xed"               # MOV BP,DI: never emitted|' \
expect_red "a check that matched nothing is a failure, not a pass" \
    "matched nothing" python3 tests/rt_exec.py
cp "$SAVED_X" tests/rt_exec.py

if rebuild; then
    if python3 tests/rt_exec.py >/dev/null 2>&1; then
        echo "  ok: rt_exec.py passes on the restored source"
        pass=$((pass + 1))
    else
        echo "NOT RESTORED: rt_exec.py is red after restoring Runtime.mod"
        python3 tests/rt_exec.py 2>&1 | tail -3 | sed 's/^/       /'
        fail=$((fail + 1))
    fi
else
    echo "NOT RESTORED: the runtime would not rebuild"
    fail=$((fail + 1))
fi

# 4. The GOLDEN and the entry goldens, which are the other half of the same
#    rule.  rt_exec.py states the contract; check_runtime.py pins the bytes.
#    They are separate mechanisms and the case below is what shows the golden
#    one works on its own -- a re-baseline of runtime.golden would otherwise
#    have absorbed the new prologues silently, and the next person to bless it
#    would have no way to know the PUSH and POP were ever missing.
cp "$SAVED_R3" Runtime.mod
python3 - <<'PYEOF'
p = 'Runtime.mod'
s = open(p).read()
a = '   M ("wrchar") ;\n   PushBp ; MovBpSp ;\n   MovAlArg4 ;\n   MovSpBp ; PopBp ;\n'
assert s.count(a) == 1, "EmitWrChar frame not found exactly once"
open(p, 'w').write(s.replace(a, '   M ("wrchar") ;\n   MovBpSp ;\n   MovAlArg2 ;\n   MovSpBp ;\n'))
PYEOF
if rebuild; then
    expect_red "the entry golden catches wrchar without its PUSH BP" \
        "entry wrchar starts 8B EC" python3 tests/check_runtime.py "$DUMP"
else
    echo "  FAIL: the runtime would not rebuild with wrchar's frame removed"
    fail=$((fail + 1))
fi
cp "$SAVED_R3" Runtime.mod

echo
echo "== the .COM layout check, and the runtime size it now measures"
# The checker used to RESTATE the runtime's size as a literal.  It had drifted
# from the runtime it described, so the header was read out of the code stream
# and EVERY linked fixture "failed" on it - a whole file of "failures" that were
# not findings at all.  A duplicated constant that has drifted does not fail
# loudly; it re-reports the same falsehood, in which the real failures hide.
# The size is now MEASURED from the image.
#
# These cases corrupt a real emitted .COM and require the checker to notice.
# They need the images, so they are built once and copied; the checker has a
# --check-only mode for exactly this, because its scratch directory is normally
# deleted on exit and a check that has only ever seen the truth is not a check.
KEEPDIR=../tmp/nonvacuity.com
rm -rf "$KEEPDIR"
TP_COM_KEEP=1 tests/run_com_tests.sh >../tmp/nonvacuity.com.log 2>&1
KEEP=$(sed -n 's/^TP_COM_KEEP=1: images left in //p' \
       ../tmp/nonvacuity.com.log | tail -1)
if [ -z "$KEEP" ] || [ ! -d "$KEEP" ]; then
    echo "  FAIL: could not obtain emitted .COM images for the layout cases"
    fail=$((fail + 1))
else
    COMCHK="tests/run_com_tests.sh --check-only"

    # 0. The baseline.  Every case below is a claim that a specific assertion
    #    turns red, and none of them means anything if the copies of untouched
    #    images already fail.  (The stale RT_SZ produced exactly that: a whole
    #    file of "failures" that were not findings.)  So this is asserted first,
    #    and a failure here is reported as a broken baseline rather than a red
    #    test.
    #
    #    The baseline is also WHERE THE HEADER OFFSET COMES FROM.  Cases 1 and 2
    #    used to carry it as the literal 435 and 439, which were ENT_SZ + the
    #    runtime size at the time -- 432.  Two 4-byte changes to the runtime
    #    later, both cases were editing the wrong bytes: 435 had become four
    #    bytes inside the runtime itself, so case 1 had stopped testing "the
    #    header cannot be found" and had started testing "the checker also
    #    notices you scribbled on the code", and case 2 had become a no-op
    #    that wrote the header where it already was.  Both still went red, for
    #    reasons the messages did not name, which is the whole problem: a
    #    hard-coded offset is a claim about the world that expires silently.
    #
    #    So the offset is read back out of the checker's own report on the
    #    untouched images, and the expected numbers below are ARITHMETIC ON IT.
    #    If the runtime grows again, these cases still test what they say.
    rm -rf "$KEEPDIR"; mkdir -p "$KEEPDIR"
    cp "$KEEP"/*.COM "$KEEP"/raw.txt "$KEEPDIR"/
    BASE_OUT=$($COMCHK "$KEEPDIR" 2>&1)
    if [ $? -eq 0 ]; then
        echo "  ok: baseline - untouched copies of the real images all pass"
        pass=$((pass + 1))
    else
        echo "  FAIL: the baseline is already red, so the cases below prove"
        echo "        nothing - fix the baseline before reading them"
        printf '%s\n' "$BASE_OUT" | grep FAIL | head -3 | sed 's/^/       /'
        fail=$((fail + 1))
    fi
    BASE_RT=$(printf '%s\n' "$BASE_OUT" \
        | sed -n 's/.*measured runtime size: \([0-9][0-9]*\) bytes.*/\1/p' \
        | head -1)
    if [ -z "$BASE_RT" ]; then
        echo "  FAIL: the checker did not report the runtime size it measured,"
        echo "        so the cases below cannot find the header to edit"
        fail=$((fail + 1))
        BASE_RT=0
    fi
    # The layout constants are ENT_SZ 3 and HDR_SZ 16 (tests/comimage.py), so the
    # header sits at hdrOff = 3 + rtSz and the entry jump's displacement must be
    # (hdrOff + 16) - 3.  The wanted number is therefore computed from the header
    # OFFSET, not from rtSz: the two differ by 3, and getting that backwards
    # produces a plausible-looking expectation three bytes out, which is how
    # this case came to expect "want 452" and then be reported as not proving
    # what it said.
    BASE_OFF=$((3 + BASE_RT))
    # Case 2 claims a runtime four bytes LONGER, so the header - and with it the
    # demanded jump target - moves four bytes further on.
    SHIFTED_WANT=$((BASE_OFF + 4 + 16 - 3))
    echo "       (measured runtime size $BASE_RT, header at image offset $BASE_OFF)"

    # 1. Break hdrDS so it no longer ties the header to its own offset.  The
    #    header must become UNFINDABLE and be reported as such - a checker that
    #    fell back to a remembered offset would report a confident number here,
    #    which is the failure mode the measurement was introduced to remove.
    rm -rf "$KEEPDIR"; mkdir -p "$KEEPDIR"
    cp "$KEEP"/*.COM "$KEEP"/raw.txt "$KEEPDIR"/
    python3 - "$KEEPDIR/t01_minimal.COM" "$BASE_OFF" <<'PYEOF'
import sys
p, off = sys.argv[1], int(sys.argv[2])
d = bytearray(open(p, 'rb').read())
d[off + 4:off + 6] = (0x1234).to_bytes(2, 'little')     # hdrDS, no longer self-consistent
open(p, 'wb').write(bytes(d))
PYEOF
    expect_red "a header that cannot be located is reported, not assumed" \
        "no program header found" $COMCHK "$KEEPDIR"

    # 2. The entry jump is now the locator: it names the first instruction,
    #    and the header sits HDR_SZ bytes before it.  Moving the jump four
    #    bytes off means no header is named, and the check must say so rather
    #    than fall back on a remembered runtime size.
    rm -rf "$KEEPDIR"; mkdir -p "$KEEPDIR"
    cp "$KEEP"/*.COM "$KEEP"/raw.txt "$KEEPDIR"/
    python3 - "$KEEPDIR/t01_minimal.COM" <<'PYEOF'
import sys
p = sys.argv[1]
d = bytearray(open(p, 'rb').read())
rel = int.from_bytes(d[1:3], 'little')
d[1:3] = ((rel + 4) & 0xFFFF).to_bytes(2, 'little')
open(p, 'wb').write(bytes(d))
PYEOF
    expect_red "the entry jump must name the header it follows" \
        "no program header found" $COMCHK "$KEEPDIR"

    # 3. The entry jump's opcode.  One byte, and the only assertion in the
    #    project that can see where execution STARTS.
    rm -rf "$KEEPDIR"; mkdir -p "$KEEPDIR"
    cp "$KEEP"/*.COM "$KEEP"/raw.txt "$KEEPDIR"/
    python3 - "$KEEPDIR/t01_minimal.COM" <<'PYEOF'
import sys
p = sys.argv[1]
d = bytearray(open(p, 'rb').read())
d[0] = 0xEA
open(p, 'wb').write(bytes(d))
PYEOF
    expect_red "the entry jump must be E9, not a near JMP" \
        "no program header found" $COMCHK "$KEEPDIR"

    # 4. The entry jump's target, moved one instruction earlier.  A .COM that
    #    lands in the middle of the prologue runs, prints something and exits
    #    cleanly, so no size or structure check can see this.
    rm -rf "$KEEPDIR"; mkdir -p "$KEEPDIR"
    cp "$KEEP"/*.COM "$KEEP"/raw.txt "$KEEPDIR"/
    python3 - "$KEEPDIR/t01_minimal.COM" <<'PYEOF'
import sys
p = sys.argv[1]
d = bytearray(open(p, 'rb').read())
d[1:3] = (100).to_bytes(2, 'little')
open(p, 'wb').write(bytes(d))
PYEOF
    expect_red "the entry jump must land on the first instruction" \
        "no program header found" $COMCHK "$KEEPDIR"

    rm -rf "$KEEPDIR"
fi

echo
echo "non-vacuity: $pass ok, $fail failed"
[ "$fail" -eq 0 ]