260 lines
9.4 KiB
Bash
Executable file
260 lines
9.4 KiB
Bash
Executable file
#!/usr/bin/env bash
|
|
# Part of JoeyLib, Copyright (c) 2026 Scott Duensing, under the MIT License.
|
|
# See LICENSE.md for license information.
|
|
# SPDX-License-Identifier: MIT
|
|
#
|
|
# verify-atarist-input.sh - Headless typed-character acceptance gate for
|
|
# the Atari ST port. Autostarts KEYS.PRG in Hatari (EmuTOS, GEMDOS
|
|
# drive), injects the RetroNet definition-of-done string through
|
|
# Hatari's command FIFO as IKBD key events, and reads the example's
|
|
# verification scanline back out of ST RAM with the built-in debugger.
|
|
# The row is planar (4 interleaved bitplane words per 16 pixels); the
|
|
# decode below reassembles the nibble pixels, which must equal the
|
|
# typed ASCII exactly.
|
|
#
|
|
# Injection encoding (Hatari 2.4 `hatari-event keypress <key>` parses a
|
|
# single-character argument as an ASCII character and a multi-character
|
|
# argument as an ST scancode): digits go as ASCII, '.' as scancode 52,
|
|
# and ':' as shift make (42) + ';' scancode 39 + shift break -- which
|
|
# also exercises the ISR's shift handling through the TOS keymap.
|
|
#
|
|
# Then the named keys the ST gives a second key for: the keypad's 8, 2, 4,
|
|
# and 6 as the arrows and its Enter as Return, each held alone (Hatari's
|
|
# keydown/keyup by scancode), and Up and the keypad's 8 held together with
|
|
# either let go first, which must leave Up down -- read off KEYS's row 4
|
|
# cells in ST RAM (scripts/lib/keysGate.sh; the cells' middles fall on a
|
|
# 16-pixel group's first pixel).
|
|
#
|
|
# Then KEYS again on German EmuTOS, whose Alt layer types @ [ ] on Alt with
|
|
# the keys U-umlaut, O-umlaut, and A-umlaut, and \ { } with Shift too; Alt
|
|
# with a letter types nothing, and a plain key goes on typing. And once more
|
|
# with the OS header made to say TOS 1.04 instead of EmuTOS (Hatari's
|
|
# debugger writes it before the boot): then the layer must come from
|
|
# src/atarist/stAltLayer.c's German table, found by the header's country,
|
|
# as on a German ST's own TOS, which keeps its layer out of Keytbl.
|
|
#
|
|
# Usage: scripts/verify-atarist-input.sh
|
|
# Requires: hatari, the EmuTOS images (US and German),
|
|
# build/atarist/bin/KEYS.PRG.
|
|
set -uo pipefail
|
|
|
|
repo=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
|
|
source "$repo/scripts/lib/joeyEnv.sh"
|
|
source "$repo/scripts/lib/keysGate.sh"
|
|
joeyNeed HATARI hatari
|
|
joeyNeed EMUTOS_IMG emutos
|
|
joeyNeed EMUTOS_DE_IMG emutos
|
|
bin_dir=$repo/build/atarist/bin
|
|
label=verify-atarist-input
|
|
|
|
target="192.168.1.10:6510"
|
|
# Alt with U-, O-, and A-umlaut (scancodes 0x1A, 0x27, 0x28), the same with
|
|
# Shift, Alt with A (nothing), then a plain 2 (an ASCII keypress).
|
|
deTarget='@[]\{}2'
|
|
|
|
[ -f "$bin_dir/KEYS.PRG" ] || { echo "$label: build KEYS.PRG first (make atarist)" >&2; exit 2; }
|
|
|
|
work=$(mktemp -d -t joeylib-st-input.XXXXXX)
|
|
cleanup() {
|
|
joeyStop "${hatari_pid:-}"
|
|
rm -rf "$work"
|
|
}
|
|
trap cleanup EXIT
|
|
|
|
|
|
send() {
|
|
timeout 5 bash -c "echo \"\$1\" > \"$work/cmd.fifo\"" _ "$1" || return 1
|
|
sleep 0.2
|
|
}
|
|
|
|
|
|
# hatariBoot TOS [HATARI-ARG...] -- KEYS in Hatari on that TOS image; sets
|
|
# hatari_pid and rowAddr, KEYS's verification row in ST RAM, once its A5A5
|
|
# sentinel is up.
|
|
# The video base is read from the shifter regs each attempt (planar
|
|
# sentinel = plane words 5000 A000 5000 A000).
|
|
hatariBoot() {
|
|
local tos="$1"
|
|
local i
|
|
local base
|
|
local addr
|
|
local row
|
|
shift
|
|
joeyStop "${hatari_pid:-}"
|
|
rm -f "$work/cmd.fifo"
|
|
(cd "$work" && exec env SDL_VIDEODRIVER=dummy SDL_AUDIODRIVER=dummy "$HATARI" \
|
|
--tos "$tos" \
|
|
--harddrive "$bin_dir" \
|
|
--gemdos-drive C \
|
|
--auto 'C:\KEYS.PRG' \
|
|
--cmd-fifo "$work/cmd.fifo" \
|
|
--fast-forward on \
|
|
"$@" \
|
|
> "$work/hatari.log" 2>&1) &
|
|
hatari_pid=$!
|
|
for i in $(seq 1 30); do
|
|
[ -p "$work/cmd.fifo" ] && break
|
|
sleep 1
|
|
done
|
|
[ -p "$work/cmd.fifo" ] || { echo "$label: FAIL - hatari never created the FIFO" >&2; exit 1; }
|
|
rowAddr=""
|
|
for i in $(seq 1 45); do
|
|
sleep 1
|
|
send 'hatari-debug m $ff8201 4' || continue
|
|
base=$(grep -E '^00FF8201:' "$work/hatari.log" | tail -1 | awk '{print $2 $4}')
|
|
[ -n "$base" ] || continue
|
|
addr=$(( (16#$base << 8) + 198 * 160 ))
|
|
send "hatari-debug m \$$(printf '%x' "$addr") 8" || continue
|
|
row=$(grep -E "^$(printf '%08X' "$addr"):" "$work/hatari.log" | tail -1)
|
|
if echo "$row" | grep -qi "50 00 a0 00 50 00 a0 00"; then
|
|
rowAddr=$addr
|
|
return 0
|
|
fi
|
|
done
|
|
echo "$label: FAIL - KEYS sentinel never appeared" >&2
|
|
tail -10 "$work/hatari.log" >&2
|
|
exit 1
|
|
}
|
|
|
|
|
|
# rowCheck TARGET -- KEYS's verification row must hold exactly TARGET.
|
|
rowCheck() {
|
|
sleep 3
|
|
send "hatari-debug m \$$(printf '%x' "$rowAddr") 160"
|
|
sleep 2
|
|
python3 - "$work/hatari.log" "$rowAddr" "$1" <<'PY'
|
|
import re
|
|
import sys
|
|
|
|
log, rowAddr, target = sys.argv[1], int(sys.argv[2]), sys.argv[3]
|
|
data = open(log, "rb").read().decode(errors="replace")
|
|
lines = {}
|
|
# Keep only the LAST dump of each address (earlier sentinel probes also match).
|
|
for m in re.finditer(r"^(00[0-9A-F]{6}): ((?:[0-9a-f]{2} ){1,16})", data, re.M):
|
|
lines[int(m.group(1), 16)] = m.group(2)
|
|
raw = b""
|
|
for off in range(0, 160, 16):
|
|
if rowAddr + off not in lines:
|
|
print(f"verify-atarist-input: FAIL - missing dump line at +{off}")
|
|
sys.exit(1)
|
|
raw += bytes.fromhex(lines[rowAddr + off].replace(" ", ""))
|
|
|
|
def group(words):
|
|
p = [int.from_bytes(words[i * 2:i * 2 + 2], "big") for i in range(4)]
|
|
return [((p[0] >> b) & 1) | (((p[1] >> b) & 1) << 1) |
|
|
(((p[2] >> b) & 1) << 2) | (((p[3] >> b) & 1) << 3)
|
|
for b in range(15, -1, -1)]
|
|
|
|
pix = []
|
|
for g in range(len(raw) // 8):
|
|
pix += group(raw[g * 8:g * 8 + 8])
|
|
|
|
if pix[0:4] != [0xA, 0x5, 0xA, 0x5]:
|
|
print(f"verify-atarist-input: FAIL - sentinel wrong: {pix[0:4]}")
|
|
sys.exit(1)
|
|
count = (pix[4] << 4) | pix[5]
|
|
chars = bytes((pix[8 + 2 * i] << 4) | pix[8 + 2 * i + 1] for i in range(count))
|
|
print(f"VERIFY-ST-INPUT count={count} chars={chars!r}")
|
|
if chars.decode("ascii", errors="replace") != target:
|
|
print(f'verify-atarist-input: FAIL - expected "{target}"')
|
|
sys.exit(1)
|
|
PY
|
|
}
|
|
|
|
|
|
hatariBoot "$EMUTOS_IMG"
|
|
|
|
# Type the string: digits as ASCII characters, '.' as scancode 52,
|
|
# ':' as shift + scancode 39.
|
|
for c in 1 9 2; do send "hatari-event keypress $c"; done
|
|
send "hatari-event keypress 52"
|
|
for c in 1 6 8; do send "hatari-event keypress $c"; done
|
|
send "hatari-event keypress 52"
|
|
send "hatari-event keypress 1"
|
|
send "hatari-event keypress 52"
|
|
for c in 1 0; do send "hatari-event keypress $c"; done
|
|
send "hatari-event keydown 42"
|
|
send "hatari-event keypress 39"
|
|
send "hatari-event keyup 42"
|
|
for c in 6 5 1 0; do send "hatari-event keypress $c"; done
|
|
rowCheck "$target" || exit 1
|
|
|
|
# KEYS's row 4 cells (scripts/lib/keysGate.sh's steps): the middle row's
|
|
# address, and each cell's 16-pixel group (examples/keys: 28x26 cells 32
|
|
# and 30 apart from (2, 2)), whose first pixel is the cell's middle. The
|
|
# keys by their ST scancodes.
|
|
cellAddr=$((rowAddr - (198 - 135) * 160))
|
|
declare -A stScan=([up]=72 [kp8]=104 [kp2]=110 [kp4]=106 [kp6]=108 [kpenter]=114)
|
|
KEYS_LABEL=$label
|
|
keysPress() {
|
|
send "hatari-event keydown ${stScan[$1]}"
|
|
}
|
|
keysRelease() {
|
|
send "hatari-event keyup ${stScan[$1]}"
|
|
}
|
|
keysRead() {
|
|
send "hatari-debug m \$$(printf '%x' "$cellAddr") 160"
|
|
sleep 1
|
|
python3 - "$work/hatari.log" "$cellAddr" <<'PY'
|
|
import re
|
|
import sys
|
|
|
|
log, addr = sys.argv[1], int(sys.argv[2])
|
|
GROUPS = (5, 7, 9, 11, 13, 15, 17)
|
|
data = open(log, "rb").read().decode(errors="replace")
|
|
lines = {}
|
|
for m in re.finditer(r"^(00[0-9A-F]{6}): ((?:[0-9a-f]{2} ){1,16})", data, re.M):
|
|
lines[int(m.group(1), 16)] = m.group(2)
|
|
raw = b""
|
|
for off in range(0, 160, 16):
|
|
raw += bytes.fromhex(lines.get(addr + off, "00 " * 16).replace(" ", ""))
|
|
digits = ""
|
|
for g in GROUPS:
|
|
colour = 0
|
|
for plane in range(4):
|
|
word = int.from_bytes(raw[g * 8 + plane * 2:g * 8 + plane * 2 + 2], "big")
|
|
colour |= ((word >> 15) & 1) << plane
|
|
digits += "1" if colour == 2 else ("0" if colour == 1 else "?")
|
|
print(digits)
|
|
PY
|
|
}
|
|
KEYS_SETTLE_SECONDS=1
|
|
keysRunSteps kp8 kp2 kp4 kp6 kpenter
|
|
if [ -n "$KEYS_FAILS" ]; then
|
|
echo "$label: FAIL - $KEYS_FAILS" >&2
|
|
exit 1
|
|
fi
|
|
|
|
# altLayerType -- the Alt layer's keys, as deTarget says.
|
|
altLayerType() {
|
|
send "hatari-event keydown 56"
|
|
for c in 26 39 40; do send "hatari-event keypress $c"; done
|
|
send "hatari-event keydown 42"
|
|
for c in 26 39 40; do send "hatari-event keypress $c"; done
|
|
send "hatari-event keyup 42"
|
|
send "hatari-event keypress 30"
|
|
send "hatari-event keyup 56"
|
|
send "hatari-event keypress 2"
|
|
}
|
|
|
|
|
|
# German EmuTOS's Alt layer, from its Keytbl tables.
|
|
hatariBoot "$EMUTOS_DE_IMG"
|
|
altLayerType
|
|
rowCheck "$deTarget" || exit 1
|
|
|
|
# The same as TOS 1.04 would show it: "XXXX" over the header's "ETOS"
|
|
# (offset 0x2C) and version 0x0104 (offset 2), in the 512 KB ROM at
|
|
# 0xE00000.
|
|
printf 'w $e0002c $58 $58 $58 $58\nw $e00002 $01 $04\n' > "$work/tos104.dbg"
|
|
hatariBoot "$EMUTOS_DE_IMG" --parse "$work/tos104.dbg"
|
|
send 'hatari-debug m $e0002c 4'
|
|
sleep 1
|
|
if ! grep -qi "^00E0002C: 58 58 58 58" "$work/hatari.log"; then
|
|
echo "$label: FAIL - the OS header still says EmuTOS: $(grep -i '^00E0002C:' "$work/hatari.log" | tail -1)" >&2
|
|
exit 1
|
|
fi
|
|
altLayerType
|
|
rowCheck "$deTarget" || exit 1
|
|
|
|
echo "$label: PASS (typed \"$target\", all ${#target} chars arrived via jlInputGetChar; $KEYS_STEPS named-key steps: the keypad's arrows and Enter, Up held with its second key; German EmuTOS's Alt layer typed \"$deTarget\", from its tables and as TOS 1.04 from the built-in German one)"
|