TP3/shell/tests/run_com_tests.sh

#!/bin/bash
# Build and run the .COM linker harness (tests/ComTest.mod), then verify every
# .COM it produced with an INDEPENDENT checker.
#
# The independent pass matters: ComTest computes the expectations from the same
# Compiler state it is testing, so a bug in the compiler would be invisible to
# it.  The Python pass re-derives what the file must contain - the runtime's
# first bytes, a zero gap, a size that covers the data area - from the
# constants only, and cross-checks.
set -u
D=/home/eric/Projets/Projets-Modula2/MyWork/TP3-comp/shell
GM2=/home/eric/bin/Modula2/Gm2/bin/gm2
cd "$D" || exit 9
FLAGS="-fiso"

echo "== support modules =="
[ -f Posix.o ] || cc -c Posix.c || exit 1
for m in TextBuf Compiler Runtime Linker; do
   $GM2 $FLAGS -c $m.mod >/tmp/cm_c_$m 2>&1 \
      || { echo "COMPILE_FAIL $m"; grep -m5 "error:" /tmp/cm_c_$m; exit 1; }
done
$GM2 $FLAGS -c tests/ComTest.mod >/tmp/cm_c_ComTest 2>&1 \
   || { echo "COMPILE_FAIL ComTest"; grep -m5 "error:" /tmp/cm_c_ComTest; exit 1; }

rm -f tests/ct.lst comtest
$GM2 $FLAGS -fgen-module-list=tests/ct.lst -o /dev/null \
    tests/ComTest.mod TextBuf.o Posix.o Compiler.o Runtime.o Linker.o \
    >/tmp/cm_p1 2>&1
p1=$?
$GM2 $FLAGS -fuse-list=tests/ct.lst -o comtest \
    tests/ComTest.mod TextBuf.o Posix.o Compiler.o Runtime.o Linker.o \
    >/tmp/cm_p2 2>&1
p2=$?
if [ $p2 -ne 0 ]; then
   echo "LINK_FAIL p1_rc=$p1 p2_rc=$p2"
   grep -E "error:|undefined" /tmp/cm_p2 | head -10
   exit 1
fi
echo "comtest built (p1_rc=$p1, phase 1 rc=1 is the expected rollup)"

# .COM files are written beside the harness, so run it in a scratch dir
OUT=$(mktemp -d) || exit 9
trap 'rm -rf "$OUT"' EXIT
cd "$OUT" || exit 9

ls "$D"/tests/fixtures/*.pas | "$D"/comtest > "$OUT/raw.txt" 2>&1
sed 's/^.*fixtures\///' "$OUT/raw.txt"

echo "----------------------------------------------------------------"
nok=$(grep -c "  OK  com=" "$OUT/raw.txt")
nerr=$(grep -c "  ERROR " "$OUT/raw.txt")
nbad=$(grep -cE "WRITE_COM_FAILED|CANNOT" "$OUT/raw.txt")
echo "linked: $nok .COM files, $nerr fixtures rejected at compile time, $nbad harness failures"

if [ "$nbad" -ne 0 ]; then
   echo "RESULT: FAIL (harness could not link every compiling fixture)"
   exit 1
fi

# ---- independent verification of the bytes on disk ------------------------
python3 - "$OUT" <<'PYEOF'
import sys, os, re, glob
out = sys.argv[1]

# Compiler layout constants, restated here on purpose: the checker must not
# ask the code under test what the answer is.
RTSZ  = 385                    # Runtime.RT_Size()
DATAB = RTSZ + 0x1000         # Compiler: data base = rtSz + 1000H
# initmem: MOV AX,AX / MOV DX,[SI+4] / MOV CX,[SI+8]
HEAD  = '8B C0 8B 54 04 8B 4C 08'

raw = open(os.path.join(out, 'raw.txt')).read()
rows = re.findall(r'(\S+\.pas)\s+OK\s+com=(\d+)\s+image=(\d+)\s+data=(\d+)\s+nonzeroInGap=(\d+)', raw)
if not rows:
    print('RESULT: FAIL (no linked fixtures found in output)')
    sys.exit(1)

bad = 0
for name, com, image, data, nzg in rows:
    com, image, data, nzg = int(com), int(image), int(data), int(nzg)
    # ComTest writes the .COM by BASENAME beside itself (it cannot graft a
    # directory onto a source path), so the checker must look for the bare
    # name, not the full source path the fixture was read from.
    path = os.path.join(out, os.path.basename(name)[:-4] + '.COM')
    errs = []
    if not os.path.exists(path):
        errs.append('no .COM file')
        d = b''
    else:
        d = open(path, 'rb').read()

    if d[:8].hex(' ').upper() != HEAD:
        errs.append('runtime not at offset 0 (first bytes %s)' % d[:8].hex(' ').upper())
    if len(d) != com:
        errs.append('file is %d bytes, harness said %d' % (len(d), com))
    if DATAB + data != len(d):
        errs.append('size %d != dataBase+data %d' % (len(d), DATAB + data))
    # the gap between the image and the data area must be entirely zero
    gap = d[image:DATAB]
    if any(gap):
        errs.append('%d non-zero bytes in the code/data gap' % sum(1 for b in gap if b))
    if nzg != 0:
        errs.append('harness itself reported %d non-zero gap bytes' % nzg)
    # the program must start exactly where the runtime ends
    if image < RTSZ:
        errs.append('image %d shorter than the runtime %d' % (image, RTSZ))
    # the program header sits at offset rtSz, and its words must describe the
    # image that is actually in the file
    if len(d) > RTSZ + 8:
        hdr = d[RTSZ:RTSZ+16]
        flag = int.from_bytes(hdr[0:2], 'little')
        cs   = int.from_bytes(hdr[2:4], 'little')
        ds   = int.from_bytes(hdr[4:6], 'little')
        heap = int.from_bytes(hdr[6:8], 'little')
        if flag != 1:
            errs.append('hdrFlag=%d' % flag)
        # hdrCS is pc, the end of the code, and the harness's `image` is
        # rtSz + code ALREADY - so the two are the same number.  Adding
        # RTSZ here counted the runtime twice.
        if cs != image:
            errs.append('hdrCS=%d, want %d (end of image)' % (cs, image))
        if ds != DATAB:
            errs.append('hdrDS=%d, want %d' % (ds, DATAB))
        if heap != DATAB + data:
            errs.append('hdrHeap=%d, want %d' % (heap, DATAB + data))

    if errs:
        bad += 1
        print('  %-24s FAIL  %s' % (os.path.basename(name)[:-4], '; '.join(errs)))
    else:
        print('  %-24s PASS  %d bytes' % (os.path.basename(name)[:-4], com))

print('----------------------------------------------------------------')
print('independent .COM check: %d checked, %d failed' % (len(rows), bad))
sys.exit(1 if bad else 0)
PYEOF
rc=$?
[ "$rc" -eq 0 ] || exit 1
echo "RESULT: ALL PASS"