AI_Slop/joeylib2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
joeylib2/scripts/verify-x68000-serial-mouse.sh

586 lines
23 KiB
Bash
Executable file
Raw Blame History

#!/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-x68000-serial-mouse.sh - the X68000's RS-232C port and mouse at once.
#
# Both live on the one Z8530 SCC: RS-232C on channel A, where JoeyLib's serial
# add-on owns the receive interrupt (src/x68000/x68kSccRxIsr.s), and the mouse
# on channel B, where the IOCS ROM owns the receive interrupt and solicits a
# packet every other Timer C tick. The chip has ONE register pointer for both
# channels, so a select-then-access register sequence split by the other
# side's interrupt goes to the wrong register, and the interrupt-under-service
# reset it swallows wedges the chip's interrupt chain. The serial and mouse
# gates each run one side alone; this one runs both together, hard, for long
# enough to matter.
#
# Boots SERMOUSE.X (examples/sermouse) under the patched MAME with SCC channel
# A on a null_modem socket and every SCC channel at the real chip's 3-byte
# receive FIFO (JOEY_Z80SCC_RX_FIFO=3), so an interrupt held off too long loses
# bytes here as it would on the machine. Then, all at once:
# serial the guest streams byte k = streamByte(k, 0xA5) and checks the
# peer's stream, byte k = streamByte(k, 0x00), in order; the host
# peer (scripts/lib/serialStreamPeer.py) checks the guest's and
# answers byte for byte. The guest also raises DTR 16 times a loop,
# the add-on's own select-then-write of channel A's WR5, so that
# sequence runs under both channels' interrupts all the time.
# mouse the Lua visits the four stage corners, pushing both axes into the
# corner EVERY frame -- a packet on channel B at every solicitation,
# while the pointer stays pinned where the clamp puts it -- checks
# the position there, then presses a button and checks it, then
# releases it (checked at the next corner). Clamp edges only: MAME's
# relative-axis injection is timing-sensitive, so interior positions
# are not testable (see verify-x68000-mouse.sh). Two left clicks a
# pass also prove the ROM's software keyboard stays off (hal.c
# X68K_SKEY_OFF): the second would bring it up and eat the next
# right click.
# Timeline: PASSES corner passes with the traffic flowing, every check also
# requiring both stream counts to have moved and no bad byte; SPACE pauses the
# guest's stream, the peer follows, and once quiet the guest's counts must
# hold still and equal a quiet snapshot of the peer's EXACTLY -- every byte
# sent either way arrived, in order; one more pass in the quiet; SPACE resumes
# and both counts must move again (the receive interrupt still fires at the
# end, the program still runs).
#
# MAME 0.264 needs one correction here, made in the Lua and not in MAME. Its
# Z8530 (src/devices/machine/z80scc.cpp) answers an interrupt acknowledge
# wrongly when BOTH channels have one pending: z80daisy_irq_ack puts the
# highest-priority source in service but returns m_chanB->m_rr2, the vector of
# whichever source was triggered LAST. The CPU then runs the other channel's
# handler, whose interrupt-under-service reset clears the source the chip
# acknowledged, and that channel's byte is left in its FIFO with nothing
# pending: the channel runs a byte behind until its FIFO overruns (serial
# loses bytes) or a stale byte starts a mouse packet (pointer and buttons go
# wrong). Measured before the correction: both, within seconds. Silicon
# returns the vector of the source it acknowledges, so a tap on the CPU's
# level-5 acknowledge rewrites the vector to that source's, and the verdict
# line reports how many acknowledges it corrected (iackFixed). Only this gate
# keeps both channels busy at once, so no other gate needs it.
#
# The guest reports through two verification rows at the bottom of the stage
# (one nibble per pixel, high nibble first), read from the text plane:
# row 198 3C3C, status, received(8), bad, sent(8), short writes, first bad(8)
# row 199 5A5A, present/left/right/middle, x, y (examples/keys' mouse row)
# The serial row changes at most every 4 frames, so a read counts only when
# two consecutive frames agree (a present caught half done cannot).
#
# PASS: every Lua check right, the peer's stream PASS, at least MIN_BYTES each
# way, and the guest's quiet counts among the peer's quiet snapshots.
#
# Variants, built here into the work directory from examples/sermouse:
# X68K_SERMOUSE_BAUD=19200|38400 the line rate (default 9600, MAME's
# null_modem default); RSDRV.SYS, which the
# boot disk loads, is what reaches past 9600
# X68K_SERMOUSE_DENSE=n stage lines 0 .. n-1 change palette on
# every line (default 0: one palette), so
# the SCB raster interrupt holds IPL 6 for
# the whole run every frame while the
# streams and the mouse run
# scripts/verify-x68000-serial-scb.sh runs the dense combinations this port
# guarantees; see "Serial under a dense SCB" in claudeDocs/x68000_port.md.
#
# Requires: ./install.sh install x68000 -- the patched MAME
# (installer/patches/mame: 0002 for the FIFO depth, 0004 for the
# RS-232C slot and the mouse) and the Human68k system disk.
#
# bash scripts/verify-x68000-serial-mouse.sh
set -uo pipefail
repo=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
source "$repo/scripts/lib/joeyEnv.sh"
joeyNeed MAME mame
joeyNeed X68K_DIR x68kFirmware
joeyNeedFile "$X68K_DIR/roms/x68000/cgrom.dat" x68kCgrom
source "$repo/scripts/lib/x68kDisk.sh"
PORT="${X68K_SERMOUSE_PORT:-6801}"
WALL="${X68K_SERMOUSE_WALL:-600}"
PASSES="${X68K_SERMOUSE_PASSES:-3}"
MIN_BYTES="${X68K_SERMOUSE_MIN_BYTES:-16384}"
BAUD="${X68K_SERMOUSE_BAUD:-9600}"
DENSE="${X68K_SERMOUSE_DENSE:-0}"
PROG="$repo/build/x68000/bin/SERMOUSE.X"
FIFO_DEPTH=3
DEFAULT_BAUD=9600
# The peer outlives MAME by this much, so it always sees the link close, and
# is given this long to report once MAME is gone.
PEER_MARGIN=30
PEER_GRACE=10
[ -f "$X68K_SYSTEM_DISK" ] || { echo "verify-x68000-serial-mouse: missing $X68K_SYSTEM_DISK" >&2; exit 2; }
[ -f "$PROG" ] || { echo "verify-x68000-serial-mouse: build SERMOUSE.X first (make -f make/x68000.mk)" >&2; exit 2; }
work=$(mktemp -d -t joey-x68sermouse.XXXXXX)
peer=""
mame=""
mameChild=""
cleanup() {
joeyStop "$mameChild" "$mame" "$peer"
rm -rf "$work"
}
trap cleanup EXIT
# A variant is examples/sermouse built against the same library with its
# line rate and SCB set (see the header).
if [ "$BAUD" != "$DEFAULT_BAUD" ] || [ "$DENSE" != 0 ]; then
joeyNeed X68K_ROOT toolchain:x68000
"$X68K_ROOT/bin/m68k-xelf-gcc" -O2 -m68000 -fomit-frame-pointer \
-DJOEYLIB_PLATFORM_X68000 -DLINE_BAUD="${BAUD}u" -DDENSE_SCB_LINES="${DENSE}u" \
-I"$repo/include" \
"$repo/examples/sermouse/sermouse.c" \
"$repo/build/x68000/lib/libjoey.a" -lm \
-o "$work/SERMOUSE.X" || exit 1
PROG="$work/SERMOUSE.X"
fi
x68kBootDisk "$work/boot.xdf" 'A:\SERMOUSE.X' || exit 1
x68kXdf add "$work/boot.xdf" "$PROG" SERMOUSE.X >/dev/null || exit 1
{
printf 'local PASSES = %d\n' "$PASSES"
printf 'local MIN_BYTES = %d\n' "$MIN_BYTES"
printf 'local BAUD = %d\n' "$BAUD"
printf 'local DENSE = %d\n' "$DENSE"
cat <<'LUA'
local cpu = manager.machine.devices[":maincpu"]
local mem = cpu.spaces["program"]
local nat = manager.machine.natkeyboard
local scc = manager.machine.devices[":scc"]
local sccA = manager.machine.devices[":scc:cha"]
local frame = 0
local t0 = 0
local biased = false
local done = false
local checks = 0
local fails = {}
local steps = {}
local pending = nil
local lastRaw = nil
local prev = nil
local quiet = nil
local pushX = 0
local pushY = 0
local axisValX = 0
local axisValY = 0
-- Stage geometry on the text plane (src/x68000/hal.c X68K_PRESENT_TEXT): four
-- bit planes 128 KB apart at 0xE00000, 128 bytes per row, leftmost pixel in
-- bit 7, the stage centred at (96, 156).
local TEXT_BASE = 0xE00000
local PLANES = 4
local PLANE_BYTES = 0x20000
local ROW_BYTES = 128
local ORIGIN_X = 96
local ORIGIN_Y = 156
-- The verification rows (examples/sermouse/sermouse.c): 16-bit words and
-- 32-bit longs, one nibble per pixel, laid end to end from the sentinel.
local WORD = 4
local LONG = 8
local SERIAL_ROW = 198
local SERIAL_SENTINEL = 0x3C3C
local SERIAL_NIBBLES = 4 * WORD + 3 * LONG
local MOUSE_ROW = 199
local MOUSE_SENTINEL = 0x5A5A
local MOUSE_NIBBLES = 4 * WORD
local STAGE_RIGHT = 319
local STAGE_BOTTOM = 199
local STATUS_OPEN = 0x0001
local STATUS_PAUSED = 0x0002
local NO_BAD_INDEX = 0xFFFFFFFF
-- Mouse drive: the x68k mouse's X/Y are 12-bit absolute counters it diffs
-- into delta packets; biased mid-range so a pass (net zero per axis, at most
-- two phases one way) never wraps them.
local AXIS_BIAS = 2048
local PUSH_STEP = 6 -- counter units per frame, per axis
local PUSH_FRAMES = 90 -- 540 units per phase: over the 319-pixel stage with room to spare
local BUTTON_FRAMES = 40
local CORNER_FRAMES = PUSH_FRAMES + BUTTON_FRAMES
local PASS_FRAMES = 4 * CORNER_FRAMES
local QUIET_SETTLE = 120 -- frames after SPACE before the line is read as quiet
local QUIET_HOLD = 60 -- and again this much later: it must not move
local RESUME_FRAMES = 120
local BOOT_BIAS_FRAME = 300
local SENTINEL_FIRST = 600
local SENTINEL_EVERY = 50
local SETTLE_FRAMES = 60
local STEADY_LIMIT = 60 -- frames a serial read may take to see two agreeing frames
local BOOT_LIMIT = 30000
-- The acknowledge-vector correction (see the script header). MAME keeps the
-- chip's six interrupt sources in m_int_state, highest priority first,
-- channel A's three then channel B's, each INT (pending) and/or IEO (in
-- service); m_int_source holds each one's type, which with the channel is the
-- 3-bit status the vector carries in bits 3-1 (WR9 status-low, as the X68000
-- runs it). The 68000 fetches the level-5 vector at 0xFFFFFA in cpu space.
local IACK5 = 0xFFFFFA
local SCC_SOURCES = 6
local SCC_A_SOURCES = 3
local DAISY_IEO = 0x02
local WR9_VIS = 0x01
local WR9_NV_SHSL = 0x12 -- no vector / status high: vectors this does not model
local STATUS_CHANNEL_A = 0x04
local STATUS_TYPE_MASK = 0x03
local VECTOR_STATUS_KEEP = 0xF1
local VECTOR_BYTE = 0xFF
local intState = emu.item(scc.items["0/m_int_state"])
local intSource = emu.item(scc.items["0/m_int_source"])
local wr9 = emu.item(scc.items["0/m_wr9"])
local wr2 = emu.item(sccA.items["0/m_wr2"])
local iackFixed = 0
-- The text plane holds two pages, and the port flips between them with the
-- text Y scroll (CRTC R11, which reads back): rows are counted from the page
-- on screen.
local function shownRow()
return mem:read_u16(0xE80016) & 0x3FF
end
local function textPix(px, y)
local sx = ORIGIN_X + px
local addr = TEXT_BASE + (ORIGIN_Y + shownRow() + y) * ROW_BYTES + (sx >> 3)
local bit = 7 - (sx & 7)
local v = 0
for p = 0, PLANES - 1 do
v = v | (((mem:read_u8(addr + p * PLANE_BYTES) >> bit) & 1) << p)
end
return v
end
local function rowNibbles(y, count)
local t = {}
for i = 0, count - 1 do
t[#t + 1] = textPix(i, y)
end
return t
end
-- A reader over a row's nibbles: each call takes the next field, high nibble
-- first.
local function fields(t)
local pos = 0
return function(count)
local v = 0
for i = pos + 1, pos + count do
v = (v << 4) | t[i]
end
pos = pos + count
return v
end
end
local function parseSerial(t)
local take = fields(t)
local s = {}
s.sentinel = take(WORD) == SERIAL_SENTINEL
s.status = take(WORD)
s.rx = take(LONG)
s.bad = take(WORD)
s.tx = take(LONG)
s.short = take(WORD)
s.firstBad = take(LONG)
return s
end
-- The flags word is one nibble per predicate: present, left, right, middle.
local function readMouse()
local take = fields(rowNibbles(MOUSE_ROW, MOUSE_NIBBLES))
local m = {}
m.sentinel = take(WORD) == MOUSE_SENTINEL
m.present = take(1)
m.left = take(1)
m.right = take(1)
m.middle = take(1)
m.x = take(WORD)
m.y = take(WORD)
return m
end
local ports = manager.machine.ioport.ports
local axisX, axisY, btnLeft, btnRight
local portX = ports[":mouse_port:x68k:X"]
local portY = ports[":mouse_port:x68k:Y"]
local portB = ports[":mouse_port:x68k:BTN"]
if portX then for _, f in pairs(portX.fields) do axisX = f end end
if portY then for _, f in pairs(portY.fields) do axisY = f end end
if portB then
for _, f in pairs(portB.fields) do
if f.mask == 2 then btnLeft = f end
if f.mask == 1 then btnRight = f end
end
end
-- After MAME has acknowledged: the source now in service is the one the
-- vector must name. A global, because a collected tap handle removes the tap.
iackTap = cpu.spaces["cpu_space"]:install_read_tap(IACK5, IACK5 + 1, "iackVector", function(offset, data, mask)
local w = wr9:read(0)
if (w & WR9_VIS) == 0 or (w & WR9_NV_SHSL) ~= 0 then
return nil
end
for i = 0, SCC_SOURCES - 1 do
if (intState:read(i) & DAISY_IEO) ~= 0 then
local status = (intSource:read(i) & STATUS_TYPE_MASK) | (i < SCC_A_SOURCES and STATUS_CHANNEL_A or 0)
local vector = (wr2:read(0) & VECTOR_STATUS_KEEP) | (status << 1)
if vector == (data & VECTOR_BYTE) then
return nil
end
iackFixed = iackFixed + 1
return (data & ~VECTOR_BYTE) | vector
end
end
return nil
end)
local function finish(verdict)
done = true
local s = prev or {}
io.write(string.format("VERIFY-X68K-SERMOUSE %s baud=%d dense=%d checks=%d fails=%d rx=%d tx=%d quiet=%s iackFixed=%d%s\n",
verdict, BAUD, DENSE, checks, #fails, s.rx or 0, s.tx or 0,
quiet and string.format("%d:%d", quiet.rx, quiet.tx) or "none", iackFixed,
#fails > 0 and (" detail=" .. table.concat(fails, ",")) or ""))
io.flush()
manager.machine:exit()
end
if not (axisX and axisY and btnLeft and btnRight) then
done = true
io.write("VERIFY-X68K-SERMOUSE error: mouse ioports not found\n")
io.flush()
manager.machine:exit()
end
-- One check; the first failure is the verdict, so the run stops there.
local function expect(name, ok, detail)
if done then return end
checks = checks + 1
if not ok then
fails[#fails + 1] = name .. (detail and ("(" .. detail .. ")") or "")
finish("FAIL")
end
end
local function expectMouse(step, x, y, l, r)
local m = readMouse()
expect(step .. ":sentinel", m.sentinel)
expect(step .. ":present", m.present == 1, tostring(m.present))
expect(step .. ":xy", m.x == x and m.y == y, string.format("%d,%d want %d,%d", m.x, m.y, x, y))
expect(step .. ":buttons", m.left == l and m.right == r and m.middle == 0,
string.format("%d%d%d want %d%d0", m.left, m.right, m.middle, l, r))
end
-- A steady serial read: fn runs with the row once two consecutive frames
-- agree on it.
local function whenSteady(name, fn)
pending = { name = name, fn = fn, since = frame }
lastRaw = nil
end
local function serialHealthy(step, s)
expect(step .. ":sentinel", s.sentinel)
expect(step .. ":open", (s.status & STATUS_OPEN) ~= 0, string.format("status %04X", s.status))
expect(step .. ":bad", s.bad == 0 and s.firstBad == NO_BAD_INDEX, string.format("%d first %d", s.bad, s.firstBad))
expect(step .. ":short", s.short == 0, tostring(s.short))
end
-- Traffic flowing: both counts moved since the last read.
local function expectMoving(step)
whenSteady(step, function(s)
serialHealthy(step, s)
expect(step .. ":paused", (s.status & STATUS_PAUSED) == 0)
if prev then
expect(step .. ":rxMoved", s.rx > prev.rx, string.format("%d -> %d", prev.rx, s.rx))
expect(step .. ":txMoved", s.tx > prev.tx, string.format("%d -> %d", prev.tx, s.tx))
end
prev = s
end)
end
-- Line quiet: both counts exactly where the pause left them.
local function expectFrozen(step)
whenSteady(step, function(s)
serialHealthy(step, s)
expect(step .. ":paused", (s.status & STATUS_PAUSED) ~= 0)
if quiet == nil then
quiet = s
expect(step .. ":rxMin", s.rx >= MIN_BYTES, tostring(s.rx))
expect(step .. ":txMin", s.tx >= MIN_BYTES, tostring(s.tx))
else
expect(step .. ":rxFrozen", s.rx == quiet.rx, string.format("%d -> %d", quiet.rx, s.rx))
expect(step .. ":txFrozen", s.tx == quiet.tx, string.format("%d -> %d", quiet.tx, s.tx))
end
prev = s
end)
end
local function at(t, fn)
steps[#steps + 1] = { at = t, run = fn }
end
-- Corners in visiting order: where the clamp pins the pointer, the push
-- direction that pins it there, and the button pressed once it is.
local corners = {
{ name = "topLeft", x = 0, y = 0, dx = -1, dy = -1, button = "left" },
{ name = "topRight", x = STAGE_RIGHT, y = 0, dx = 1, dy = -1, button = "right" },
{ name = "bottomRight", x = STAGE_RIGHT, y = STAGE_BOTTOM, dx = 1, dy = 1, button = "left" },
{ name = "bottomLeft", x = 0, y = STAGE_BOTTOM, dx = -1, dy = 1, button = "right" },
}
-- One pass over the corners from frame `base`; `serialCheck` runs beside
-- each position check.
local function pass(base, label, serialCheck)
for i, c in ipairs(corners) do
local t = base + (i - 1) * CORNER_FRAMES
local step = label .. ":" .. c.name
local button = c.button == "left" and btnLeft or btnRight
local l = c.button == "left" and 1 or 0
at(t, function() pushX = c.dx; pushY = c.dy end)
at(t + PUSH_FRAMES, function()
expectMouse(step, c.x, c.y, 0, 0)
serialCheck(step)
button:set_value(1)
end)
at(t + CORNER_FRAMES - 1, function()
expectMouse(step .. "Button", c.x, c.y, l, 1 - l)
button:clear_value()
end)
end
end
local t = 0
for p = 1, PASSES do
pass(t, "busy" .. p, expectMoving)
t = t + PASS_FRAMES
end
at(t, function() nat:post(" ") end)
at(t + QUIET_SETTLE, function() expectFrozen("pause") end)
at(t + QUIET_SETTLE + QUIET_HOLD, function() expectFrozen("pauseHold") end)
t = t + QUIET_SETTLE + QUIET_HOLD + 1
pass(t, "quiet", expectFrozen)
t = t + PASS_FRAMES
at(t, function() nat:post(" ") end)
at(t + RESUME_FRAMES, function()
prev = quiet
expectMoving("resumed")
end)
local finalFrame = t + RESUME_FRAMES
emu.register_frame_done(function()
frame = frame + 1
if done then return end
if not biased and frame == BOOT_BIAS_FRAME then
biased = true
axisValX = AXIS_BIAS
axisValY = AXIS_BIAS
axisX:set_value(axisValX)
axisY:set_value(axisValY)
end
if t0 == 0 then
if frame > SENTINEL_FIRST and frame % SENTINEL_EVERY == 0 then
local s = parseSerial(rowNibbles(SERIAL_ROW, SERIAL_NIBBLES))
if s.sentinel and readMouse().sentinel then
t0 = frame + SETTLE_FRAMES
end
end
if frame > BOOT_LIMIT then
done = true
io.write("VERIFY-X68K-SERMOUSE timeout: SERMOUSE never came up\n")
io.flush()
manager.machine:exit()
end
return
end
if pushX ~= 0 or pushY ~= 0 then
axisValX = axisValX + pushX * PUSH_STEP
axisValY = axisValY + pushY * PUSH_STEP
axisX:set_value(axisValX)
axisY:set_value(axisValY)
end
for _, s in ipairs(steps) do
if frame == t0 + s.at and not done then s.run() end
end
if pending and not done then
local raw = table.concat(rowNibbles(SERIAL_ROW, SERIAL_NIBBLES), ",")
if raw == lastRaw then
local p = pending
pending = nil
p.fn(parseSerial(rowNibbles(SERIAL_ROW, SERIAL_NIBBLES)))
elseif frame - pending.since > STEADY_LIMIT then
expect(pending.name .. ":steady", false)
else
lastRaw = raw
end
end
if not done and not pending and frame > t0 + finalFrame then
finish(#fails == 0 and "PASS" or "FAIL")
end
end)
LUA
} > "$work/sermouse.lua"
python3 "$repo/scripts/lib/serialStreamPeer.py" "$PORT" "$((WALL + PEER_MARGIN))" "$MIN_BYTES" \
> "$work/peer.out" 2>&1 &
peer=$!
# The peer must be listening before MAME connects out to it.
for _ in $(seq 1 50); do
grep -q '^STREAM listening' "$work/peer.out" 2>/dev/null && break
sleep 0.1
done
# From the work dir, so MAME's cfg/ and nvram/ land there. Under timeout so a
# hung run cannot outlive WALL whatever happens to this script; mameChild is
# MAME itself, which cleanup stops first (stopping only the timeout process
# could leave MAME running).
cd "$work" || exit 1
if [ "$BAUD" != "$DEFAULT_BAUD" ]; then
mkdir -p "$work/cfg"
python3 "$repo/scripts/lib/mameNullModemCfg.py" x68000 :rs232c:null_modem "$BAUD" \
> "$work/cfg/x68000.cfg" || exit 2
fi
JOEY_Z80SCC_RX_FIFO=$FIFO_DEPTH timeout -s KILL "$WALL" "$MAME" x68000 -bios ipl10 \
-rompath "$X68K_DIR/roms" -flop1 "$work/boot.xdf" \
-rs232c null_modem -bitb "socket.127.0.0.1:$PORT" \
-video none -sound none -nothrottle \
-autoboot_script "$work/sermouse.lua" </dev/null > "$work/mame.out" 2>&1 &
mame=$!
sleep 1
mameChild=$(pgrep -P "$mame" | head -1)
# The Lua ends the run: after its last check, or at its first failure.
wait "$mame"
mame=""
mameChild=""
for _ in $(seq 1 "$PEER_GRACE"); do
joeyAlive "$peer" || break
sleep 1
done
joeyStop "$peer"
peer=""
lua=$(grep -E '^VERIFY-X68K-SERMOUSE ' "$work/mame.out" | tail -1)
stream=$(grep -E '^STREAM (PASS|FAIL)' "$work/peer.out" | tail -1)
echo "${lua:-VERIFY-X68K-SERMOUSE: no verdict from the Lua}"
echo "${stream:-STREAM: no verdict from the peer}"
if ! grep -q "RX FIFO depth $FIFO_DEPTH" "$work/mame.out"; then
echo "verify-x68000-serial-mouse: SKIP - this MAME does not take JOEY_Z80SCC_RX_FIFO (reinstall: ./install.sh install mame)" >&2
exit 2
fi
fail=0
if ! echo "$lua" | grep -q '^VERIFY-X68K-SERMOUSE PASS .* fails=0 '; then
echo "verify-x68000-serial-mouse: FAIL - guest or mouse check (Lua line above)" >&2
tail -5 "$work/mame.out" >&2
fail=1
fi
if ! echo "$stream" | grep -q '^STREAM PASS '; then
echo "verify-x68000-serial-mouse: FAIL - the guest's stream to the host (peer line above)" >&2
fail=1
fi
guestQuiet=$(echo "$lua" | sed -n 's/.* quiet=\([0-9]*:[0-9]*\).*/\1/p')
peerQuiet=$(echo "$stream" | sed -n 's/.* quiet=\([0-9:,]*\) .*/\1/p')
if [ -z "$guestQuiet" ] || [[ ",$peerQuiet," != *",$guestQuiet,"* ]]; then
echo "verify-x68000-serial-mouse: FAIL - quiet counts differ: guest received:sent $guestQuiet, peer sent:received $peerQuiet" >&2
fail=1
fi
if [ "$fail" -ne 0 ]; then
exit 1
fi
echo "verify-x68000-serial-mouse: PASS at $BAUD baud, $DENSE dense-SCB lines (both streams byte-exact and complete at the pause, mouse corners and buttons right throughout, receive interrupt alive at the end)"
Reference in a new issue View git blame Copy permalink