Files
R8Forge/tests/widths.ps1
T
dsh c417304140 term: a line-editing terminal -- buffer, backspace and command dispatch
examples/term.r8asm was a per-character echo (prompt, echo, backspace erase,
newline, EOF).  It is now a small shell: a 4 character line buffer, a backspace
that really removes a character, and Enter -- or EOF, for a half typed line --
commits the line and dispatches on its first character.  'l' prints the length,
'r' prints the buffer backwards, 'q' quits, anything else is ignored.

The header session "lhi" exercises the whole chain: EOF commits the pending
line, so examples_test sees the '3'.  Three more sessions are documented in the
header: "rab" gives NUL+'b'+'a'+'r', "lab<BS>" gives '2' (the backspace really
dropped the 'b'), and "lhi<NL>rxy<NL>" prints '3' then the reversed second
line.

Three things ate most of the debugging time; all three are written up in the
file:

* "else" needs a flag cell.  biz enters when the low bit is set, so "if not A
  then B" cannot be inferred from "the last test missed": set FLAG=1 before the
  test, clear it in the matched branch, look at FLAG afterwards.  And biz tests
  the CURRENT dp cell, so the order has to be "set FLAG, then .tp to the
  condition cell, then biz" -- the wrong order made every character look like
  a commit key.
* clb_sub_nc eats its operands, so the echo and the append both work from the
  copy CE.  The first version appended C (already zeroed by the comparison),
  which left the line buffer empty: 'l' printed 0 and 'r' printed four NULs.
* the cell layout dominates the tape.  copy / clb_sub_nc / clb_nonzero all emit
  .tp internally, some of them inside %rep _CELL_SIZE, so a 20 cell gap costs
  a couple of thousand characters: putting the constants at 22..28 gave 33067
  characters, packing the hot cells into 0..27 gives 21721.

The buffer is left aligned with a length counter -- appending needs a dispatch
on LEN, but backspace is just LEN-- -- and 'r' prints all four cells instead of
dispatching on the length, which costs a NUL for the unused cells and is
documented.

tests/widths.ps1 now also checks term.r8asm at every width (its expected
stream is width independent, which is what makes it a good second program for
the matrix), and TODO/AGENTS/README record the item as done.
2026-11-18 21:58:29 +08:00

88 lines
4.6 KiB
PowerShell

# Build the toolchain at a set of cell widths and *check* what should hold there.
#
# powershell -File tests\widths.ps1 # 7,8,11,16,17,31,32
# powershell -File tests\widths.ps1 -Widths 11,16,32
#
# Per width, this asserts:
# * the `widthfree` ctest label passes (bit level slices, the synthesizer, the
# looping demo, the macro comment format);
# * examples/calc.r8asm assembles and `12 34 + .` prints D digits, where
# D = floor(W * 30103 / 100000) + 1 -- the same formula the library uses. A
# width that silently did not take effect fails this, because it would print
# four digits;
# * if the reference machine is built next door, it prints the same thing
# (`rot8_test --cell <W>`), which is the three way check. That one only
# runs for W >= 8: the viz switches to serial ASCII only when a cell is at
# least 8 bits wide, and below that it prints one number per OUT -- so a
# "> 046" comparison at 7 bits would fail for a reason that has nothing to
# do with the tape (the calc itself is still checked there).
# Widths under 7 cannot hold '0' (48) in a cell, so they get the library tests
# only.
# A comma separated string rather than [int[]]: `powershell -File ... -Widths 11,16`
# binds as one string, and 11,16 would quietly become 1116.
param(
[string]$Widths = "7,8,11,16,17,31,32",
[string]$CMake = "C:/Program Files/Microsoft Visual Studio/18/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cmake.exe"
)
$ErrorActionPreference = "Continue"
$root = Split-Path -Parent $PSScriptRoot
$ctest = Join-Path (Split-Path $CMake) "ctest.exe"
$viz = Join-Path $root "..\ROT-8-viz\build\Release\rot8_test.exe"
$failed = @()
foreach ($w in ($Widths.Split(",") | ForEach-Object { [int]$_.Trim() })) {
$dir = Join-Path $root "build$w"
$d = [int][math]::Floor($w * 0.30103) + 1
$nums = @(62, 32) + (@(48) * ($d - 2)) + @(52, 54) + @(10)
$want = "out " + ($nums -join " ")
Write-Host "=== cell $w (D = $d)"
& $CMake -S $root -B $dir "-DR8FORGE_CELL_SIZE=$w" 2>$null | Out-Null
& $CMake --build $dir --config Release 2>$null | Out-Null
& $ctest --test-dir $dir -C Release -L widthfree 2>$null | Out-Null
if ($LASTEXITCODE -ne 0) { Write-Host " widthfree tests FAILED"; $failed += $w }
else { Write-Host " widthfree tests ok" }
$r8 = Join-Path $dir "Release\r8forge.exe"
$derive = Join-Path $dir "Release\r8forge_derive.exe"
$tape = (& $r8 "examples/calc.r8asm" --quiet 2>$null | Out-String).TrimEnd("`r", "`n")
Write-Host (" calc tape: " + $tape.Length + " chars")
$got = (& $derive "examples/calc.r8asm" 0 -i "12 34 + ." 2>$null | Out-String).Trim()
if ($got -ne $want) { Write-Host " calc FAILED: want '$want' got '$got'"; $failed += $w }
else { Write-Host " calc ok: $want" }
# The terminal tape: prompt, echo, EOF-commit and the 'l' command. None of
# these numbers depend on the cell width (the length is printed as '0'+LEN),
# so the expected stream is the same at every width -- which is exactly what
# makes it a good second program for the matrix.
$termWant = "out 62 32 108 104 105 10 51 10 62 32 10"
$termGot = (& $derive "examples/term.r8asm" 0 -i "lhi" 2>$null | Out-String).Trim()
if ($termGot -ne $termWant) { Write-Host " term FAILED: want '$termWant' got '$termGot'"; $failed += $w }
else { Write-Host " term ok: $termWant" }
if (Test-Path $viz) {
# The viz only speaks serial ASCII when a cell is at least 8 bits wide
# (bit 7 doubles as the 7E1 parity/stop bit; below that it prints one
# number per OUT). Comparing a 7 bit tape with "> 046" therefore says
# nothing: at 7 bits the same tape legitimately prints numbers. The
# calc check above already covers 7 bits, so skip the viz there.
if ($w -lt 8) {
Write-Host " viz skipped: serial I/O needs >= 8 bit cells"
} else {
$tmp = Join-Path $env:TEMP "calc$w.rot8"
[System.IO.File]::WriteAllText($tmp, $tape, (New-Object System.Text.UTF8Encoding($false)))
$serial = (& $viz "--cell" $w "--input" "12 34 + ." $tmp 2>$null | Out-String).Trim()
$wantSerial = "> " + ("0" * ($d - 2)) + "46"
if ($serial -ne $wantSerial) { Write-Host " viz FAILED: want '$wantSerial' got '$serial'"; $failed += $w }
else { Write-Host " viz ok: $wantSerial" }
Remove-Item $tmp -ErrorAction SilentlyContinue
}
}
Remove-Item -Recurse -Force $dir
}
if ($failed.Count -gt 0) { Write-Host ("FAILED at widths: " + ($failed -join ", ")); exit 1 }
Write-Host "all requested widths ok"