Compare commits
20 Commits
loops/erla
...
loops/fort
| Author | SHA1 | Date | |
|---|---|---|---|
| c28333adb3 | |||
| 1b2935828c | |||
| 64af162b5d | |||
| 8ca2fe3564 | |||
| b1a7852045 | |||
| 89a879799a | |||
| 47f66ad1be | |||
| c726a9e0fe | |||
| b6810e90ab | |||
| 3ab01b271d | |||
| 8e1466032a | |||
| 387a6e7f5d | |||
| acf9c273a2 | |||
| 35ce18eb97 | |||
| 1c975f229d | |||
| 0e509af0a2 | |||
| a47b3e5420 | |||
| e066e14267 | |||
| bb16477fd4 | |||
| b2939c1922 |
@@ -1,86 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
# Erlang-on-SX ring benchmark.
|
||||
#
|
||||
# Spawns N processes in a ring, passes a token N hops (one full round),
|
||||
# and reports wall-clock time + throughput. Aspirational target from
|
||||
# the plan is 1M processes; current sync-scheduler architecture caps out
|
||||
# orders of magnitude lower — this script measures honestly across a
|
||||
# range of N so the result/scaling is recorded.
|
||||
#
|
||||
# Usage:
|
||||
# bash lib/erlang/bench_ring.sh # default ladder
|
||||
# bash lib/erlang/bench_ring.sh 100 1000 5000 # custom Ns
|
||||
|
||||
set -uo pipefail
|
||||
cd "$(git rev-parse --show-toplevel)"
|
||||
|
||||
SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
|
||||
if [ ! -x "$SX_SERVER" ]; then
|
||||
SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
|
||||
fi
|
||||
if [ ! -x "$SX_SERVER" ]; then
|
||||
echo "ERROR: sx_server.exe not found." >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ "$#" -gt 0 ]; then
|
||||
NS=("$@")
|
||||
else
|
||||
NS=(10 100 500 1000)
|
||||
fi
|
||||
|
||||
TMPFILE=$(mktemp)
|
||||
trap "rm -f $TMPFILE" EXIT
|
||||
|
||||
# One-line Erlang program. Replaces __N__ with the size for each run.
|
||||
PROGRAM='Me = self(), N = __N__, Spawner = fun () -> receive {setup, Next} -> Loop = fun () -> receive {token, 0, Parent} -> Parent ! done; {token, K, Parent} -> Next ! {token, K-1, Parent}, Loop() end end, Loop() end end, BuildRing = fun (K, Acc) -> if K =:= 0 -> Acc; true -> BuildRing(K-1, [spawn(Spawner) | Acc]) end end, Pids = BuildRing(N, []), Wire = fun (Ps) -> case Ps of [P, Q | _] -> P ! {setup, Q}, Wire(tl(Ps)); [Last] -> Last ! {setup, hd(Pids)} end end, Wire(Pids), hd(Pids) ! {token, N, Me}, receive done -> done end'
|
||||
|
||||
run_n() {
|
||||
local n="$1"
|
||||
local prog="${PROGRAM//__N__/$n}"
|
||||
cat > "$TMPFILE" <<EPOCHS
|
||||
(epoch 1)
|
||||
(load "lib/erlang/tokenizer.sx")
|
||||
(load "lib/erlang/parser.sx")
|
||||
(load "lib/erlang/parser-core.sx")
|
||||
(load "lib/erlang/parser-expr.sx")
|
||||
(load "lib/erlang/parser-module.sx")
|
||||
(load "lib/erlang/transpile.sx")
|
||||
(load "lib/erlang/runtime.sx")
|
||||
(epoch 2)
|
||||
(eval "(erlang-eval-ast \"${prog//\"/\\\"}\")")
|
||||
EPOCHS
|
||||
|
||||
local start_s start_ns end_s end_ns elapsed_ms
|
||||
start_s=$(date +%s)
|
||||
start_ns=$(date +%N)
|
||||
out=$(timeout 300 "$SX_SERVER" < "$TMPFILE" 2>&1)
|
||||
end_s=$(date +%s)
|
||||
end_ns=$(date +%N)
|
||||
|
||||
local ok="false"
|
||||
if echo "$out" | grep -q ':name "done"'; then ok="true"; fi
|
||||
|
||||
# ms = (end_s - start_s)*1000 + (end_ns - start_ns)/1e6
|
||||
elapsed_ms=$(awk -v s1="$start_s" -v n1="$start_ns" -v s2="$end_s" -v n2="$end_ns" \
|
||||
'BEGIN { printf "%d", (s2 - s1) * 1000 + (n2 - n1) / 1000000 }')
|
||||
|
||||
if [ "$ok" = "true" ]; then
|
||||
local hops_per_s
|
||||
hops_per_s=$(awk -v n="$n" -v ms="$elapsed_ms" \
|
||||
'BEGIN { if (ms == 0) ms = 1; printf "%.0f", n * 1000 / ms }')
|
||||
printf " N=%-8s hops=%-8s %sms (%s hops/s)\n" "$n" "$n" "$elapsed_ms" "$hops_per_s"
|
||||
else
|
||||
printf " N=%-8s FAILED %sms\n" "$n" "$elapsed_ms"
|
||||
fi
|
||||
}
|
||||
|
||||
echo "Ring benchmark — sx_server.exe (synchronous scheduler)"
|
||||
echo
|
||||
for n in "${NS[@]}"; do
|
||||
run_n "$n"
|
||||
done
|
||||
echo
|
||||
echo "Note: 1M-process target from the plan is aspirational; the synchronous"
|
||||
echo "scheduler with shift-based suspension and dict-based env copies is not"
|
||||
echo "engineered for that scale. Numbers above are honest baselines."
|
||||
@@ -1,35 +0,0 @@
|
||||
# Ring Benchmark Results
|
||||
|
||||
Generated by `lib/erlang/bench_ring.sh` against `sx_server.exe` on the
|
||||
synchronous Erlang-on-SX scheduler.
|
||||
|
||||
| N (processes) | Hops | Wall-clock | Throughput |
|
||||
|---|---|---|---|
|
||||
| 10 | 10 | 907ms | 11 hops/s |
|
||||
| 50 | 50 | 2107ms | 24 hops/s |
|
||||
| 100 | 100 | 3827ms | 26 hops/s |
|
||||
| 500 | 500 | 17004ms | 29 hops/s |
|
||||
| 1000 | 1000 | 29832ms | 34 hops/s |
|
||||
|
||||
(Each `Nm` row spawns N processes connected in a ring and passes a
|
||||
single token N hops total — i.e. the token completes one full lap.)
|
||||
|
||||
## Status of the 1M-process target
|
||||
|
||||
Phase 3's stretch goal in `plans/erlang-on-sx.md` is a million-process
|
||||
ring benchmark. **That target is not met** in the current synchronous
|
||||
scheduler; extrapolating from the table above, 1M hops would take
|
||||
~30 000 s. Correctness is fine — the program runs at every measured
|
||||
size — but throughput is bound by per-hop overhead.
|
||||
|
||||
Per-hop cost is dominated by:
|
||||
- `er-env-copy` per fun clause attempt (whole-dict copy each time)
|
||||
- `call/cc` capture + `raise`/`guard` unwind on every `receive`
|
||||
- `er-q-delete-at!` rebuilds the mailbox backing list on every match
|
||||
- `dict-set!`/`dict-has?` lookups in the global processes table
|
||||
|
||||
To reach 1M-process throughput in this architecture would need at
|
||||
least: persistent (path-copying) envs, an inline scheduler that
|
||||
doesn't call/cc on the common path (msg-already-in-mailbox), and a
|
||||
linked-list mailbox. None of those are in scope for the Phase 3
|
||||
checkbox — captured here as the floor we're starting from.
|
||||
@@ -1,153 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
# Erlang-on-SX conformance runner.
|
||||
#
|
||||
# Loads every erlang test suite via the epoch protocol, collects
|
||||
# pass/fail counts, and writes lib/erlang/scoreboard.json + .md.
|
||||
#
|
||||
# Usage:
|
||||
# bash lib/erlang/conformance.sh # run all suites
|
||||
# bash lib/erlang/conformance.sh -v # verbose per-suite
|
||||
|
||||
set -uo pipefail
|
||||
cd "$(git rev-parse --show-toplevel)"
|
||||
|
||||
SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
|
||||
if [ ! -x "$SX_SERVER" ]; then
|
||||
SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
|
||||
fi
|
||||
if [ ! -x "$SX_SERVER" ]; then
|
||||
echo "ERROR: sx_server.exe not found." >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
VERBOSE="${1:-}"
|
||||
TMPFILE=$(mktemp)
|
||||
OUTFILE=$(mktemp)
|
||||
trap "rm -f $TMPFILE $OUTFILE" EXIT
|
||||
|
||||
# Each suite: name | counter pass | counter total
|
||||
SUITES=(
|
||||
"tokenize|er-test-pass|er-test-count"
|
||||
"parse|er-parse-test-pass|er-parse-test-count"
|
||||
"eval|er-eval-test-pass|er-eval-test-count"
|
||||
"runtime|er-rt-test-pass|er-rt-test-count"
|
||||
"ring|er-ring-test-pass|er-ring-test-count"
|
||||
"ping-pong|er-pp-test-pass|er-pp-test-count"
|
||||
"bank|er-bank-test-pass|er-bank-test-count"
|
||||
"echo|er-echo-test-pass|er-echo-test-count"
|
||||
"fib|er-fib-test-pass|er-fib-test-count"
|
||||
)
|
||||
|
||||
cat > "$TMPFILE" << 'EPOCHS'
|
||||
(epoch 1)
|
||||
(load "lib/erlang/tokenizer.sx")
|
||||
(load "lib/erlang/parser.sx")
|
||||
(load "lib/erlang/parser-core.sx")
|
||||
(load "lib/erlang/parser-expr.sx")
|
||||
(load "lib/erlang/parser-module.sx")
|
||||
(load "lib/erlang/transpile.sx")
|
||||
(load "lib/erlang/runtime.sx")
|
||||
(load "lib/erlang/tests/tokenize.sx")
|
||||
(load "lib/erlang/tests/parse.sx")
|
||||
(load "lib/erlang/tests/eval.sx")
|
||||
(load "lib/erlang/tests/runtime.sx")
|
||||
(load "lib/erlang/tests/programs/ring.sx")
|
||||
(load "lib/erlang/tests/programs/ping_pong.sx")
|
||||
(load "lib/erlang/tests/programs/bank.sx")
|
||||
(load "lib/erlang/tests/programs/echo.sx")
|
||||
(load "lib/erlang/tests/programs/fib_server.sx")
|
||||
(epoch 100)
|
||||
(eval "(list er-test-pass er-test-count)")
|
||||
(epoch 101)
|
||||
(eval "(list er-parse-test-pass er-parse-test-count)")
|
||||
(epoch 102)
|
||||
(eval "(list er-eval-test-pass er-eval-test-count)")
|
||||
(epoch 103)
|
||||
(eval "(list er-rt-test-pass er-rt-test-count)")
|
||||
(epoch 104)
|
||||
(eval "(list er-ring-test-pass er-ring-test-count)")
|
||||
(epoch 105)
|
||||
(eval "(list er-pp-test-pass er-pp-test-count)")
|
||||
(epoch 106)
|
||||
(eval "(list er-bank-test-pass er-bank-test-count)")
|
||||
(epoch 107)
|
||||
(eval "(list er-echo-test-pass er-echo-test-count)")
|
||||
(epoch 108)
|
||||
(eval "(list er-fib-test-pass er-fib-test-count)")
|
||||
EPOCHS
|
||||
|
||||
timeout 120 "$SX_SERVER" < "$TMPFILE" > "$OUTFILE" 2>&1
|
||||
|
||||
# Parse "(N M)" from the line after each "(ok-len <epoch> ...)" marker.
|
||||
parse_pair() {
|
||||
local epoch="$1"
|
||||
local line
|
||||
line=$(grep -A1 "^(ok-len $epoch " "$OUTFILE" | tail -1)
|
||||
echo "$line" | sed -E 's/[()]//g'
|
||||
}
|
||||
|
||||
TOTAL_PASS=0
|
||||
TOTAL_COUNT=0
|
||||
JSON_SUITES=""
|
||||
MD_ROWS=""
|
||||
|
||||
idx=0
|
||||
for entry in "${SUITES[@]}"; do
|
||||
name="${entry%%|*}"
|
||||
epoch=$((100 + idx))
|
||||
pair=$(parse_pair "$epoch")
|
||||
pass=$(echo "$pair" | awk '{print $1}')
|
||||
count=$(echo "$pair" | awk '{print $2}')
|
||||
if [ -z "$pass" ] || [ -z "$count" ]; then
|
||||
pass=0
|
||||
count=0
|
||||
fi
|
||||
TOTAL_PASS=$((TOTAL_PASS + pass))
|
||||
TOTAL_COUNT=$((TOTAL_COUNT + count))
|
||||
status="ok"
|
||||
marker="✅"
|
||||
if [ "$pass" != "$count" ]; then
|
||||
status="fail"
|
||||
marker="❌"
|
||||
fi
|
||||
if [ "$VERBOSE" = "-v" ]; then
|
||||
printf " %-12s %s/%s\n" "$name" "$pass" "$count"
|
||||
fi
|
||||
if [ -n "$JSON_SUITES" ]; then JSON_SUITES+=","; fi
|
||||
JSON_SUITES+=$'\n '
|
||||
JSON_SUITES+="{\"name\":\"$name\",\"pass\":$pass,\"total\":$count,\"status\":\"$status\"}"
|
||||
MD_ROWS+="| $marker | $name | $pass | $count |"$'\n'
|
||||
idx=$((idx + 1))
|
||||
done
|
||||
|
||||
printf '\nErlang-on-SX conformance: %d / %d\n' "$TOTAL_PASS" "$TOTAL_COUNT"
|
||||
|
||||
# scoreboard.json
|
||||
cat > lib/erlang/scoreboard.json <<JSON
|
||||
{
|
||||
"language": "erlang",
|
||||
"total_pass": $TOTAL_PASS,
|
||||
"total": $TOTAL_COUNT,
|
||||
"suites": [$JSON_SUITES
|
||||
]
|
||||
}
|
||||
JSON
|
||||
|
||||
# scoreboard.md
|
||||
cat > lib/erlang/scoreboard.md <<MD
|
||||
# Erlang-on-SX Scoreboard
|
||||
|
||||
**Total: ${TOTAL_PASS} / ${TOTAL_COUNT} tests passing**
|
||||
|
||||
| | Suite | Pass | Total |
|
||||
|---|---|---|---|
|
||||
$MD_ROWS
|
||||
|
||||
Generated by \`lib/erlang/conformance.sh\`.
|
||||
MD
|
||||
|
||||
if [ "$TOTAL_PASS" -eq "$TOTAL_COUNT" ]; then
|
||||
exit 0
|
||||
else
|
||||
exit 1
|
||||
fi
|
||||
@@ -1,744 +0,0 @@
|
||||
;; Erlang runtime — scheduler, process records, mailbox queue.
|
||||
;; Phase 3 foundation. spawn/send/receive build on these primitives.
|
||||
;;
|
||||
;; Scheduler is a single global dict in `er-scheduler` holding:
|
||||
;; :next-pid INT — counter for fresh pid allocation
|
||||
;; :processes DICT — pid-key (string) -> process record
|
||||
;; :runnable QUEUE — FIFO of pids ready to run
|
||||
;; :current PID — pid currently executing, or nil
|
||||
;;
|
||||
;; A pid value is tagged: {:tag "pid" :id INT}. Pids compare by id.
|
||||
;;
|
||||
;; Process record fields:
|
||||
;; :pid — this process's pid
|
||||
;; :mailbox — queue of received messages (arrival order)
|
||||
;; :state — "runnable" | "running" | "waiting" | "exiting" | "dead"
|
||||
;; :continuation — saved k (for receive suspension); nil otherwise
|
||||
;; :receive-pats — patterns the process is blocked on; nil otherwise
|
||||
;; :trap-exit — bool
|
||||
;; :links — list of pids
|
||||
;; :monitors — list of {:ref :pid}
|
||||
;; :env — Erlang env at the last yield
|
||||
;; :exit-reason — nil until the process exits
|
||||
;;
|
||||
;; Queue — amortised-O(1) FIFO with head-pointer + slab-compact:
|
||||
;; {:items (list...) :head-idx INT}
|
||||
|
||||
;; ── queue ────────────────────────────────────────────────────────
|
||||
(define er-q-new (fn () {:head-idx 0 :items (list)}))
|
||||
|
||||
(define er-q-push! (fn (q x) (append! (get q :items) x)))
|
||||
|
||||
(define
|
||||
er-q-pop!
|
||||
(fn
|
||||
(q)
|
||||
(let
|
||||
((h (get q :head-idx)) (items (get q :items)))
|
||||
(if
|
||||
(>= h (len items))
|
||||
nil
|
||||
(let
|
||||
((x (nth items h)))
|
||||
(dict-set! q :head-idx (+ h 1))
|
||||
(er-q-compact! q)
|
||||
x)))))
|
||||
|
||||
(define
|
||||
er-q-peek
|
||||
(fn
|
||||
(q)
|
||||
(let
|
||||
((h (get q :head-idx)) (items (get q :items)))
|
||||
(if (>= h (len items)) nil (nth items h)))))
|
||||
|
||||
(define
|
||||
er-q-len
|
||||
(fn (q) (- (len (get q :items)) (get q :head-idx))))
|
||||
|
||||
(define er-q-empty? (fn (q) (= (er-q-len q) 0)))
|
||||
|
||||
;; Compact the backing list when the head pointer gets large so the
|
||||
;; queue doesn't grow without bound. Threshold chosen to amortise the
|
||||
;; O(n) copy — pops are still amortised O(1).
|
||||
(define
|
||||
er-q-compact!
|
||||
(fn
|
||||
(q)
|
||||
(let
|
||||
((h (get q :head-idx)) (items (get q :items)))
|
||||
(when
|
||||
(> h 128)
|
||||
(let
|
||||
((new (list)))
|
||||
(for-each
|
||||
(fn (i) (append! new (nth items i)))
|
||||
(range h (len items)))
|
||||
(dict-set! q :items new)
|
||||
(dict-set! q :head-idx 0))))))
|
||||
|
||||
(define
|
||||
er-q-to-list
|
||||
(fn
|
||||
(q)
|
||||
(let
|
||||
((h (get q :head-idx)) (items (get q :items)) (out (list)))
|
||||
(for-each
|
||||
(fn (i) (append! out (nth items i)))
|
||||
(range h (len items)))
|
||||
out)))
|
||||
|
||||
;; Read the i'th entry (relative to head) without popping.
|
||||
(define
|
||||
er-q-nth
|
||||
(fn (q i) (nth (get q :items) (+ (get q :head-idx) i))))
|
||||
|
||||
;; Remove entry at logical index i, shift tail in.
|
||||
(define
|
||||
er-q-delete-at!
|
||||
(fn
|
||||
(q i)
|
||||
(let
|
||||
((h (get q :head-idx)) (items (get q :items)) (new (list)))
|
||||
(for-each
|
||||
(fn
|
||||
(j)
|
||||
(when (not (= j (+ h i))) (append! new (nth items j))))
|
||||
(range h (len items)))
|
||||
(dict-set! q :items new)
|
||||
(dict-set! q :head-idx 0))))
|
||||
|
||||
;; ── pids ─────────────────────────────────────────────────────────
|
||||
(define er-mk-pid (fn (id) {:id id :tag "pid"}))
|
||||
(define er-pid? (fn (v) (er-is-tagged? v "pid")))
|
||||
(define er-pid-id (fn (pid) (get pid :id)))
|
||||
(define er-pid-key (fn (pid) (str "p" (er-pid-id pid))))
|
||||
(define
|
||||
er-pid-equal?
|
||||
(fn (a b) (and (er-pid? a) (er-pid? b) (= (er-pid-id a) (er-pid-id b)))))
|
||||
|
||||
;; ── refs ─────────────────────────────────────────────────────────
|
||||
(define er-mk-ref (fn (id) {:id id :tag "ref"}))
|
||||
(define er-ref? (fn (v) (er-is-tagged? v "ref")))
|
||||
(define
|
||||
er-ref-equal?
|
||||
(fn (a b) (and (er-ref? a) (er-ref? b) (= (get a :id) (get b :id)))))
|
||||
|
||||
(define
|
||||
er-ref-new!
|
||||
(fn
|
||||
()
|
||||
(let
|
||||
((s (er-sched)))
|
||||
(let
|
||||
((n (get s :next-ref)))
|
||||
(dict-set! s :next-ref (+ n 1))
|
||||
(er-mk-ref n)))))
|
||||
|
||||
;; ── scheduler state ──────────────────────────────────────────────
|
||||
(define er-scheduler (list nil))
|
||||
|
||||
(define
|
||||
er-sched-init!
|
||||
(fn
|
||||
()
|
||||
(set-nth!
|
||||
er-scheduler
|
||||
0
|
||||
{:next-pid 0
|
||||
:next-ref 0
|
||||
:current nil
|
||||
:processes {}
|
||||
:runnable (er-q-new)})))
|
||||
|
||||
(define er-sched (fn () (nth er-scheduler 0)))
|
||||
|
||||
(define
|
||||
er-pid-new!
|
||||
(fn
|
||||
()
|
||||
(let
|
||||
((s (er-sched)))
|
||||
(let
|
||||
((n (get s :next-pid)))
|
||||
(dict-set! s :next-pid (+ n 1))
|
||||
(er-mk-pid n)))))
|
||||
|
||||
(define
|
||||
er-sched-runnable
|
||||
(fn () (get (er-sched) :runnable)))
|
||||
|
||||
(define
|
||||
er-sched-processes
|
||||
(fn () (get (er-sched) :processes)))
|
||||
|
||||
(define
|
||||
er-sched-enqueue!
|
||||
(fn (pid) (er-q-push! (er-sched-runnable) pid)))
|
||||
|
||||
(define
|
||||
er-sched-next-runnable!
|
||||
(fn () (er-q-pop! (er-sched-runnable))))
|
||||
|
||||
(define
|
||||
er-sched-runnable-count
|
||||
(fn () (er-q-len (er-sched-runnable))))
|
||||
|
||||
(define
|
||||
er-sched-set-current!
|
||||
(fn (pid) (dict-set! (er-sched) :current pid)))
|
||||
|
||||
(define er-sched-current-pid (fn () (get (er-sched) :current)))
|
||||
|
||||
(define
|
||||
er-sched-process-count
|
||||
(fn () (len (keys (er-sched-processes)))))
|
||||
|
||||
;; ── process records ──────────────────────────────────────────────
|
||||
(define
|
||||
er-proc-new!
|
||||
(fn
|
||||
(env)
|
||||
(let
|
||||
((pid (er-pid-new!)))
|
||||
(let
|
||||
((proc
|
||||
{:pid pid
|
||||
:env env
|
||||
:links (list)
|
||||
:mailbox (er-q-new)
|
||||
:state "runnable"
|
||||
:monitors (list)
|
||||
:monitored-by (list)
|
||||
:continuation nil
|
||||
:receive-pats nil
|
||||
:trap-exit false
|
||||
:has-timeout false
|
||||
:timed-out false
|
||||
:exit-reason nil}))
|
||||
(dict-set! (er-sched-processes) (er-pid-key pid) proc)
|
||||
(er-sched-enqueue! pid)
|
||||
proc))))
|
||||
|
||||
(define
|
||||
er-proc-get
|
||||
(fn (pid) (get (er-sched-processes) (er-pid-key pid))))
|
||||
|
||||
(define
|
||||
er-proc-exists?
|
||||
(fn (pid) (dict-has? (er-sched-processes) (er-pid-key pid))))
|
||||
|
||||
(define
|
||||
er-proc-field
|
||||
(fn (pid field) (get (er-proc-get pid) field)))
|
||||
|
||||
(define
|
||||
er-proc-set!
|
||||
(fn
|
||||
(pid field val)
|
||||
(let
|
||||
((p (er-proc-get pid)))
|
||||
(if
|
||||
(= p nil)
|
||||
(error (str "Erlang: no such process " (er-pid-key pid)))
|
||||
(dict-set! p field val)))))
|
||||
|
||||
(define
|
||||
er-proc-mailbox-push!
|
||||
(fn (pid msg) (er-q-push! (er-proc-field pid :mailbox) msg)))
|
||||
|
||||
(define
|
||||
er-proc-mailbox-size
|
||||
(fn (pid) (er-q-len (er-proc-field pid :mailbox))))
|
||||
|
||||
;; Main process is always pid 0 (scheduler starts with next-pid 0 and
|
||||
;; erlang-eval-ast calls er-proc-new! first). Returns nil if no eval
|
||||
;; has run.
|
||||
(define
|
||||
er-main-pid
|
||||
(fn () (er-mk-pid 0)))
|
||||
|
||||
(define
|
||||
er-last-main-exit-reason
|
||||
(fn
|
||||
()
|
||||
(if
|
||||
(er-proc-exists? (er-main-pid))
|
||||
(er-proc-field (er-main-pid) :exit-reason)
|
||||
nil)))
|
||||
|
||||
;; ── process BIFs ────────────────────────────────────────────────
|
||||
(define
|
||||
er-bif-is-pid
|
||||
(fn (vs) (er-bool (er-pid? (er-bif-arg1 vs "is_pid")))))
|
||||
|
||||
(define
|
||||
er-bif-self
|
||||
(fn
|
||||
(vs)
|
||||
(if
|
||||
(not (= (len vs) 0))
|
||||
(error "Erlang: self/0: arity")
|
||||
(let
|
||||
((pid (er-sched-current-pid)))
|
||||
(if
|
||||
(= pid nil)
|
||||
(error "Erlang: self/0: no current process")
|
||||
pid)))))
|
||||
|
||||
(define
|
||||
er-bif-spawn
|
||||
(fn
|
||||
(vs)
|
||||
(cond
|
||||
(= (len vs) 1) (er-spawn-fun (nth vs 0))
|
||||
(= (len vs) 3) (error
|
||||
"Erlang: spawn/3: module-based spawn deferred to Phase 5 (modules)")
|
||||
:else (error "Erlang: spawn: wrong arity"))))
|
||||
|
||||
(define
|
||||
er-spawn-fun
|
||||
(fn
|
||||
(fv)
|
||||
(if
|
||||
(not (er-fun? fv))
|
||||
(error "Erlang: spawn/1: not a fun")
|
||||
(let
|
||||
((proc (er-proc-new! (er-env-new))))
|
||||
(dict-set! proc :initial-fun fv)
|
||||
(get proc :pid)))))
|
||||
|
||||
(define
|
||||
er-bif-exit
|
||||
(fn
|
||||
(vs)
|
||||
(cond
|
||||
(= (len vs) 1) (raise (er-mk-exit-marker (nth vs 0)))
|
||||
(= (len vs) 2)
|
||||
(error
|
||||
"Erlang: exit/2 (signal another process) deferred to next Phase 4 step (signal propagation)")
|
||||
:else (error "Erlang: exit: wrong arity"))))
|
||||
|
||||
;; ── links / monitors / refs ─────────────────────────────────────
|
||||
(define
|
||||
er-bif-is-reference
|
||||
(fn (vs) (er-bool (er-ref? (er-bif-arg1 vs "is_reference")))))
|
||||
|
||||
(define
|
||||
er-bif-process-flag
|
||||
(fn
|
||||
(vs)
|
||||
(if
|
||||
(not (= (len vs) 2))
|
||||
(error "Erlang: process_flag/2: arity")
|
||||
(let
|
||||
((flag (nth vs 0))
|
||||
(val (nth vs 1))
|
||||
(me (er-sched-current-pid)))
|
||||
(cond
|
||||
(and (er-atom? flag) (= (get flag :name) "trap_exit"))
|
||||
(let
|
||||
((old (er-proc-field me :trap-exit)))
|
||||
(er-proc-set! me :trap-exit (er-truthy? val))
|
||||
(er-bool old))
|
||||
:else (error
|
||||
(str
|
||||
"Erlang: process_flag: unsupported flag '"
|
||||
(er-format-value flag)
|
||||
"'")))))))
|
||||
|
||||
(define
|
||||
er-bif-make-ref
|
||||
(fn
|
||||
(vs)
|
||||
(if
|
||||
(not (= (len vs) 0))
|
||||
(error "Erlang: make_ref/0: arity")
|
||||
(er-ref-new!))))
|
||||
|
||||
;; Add `target` to `pid`'s :links list if not already there.
|
||||
(define
|
||||
er-link-add-one!
|
||||
(fn
|
||||
(pid target)
|
||||
(let
|
||||
((links (er-proc-field pid :links)))
|
||||
(when
|
||||
(not (er-link-has? links target))
|
||||
(append! links target)))))
|
||||
|
||||
(define
|
||||
er-link-has?
|
||||
(fn
|
||||
(links target)
|
||||
(cond
|
||||
(= (len links) 0) false
|
||||
(er-pid-equal? (nth links 0) target) true
|
||||
:else (er-link-has? (er-slice-list links 1) target))))
|
||||
|
||||
(define
|
||||
er-link-remove-one!
|
||||
(fn
|
||||
(pid target)
|
||||
(let
|
||||
((old (er-proc-field pid :links)) (out (list)))
|
||||
(for-each
|
||||
(fn
|
||||
(i)
|
||||
(let
|
||||
((p (nth old i)))
|
||||
(when (not (er-pid-equal? p target)) (append! out p))))
|
||||
(range 0 (len old)))
|
||||
(er-proc-set! pid :links out))))
|
||||
|
||||
(define
|
||||
er-bif-link
|
||||
(fn
|
||||
(vs)
|
||||
(let
|
||||
((target (er-bif-arg1 vs "link")) (me (er-sched-current-pid)))
|
||||
(cond
|
||||
(not (er-pid? target)) (error "Erlang: link: not a pid")
|
||||
(er-pid-equal? target me) (er-mk-atom "true")
|
||||
(not (er-proc-exists? target))
|
||||
(raise (er-mk-exit-marker (er-mk-atom "noproc")))
|
||||
:else (do
|
||||
(er-link-add-one! me target)
|
||||
(er-link-add-one! target me)
|
||||
(er-mk-atom "true"))))))
|
||||
|
||||
(define
|
||||
er-bif-unlink
|
||||
(fn
|
||||
(vs)
|
||||
(let
|
||||
((target (er-bif-arg1 vs "unlink")) (me (er-sched-current-pid)))
|
||||
(cond
|
||||
(not (er-pid? target)) (error "Erlang: unlink: not a pid")
|
||||
:else (do
|
||||
(er-link-remove-one! me target)
|
||||
(when
|
||||
(er-proc-exists? target)
|
||||
(er-link-remove-one! target me))
|
||||
(er-mk-atom "true"))))))
|
||||
|
||||
(define
|
||||
er-bif-monitor
|
||||
(fn
|
||||
(vs)
|
||||
(if
|
||||
(not (= (len vs) 2))
|
||||
(error "Erlang: monitor/2: arity")
|
||||
(let
|
||||
((kind (nth vs 0))
|
||||
(target (nth vs 1))
|
||||
(me (er-sched-current-pid)))
|
||||
(cond
|
||||
(not (and (er-atom? kind) (= (get kind :name) "process")))
|
||||
(error "Erlang: monitor: only 'process' supported")
|
||||
(not (er-pid? target)) (error "Erlang: monitor: not a pid")
|
||||
:else (let
|
||||
((ref (er-ref-new!)))
|
||||
(append!
|
||||
(er-proc-field me :monitors)
|
||||
{:ref ref :pid target})
|
||||
(when
|
||||
(er-proc-exists? target)
|
||||
(append!
|
||||
(er-proc-field target :monitored-by)
|
||||
{:from me :ref ref}))
|
||||
ref))))))
|
||||
|
||||
(define
|
||||
er-bif-demonitor
|
||||
(fn
|
||||
(vs)
|
||||
(let
|
||||
((ref (er-bif-arg1 vs "demonitor")) (me (er-sched-current-pid)))
|
||||
(if
|
||||
(not (er-ref? ref))
|
||||
(error "Erlang: demonitor: not a reference")
|
||||
(do
|
||||
(er-demonitor-purge! me ref)
|
||||
(er-mk-atom "true"))))))
|
||||
|
||||
(define
|
||||
er-demonitor-purge!
|
||||
(fn
|
||||
(me ref)
|
||||
(let
|
||||
((old (er-proc-field me :monitors)) (out (list)) (target-ref (list nil)))
|
||||
(for-each
|
||||
(fn
|
||||
(i)
|
||||
(let
|
||||
((m (nth old i)))
|
||||
(if
|
||||
(er-ref-equal? (get m :ref) ref)
|
||||
(set-nth! target-ref 0 (get m :pid))
|
||||
(append! out m))))
|
||||
(range 0 (len old)))
|
||||
(er-proc-set! me :monitors out)
|
||||
(when
|
||||
(and
|
||||
(not (= (nth target-ref 0) nil))
|
||||
(er-proc-exists? (nth target-ref 0)))
|
||||
(let
|
||||
((target (nth target-ref 0))
|
||||
(oldby (er-proc-field (nth target-ref 0) :monitored-by))
|
||||
(out2 (list)))
|
||||
(for-each
|
||||
(fn
|
||||
(i)
|
||||
(let
|
||||
((m (nth oldby i)))
|
||||
(when
|
||||
(not (er-ref-equal? (get m :ref) ref))
|
||||
(append! out2 m))))
|
||||
(range 0 (len oldby)))
|
||||
(er-proc-set! target :monitored-by out2))))))
|
||||
|
||||
;; ── scheduler loop ──────────────────────────────────────────────
|
||||
;; Each scheduler step wraps the process body in `guard`. `receive`
|
||||
;; with no match captures a `call/cc` continuation onto the proc
|
||||
;; record and then `raise`s `er-suspend-marker`; the guard catches
|
||||
;; the raise and the scheduler moves on. `exit/1` raises an exit
|
||||
;; marker the same way. Resumption from a saved continuation also
|
||||
;; runs under a fresh `guard` so a resumed receive that needs to
|
||||
;; suspend again has a handler to unwind to. `shift`/`reset` aren't
|
||||
;; usable here because SX's captured delimited continuations don't
|
||||
;; re-establish their own reset boundary when invoked — a second
|
||||
;; suspension during replay raises "shift without enclosing reset".
|
||||
(define er-suspend-marker {:tag "er-suspend-marker"})
|
||||
|
||||
(define
|
||||
er-suspended?
|
||||
(fn
|
||||
(v)
|
||||
(and
|
||||
(= (type-of v) "dict")
|
||||
(= (get v :tag) "er-suspend-marker"))))
|
||||
|
||||
(define
|
||||
er-exited?
|
||||
(fn
|
||||
(v)
|
||||
(and
|
||||
(= (type-of v) "dict")
|
||||
(= (get v :tag) "er-exit-marker"))))
|
||||
|
||||
(define
|
||||
er-mk-exit-marker
|
||||
(fn (reason) {:tag "er-exit-marker" :reason reason}))
|
||||
|
||||
(define
|
||||
er-mk-throw-marker
|
||||
(fn (reason) {:tag "er-throw-marker" :reason reason}))
|
||||
|
||||
(define
|
||||
er-mk-error-marker
|
||||
(fn (reason) {:tag "er-error-marker" :reason reason}))
|
||||
|
||||
(define
|
||||
er-thrown?
|
||||
(fn
|
||||
(v)
|
||||
(and
|
||||
(= (type-of v) "dict")
|
||||
(= (get v :tag) "er-throw-marker"))))
|
||||
|
||||
(define
|
||||
er-errored?
|
||||
(fn
|
||||
(v)
|
||||
(and
|
||||
(= (type-of v) "dict")
|
||||
(= (get v :tag) "er-error-marker"))))
|
||||
|
||||
(define
|
||||
er-sched-run-all!
|
||||
(fn
|
||||
()
|
||||
(let
|
||||
((pid (er-sched-next-runnable!)))
|
||||
(cond
|
||||
(not (= pid nil))
|
||||
(do (er-sched-step! pid) (er-sched-run-all!))
|
||||
;; Queue empty — fire one pending receive-with-timeout and go again.
|
||||
(er-sched-fire-one-timeout!) (er-sched-run-all!)
|
||||
:else nil))))
|
||||
|
||||
;; Wake one waiting process whose receive had an `after Ms` clause.
|
||||
;; Returns true if one fired. In our synchronous model "time passes"
|
||||
;; once the runnable queue drains — timeouts only fire then.
|
||||
(define
|
||||
er-sched-fire-one-timeout!
|
||||
(fn
|
||||
()
|
||||
(let
|
||||
((ks (keys (er-sched-processes))) (fired (list false)))
|
||||
(for-each
|
||||
(fn
|
||||
(k)
|
||||
(when
|
||||
(not (nth fired 0))
|
||||
(let
|
||||
((p (get (er-sched-processes) k)))
|
||||
(when
|
||||
(and
|
||||
(= (get p :state) "waiting")
|
||||
(get p :has-timeout))
|
||||
(dict-set! p :timed-out true)
|
||||
(dict-set! p :has-timeout false)
|
||||
(dict-set! p :state "runnable")
|
||||
(er-sched-enqueue! (get p :pid))
|
||||
(set-nth! fired 0 true)))))
|
||||
ks)
|
||||
(nth fired 0))))
|
||||
|
||||
(define
|
||||
er-sched-step!
|
||||
(fn
|
||||
(pid)
|
||||
(cond
|
||||
(= (er-proc-field pid :state) "dead") nil
|
||||
:else (er-sched-step-alive! pid))))
|
||||
|
||||
(define
|
||||
er-sched-step-alive!
|
||||
(fn
|
||||
(pid)
|
||||
(er-sched-set-current! pid)
|
||||
(er-proc-set! pid :state "running")
|
||||
(let
|
||||
((prev-k (er-proc-field pid :continuation))
|
||||
(result-ref (list nil)))
|
||||
(guard
|
||||
(c
|
||||
((er-suspended? c) (set-nth! result-ref 0 c))
|
||||
((er-exited? c) (set-nth! result-ref 0 c))
|
||||
((er-thrown? c)
|
||||
(set-nth!
|
||||
result-ref
|
||||
0
|
||||
(er-mk-exit-marker
|
||||
(er-mk-tuple
|
||||
(list (er-mk-atom "nocatch") (get c :reason))))))
|
||||
((er-errored? c)
|
||||
(set-nth! result-ref 0 (er-mk-exit-marker (get c :reason)))))
|
||||
(set-nth!
|
||||
result-ref
|
||||
0
|
||||
(if
|
||||
(= prev-k nil)
|
||||
(er-apply-fun (er-proc-field pid :initial-fun) (list))
|
||||
(do (er-proc-set! pid :continuation nil) (prev-k nil)))))
|
||||
(let
|
||||
((r (nth result-ref 0)))
|
||||
(cond
|
||||
(er-suspended? r) nil
|
||||
(er-exited? r)
|
||||
(do
|
||||
(er-proc-set! pid :state "dead")
|
||||
(er-proc-set! pid :exit-reason (get r :reason))
|
||||
(er-proc-set! pid :exit-result nil)
|
||||
(er-proc-set! pid :continuation nil)
|
||||
(er-propagate-exit! pid (get r :reason)))
|
||||
:else (do
|
||||
(er-proc-set! pid :state "dead")
|
||||
(er-proc-set! pid :exit-reason (er-mk-atom "normal"))
|
||||
(er-proc-set! pid :exit-result r)
|
||||
(er-proc-set! pid :continuation nil)
|
||||
(er-propagate-exit! pid (er-mk-atom "normal"))))))
|
||||
(er-sched-set-current! nil)))
|
||||
|
||||
;; ── exit-signal propagation ─────────────────────────────────────
|
||||
;; Called when `pid` finishes (normally or via exit). Walks the
|
||||
;; process's `:monitored-by` and `:links` lists to deliver `{'DOWN'}`
|
||||
;; messages and exit signals respectively. Linked processes without
|
||||
;; `trap_exit` cascade-die with the same reason; those with
|
||||
;; `trap_exit` true receive an `{'EXIT', From, Reason}` message.
|
||||
(define
|
||||
er-propagate-exit!
|
||||
(fn
|
||||
(pid reason)
|
||||
(er-fire-monitors! pid reason)
|
||||
(er-fire-links! pid reason)))
|
||||
|
||||
(define
|
||||
er-fire-monitors!
|
||||
(fn
|
||||
(pid reason)
|
||||
(let
|
||||
((mons (er-proc-field pid :monitored-by)))
|
||||
(for-each
|
||||
(fn
|
||||
(i)
|
||||
(let
|
||||
((m (nth mons i)))
|
||||
(let
|
||||
((from (get m :from)) (ref (get m :ref)))
|
||||
(when
|
||||
(and (er-proc-exists? from)
|
||||
(not (= (er-proc-field from :state) "dead")))
|
||||
(let
|
||||
((msg
|
||||
(er-mk-tuple
|
||||
(list
|
||||
(er-mk-atom "DOWN")
|
||||
ref
|
||||
(er-mk-atom "process")
|
||||
pid
|
||||
reason))))
|
||||
(er-proc-mailbox-push! from msg)
|
||||
(when
|
||||
(= (er-proc-field from :state) "waiting")
|
||||
(er-proc-set! from :state "runnable")
|
||||
(er-sched-enqueue! from)))))))
|
||||
(range 0 (len mons))))))
|
||||
|
||||
(define
|
||||
er-fire-links!
|
||||
(fn
|
||||
(pid reason)
|
||||
(let
|
||||
((links (er-proc-field pid :links))
|
||||
(is-normal (er-is-atom-named? reason "normal")))
|
||||
(for-each
|
||||
(fn
|
||||
(i)
|
||||
(let
|
||||
((target (nth links i)))
|
||||
(when
|
||||
(and (er-proc-exists? target)
|
||||
(not (= (er-proc-field target :state) "dead")))
|
||||
(let
|
||||
((trap (er-proc-field target :trap-exit)))
|
||||
(cond
|
||||
trap (er-deliver-exit-msg! target pid reason)
|
||||
is-normal nil
|
||||
:else (er-cascade-exit! target reason))))))
|
||||
(range 0 (len links))))))
|
||||
|
||||
(define
|
||||
er-deliver-exit-msg!
|
||||
(fn
|
||||
(target from reason)
|
||||
(let
|
||||
((msg
|
||||
(er-mk-tuple (list (er-mk-atom "EXIT") from reason))))
|
||||
(er-proc-mailbox-push! target msg)
|
||||
(when
|
||||
(= (er-proc-field target :state) "waiting")
|
||||
(er-proc-set! target :state "runnable")
|
||||
(er-sched-enqueue! target)))))
|
||||
|
||||
(define
|
||||
er-cascade-exit!
|
||||
(fn
|
||||
(target reason)
|
||||
(er-proc-set! target :state "dead")
|
||||
(er-proc-set! target :exit-reason reason)
|
||||
(er-proc-set! target :exit-result nil)
|
||||
(er-proc-set! target :continuation nil)
|
||||
(er-propagate-exit! target reason)))
|
||||
@@ -1,16 +0,0 @@
|
||||
{
|
||||
"language": "erlang",
|
||||
"total_pass": 405,
|
||||
"total": 405,
|
||||
"suites": [
|
||||
{"name":"tokenize","pass":62,"total":62,"status":"ok"},
|
||||
{"name":"parse","pass":52,"total":52,"status":"ok"},
|
||||
{"name":"eval","pass":221,"total":221,"status":"ok"},
|
||||
{"name":"runtime","pass":39,"total":39,"status":"ok"},
|
||||
{"name":"ring","pass":4,"total":4,"status":"ok"},
|
||||
{"name":"ping-pong","pass":4,"total":4,"status":"ok"},
|
||||
{"name":"bank","pass":8,"total":8,"status":"ok"},
|
||||
{"name":"echo","pass":7,"total":7,"status":"ok"},
|
||||
{"name":"fib","pass":8,"total":8,"status":"ok"}
|
||||
]
|
||||
}
|
||||
@@ -1,18 +0,0 @@
|
||||
# Erlang-on-SX Scoreboard
|
||||
|
||||
**Total: 405 / 405 tests passing**
|
||||
|
||||
| | Suite | Pass | Total |
|
||||
|---|---|---|---|
|
||||
| ✅ | tokenize | 62 | 62 |
|
||||
| ✅ | parse | 52 | 52 |
|
||||
| ✅ | eval | 221 | 221 |
|
||||
| ✅ | runtime | 39 | 39 |
|
||||
| ✅ | ring | 4 | 4 |
|
||||
| ✅ | ping-pong | 4 | 4 |
|
||||
| ✅ | bank | 8 | 8 |
|
||||
| ✅ | echo | 7 | 7 |
|
||||
| ✅ | fib | 8 | 8 |
|
||||
|
||||
|
||||
Generated by `lib/erlang/conformance.sh`.
|
||||
@@ -1,639 +0,0 @@
|
||||
;; Erlang evaluator tests — sequential expressions.
|
||||
|
||||
(define er-eval-test-count 0)
|
||||
(define er-eval-test-pass 0)
|
||||
(define er-eval-test-fails (list))
|
||||
|
||||
(define
|
||||
eev-deep=
|
||||
(fn
|
||||
(a b)
|
||||
(cond
|
||||
(and (= (type-of a) "dict") (= (type-of b) "dict"))
|
||||
(let
|
||||
((ka (sort (keys a))) (kb (sort (keys b))))
|
||||
(and (= ka kb) (every? (fn (k) (eev-deep= (get a k) (get b k))) ka)))
|
||||
(and (= (type-of a) "list") (= (type-of b) "list"))
|
||||
(and
|
||||
(= (len a) (len b))
|
||||
(every? (fn (i) (eev-deep= (nth a i) (nth b i))) (range 0 (len a))))
|
||||
:else (= a b))))
|
||||
|
||||
(define
|
||||
er-eval-test
|
||||
(fn
|
||||
(name actual expected)
|
||||
(set! er-eval-test-count (+ er-eval-test-count 1))
|
||||
(if
|
||||
(eev-deep= actual expected)
|
||||
(set! er-eval-test-pass (+ er-eval-test-pass 1))
|
||||
(append! er-eval-test-fails {:actual actual :expected expected :name name}))))
|
||||
|
||||
(define ev erlang-eval-ast)
|
||||
(define nm (fn (v) (get v :name)))
|
||||
|
||||
;; ── literals ──────────────────────────────────────────────────────
|
||||
(er-eval-test "int" (ev "42") 42)
|
||||
(er-eval-test "zero" (ev "0") 0)
|
||||
(er-eval-test "float" (ev "3.14") 3.14)
|
||||
(er-eval-test "string" (ev "\"hi\"") "hi")
|
||||
(er-eval-test "atom" (nm (ev "ok")) "ok")
|
||||
(er-eval-test "atom true" (nm (ev "true")) "true")
|
||||
(er-eval-test "atom false" (nm (ev "false")) "false")
|
||||
|
||||
;; ── arithmetic ────────────────────────────────────────────────────
|
||||
(er-eval-test "add" (ev "1 + 2") 3)
|
||||
(er-eval-test "sub" (ev "5 - 3") 2)
|
||||
(er-eval-test "mul" (ev "4 * 3") 12)
|
||||
(er-eval-test "div-real" (ev "10 / 4") 2.5)
|
||||
(er-eval-test "div-int" (ev "10 div 3") 3)
|
||||
(er-eval-test "rem" (ev "10 rem 3") 1)
|
||||
(er-eval-test "div-neg" (ev "-10 div 3") -3)
|
||||
(er-eval-test "precedence" (ev "1 + 2 * 3") 7)
|
||||
(er-eval-test "parens" (ev "(1 + 2) * 3") 9)
|
||||
(er-eval-test "unary-neg" (ev "-(1 + 2)") -3)
|
||||
(er-eval-test "unary-neg int" (ev "-7") -7)
|
||||
|
||||
;; ── comparison ────────────────────────────────────────────────────
|
||||
(er-eval-test "lt true" (nm (ev "1 < 2")) "true")
|
||||
(er-eval-test "gt false" (nm (ev "1 > 2")) "false")
|
||||
(er-eval-test "le equal" (nm (ev "2 =< 2")) "true")
|
||||
(er-eval-test "ge equal" (nm (ev "2 >= 2")) "true")
|
||||
(er-eval-test "eq" (nm (ev "2 == 2")) "true")
|
||||
(er-eval-test "neq" (nm (ev "1 /= 2")) "true")
|
||||
(er-eval-test "exact-eq same" (nm (ev "1 =:= 1")) "true")
|
||||
(er-eval-test "exact-neq int" (nm (ev "1 =:= 2")) "false")
|
||||
(er-eval-test "=/= true" (nm (ev "1 =/= 2")) "true")
|
||||
(er-eval-test "atom-eq" (nm (ev "ok == ok")) "true")
|
||||
(er-eval-test "atom-neq" (nm (ev "ok == error")) "false")
|
||||
|
||||
;; ── logical ───────────────────────────────────────────────────────
|
||||
(er-eval-test "and tt" (nm (ev "true and true")) "true")
|
||||
(er-eval-test "and tf" (nm (ev "true and false")) "false")
|
||||
(er-eval-test "or tf" (nm (ev "true or false")) "true")
|
||||
(er-eval-test
|
||||
"andalso short"
|
||||
(nm (ev "false andalso Neverref"))
|
||||
"false")
|
||||
(er-eval-test
|
||||
"orelse short"
|
||||
(nm (ev "true orelse Neverref"))
|
||||
"true")
|
||||
(er-eval-test "not true" (nm (ev "not true")) "false")
|
||||
(er-eval-test "not false" (nm (ev "not false")) "true")
|
||||
|
||||
;; ── tuples & lists ────────────────────────────────────────────────
|
||||
(er-eval-test "tuple tag" (get (ev "{1, 2, 3}") :tag) "tuple")
|
||||
(er-eval-test "tuple len" (len (get (ev "{1, 2, 3}") :elements)) 3)
|
||||
(er-eval-test "tuple elem" (nth (get (ev "{10, 20}") :elements) 1) 20)
|
||||
(er-eval-test "empty tuple" (len (get (ev "{}") :elements)) 0)
|
||||
(er-eval-test "nested tuple"
|
||||
(nm (nth (get (ev "{ok, error}") :elements) 0)) "ok")
|
||||
(er-eval-test "nil list" (get (ev "[]") :tag) "nil")
|
||||
(er-eval-test "list head" (get (ev "[1, 2, 3]") :head) 1)
|
||||
(er-eval-test
|
||||
"list tail tail head"
|
||||
(get (get (get (ev "[1, 2, 3]") :tail) :tail) :head)
|
||||
3)
|
||||
|
||||
;; ── list ops ──────────────────────────────────────────────────────
|
||||
(er-eval-test "++ head" (get (ev "[1, 2] ++ [3]") :head) 1)
|
||||
(er-eval-test "++ last"
|
||||
(get (get (get (ev "[1, 2] ++ [3]") :tail) :tail) :head) 3)
|
||||
|
||||
;; ── block ─────────────────────────────────────────────────────────
|
||||
(er-eval-test "block last wins" (ev "begin 1, 2, 3 end") 3)
|
||||
(er-eval-test "bare body" (ev "1, 2, 99") 99)
|
||||
|
||||
;; ── match + var ───────────────────────────────────────────────────
|
||||
(er-eval-test "match bind-and-use" (ev "X = 5, X + 1") 6)
|
||||
(er-eval-test "match sequential" (ev "X = 1, Y = 2, X + Y") 3)
|
||||
(er-eval-test
|
||||
"rebind equal ok"
|
||||
(ev "X = 5, X = 5, X") 5)
|
||||
|
||||
;; ── if ────────────────────────────────────────────────────────────
|
||||
(er-eval-test "if picks first" (ev "if true -> 1; true -> 2 end") 1)
|
||||
(er-eval-test
|
||||
"if picks second"
|
||||
(nm (ev "if 1 > 2 -> bad; true -> good end"))
|
||||
"good")
|
||||
(er-eval-test
|
||||
"if with guard"
|
||||
(ev "X = 5, if X > 0 -> 1; true -> 0 end")
|
||||
1)
|
||||
|
||||
;; ── pattern matching ─────────────────────────────────────────────
|
||||
(er-eval-test "match atom literal" (nm (ev "ok = ok, done")) "done")
|
||||
(er-eval-test "match int literal" (ev "5 = 5, 42") 42)
|
||||
(er-eval-test "match tuple bind"
|
||||
(ev "{ok, V} = {ok, 99}, V") 99)
|
||||
(er-eval-test "match tuple nested"
|
||||
(ev "{A, {B, C}} = {1, {2, 3}}, A + B + C") 6)
|
||||
(er-eval-test "match cons head"
|
||||
(ev "[H|T] = [1, 2, 3], H") 1)
|
||||
(er-eval-test "match cons tail head"
|
||||
(ev "[_, H|_] = [1, 2, 3], H") 2)
|
||||
(er-eval-test "match nil"
|
||||
(ev "[] = [], 7") 7)
|
||||
(er-eval-test "match wildcard always"
|
||||
(ev "_ = 42, 7") 7)
|
||||
(er-eval-test "match var reuse equal"
|
||||
(ev "X = 5, X = 5, X") 5)
|
||||
|
||||
;; ── case ─────────────────────────────────────────────────────────
|
||||
(er-eval-test "case bind" (ev "case 5 of N -> N end") 5)
|
||||
(er-eval-test "case tuple"
|
||||
(ev "case {ok, 42} of {ok, V} -> V end") 42)
|
||||
(er-eval-test "case cons"
|
||||
(ev "case [1, 2, 3] of [H|_] -> H end") 1)
|
||||
(er-eval-test "case fallthrough"
|
||||
(ev "case error of ok -> 1; error -> 2 end") 2)
|
||||
(er-eval-test "case wildcard"
|
||||
(nm (ev "case x of ok -> ok; _ -> err end"))
|
||||
"err")
|
||||
(er-eval-test "case guard"
|
||||
(ev "case 5 of N when N > 0 -> pos; _ -> neg end")
|
||||
(er-mk-atom "pos"))
|
||||
(er-eval-test "case guard fallthrough"
|
||||
(ev "case -3 of N when N > 0 -> pos; _ -> neg end")
|
||||
(er-mk-atom "neg"))
|
||||
(er-eval-test "case bound re-match"
|
||||
(ev "X = 5, case 5 of X -> same; _ -> diff end")
|
||||
(er-mk-atom "same"))
|
||||
(er-eval-test "case bound re-match fail"
|
||||
(ev "X = 5, case 6 of X -> same; _ -> diff end")
|
||||
(er-mk-atom "diff"))
|
||||
(er-eval-test "case nested tuple"
|
||||
(ev "case {ok, {value, 42}} of {ok, {value, V}} -> V end")
|
||||
42)
|
||||
(er-eval-test "case multi-clause"
|
||||
(ev "case 2 of 1 -> one; 2 -> two; _ -> other end")
|
||||
(er-mk-atom "two"))
|
||||
(er-eval-test "case leak binding"
|
||||
(ev "case {ok, 7} of {ok, X} -> X end + 1")
|
||||
8)
|
||||
|
||||
;; ── guard BIFs (is_*) ────────────────────────────────────────────
|
||||
(er-eval-test "is_integer 42" (nm (ev "is_integer(42)")) "true")
|
||||
(er-eval-test "is_integer ok" (nm (ev "is_integer(ok)")) "false")
|
||||
(er-eval-test "is_atom ok" (nm (ev "is_atom(ok)")) "true")
|
||||
(er-eval-test "is_atom int" (nm (ev "is_atom(42)")) "false")
|
||||
(er-eval-test "is_list cons" (nm (ev "is_list([1,2])")) "true")
|
||||
(er-eval-test "is_list nil" (nm (ev "is_list([])")) "true")
|
||||
(er-eval-test "is_list tuple" (nm (ev "is_list({1,2})")) "false")
|
||||
(er-eval-test "is_tuple tuple" (nm (ev "is_tuple({ok,1})")) "true")
|
||||
(er-eval-test "is_tuple list" (nm (ev "is_tuple([1])")) "false")
|
||||
(er-eval-test "is_number int" (nm (ev "is_number(42)")) "true")
|
||||
(er-eval-test "is_number atom" (nm (ev "is_number(foo)")) "false")
|
||||
(er-eval-test "is_boolean true" (nm (ev "is_boolean(true)")) "true")
|
||||
(er-eval-test "is_boolean false" (nm (ev "is_boolean(false)")) "true")
|
||||
(er-eval-test "is_boolean atom" (nm (ev "is_boolean(foo)")) "false")
|
||||
|
||||
;; ── guard BIFs wired into case / if ─────────────────────────────
|
||||
(er-eval-test "guard is_integer pick"
|
||||
(nm (ev "case 5 of N when is_integer(N) -> int; _ -> other end"))
|
||||
"int")
|
||||
(er-eval-test "guard is_integer reject"
|
||||
(nm (ev "case foo of N when is_integer(N) -> int; _ -> other end"))
|
||||
"other")
|
||||
(er-eval-test "guard is_atom"
|
||||
(nm (ev "case foo of X when is_atom(X) -> atom_yes; _ -> no end"))
|
||||
"atom_yes")
|
||||
(er-eval-test "guard conjunction"
|
||||
(nm (ev "case 5 of N when is_integer(N), N > 0 -> pos; _ -> np end"))
|
||||
"pos")
|
||||
(er-eval-test "guard disjunction (if)"
|
||||
(nm (ev "X = foo, if is_integer(X); is_atom(X) -> yes; true -> no end"))
|
||||
"yes")
|
||||
(er-eval-test "guard arith"
|
||||
(nm (ev "case 3 of N when N * 2 > 5 -> big; _ -> small end"))
|
||||
"big")
|
||||
|
||||
;; ── BIFs: list + tuple ──────────────────────────────────────────
|
||||
(er-eval-test "length empty" (ev "length([])") 0)
|
||||
(er-eval-test "length 3" (ev "length([a, b, c])") 3)
|
||||
(er-eval-test "length cons chain" (ev "length([1 | [2 | [3 | []]]])") 3)
|
||||
(er-eval-test "hd" (ev "hd([10, 20, 30])") 10)
|
||||
(er-eval-test "hd atom"
|
||||
(nm (ev "hd([ok, err])")) "ok")
|
||||
(er-eval-test "tl head"
|
||||
(get (ev "tl([1, 2, 3])") :head) 2)
|
||||
(er-eval-test "tl of single" (get (ev "tl([1])") :tag) "nil")
|
||||
(er-eval-test "element 1" (nm (ev "element(1, {ok, value})")) "ok")
|
||||
(er-eval-test "element 2" (ev "element(2, {ok, 42})") 42)
|
||||
(er-eval-test "element 3"
|
||||
(nm (ev "element(3, {a, b, c, d})")) "c")
|
||||
(er-eval-test "tuple_size 2" (ev "tuple_size({a, b})") 2)
|
||||
(er-eval-test "tuple_size 0" (ev "tuple_size({})") 0)
|
||||
|
||||
;; ── BIFs: atom / list conversions ───────────────────────────────
|
||||
(er-eval-test "atom_to_list" (ev "atom_to_list(hello)") "hello")
|
||||
(er-eval-test "list_to_atom roundtrip"
|
||||
(nm (ev "list_to_atom(atom_to_list(foo))")) "foo")
|
||||
(er-eval-test "list_to_atom fresh"
|
||||
(nm (ev "list_to_atom(\"bar\")")) "bar")
|
||||
|
||||
;; ── lists module ────────────────────────────────────────────────
|
||||
(er-eval-test "lists:reverse empty"
|
||||
(get (ev "lists:reverse([])") :tag) "nil")
|
||||
(er-eval-test "lists:reverse 3"
|
||||
(ev "hd(lists:reverse([1, 2, 3]))") 3)
|
||||
(er-eval-test "lists:reverse full"
|
||||
(ev "lists:foldl(fun (X, Acc) -> Acc + X end, 0, lists:reverse([1, 2, 3]))") 6)
|
||||
|
||||
;; ── funs + lists:map / lists:foldl ──────────────────────────────
|
||||
(er-eval-test "fun call" (ev "F = fun (X) -> X + 1 end, F(10)") 11)
|
||||
(er-eval-test "fun two-arg"
|
||||
(ev "F = fun (X, Y) -> X * Y end, F(3, 4)") 12)
|
||||
(er-eval-test "fun closure"
|
||||
(ev "N = 100, F = fun (X) -> X + N end, F(5)") 105)
|
||||
(er-eval-test "fun clauses"
|
||||
(ev "F = fun (0) -> zero; (N) -> N end, element(1, {F(0), F(7)})")
|
||||
(er-mk-atom "zero"))
|
||||
(er-eval-test "fun multi-clause second"
|
||||
(ev "F = fun (0) -> 0; (N) -> N * 2 end, F(5)") 10)
|
||||
(er-eval-test "lists:map empty"
|
||||
(get (ev "lists:map(fun (X) -> X end, [])") :tag) "nil")
|
||||
(er-eval-test "lists:map double"
|
||||
(ev "hd(lists:map(fun (X) -> X * 2 end, [1, 2, 3]))") 2)
|
||||
(er-eval-test "lists:map sum-length"
|
||||
(ev "length(lists:map(fun (X) -> X end, [a, b, c, d]))") 4)
|
||||
(er-eval-test "lists:foldl sum"
|
||||
(ev "lists:foldl(fun (X, Acc) -> X + Acc end, 0, [1, 2, 3, 4, 5])") 15)
|
||||
(er-eval-test "lists:foldl product"
|
||||
(ev "lists:foldl(fun (X, Acc) -> X * Acc end, 1, [1, 2, 3, 4])") 24)
|
||||
(er-eval-test "lists:foldl as reverse"
|
||||
(ev "hd(lists:foldl(fun (X, Acc) -> [X | Acc] end, [], [1, 2, 3]))") 3)
|
||||
|
||||
;; ── io:format (via capture buffer) ──────────────────────────────
|
||||
(er-eval-test "io:format plain"
|
||||
(do (er-io-flush!) (ev "io:format(\"hello~n\")") (er-io-buffer-content))
|
||||
"hello\n")
|
||||
(er-eval-test "io:format args"
|
||||
(do (er-io-flush!) (ev "io:format(\"x=~p y=~p~n\", [42, hello])") (er-io-buffer-content))
|
||||
"x=42 y=hello\n")
|
||||
(er-eval-test "io:format returns ok"
|
||||
(nm (do (er-io-flush!) (ev "io:format(\"~n\")"))) "ok")
|
||||
(er-eval-test "io:format tuple"
|
||||
(do (er-io-flush!) (ev "io:format(\"~p\", [{ok, 1}])") (er-io-buffer-content))
|
||||
"{ok,1}")
|
||||
(er-eval-test "io:format list"
|
||||
(do (er-io-flush!) (ev "io:format(\"~p\", [[1,2,3]])") (er-io-buffer-content))
|
||||
"[1,2,3]")
|
||||
(er-eval-test "io:format escape"
|
||||
(do (er-io-flush!) (ev "io:format(\"50~~\")") (er-io-buffer-content))
|
||||
"50~")
|
||||
|
||||
;; ── processes: self/0, spawn/1, is_pid ──────────────────────────
|
||||
(er-eval-test "self tag"
|
||||
(get (ev "self()") :tag) "pid")
|
||||
(er-eval-test "is_pid self"
|
||||
(nm (ev "is_pid(self())")) "true")
|
||||
(er-eval-test "is_pid number"
|
||||
(nm (ev "is_pid(42)")) "false")
|
||||
(er-eval-test "is_pid atom"
|
||||
(nm (ev "is_pid(ok)")) "false")
|
||||
(er-eval-test "self equals self"
|
||||
(nm (ev "Pid = self(), Pid =:= Pid")) "true")
|
||||
(er-eval-test "self =:= self expr"
|
||||
(nm (ev "self() == self()")) "true")
|
||||
(er-eval-test "spawn returns pid"
|
||||
(get (ev "spawn(fun () -> ok end)") :tag) "pid")
|
||||
(er-eval-test "is_pid spawn"
|
||||
(nm (ev "is_pid(spawn(fun () -> ok end))")) "true")
|
||||
(er-eval-test "spawn new pid distinct"
|
||||
(nm (ev "P1 = self(), P2 = spawn(fun () -> ok end), P1 =:= P2"))
|
||||
"false")
|
||||
(er-eval-test "two spawns distinct"
|
||||
(nm (ev "P1 = spawn(fun () -> ok end), P2 = spawn(fun () -> ok end), P1 =:= P2"))
|
||||
"false")
|
||||
(er-eval-test "spawn then drain io"
|
||||
(do
|
||||
(er-io-flush!)
|
||||
(ev "spawn(fun () -> io:format(\"child~n\") end), io:format(\"parent~n\")")
|
||||
(er-io-buffer-content))
|
||||
"parent\nchild\n")
|
||||
(er-eval-test "multiple spawn ordering"
|
||||
(do
|
||||
(er-io-flush!)
|
||||
(ev "spawn(fun () -> io:format(\"a~n\") end), spawn(fun () -> io:format(\"b~n\") end), io:format(\"main~n\")")
|
||||
(er-io-buffer-content))
|
||||
"main\na\nb\n")
|
||||
(er-eval-test "child self is its own pid"
|
||||
(do
|
||||
(er-io-flush!)
|
||||
(ev "P = spawn(fun () -> io:format(\"~p\", [is_pid(self())]) end), io:format(\"~p;\", [is_pid(P)])")
|
||||
(er-io-buffer-content))
|
||||
"true;true")
|
||||
|
||||
;; ── ! (send) + receive ──────────────────────────────────────────
|
||||
(er-eval-test "self-send + receive"
|
||||
(nm (ev "Me = self(), Me ! hello, receive Msg -> Msg end")) "hello")
|
||||
(er-eval-test "send returns msg"
|
||||
(nm (ev "Me = self(), Msg = Me ! ok, Me ! x, receive _ -> Msg end")) "ok")
|
||||
(er-eval-test "receive int"
|
||||
(ev "Me = self(), Me ! 42, receive N -> N + 1 end") 43)
|
||||
(er-eval-test "receive with pattern"
|
||||
(ev "Me = self(), Me ! {ok, 7}, receive {ok, V} -> V * 2 end") 14)
|
||||
(er-eval-test "receive with guard"
|
||||
(ev "Me = self(), Me ! 5, receive N when N > 0 -> positive end")
|
||||
(er-mk-atom "positive"))
|
||||
(er-eval-test "receive skips non-match"
|
||||
(nm (ev "Me = self(), Me ! wrong, Me ! right, receive right -> ok end"))
|
||||
"ok")
|
||||
(er-eval-test "receive selective leaves others"
|
||||
(nm (ev "Me = self(), Me ! a, Me ! b, receive b -> got_b end"))
|
||||
"got_b")
|
||||
(er-eval-test "two receives consume both"
|
||||
(ev "Me = self(), Me ! 1, Me ! 2, X = receive A -> A end, Y = receive B -> B end, X + Y") 3)
|
||||
|
||||
;; ── spawn + send + receive (real process communication) ─────────
|
||||
(er-eval-test "spawn sends back"
|
||||
(nm
|
||||
(ev "Me = self(), spawn(fun () -> Me ! pong end), receive pong -> got_pong end"))
|
||||
"got_pong")
|
||||
(er-eval-test "ping-pong"
|
||||
(do
|
||||
(er-io-flush!)
|
||||
(ev "Me = self(), Child = spawn(fun () -> receive {ping, From} -> From ! pong end end), Child ! {ping, Me}, receive pong -> io:format(\"pong~n\") end")
|
||||
(er-io-buffer-content))
|
||||
"pong\n")
|
||||
(er-eval-test "echo server"
|
||||
(ev "Me = self(), Echo = spawn(fun () -> receive {From, Msg} -> From ! Msg end end), Echo ! {Me, 99}, receive R -> R end") 99)
|
||||
|
||||
;; ── receive with multiple clauses ────────────────────────────────
|
||||
(er-eval-test "receive multi-clause"
|
||||
(nm (ev "Me = self(), Me ! foo, receive ok -> a; foo -> b; bar -> c end"))
|
||||
"b")
|
||||
(er-eval-test "receive nested tuple"
|
||||
(ev "Me = self(), Me ! {result, {ok, 42}}, receive {result, {ok, V}} -> V end") 42)
|
||||
|
||||
;; ── receive ... after ... ───────────────────────────────────────
|
||||
(er-eval-test "after 0 empty mailbox"
|
||||
(nm (ev "receive _ -> got after 0 -> timeout end"))
|
||||
"timeout")
|
||||
(er-eval-test "after 0 match wins"
|
||||
(nm (ev "Me = self(), Me ! ok, receive ok -> got after 0 -> timeout end"))
|
||||
"got")
|
||||
(er-eval-test "after 0 non-match fires timeout"
|
||||
(nm (ev "Me = self(), Me ! wrong, receive right -> got after 0 -> timeout end"))
|
||||
"timeout")
|
||||
(er-eval-test "after 0 leaves non-match"
|
||||
(ev "Me = self(), Me ! wrong, receive right -> got after 0 -> to end, receive X -> X end")
|
||||
(er-mk-atom "wrong"))
|
||||
(er-eval-test "after Ms no sender — timeout fires"
|
||||
(nm (ev "receive _ -> got after 100 -> timed_out end"))
|
||||
"timed_out")
|
||||
(er-eval-test "after Ms with sender — match wins"
|
||||
(nm (ev "Me = self(), spawn(fun () -> Me ! hi end), receive hi -> got after 100 -> to end"))
|
||||
"got")
|
||||
(er-eval-test "after Ms computed"
|
||||
(nm (ev "Ms = 50, receive _ -> got after Ms -> done end"))
|
||||
"done")
|
||||
(er-eval-test "after 0 body side effect"
|
||||
(do (er-io-flush!)
|
||||
(ev "receive _ -> ok after 0 -> io:format(\"to~n\") end")
|
||||
(er-io-buffer-content))
|
||||
"to\n")
|
||||
(er-eval-test "after zero poll selective"
|
||||
(ev "Me = self(), Me ! first, Me ! second, X = receive second -> got_second after 0 -> to end, Y = receive first -> got_first after 0 -> to end, {X, Y}")
|
||||
(er-mk-tuple (list (er-mk-atom "got_second") (er-mk-atom "got_first"))))
|
||||
|
||||
;; ── exit/1 + process termination ─────────────────────────────────
|
||||
(er-eval-test "exit normal returns nil" (ev "exit(normal)") nil)
|
||||
(er-eval-test "exit normal reason"
|
||||
(do (ev "exit(normal)") (nm (er-last-main-exit-reason))) "normal")
|
||||
(er-eval-test "exit bye reason"
|
||||
(do (ev "exit(bye)") (nm (er-last-main-exit-reason))) "bye")
|
||||
(er-eval-test "exit tuple reason"
|
||||
(do (ev "exit({shutdown, crash})")
|
||||
(get (er-last-main-exit-reason) :tag))
|
||||
"tuple")
|
||||
(er-eval-test "normal completion reason"
|
||||
(do (ev "42") (nm (er-last-main-exit-reason))) "normal")
|
||||
(er-eval-test "exit aborts subsequent"
|
||||
(do (er-io-flush!) (ev "io:format(\"a~n\"), exit(bye), io:format(\"b~n\")") (er-io-buffer-content))
|
||||
"a\n")
|
||||
(er-eval-test "child exit doesn't kill parent"
|
||||
(do
|
||||
(er-io-flush!)
|
||||
(ev "spawn(fun () -> io:format(\"before~n\"), exit(quit), io:format(\"after~n\") end), io:format(\"main~n\")")
|
||||
(er-io-buffer-content))
|
||||
"main\nbefore\n")
|
||||
(er-eval-test "child exit reason recorded on child"
|
||||
(do
|
||||
(er-io-flush!)
|
||||
(ev "P = spawn(fun () -> exit(child_bye) end), io:format(\"~p\", [is_pid(P)])")
|
||||
(er-io-buffer-content))
|
||||
"true")
|
||||
(er-eval-test "exit inside fn chain"
|
||||
(do (ev "F = fun () -> exit(from_fn) end, F()")
|
||||
(nm (er-last-main-exit-reason)))
|
||||
"from_fn")
|
||||
|
||||
;; ── refs / link / monitor ──────────────────────────────────────
|
||||
(er-eval-test "make_ref tag"
|
||||
(get (ev "make_ref()") :tag) "ref")
|
||||
(er-eval-test "is_reference fresh"
|
||||
(nm (ev "R = make_ref(), is_reference(R)")) "true")
|
||||
(er-eval-test "is_reference pid"
|
||||
(nm (ev "is_reference(self())")) "false")
|
||||
(er-eval-test "is_reference number"
|
||||
(nm (ev "is_reference(42)")) "false")
|
||||
(er-eval-test "make_ref distinct"
|
||||
(nm (ev "R1 = make_ref(), R2 = make_ref(), R1 =:= R2")) "false")
|
||||
(er-eval-test "make_ref same id eq"
|
||||
(nm (ev "R = make_ref(), R =:= R")) "true")
|
||||
|
||||
(er-eval-test "link returns true"
|
||||
(nm (ev "P = spawn(fun () -> ok end), link(P)")) "true")
|
||||
(er-eval-test "self link returns true"
|
||||
(nm (ev "link(self())")) "true")
|
||||
(er-eval-test "unlink returns true"
|
||||
(nm (ev "P = spawn(fun () -> ok end), link(P), unlink(P)")) "true")
|
||||
(er-eval-test "unlink without link"
|
||||
(nm (ev "P = spawn(fun () -> ok end), unlink(P)")) "true")
|
||||
|
||||
(er-eval-test "monitor returns ref"
|
||||
(get (ev "P = spawn(fun () -> ok end), monitor(process, P)") :tag)
|
||||
"ref")
|
||||
(er-eval-test "monitor refs distinct"
|
||||
(nm (ev "P = spawn(fun () -> ok end), R1 = monitor(process, P), R2 = monitor(process, P), R1 =:= R2"))
|
||||
"false")
|
||||
(er-eval-test "demonitor returns true"
|
||||
(nm (ev "P = spawn(fun () -> ok end), R = monitor(process, P), demonitor(R)"))
|
||||
"true")
|
||||
|
||||
;; Bidirectional link recorded on both sides.
|
||||
(er-eval-test "link bidirectional"
|
||||
(do
|
||||
(ev "P = spawn(fun () -> receive forever -> ok end end), link(P)")
|
||||
;; After eval, check links on main + child via accessors.
|
||||
(and
|
||||
(= (len (er-proc-field (er-mk-pid 0) :links)) 1)
|
||||
(= (len (er-proc-field (er-mk-pid 1) :links)) 1)))
|
||||
true)
|
||||
|
||||
;; unlink clears both sides.
|
||||
(er-eval-test "unlink clears both"
|
||||
(do
|
||||
(ev "P = spawn(fun () -> receive forever -> ok end end), link(P), unlink(P)")
|
||||
(and
|
||||
(= (len (er-proc-field (er-mk-pid 0) :links)) 0)
|
||||
(= (len (er-proc-field (er-mk-pid 1) :links)) 0)))
|
||||
true)
|
||||
|
||||
;; monitor adds entries to both lists.
|
||||
(er-eval-test "monitor records both sides"
|
||||
(do
|
||||
(ev "P = spawn(fun () -> receive forever -> ok end end), monitor(process, P)")
|
||||
(and
|
||||
(= (len (er-proc-field (er-mk-pid 0) :monitors)) 1)
|
||||
(= (len (er-proc-field (er-mk-pid 1) :monitored-by)) 1)))
|
||||
true)
|
||||
|
||||
;; demonitor clears both lists.
|
||||
(er-eval-test "demonitor clears both"
|
||||
(do
|
||||
(ev "P = spawn(fun () -> receive forever -> ok end end), R = monitor(process, P), demonitor(R)")
|
||||
(and
|
||||
(= (len (er-proc-field (er-mk-pid 0) :monitors)) 0)
|
||||
(= (len (er-proc-field (er-mk-pid 1) :monitored-by)) 0)))
|
||||
true)
|
||||
|
||||
;; ── exit-signal propagation + trap_exit ────────────────────────
|
||||
(er-eval-test "process_flag default false"
|
||||
(nm (ev "process_flag(trap_exit, true)")) "false")
|
||||
(er-eval-test "process_flag returns prev"
|
||||
(nm (ev "process_flag(trap_exit, true), process_flag(trap_exit, false)"))
|
||||
"true")
|
||||
|
||||
;; Monitor fires on normal exit.
|
||||
(er-eval-test "monitor DOWN normal"
|
||||
(nm (ev "P = spawn(fun () -> ok end), monitor(process, P), receive {'DOWN', _, process, _, R} -> R end"))
|
||||
"normal")
|
||||
|
||||
;; Monitor fires on abnormal exit.
|
||||
(er-eval-test "monitor DOWN abnormal"
|
||||
(nm (ev "P = spawn(fun () -> exit(boom) end), monitor(process, P), receive {'DOWN', _, process, _, R} -> R end"))
|
||||
"boom")
|
||||
|
||||
;; Monitor's ref appears in DOWN message.
|
||||
(er-eval-test "monitor DOWN ref matches"
|
||||
(nm (ev "P = spawn(fun () -> exit(bye) end), Ref = monitor(process, P), receive {'DOWN', Ref, process, _, _} -> ok_match end"))
|
||||
"ok_match")
|
||||
|
||||
;; Two monitors -> both fire.
|
||||
(er-eval-test "two monitors both fire"
|
||||
(ev "P = spawn(fun () -> exit(crash) end), monitor(process, P), monitor(process, P), receive {'DOWN', _, _, _, _} -> ok end, receive {'DOWN', _, _, _, _} -> 2 end")
|
||||
2)
|
||||
|
||||
;; trap_exit + link + abnormal exit -> {'EXIT', From, Reason} message.
|
||||
(er-eval-test "trap_exit catches abnormal"
|
||||
(nm (ev "process_flag(trap_exit, true), P = spawn(fun () -> exit(boom) end), link(P), receive {'EXIT', _, R} -> R end"))
|
||||
"boom")
|
||||
|
||||
;; trap_exit + link + normal exit -> {'EXIT', From, normal}.
|
||||
(er-eval-test "trap_exit catches normal"
|
||||
(nm (ev "process_flag(trap_exit, true), P = spawn(fun () -> ok end), link(P), receive {'EXIT', _, R} -> R end"))
|
||||
"normal")
|
||||
|
||||
;; Cascade exit: A links B, B dies abnormally, A dies with same reason.
|
||||
(er-eval-test "cascade reason"
|
||||
(do
|
||||
(ev "A = spawn(fun () -> B = spawn(fun () -> exit(crash) end), link(B), receive forever -> ok end end), receive after 0 -> ok end")
|
||||
(nm (er-proc-field (er-mk-pid 1) :exit-reason)))
|
||||
"crash")
|
||||
|
||||
;; Normal exit doesn't cascade (without trap_exit) — A's body returns
|
||||
;; "survived" via the `after` clause and A dies normally.
|
||||
(er-eval-test "normal exit no cascade"
|
||||
(do
|
||||
(ev "A = spawn(fun () -> B = spawn(fun () -> ok end), link(B), receive {'EXIT', _, _} -> got_exit after 50 -> survived end end), receive after 0 -> ok end")
|
||||
(list
|
||||
(nm (er-proc-field (er-mk-pid 1) :exit-reason))
|
||||
(nm (er-proc-field (er-mk-pid 1) :exit-result))))
|
||||
(list "normal" "survived"))
|
||||
|
||||
;; Monitor without trap_exit: monitored proc abnormal doesn't kill the monitor.
|
||||
(er-eval-test "monitor doesn't cascade"
|
||||
(nm (ev "P = spawn(fun () -> exit(boom) end), monitor(process, P), receive {'DOWN', _, _, _, _} -> alive end"))
|
||||
"alive")
|
||||
|
||||
;; ── try / catch / of / after ─────────────────────────────────
|
||||
(er-eval-test "try plain"
|
||||
(ev "try 1 + 2 catch _ -> oops end") 3)
|
||||
|
||||
(er-eval-test "try throw caught"
|
||||
(nm (ev "try throw(boom) catch throw:X -> X end")) "boom")
|
||||
(er-eval-test "try error caught"
|
||||
(nm (ev "try error(crash) catch error:X -> X end")) "crash")
|
||||
(er-eval-test "try exit caught"
|
||||
(nm (ev "try exit(quit) catch exit:X -> X end")) "quit")
|
||||
|
||||
(er-eval-test "default class is throw"
|
||||
(nm (ev "try throw(bye) catch X -> X end")) "bye")
|
||||
(er-eval-test "default class doesn't catch error"
|
||||
(do
|
||||
(ev "P = spawn(fun () -> try error(crash) catch X -> X end end), receive after 0 -> ok end")
|
||||
(nm (er-proc-field (er-mk-pid 1) :exit-reason)))
|
||||
"crash")
|
||||
|
||||
;; of clauses
|
||||
(er-eval-test "try of single"
|
||||
(ev "try 42 of N -> N * 2 catch _ -> 0 end") 84)
|
||||
(er-eval-test "try of multi"
|
||||
(nm (ev "try ok of ok -> matched; _ -> nope catch _ -> oops end"))
|
||||
"matched")
|
||||
(er-eval-test "try of fallthrough"
|
||||
(nm (ev "try x of ok -> a; error -> b; _ -> default catch _ -> oops end"))
|
||||
"default")
|
||||
(er-eval-test "try of with guard"
|
||||
(nm (ev "try 5 of N when N > 0 -> pos; _ -> nonneg catch _ -> oops end"))
|
||||
"pos")
|
||||
|
||||
;; after clause
|
||||
(er-eval-test "after on success"
|
||||
(do (er-io-flush!)
|
||||
(ev "try 7 after io:format(\"a\") end")
|
||||
(er-io-buffer-content))
|
||||
"a")
|
||||
(er-eval-test "after on caught"
|
||||
(do (er-io-flush!)
|
||||
(ev "try throw(b) catch throw:_ -> caught after io:format(\"x\") end")
|
||||
(er-io-buffer-content))
|
||||
"x")
|
||||
(er-eval-test "after returns body value"
|
||||
(ev "try 99 after 0 end") 99)
|
||||
(er-eval-test "try preserves catch result"
|
||||
(nm (ev "try throw(x) catch throw:_ -> recovered after 0 end"))
|
||||
"recovered")
|
||||
|
||||
;; nested try
|
||||
(er-eval-test "try nested catch outer"
|
||||
(nm (ev "try (try throw(inner) catch error:_ -> bad end) catch throw:X -> X end"))
|
||||
"inner")
|
||||
(er-eval-test "try nested catch inner"
|
||||
(nm (ev "try (try throw(inner) catch throw:X -> X end) catch _ -> outer end"))
|
||||
"inner")
|
||||
|
||||
;; class re-raise on no-match
|
||||
(er-eval-test "throw without catch-throw escapes"
|
||||
(do
|
||||
(ev "P = spawn(fun () -> try throw(bye) catch error:_ -> nope end end), receive after 0 -> ok end")
|
||||
(let ((reason (er-proc-field (er-mk-pid 1) :exit-reason)))
|
||||
(and (er-tuple? reason) (nm (nth (get reason :elements) 0)))))
|
||||
"nocatch")
|
||||
|
||||
;; multi-clause catch
|
||||
(er-eval-test "multi-clause catch picks throw"
|
||||
(nm (ev "try throw(a) catch error:X -> e; throw:X -> t; exit:X -> x end"))
|
||||
"t")
|
||||
(er-eval-test "multi-clause catch picks exit"
|
||||
(nm (ev "try exit(a) catch error:X -> e; throw:X -> t; exit:X -> x end"))
|
||||
"x")
|
||||
|
||||
(define
|
||||
er-eval-test-summary
|
||||
(str "eval " er-eval-test-pass "/" er-eval-test-count))
|
||||
@@ -1,159 +0,0 @@
|
||||
;; Bank account server — stateful process, balance threaded through
|
||||
;; recursive loop. Handles {deposit, Amt, From}, {withdraw, Amt, From},
|
||||
;; {balance, From}, stop. Tests stateful process patterns.
|
||||
|
||||
(define er-bank-test-count 0)
|
||||
(define er-bank-test-pass 0)
|
||||
(define er-bank-test-fails (list))
|
||||
|
||||
(define
|
||||
er-bank-test
|
||||
(fn
|
||||
(name actual expected)
|
||||
(set! er-bank-test-count (+ er-bank-test-count 1))
|
||||
(if
|
||||
(= actual expected)
|
||||
(set! er-bank-test-pass (+ er-bank-test-pass 1))
|
||||
(append! er-bank-test-fails {:actual actual :expected expected :name name}))))
|
||||
|
||||
(define bank-ev erlang-eval-ast)
|
||||
|
||||
;; Server fun shared by all tests — threaded via the program string.
|
||||
(define
|
||||
er-bank-server-src
|
||||
"Server = fun (Balance) ->
|
||||
receive
|
||||
{deposit, Amt, From} -> From ! ok, Server(Balance + Amt);
|
||||
{withdraw, Amt, From} ->
|
||||
if Amt > Balance -> From ! insufficient, Server(Balance);
|
||||
true -> From ! ok, Server(Balance - Amt)
|
||||
end;
|
||||
{balance, From} -> From ! Balance, Server(Balance);
|
||||
stop -> ok
|
||||
end
|
||||
end")
|
||||
|
||||
;; Open account, deposit, check balance.
|
||||
(er-bank-test
|
||||
"deposit 100 -> balance 100"
|
||||
(bank-ev
|
||||
(str
|
||||
er-bank-server-src
|
||||
", Me = self(),
|
||||
Bank = spawn(fun () -> Server(0) end),
|
||||
Bank ! {deposit, 100, Me},
|
||||
receive ok -> ok end,
|
||||
Bank ! {balance, Me},
|
||||
receive B -> Bank ! stop, B end"))
|
||||
100)
|
||||
|
||||
;; Multiple deposits accumulate.
|
||||
(er-bank-test
|
||||
"deposits accumulate"
|
||||
(bank-ev
|
||||
(str
|
||||
er-bank-server-src
|
||||
", Me = self(),
|
||||
Bank = spawn(fun () -> Server(0) end),
|
||||
Bank ! {deposit, 50, Me}, receive ok -> ok end,
|
||||
Bank ! {deposit, 25, Me}, receive ok -> ok end,
|
||||
Bank ! {deposit, 10, Me}, receive ok -> ok end,
|
||||
Bank ! {balance, Me},
|
||||
receive B -> Bank ! stop, B end"))
|
||||
85)
|
||||
|
||||
;; Withdraw within balance succeeds; insufficient gets rejected.
|
||||
(er-bank-test
|
||||
"withdraw within balance"
|
||||
(bank-ev
|
||||
(str
|
||||
er-bank-server-src
|
||||
", Me = self(),
|
||||
Bank = spawn(fun () -> Server(100) end),
|
||||
Bank ! {withdraw, 30, Me}, receive ok -> ok end,
|
||||
Bank ! {balance, Me},
|
||||
receive B -> Bank ! stop, B end"))
|
||||
70)
|
||||
|
||||
(er-bank-test
|
||||
"withdraw insufficient"
|
||||
(get
|
||||
(bank-ev
|
||||
(str
|
||||
er-bank-server-src
|
||||
", Me = self(),
|
||||
Bank = spawn(fun () -> Server(20) end),
|
||||
Bank ! {withdraw, 100, Me},
|
||||
receive R -> Bank ! stop, R end"))
|
||||
:name)
|
||||
"insufficient")
|
||||
|
||||
;; State preserved across an insufficient withdrawal.
|
||||
(er-bank-test
|
||||
"state preserved on rejection"
|
||||
(bank-ev
|
||||
(str
|
||||
er-bank-server-src
|
||||
", Me = self(),
|
||||
Bank = spawn(fun () -> Server(50) end),
|
||||
Bank ! {withdraw, 1000, Me}, receive _ -> ok end,
|
||||
Bank ! {balance, Me},
|
||||
receive B -> Bank ! stop, B end"))
|
||||
50)
|
||||
|
||||
;; Mixed deposits and withdrawals.
|
||||
(er-bank-test
|
||||
"mixed transactions"
|
||||
(bank-ev
|
||||
(str
|
||||
er-bank-server-src
|
||||
", Me = self(),
|
||||
Bank = spawn(fun () -> Server(100) end),
|
||||
Bank ! {deposit, 50, Me}, receive ok -> ok end,
|
||||
Bank ! {withdraw, 30, Me}, receive ok -> ok end,
|
||||
Bank ! {deposit, 10, Me}, receive ok -> ok end,
|
||||
Bank ! {withdraw, 5, Me}, receive ok -> ok end,
|
||||
Bank ! {balance, Me},
|
||||
receive B -> Bank ! stop, B end"))
|
||||
125)
|
||||
|
||||
;; Server.stop terminates the bank cleanly — main can verify by
|
||||
;; sending stop and then exiting normally.
|
||||
(er-bank-test
|
||||
"server stops cleanly"
|
||||
(get
|
||||
(bank-ev
|
||||
(str
|
||||
er-bank-server-src
|
||||
", Me = self(),
|
||||
Bank = spawn(fun () -> Server(0) end),
|
||||
Bank ! stop,
|
||||
done"))
|
||||
:name)
|
||||
"done")
|
||||
|
||||
;; Two clients sharing one bank — interleaved transactions.
|
||||
(er-bank-test
|
||||
"two clients share bank"
|
||||
(bank-ev
|
||||
(str
|
||||
er-bank-server-src
|
||||
", Me = self(),
|
||||
Bank = spawn(fun () -> Server(0) end),
|
||||
Client = fun (Amt) ->
|
||||
spawn(fun () ->
|
||||
Bank ! {deposit, Amt, self()},
|
||||
receive ok -> Me ! deposited end
|
||||
end)
|
||||
end,
|
||||
Client(40),
|
||||
Client(60),
|
||||
receive deposited -> ok end,
|
||||
receive deposited -> ok end,
|
||||
Bank ! {balance, Me},
|
||||
receive B -> Bank ! stop, B end"))
|
||||
100)
|
||||
|
||||
(define
|
||||
er-bank-test-summary
|
||||
(str "bank " er-bank-test-pass "/" er-bank-test-count))
|
||||
@@ -1,140 +0,0 @@
|
||||
;; Echo server — minimal classic Erlang server. Receives {From, Msg}
|
||||
;; and sends Msg back to From, then loops. `stop` ends the server.
|
||||
|
||||
(define er-echo-test-count 0)
|
||||
(define er-echo-test-pass 0)
|
||||
(define er-echo-test-fails (list))
|
||||
|
||||
(define
|
||||
er-echo-test
|
||||
(fn
|
||||
(name actual expected)
|
||||
(set! er-echo-test-count (+ er-echo-test-count 1))
|
||||
(if
|
||||
(= actual expected)
|
||||
(set! er-echo-test-pass (+ er-echo-test-pass 1))
|
||||
(append! er-echo-test-fails {:actual actual :expected expected :name name}))))
|
||||
|
||||
(define echo-ev erlang-eval-ast)
|
||||
|
||||
(define
|
||||
er-echo-server-src
|
||||
"EchoSrv = fun () ->
|
||||
Loop = fun () ->
|
||||
receive
|
||||
{From, Msg} -> From ! Msg, Loop();
|
||||
stop -> ok
|
||||
end
|
||||
end,
|
||||
Loop()
|
||||
end")
|
||||
|
||||
;; Single round-trip with an atom.
|
||||
(er-echo-test
|
||||
"atom round-trip"
|
||||
(get
|
||||
(echo-ev
|
||||
(str
|
||||
er-echo-server-src
|
||||
", Me = self(),
|
||||
Echo = spawn(EchoSrv),
|
||||
Echo ! {Me, hello},
|
||||
receive R -> Echo ! stop, R end"))
|
||||
:name)
|
||||
"hello")
|
||||
|
||||
;; Number round-trip.
|
||||
(er-echo-test
|
||||
"number round-trip"
|
||||
(echo-ev
|
||||
(str
|
||||
er-echo-server-src
|
||||
", Me = self(),
|
||||
Echo = spawn(EchoSrv),
|
||||
Echo ! {Me, 42},
|
||||
receive R -> Echo ! stop, R end"))
|
||||
42)
|
||||
|
||||
;; Tuple round-trip — pattern-match the reply to extract V.
|
||||
(er-echo-test
|
||||
"tuple round-trip"
|
||||
(echo-ev
|
||||
(str
|
||||
er-echo-server-src
|
||||
", Me = self(),
|
||||
Echo = spawn(EchoSrv),
|
||||
Echo ! {Me, {ok, 7}},
|
||||
receive {ok, V} -> Echo ! stop, V end"))
|
||||
7)
|
||||
|
||||
;; List round-trip.
|
||||
(er-echo-test
|
||||
"list round-trip"
|
||||
(echo-ev
|
||||
(str
|
||||
er-echo-server-src
|
||||
", Me = self(),
|
||||
Echo = spawn(EchoSrv),
|
||||
Echo ! {Me, [1, 2, 3]},
|
||||
receive [H | _] -> Echo ! stop, H end"))
|
||||
1)
|
||||
|
||||
;; Multiple sequential round-trips.
|
||||
(er-echo-test
|
||||
"three round-trips"
|
||||
(echo-ev
|
||||
(str
|
||||
er-echo-server-src
|
||||
", Me = self(),
|
||||
Echo = spawn(EchoSrv),
|
||||
Echo ! {Me, 10}, A = receive Ra -> Ra end,
|
||||
Echo ! {Me, 20}, B = receive Rb -> Rb end,
|
||||
Echo ! {Me, 30}, C = receive Rc -> Rc end,
|
||||
Echo ! stop,
|
||||
A + B + C"))
|
||||
60)
|
||||
|
||||
;; Two clients sharing one echo server. Each gets its own reply.
|
||||
(er-echo-test
|
||||
"two clients"
|
||||
(get
|
||||
(echo-ev
|
||||
(str
|
||||
er-echo-server-src
|
||||
", Me = self(),
|
||||
Echo = spawn(EchoSrv),
|
||||
Client = fun (Tag) ->
|
||||
spawn(fun () ->
|
||||
Echo ! {self(), Tag},
|
||||
receive R -> Me ! {got, R} end
|
||||
end)
|
||||
end,
|
||||
Client(a),
|
||||
Client(b),
|
||||
receive {got, _} -> ok end,
|
||||
receive {got, _} -> ok end,
|
||||
Echo ! stop,
|
||||
finished"))
|
||||
:name)
|
||||
"finished")
|
||||
|
||||
;; Echo via io trace — verify each message round-trips through.
|
||||
(er-echo-test
|
||||
"trace 4 messages"
|
||||
(do
|
||||
(er-io-flush!)
|
||||
(echo-ev
|
||||
(str
|
||||
er-echo-server-src
|
||||
", Me = self(),
|
||||
Echo = spawn(EchoSrv),
|
||||
Send = fun (V) -> Echo ! {Me, V}, receive R -> io:format(\"~p \", [R]) end end,
|
||||
Send(1), Send(2), Send(3), Send(4),
|
||||
Echo ! stop,
|
||||
done"))
|
||||
(er-io-buffer-content))
|
||||
"1 2 3 4 ")
|
||||
|
||||
(define
|
||||
er-echo-test-summary
|
||||
(str "echo " er-echo-test-pass "/" er-echo-test-count))
|
||||
@@ -1,152 +0,0 @@
|
||||
;; Fib server — long-lived process that computes fibonacci numbers on
|
||||
;; request. Tests recursive function evaluation inside a server loop.
|
||||
|
||||
(define er-fib-test-count 0)
|
||||
(define er-fib-test-pass 0)
|
||||
(define er-fib-test-fails (list))
|
||||
|
||||
(define
|
||||
er-fib-test
|
||||
(fn
|
||||
(name actual expected)
|
||||
(set! er-fib-test-count (+ er-fib-test-count 1))
|
||||
(if
|
||||
(= actual expected)
|
||||
(set! er-fib-test-pass (+ er-fib-test-pass 1))
|
||||
(append! er-fib-test-fails {:actual actual :expected expected :name name}))))
|
||||
|
||||
(define fib-ev erlang-eval-ast)
|
||||
|
||||
;; Fib + server-loop source. Standalone so each test can chain queries.
|
||||
(define
|
||||
er-fib-server-src
|
||||
"Fib = fun (0) -> 0; (1) -> 1; (N) -> Fib(N-1) + Fib(N-2) end,
|
||||
FibSrv = fun () ->
|
||||
Loop = fun () ->
|
||||
receive
|
||||
{fib, N, From} -> From ! Fib(N), Loop();
|
||||
stop -> ok
|
||||
end
|
||||
end,
|
||||
Loop()
|
||||
end")
|
||||
|
||||
;; Base cases.
|
||||
(er-fib-test
|
||||
"fib(0)"
|
||||
(fib-ev
|
||||
(str
|
||||
er-fib-server-src
|
||||
", Me = self(),
|
||||
Srv = spawn(FibSrv),
|
||||
Srv ! {fib, 0, Me},
|
||||
receive R -> Srv ! stop, R end"))
|
||||
0)
|
||||
|
||||
(er-fib-test
|
||||
"fib(1)"
|
||||
(fib-ev
|
||||
(str
|
||||
er-fib-server-src
|
||||
", Me = self(),
|
||||
Srv = spawn(FibSrv),
|
||||
Srv ! {fib, 1, Me},
|
||||
receive R -> Srv ! stop, R end"))
|
||||
1)
|
||||
|
||||
;; Larger values.
|
||||
(er-fib-test
|
||||
"fib(10) = 55"
|
||||
(fib-ev
|
||||
(str
|
||||
er-fib-server-src
|
||||
", Me = self(),
|
||||
Srv = spawn(FibSrv),
|
||||
Srv ! {fib, 10, Me},
|
||||
receive R -> Srv ! stop, R end"))
|
||||
55)
|
||||
|
||||
(er-fib-test
|
||||
"fib(15) = 610"
|
||||
(fib-ev
|
||||
(str
|
||||
er-fib-server-src
|
||||
", Me = self(),
|
||||
Srv = spawn(FibSrv),
|
||||
Srv ! {fib, 15, Me},
|
||||
receive R -> Srv ! stop, R end"))
|
||||
610)
|
||||
|
||||
;; Multiple sequential queries to one server. Sum to avoid dict-equality.
|
||||
(er-fib-test
|
||||
"sequential fib(5..8) sum"
|
||||
(fib-ev
|
||||
(str
|
||||
er-fib-server-src
|
||||
", Me = self(),
|
||||
Srv = spawn(FibSrv),
|
||||
Srv ! {fib, 5, Me}, A = receive Ra -> Ra end,
|
||||
Srv ! {fib, 6, Me}, B = receive Rb -> Rb end,
|
||||
Srv ! {fib, 7, Me}, C = receive Rc -> Rc end,
|
||||
Srv ! {fib, 8, Me}, D = receive Rd -> Rd end,
|
||||
Srv ! stop,
|
||||
A + B + C + D"))
|
||||
47)
|
||||
|
||||
;; Verify Fib obeys the recurrence — fib(n) = fib(n-1) + fib(n-2).
|
||||
(er-fib-test
|
||||
"fib recurrence at n=12"
|
||||
(fib-ev
|
||||
(str
|
||||
er-fib-server-src
|
||||
", Me = self(),
|
||||
Srv = spawn(FibSrv),
|
||||
Srv ! {fib, 10, Me}, A = receive Ra -> Ra end,
|
||||
Srv ! {fib, 11, Me}, B = receive Rb -> Rb end,
|
||||
Srv ! {fib, 12, Me}, C = receive Rc -> Rc end,
|
||||
Srv ! stop,
|
||||
C - (A + B)"))
|
||||
0)
|
||||
|
||||
;; Two clients each get their own answer; main sums the results.
|
||||
(er-fib-test
|
||||
"two clients sum"
|
||||
(fib-ev
|
||||
(str
|
||||
er-fib-server-src
|
||||
", Me = self(),
|
||||
Srv = spawn(FibSrv),
|
||||
Client = fun (N) ->
|
||||
spawn(fun () ->
|
||||
Srv ! {fib, N, self()},
|
||||
receive R -> Me ! {result, R} end
|
||||
end)
|
||||
end,
|
||||
Client(7),
|
||||
Client(9),
|
||||
{result, A} = receive M1 -> M1 end,
|
||||
{result, B} = receive M2 -> M2 end,
|
||||
Srv ! stop,
|
||||
A + B"))
|
||||
47)
|
||||
|
||||
;; Trace queries via io-buffer.
|
||||
(er-fib-test
|
||||
"trace fib 0..6"
|
||||
(do
|
||||
(er-io-flush!)
|
||||
(fib-ev
|
||||
(str
|
||||
er-fib-server-src
|
||||
", Me = self(),
|
||||
Srv = spawn(FibSrv),
|
||||
Ask = fun (N) -> Srv ! {fib, N, Me}, receive R -> io:format(\"~p \", [R]) end end,
|
||||
Ask(0), Ask(1), Ask(2), Ask(3), Ask(4), Ask(5), Ask(6),
|
||||
Srv ! stop,
|
||||
done"))
|
||||
(er-io-buffer-content))
|
||||
"0 1 1 2 3 5 8 ")
|
||||
|
||||
(define
|
||||
er-fib-test-summary
|
||||
(str "fib " er-fib-test-pass "/" er-fib-test-count))
|
||||
@@ -1,127 +0,0 @@
|
||||
;; Ping-pong program — two processes exchange N messages, then signal
|
||||
;; main via separate `ping_done` / `pong_done` notifications.
|
||||
|
||||
(define er-pp-test-count 0)
|
||||
(define er-pp-test-pass 0)
|
||||
(define er-pp-test-fails (list))
|
||||
|
||||
(define
|
||||
er-pp-test
|
||||
(fn
|
||||
(name actual expected)
|
||||
(set! er-pp-test-count (+ er-pp-test-count 1))
|
||||
(if
|
||||
(= actual expected)
|
||||
(set! er-pp-test-pass (+ er-pp-test-pass 1))
|
||||
(append! er-pp-test-fails {:actual actual :expected expected :name name}))))
|
||||
|
||||
(define pp-ev erlang-eval-ast)
|
||||
|
||||
;; Three rounds of ping-pong, then stop. Main receives ping_done and
|
||||
;; pong_done in arrival order (Ping finishes first because Pong exits
|
||||
;; only after receiving stop).
|
||||
(define
|
||||
er-pp-program
|
||||
"Me = self(),
|
||||
Pong = spawn(fun () ->
|
||||
Loop = fun () ->
|
||||
receive
|
||||
{ping, From} -> From ! pong, Loop();
|
||||
stop -> Me ! pong_done
|
||||
end
|
||||
end,
|
||||
Loop()
|
||||
end),
|
||||
Ping = fun (Target, K) ->
|
||||
if K =:= 0 -> Target ! stop, Me ! ping_done;
|
||||
true -> Target ! {ping, self()}, receive pong -> Ping(Target, K - 1) end
|
||||
end
|
||||
end,
|
||||
spawn(fun () -> Ping(Pong, 3) end),
|
||||
receive ping_done -> ok end,
|
||||
receive pong_done -> both_done end")
|
||||
|
||||
(er-pp-test
|
||||
"ping-pong 3 rounds"
|
||||
(get (pp-ev er-pp-program) :name)
|
||||
"both_done")
|
||||
|
||||
;; Count exchanges via io-buffer — each pong trip prints "p".
|
||||
(er-pp-test
|
||||
"ping-pong 5 rounds trace"
|
||||
(do
|
||||
(er-io-flush!)
|
||||
(pp-ev
|
||||
"Me = self(),
|
||||
Pong = spawn(fun () ->
|
||||
Loop = fun () ->
|
||||
receive
|
||||
{ping, From} -> io:format(\"p\"), From ! pong, Loop();
|
||||
stop -> Me ! pong_done
|
||||
end
|
||||
end,
|
||||
Loop()
|
||||
end),
|
||||
Ping = fun (Target, K) ->
|
||||
if K =:= 0 -> Target ! stop, Me ! ping_done;
|
||||
true -> Target ! {ping, self()}, receive pong -> Ping(Target, K - 1) end
|
||||
end
|
||||
end,
|
||||
spawn(fun () -> Ping(Pong, 5) end),
|
||||
receive ping_done -> ok end,
|
||||
receive pong_done -> ok end")
|
||||
(er-io-buffer-content))
|
||||
"ppppp")
|
||||
|
||||
;; Main → Pong directly (no Ping process). Main plays the ping role.
|
||||
(er-pp-test
|
||||
"main-as-pinger 4 rounds"
|
||||
(pp-ev
|
||||
"Me = self(),
|
||||
Pong = spawn(fun () ->
|
||||
Loop = fun () ->
|
||||
receive
|
||||
{ping, From} -> From ! pong, Loop();
|
||||
stop -> ok
|
||||
end
|
||||
end,
|
||||
Loop()
|
||||
end),
|
||||
Go = fun (K) ->
|
||||
if K =:= 0 -> Pong ! stop, K;
|
||||
true -> Pong ! {ping, Me}, receive pong -> Go(K - 1) end
|
||||
end
|
||||
end,
|
||||
Go(4)")
|
||||
0)
|
||||
|
||||
;; Ensure the processes really interleave — inject an id into each
|
||||
;; ping and check we get them all back via trace (the order is
|
||||
;; deterministic under our sync scheduler).
|
||||
(er-pp-test
|
||||
"ids round-trip"
|
||||
(do
|
||||
(er-io-flush!)
|
||||
(pp-ev
|
||||
"Me = self(),
|
||||
Pong = spawn(fun () ->
|
||||
Loop = fun () ->
|
||||
receive
|
||||
{ping, From, Id} -> From ! {pong, Id}, Loop();
|
||||
stop -> ok
|
||||
end
|
||||
end,
|
||||
Loop()
|
||||
end),
|
||||
Go = fun (K) ->
|
||||
if K =:= 0 -> Pong ! stop, done;
|
||||
true -> Pong ! {ping, Me, K}, receive {pong, RId} -> io:format(\"~p \", [RId]), Go(K - 1) end
|
||||
end
|
||||
end,
|
||||
Go(4)")
|
||||
(er-io-buffer-content))
|
||||
"4 3 2 1 ")
|
||||
|
||||
(define
|
||||
er-pp-test-summary
|
||||
(str "ping-pong " er-pp-test-pass "/" er-pp-test-count))
|
||||
@@ -1,132 +0,0 @@
|
||||
;; Ring program — N processes in a ring, token passes M times.
|
||||
;;
|
||||
;; Each process waits for {setup, Next} so main can tie the knot
|
||||
;; (can't reference a pid before spawning it). Once wired, main
|
||||
;; injects the first token; each process forwards decrementing K
|
||||
;; until it hits 0, at which point it signals `done` to main.
|
||||
|
||||
(define er-ring-test-count 0)
|
||||
(define er-ring-test-pass 0)
|
||||
(define er-ring-test-fails (list))
|
||||
|
||||
(define
|
||||
er-ring-test
|
||||
(fn
|
||||
(name actual expected)
|
||||
(set! er-ring-test-count (+ er-ring-test-count 1))
|
||||
(if
|
||||
(= actual expected)
|
||||
(set! er-ring-test-pass (+ er-ring-test-pass 1))
|
||||
(append! er-ring-test-fails {:actual actual :expected expected :name name}))))
|
||||
|
||||
(define ring-ev erlang-eval-ast)
|
||||
|
||||
(define
|
||||
er-ring-program-3-6
|
||||
"Me = self(),
|
||||
Spawner = fun () ->
|
||||
receive {setup, Next} ->
|
||||
Loop = fun () ->
|
||||
receive
|
||||
{token, 0, Parent} -> Parent ! done;
|
||||
{token, K, Parent} -> Next ! {token, K-1, Parent}, Loop()
|
||||
end
|
||||
end,
|
||||
Loop()
|
||||
end
|
||||
end,
|
||||
P1 = spawn(Spawner),
|
||||
P2 = spawn(Spawner),
|
||||
P3 = spawn(Spawner),
|
||||
P1 ! {setup, P2},
|
||||
P2 ! {setup, P3},
|
||||
P3 ! {setup, P1},
|
||||
P1 ! {token, 5, Me},
|
||||
receive done -> finished end")
|
||||
|
||||
(er-ring-test
|
||||
"ring N=3 M=6"
|
||||
(get (ring-ev er-ring-program-3-6) :name)
|
||||
"finished")
|
||||
|
||||
;; Two-node ring — token bounces twice between P1 and P2.
|
||||
(er-ring-test
|
||||
"ring N=2 M=4"
|
||||
(get (ring-ev
|
||||
"Me = self(),
|
||||
Spawner = fun () ->
|
||||
receive {setup, Next} ->
|
||||
Loop = fun () ->
|
||||
receive
|
||||
{token, 0, Parent} -> Parent ! done;
|
||||
{token, K, Parent} -> Next ! {token, K-1, Parent}, Loop()
|
||||
end
|
||||
end,
|
||||
Loop()
|
||||
end
|
||||
end,
|
||||
P1 = spawn(Spawner),
|
||||
P2 = spawn(Spawner),
|
||||
P1 ! {setup, P2},
|
||||
P2 ! {setup, P1},
|
||||
P1 ! {token, 3, Me},
|
||||
receive done -> done end") :name)
|
||||
"done")
|
||||
|
||||
;; Single-node "ring" — P sends to itself M times.
|
||||
(er-ring-test
|
||||
"ring N=1 M=5"
|
||||
(get (ring-ev
|
||||
"Me = self(),
|
||||
Spawner = fun () ->
|
||||
receive {setup, Next} ->
|
||||
Loop = fun () ->
|
||||
receive
|
||||
{token, 0, Parent} -> Parent ! finished_loop;
|
||||
{token, K, Parent} -> Next ! {token, K-1, Parent}, Loop()
|
||||
end
|
||||
end,
|
||||
Loop()
|
||||
end
|
||||
end,
|
||||
P = spawn(Spawner),
|
||||
P ! {setup, P},
|
||||
P ! {token, 4, Me},
|
||||
receive finished_loop -> ok end") :name)
|
||||
"ok")
|
||||
|
||||
;; Confirm the token really went around — count hops via io-buffer.
|
||||
(er-ring-test
|
||||
"ring N=3 M=9 hop count"
|
||||
(do
|
||||
(er-io-flush!)
|
||||
(ring-ev
|
||||
"Me = self(),
|
||||
Spawner = fun () ->
|
||||
receive {setup, Next} ->
|
||||
Loop = fun () ->
|
||||
receive
|
||||
{token, 0, Parent} -> Parent ! done;
|
||||
{token, K, Parent} ->
|
||||
io:format(\"~p \", [K]),
|
||||
Next ! {token, K-1, Parent},
|
||||
Loop()
|
||||
end
|
||||
end,
|
||||
Loop()
|
||||
end
|
||||
end,
|
||||
P1 = spawn(Spawner),
|
||||
P2 = spawn(Spawner),
|
||||
P3 = spawn(Spawner),
|
||||
P1 ! {setup, P2},
|
||||
P2 ! {setup, P3},
|
||||
P3 ! {setup, P1},
|
||||
P1 ! {token, 8, Me},
|
||||
receive done -> done end")
|
||||
(er-io-buffer-content))
|
||||
"8 7 6 5 4 3 2 1 ")
|
||||
|
||||
(define
|
||||
er-ring-test-summary
|
||||
(str "ring " er-ring-test-pass "/" er-ring-test-count))
|
||||
@@ -1,139 +0,0 @@
|
||||
;; Erlang runtime tests — scheduler + process-record primitives.
|
||||
|
||||
(define er-rt-test-count 0)
|
||||
(define er-rt-test-pass 0)
|
||||
(define er-rt-test-fails (list))
|
||||
|
||||
(define
|
||||
er-rt-test
|
||||
(fn
|
||||
(name actual expected)
|
||||
(set! er-rt-test-count (+ er-rt-test-count 1))
|
||||
(if
|
||||
(= actual expected)
|
||||
(set! er-rt-test-pass (+ er-rt-test-pass 1))
|
||||
(append! er-rt-test-fails {:actual actual :expected expected :name name}))))
|
||||
|
||||
;; ── queue ─────────────────────────────────────────────────────────
|
||||
(er-rt-test "queue empty len" (er-q-len (er-q-new)) 0)
|
||||
(er-rt-test "queue empty?" (er-q-empty? (er-q-new)) true)
|
||||
|
||||
(define q1 (er-q-new))
|
||||
(er-q-push! q1 "a")
|
||||
(er-q-push! q1 "b")
|
||||
(er-q-push! q1 "c")
|
||||
(er-rt-test "queue push len" (er-q-len q1) 3)
|
||||
(er-rt-test "queue empty? after push" (er-q-empty? q1) false)
|
||||
(er-rt-test "queue peek" (er-q-peek q1) "a")
|
||||
(er-rt-test "queue pop 1" (er-q-pop! q1) "a")
|
||||
(er-rt-test "queue pop 2" (er-q-pop! q1) "b")
|
||||
(er-rt-test "queue len after pops" (er-q-len q1) 1)
|
||||
(er-rt-test "queue pop 3" (er-q-pop! q1) "c")
|
||||
(er-rt-test "queue empty again" (er-q-empty? q1) true)
|
||||
(er-rt-test "queue pop empty" (er-q-pop! q1) nil)
|
||||
|
||||
;; Queue FIFO under interleaved push/pop
|
||||
(define q2 (er-q-new))
|
||||
(er-q-push! q2 1)
|
||||
(er-q-push! q2 2)
|
||||
(er-q-pop! q2)
|
||||
(er-q-push! q2 3)
|
||||
(er-rt-test "queue interleave peek" (er-q-peek q2) 2)
|
||||
(er-rt-test "queue to-list" (er-q-to-list q2) (list 2 3))
|
||||
|
||||
;; ── scheduler init ─────────────────────────────────────────────
|
||||
(er-sched-init!)
|
||||
(er-rt-test "sched process count 0" (er-sched-process-count) 0)
|
||||
(er-rt-test "sched runnable count 0" (er-sched-runnable-count) 0)
|
||||
(er-rt-test "sched current nil" (er-sched-current-pid) nil)
|
||||
|
||||
;; ── pid allocation ─────────────────────────────────────────────
|
||||
(define pa (er-pid-new!))
|
||||
(define pb (er-pid-new!))
|
||||
(er-rt-test "pid tag" (get pa :tag) "pid")
|
||||
(er-rt-test "pid ids distinct" (= (er-pid-id pa) (er-pid-id pb)) false)
|
||||
(er-rt-test "pid? true" (er-pid? pa) true)
|
||||
(er-rt-test "pid? false" (er-pid? 42) false)
|
||||
(er-rt-test
|
||||
"pid-equal same"
|
||||
(er-pid-equal? pa (er-mk-pid (er-pid-id pa)))
|
||||
true)
|
||||
(er-rt-test "pid-equal diff" (er-pid-equal? pa pb) false)
|
||||
|
||||
;; ── process lifecycle ──────────────────────────────────────────
|
||||
(er-sched-init!)
|
||||
(define p1 (er-proc-new! {}))
|
||||
(define p2 (er-proc-new! {}))
|
||||
(er-rt-test "proc count 2" (er-sched-process-count) 2)
|
||||
(er-rt-test "runnable count 2" (er-sched-runnable-count) 2)
|
||||
(er-rt-test
|
||||
"proc state runnable"
|
||||
(er-proc-field (get p1 :pid) :state)
|
||||
"runnable")
|
||||
(er-rt-test
|
||||
"proc mailbox empty"
|
||||
(er-proc-mailbox-size (get p1 :pid))
|
||||
0)
|
||||
(er-rt-test
|
||||
"proc lookup"
|
||||
(er-pid-equal? (get (er-proc-get (get p1 :pid)) :pid) (get p1 :pid))
|
||||
true)
|
||||
(er-rt-test "proc exists" (er-proc-exists? (get p1 :pid)) true)
|
||||
(er-rt-test
|
||||
"proc no-such-pid"
|
||||
(er-proc-exists? (er-mk-pid 9999))
|
||||
false)
|
||||
|
||||
;; runnable queue dequeue order
|
||||
(er-rt-test
|
||||
"dequeue first"
|
||||
(er-pid-equal? (er-sched-next-runnable!) (get p1 :pid))
|
||||
true)
|
||||
(er-rt-test
|
||||
"dequeue second"
|
||||
(er-pid-equal? (er-sched-next-runnable!) (get p2 :pid))
|
||||
true)
|
||||
(er-rt-test "dequeue empty" (er-sched-next-runnable!) nil)
|
||||
|
||||
;; current-pid get/set
|
||||
(er-sched-set-current! (get p1 :pid))
|
||||
(er-rt-test
|
||||
"current pid set"
|
||||
(er-pid-equal? (er-sched-current-pid) (get p1 :pid))
|
||||
true)
|
||||
|
||||
;; ── mailbox push ──────────────────────────────────────────────
|
||||
(er-proc-mailbox-push! (get p1 :pid) {:tag "atom" :name "ping"})
|
||||
(er-proc-mailbox-push! (get p1 :pid) 42)
|
||||
(er-rt-test "mailbox size 2" (er-proc-mailbox-size (get p1 :pid)) 2)
|
||||
|
||||
;; ── field update ──────────────────────────────────────────────
|
||||
(er-proc-set! (get p1 :pid) :state "waiting")
|
||||
(er-rt-test
|
||||
"proc state waiting"
|
||||
(er-proc-field (get p1 :pid) :state)
|
||||
"waiting")
|
||||
(er-proc-set! (get p1 :pid) :trap-exit true)
|
||||
(er-rt-test
|
||||
"proc trap-exit"
|
||||
(er-proc-field (get p1 :pid) :trap-exit)
|
||||
true)
|
||||
|
||||
;; ── fresh scheduler ends in clean state ───────────────────────
|
||||
(er-sched-init!)
|
||||
(er-rt-test
|
||||
"sched init resets count"
|
||||
(er-sched-process-count)
|
||||
0)
|
||||
(er-rt-test
|
||||
"sched init resets queue"
|
||||
(er-sched-runnable-count)
|
||||
0)
|
||||
(er-rt-test
|
||||
"sched init resets current"
|
||||
(er-sched-current-pid)
|
||||
nil)
|
||||
|
||||
(define
|
||||
er-rt-test-summary
|
||||
(str "runtime " er-rt-test-pass "/" er-rt-test-count))
|
||||
File diff suppressed because it is too large
Load Diff
14
lib/forth/ans-tests/README.md
Normal file
14
lib/forth/ans-tests/README.md
Normal file
@@ -0,0 +1,14 @@
|
||||
ANS Forth conformance tests — vendored from
|
||||
https://github.com/gerryjackson/forth2012-test-suite (master, commit-locked
|
||||
on first fetch: 2026-04-24).
|
||||
|
||||
Files in this directory are pristine copies of upstream — do not edit them.
|
||||
They are consumed by the conformance runner in `lib/forth/conformance.sh`.
|
||||
|
||||
- `tester.fr` — John Hayes' test harness (`T{ ... -> ... }T`). (C) 1995
|
||||
Johns Hopkins APL, distributable under its notice.
|
||||
- `core.fr` — Core word set tests (Hayes, ~1000 lines).
|
||||
- `coreexttest.fth` — Core Extension tests (Gerry Jackson).
|
||||
|
||||
Only `core.fr` is expected to run green end-to-end for Phase 3; the others
|
||||
stay parked until later phases.
|
||||
1009
lib/forth/ans-tests/core.fr
Normal file
1009
lib/forth/ans-tests/core.fr
Normal file
File diff suppressed because it is too large
Load Diff
775
lib/forth/ans-tests/coreexttest.fth
Normal file
775
lib/forth/ans-tests/coreexttest.fth
Normal file
@@ -0,0 +1,775 @@
|
||||
\ To test the ANS Forth Core Extension word set
|
||||
|
||||
\ This program was written by Gerry Jackson in 2006, with contributions from
|
||||
\ others where indicated, and is in the public domain - it can be distributed
|
||||
\ and/or modified in any way but please retain this notice.
|
||||
|
||||
\ This program is distributed in the hope that it will be useful,
|
||||
\ but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
\ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
|
||||
\ The tests are not claimed to be comprehensive or correct
|
||||
|
||||
\ ------------------------------------------------------------------------------
|
||||
\ Version 0.15 1 August 2025 Added two tests to VALUE
|
||||
\ 0.14 21 July 2022 Updated first line of BUFFER: test as recommended
|
||||
\ in issue 32
|
||||
\ 0.13 28 October 2015
|
||||
\ Replace <FALSE> and <TRUE> with FALSE and TRUE to avoid
|
||||
\ dependence on Core tests
|
||||
\ Moved SAVE-INPUT and RESTORE-INPUT tests in a file to filetest.fth
|
||||
\ Use of 2VARIABLE (from optional wordset) replaced with CREATE.
|
||||
\ Minor lower to upper case conversions.
|
||||
\ Calls to COMPARE replaced by S= (in utilities.fth) to avoid use
|
||||
\ of a word from an optional word set.
|
||||
\ UNUSED tests revised as UNUSED UNUSED = may return FALSE when an
|
||||
\ implementation has the data stack sharing unused dataspace.
|
||||
\ Double number input dependency removed from the HOLDS tests.
|
||||
\ Minor case sensitivities removed in definition names.
|
||||
\ 0.11 25 April 2015
|
||||
\ Added tests for PARSE-NAME HOLDS BUFFER:
|
||||
\ S\" tests added
|
||||
\ DEFER IS ACTION-OF DEFER! DEFER@ tests added
|
||||
\ Empty CASE statement test added
|
||||
\ [COMPILE] tests removed because it is obsolescent in Forth 2012
|
||||
\ 0.10 1 August 2014
|
||||
\ Added tests contributed by James Bowman for:
|
||||
\ <> U> 0<> 0> NIP TUCK ROLL PICK 2>R 2R@ 2R>
|
||||
\ HEX WITHIN UNUSED AGAIN MARKER
|
||||
\ Added tests for:
|
||||
\ .R U.R ERASE PAD REFILL SOURCE-ID
|
||||
\ Removed ABORT from NeverExecuted to enable Win32
|
||||
\ to continue after failure of RESTORE-INPUT.
|
||||
\ Removed max-intx which is no longer used.
|
||||
\ 0.7 6 June 2012 Extra CASE test added
|
||||
\ 0.6 1 April 2012 Tests placed in the public domain.
|
||||
\ SAVE-INPUT & RESTORE-INPUT tests, position
|
||||
\ of T{ moved so that tests work with ttester.fs
|
||||
\ CONVERT test deleted - obsolete word removed from Forth 200X
|
||||
\ IMMEDIATE VALUEs tested
|
||||
\ RECURSE with :NONAME tested
|
||||
\ PARSE and .( tested
|
||||
\ Parsing behaviour of C" added
|
||||
\ 0.5 14 September 2011 Removed the double [ELSE] from the
|
||||
\ initial SAVE-INPUT & RESTORE-INPUT test
|
||||
\ 0.4 30 November 2009 max-int replaced with max-intx to
|
||||
\ avoid redefinition warnings.
|
||||
\ 0.3 6 March 2009 { and } replaced with T{ and }T
|
||||
\ CONVERT test now independent of cell size
|
||||
\ 0.2 20 April 2007 ANS Forth words changed to upper case
|
||||
\ Tests qd3 to qd6 by Reinhold Straub
|
||||
\ 0.1 Oct 2006 First version released
|
||||
\ -----------------------------------------------------------------------------
|
||||
\ The tests are based on John Hayes test program for the core word set
|
||||
|
||||
\ Words tested in this file are:
|
||||
\ .( .R 0<> 0> 2>R 2R> 2R@ :NONAME <> ?DO AGAIN C" CASE COMPILE, ENDCASE
|
||||
\ ENDOF ERASE FALSE HEX MARKER NIP OF PAD PARSE PICK REFILL
|
||||
\ RESTORE-INPUT ROLL SAVE-INPUT SOURCE-ID TO TRUE TUCK U.R U> UNUSED
|
||||
\ VALUE WITHIN [COMPILE]
|
||||
|
||||
\ Words not tested or partially tested:
|
||||
\ \ because it has been extensively used already and is, hence, unnecessary
|
||||
\ REFILL and SOURCE-ID from the user input device which are not possible
|
||||
\ when testing from a file such as this one
|
||||
\ UNUSED (partially tested) as the value returned is system dependent
|
||||
\ Obsolescent words #TIB CONVERT EXPECT QUERY SPAN TIB as they have been
|
||||
\ removed from the Forth 2012 standard
|
||||
|
||||
\ Results from words that output to the user output device have to visually
|
||||
\ checked for correctness. These are .R U.R .(
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
\ Assumptions & dependencies:
|
||||
\ - tester.fr (or ttester.fs), errorreport.fth and utilities.fth have been
|
||||
\ included prior to this file
|
||||
\ - the Core word set available
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING Core Extension words
|
||||
|
||||
DECIMAL
|
||||
|
||||
TESTING TRUE FALSE
|
||||
|
||||
T{ TRUE -> 0 INVERT }T
|
||||
T{ FALSE -> 0 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING <> U> (contributed by James Bowman)
|
||||
|
||||
T{ 0 0 <> -> FALSE }T
|
||||
T{ 1 1 <> -> FALSE }T
|
||||
T{ -1 -1 <> -> FALSE }T
|
||||
T{ 1 0 <> -> TRUE }T
|
||||
T{ -1 0 <> -> TRUE }T
|
||||
T{ 0 1 <> -> TRUE }T
|
||||
T{ 0 -1 <> -> TRUE }T
|
||||
|
||||
T{ 0 1 U> -> FALSE }T
|
||||
T{ 1 2 U> -> FALSE }T
|
||||
T{ 0 MID-UINT U> -> FALSE }T
|
||||
T{ 0 MAX-UINT U> -> FALSE }T
|
||||
T{ MID-UINT MAX-UINT U> -> FALSE }T
|
||||
T{ 0 0 U> -> FALSE }T
|
||||
T{ 1 1 U> -> FALSE }T
|
||||
T{ 1 0 U> -> TRUE }T
|
||||
T{ 2 1 U> -> TRUE }T
|
||||
T{ MID-UINT 0 U> -> TRUE }T
|
||||
T{ MAX-UINT 0 U> -> TRUE }T
|
||||
T{ MAX-UINT MID-UINT U> -> TRUE }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING 0<> 0> (contributed by James Bowman)
|
||||
|
||||
T{ 0 0<> -> FALSE }T
|
||||
T{ 1 0<> -> TRUE }T
|
||||
T{ 2 0<> -> TRUE }T
|
||||
T{ -1 0<> -> TRUE }T
|
||||
T{ MAX-UINT 0<> -> TRUE }T
|
||||
T{ MIN-INT 0<> -> TRUE }T
|
||||
T{ MAX-INT 0<> -> TRUE }T
|
||||
|
||||
T{ 0 0> -> FALSE }T
|
||||
T{ -1 0> -> FALSE }T
|
||||
T{ MIN-INT 0> -> FALSE }T
|
||||
T{ 1 0> -> TRUE }T
|
||||
T{ MAX-INT 0> -> TRUE }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING NIP TUCK ROLL PICK (contributed by James Bowman)
|
||||
|
||||
T{ 1 2 NIP -> 2 }T
|
||||
T{ 1 2 3 NIP -> 1 3 }T
|
||||
|
||||
T{ 1 2 TUCK -> 2 1 2 }T
|
||||
T{ 1 2 3 TUCK -> 1 3 2 3 }T
|
||||
|
||||
T{ : RO5 100 200 300 400 500 ; -> }T
|
||||
T{ RO5 3 ROLL -> 100 300 400 500 200 }T
|
||||
T{ RO5 2 ROLL -> RO5 ROT }T
|
||||
T{ RO5 1 ROLL -> RO5 SWAP }T
|
||||
T{ RO5 0 ROLL -> RO5 }T
|
||||
|
||||
T{ RO5 2 PICK -> 100 200 300 400 500 300 }T
|
||||
T{ RO5 1 PICK -> RO5 OVER }T
|
||||
T{ RO5 0 PICK -> RO5 DUP }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING 2>R 2R@ 2R> (contributed by James Bowman)
|
||||
|
||||
T{ : RR0 2>R 100 R> R> ; -> }T
|
||||
T{ 300 400 RR0 -> 100 400 300 }T
|
||||
T{ 200 300 400 RR0 -> 200 100 400 300 }T
|
||||
|
||||
T{ : RR1 2>R 100 2R@ R> R> ; -> }T
|
||||
T{ 300 400 RR1 -> 100 300 400 400 300 }T
|
||||
T{ 200 300 400 RR1 -> 200 100 300 400 400 300 }T
|
||||
|
||||
T{ : RR2 2>R 100 2R> ; -> }T
|
||||
T{ 300 400 RR2 -> 100 300 400 }T
|
||||
T{ 200 300 400 RR2 -> 200 100 300 400 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING HEX (contributed by James Bowman)
|
||||
|
||||
T{ BASE @ HEX BASE @ DECIMAL BASE @ - SWAP BASE ! -> 6 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING WITHIN (contributed by James Bowman)
|
||||
|
||||
T{ 0 0 0 WITHIN -> FALSE }T
|
||||
T{ 0 0 MID-UINT WITHIN -> TRUE }T
|
||||
T{ 0 0 MID-UINT+1 WITHIN -> TRUE }T
|
||||
T{ 0 0 MAX-UINT WITHIN -> TRUE }T
|
||||
T{ 0 MID-UINT 0 WITHIN -> FALSE }T
|
||||
T{ 0 MID-UINT MID-UINT WITHIN -> FALSE }T
|
||||
T{ 0 MID-UINT MID-UINT+1 WITHIN -> FALSE }T
|
||||
T{ 0 MID-UINT MAX-UINT WITHIN -> FALSE }T
|
||||
T{ 0 MID-UINT+1 0 WITHIN -> FALSE }T
|
||||
T{ 0 MID-UINT+1 MID-UINT WITHIN -> TRUE }T
|
||||
T{ 0 MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
|
||||
T{ 0 MID-UINT+1 MAX-UINT WITHIN -> FALSE }T
|
||||
T{ 0 MAX-UINT 0 WITHIN -> FALSE }T
|
||||
T{ 0 MAX-UINT MID-UINT WITHIN -> TRUE }T
|
||||
T{ 0 MAX-UINT MID-UINT+1 WITHIN -> TRUE }T
|
||||
T{ 0 MAX-UINT MAX-UINT WITHIN -> FALSE }T
|
||||
T{ MID-UINT 0 0 WITHIN -> FALSE }T
|
||||
T{ MID-UINT 0 MID-UINT WITHIN -> FALSE }T
|
||||
T{ MID-UINT 0 MID-UINT+1 WITHIN -> TRUE }T
|
||||
T{ MID-UINT 0 MAX-UINT WITHIN -> TRUE }T
|
||||
T{ MID-UINT MID-UINT 0 WITHIN -> TRUE }T
|
||||
T{ MID-UINT MID-UINT MID-UINT WITHIN -> FALSE }T
|
||||
T{ MID-UINT MID-UINT MID-UINT+1 WITHIN -> TRUE }T
|
||||
T{ MID-UINT MID-UINT MAX-UINT WITHIN -> TRUE }T
|
||||
T{ MID-UINT MID-UINT+1 0 WITHIN -> FALSE }T
|
||||
T{ MID-UINT MID-UINT+1 MID-UINT WITHIN -> FALSE }T
|
||||
T{ MID-UINT MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
|
||||
T{ MID-UINT MID-UINT+1 MAX-UINT WITHIN -> FALSE }T
|
||||
T{ MID-UINT MAX-UINT 0 WITHIN -> FALSE }T
|
||||
T{ MID-UINT MAX-UINT MID-UINT WITHIN -> FALSE }T
|
||||
T{ MID-UINT MAX-UINT MID-UINT+1 WITHIN -> TRUE }T
|
||||
T{ MID-UINT MAX-UINT MAX-UINT WITHIN -> FALSE }T
|
||||
T{ MID-UINT+1 0 0 WITHIN -> FALSE }T
|
||||
T{ MID-UINT+1 0 MID-UINT WITHIN -> FALSE }T
|
||||
T{ MID-UINT+1 0 MID-UINT+1 WITHIN -> FALSE }T
|
||||
T{ MID-UINT+1 0 MAX-UINT WITHIN -> TRUE }T
|
||||
T{ MID-UINT+1 MID-UINT 0 WITHIN -> TRUE }T
|
||||
T{ MID-UINT+1 MID-UINT MID-UINT WITHIN -> FALSE }T
|
||||
T{ MID-UINT+1 MID-UINT MID-UINT+1 WITHIN -> FALSE }T
|
||||
T{ MID-UINT+1 MID-UINT MAX-UINT WITHIN -> TRUE }T
|
||||
T{ MID-UINT+1 MID-UINT+1 0 WITHIN -> TRUE }T
|
||||
T{ MID-UINT+1 MID-UINT+1 MID-UINT WITHIN -> TRUE }T
|
||||
T{ MID-UINT+1 MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
|
||||
T{ MID-UINT+1 MID-UINT+1 MAX-UINT WITHIN -> TRUE }T
|
||||
T{ MID-UINT+1 MAX-UINT 0 WITHIN -> FALSE }T
|
||||
T{ MID-UINT+1 MAX-UINT MID-UINT WITHIN -> FALSE }T
|
||||
T{ MID-UINT+1 MAX-UINT MID-UINT+1 WITHIN -> FALSE }T
|
||||
T{ MID-UINT+1 MAX-UINT MAX-UINT WITHIN -> FALSE }T
|
||||
T{ MAX-UINT 0 0 WITHIN -> FALSE }T
|
||||
T{ MAX-UINT 0 MID-UINT WITHIN -> FALSE }T
|
||||
T{ MAX-UINT 0 MID-UINT+1 WITHIN -> FALSE }T
|
||||
T{ MAX-UINT 0 MAX-UINT WITHIN -> FALSE }T
|
||||
T{ MAX-UINT MID-UINT 0 WITHIN -> TRUE }T
|
||||
T{ MAX-UINT MID-UINT MID-UINT WITHIN -> FALSE }T
|
||||
T{ MAX-UINT MID-UINT MID-UINT+1 WITHIN -> FALSE }T
|
||||
T{ MAX-UINT MID-UINT MAX-UINT WITHIN -> FALSE }T
|
||||
T{ MAX-UINT MID-UINT+1 0 WITHIN -> TRUE }T
|
||||
T{ MAX-UINT MID-UINT+1 MID-UINT WITHIN -> TRUE }T
|
||||
T{ MAX-UINT MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
|
||||
T{ MAX-UINT MID-UINT+1 MAX-UINT WITHIN -> FALSE }T
|
||||
T{ MAX-UINT MAX-UINT 0 WITHIN -> TRUE }T
|
||||
T{ MAX-UINT MAX-UINT MID-UINT WITHIN -> TRUE }T
|
||||
T{ MAX-UINT MAX-UINT MID-UINT+1 WITHIN -> TRUE }T
|
||||
T{ MAX-UINT MAX-UINT MAX-UINT WITHIN -> FALSE }T
|
||||
|
||||
T{ MIN-INT MIN-INT MIN-INT WITHIN -> FALSE }T
|
||||
T{ MIN-INT MIN-INT 0 WITHIN -> TRUE }T
|
||||
T{ MIN-INT MIN-INT 1 WITHIN -> TRUE }T
|
||||
T{ MIN-INT MIN-INT MAX-INT WITHIN -> TRUE }T
|
||||
T{ MIN-INT 0 MIN-INT WITHIN -> FALSE }T
|
||||
T{ MIN-INT 0 0 WITHIN -> FALSE }T
|
||||
T{ MIN-INT 0 1 WITHIN -> FALSE }T
|
||||
T{ MIN-INT 0 MAX-INT WITHIN -> FALSE }T
|
||||
T{ MIN-INT 1 MIN-INT WITHIN -> FALSE }T
|
||||
T{ MIN-INT 1 0 WITHIN -> TRUE }T
|
||||
T{ MIN-INT 1 1 WITHIN -> FALSE }T
|
||||
T{ MIN-INT 1 MAX-INT WITHIN -> FALSE }T
|
||||
T{ MIN-INT MAX-INT MIN-INT WITHIN -> FALSE }T
|
||||
T{ MIN-INT MAX-INT 0 WITHIN -> TRUE }T
|
||||
T{ MIN-INT MAX-INT 1 WITHIN -> TRUE }T
|
||||
T{ MIN-INT MAX-INT MAX-INT WITHIN -> FALSE }T
|
||||
T{ 0 MIN-INT MIN-INT WITHIN -> FALSE }T
|
||||
T{ 0 MIN-INT 0 WITHIN -> FALSE }T
|
||||
T{ 0 MIN-INT 1 WITHIN -> TRUE }T
|
||||
T{ 0 MIN-INT MAX-INT WITHIN -> TRUE }T
|
||||
T{ 0 0 MIN-INT WITHIN -> TRUE }T
|
||||
T{ 0 0 0 WITHIN -> FALSE }T
|
||||
T{ 0 0 1 WITHIN -> TRUE }T
|
||||
T{ 0 0 MAX-INT WITHIN -> TRUE }T
|
||||
T{ 0 1 MIN-INT WITHIN -> FALSE }T
|
||||
T{ 0 1 0 WITHIN -> FALSE }T
|
||||
T{ 0 1 1 WITHIN -> FALSE }T
|
||||
T{ 0 1 MAX-INT WITHIN -> FALSE }T
|
||||
T{ 0 MAX-INT MIN-INT WITHIN -> FALSE }T
|
||||
T{ 0 MAX-INT 0 WITHIN -> FALSE }T
|
||||
T{ 0 MAX-INT 1 WITHIN -> TRUE }T
|
||||
T{ 0 MAX-INT MAX-INT WITHIN -> FALSE }T
|
||||
T{ 1 MIN-INT MIN-INT WITHIN -> FALSE }T
|
||||
T{ 1 MIN-INT 0 WITHIN -> FALSE }T
|
||||
T{ 1 MIN-INT 1 WITHIN -> FALSE }T
|
||||
T{ 1 MIN-INT MAX-INT WITHIN -> TRUE }T
|
||||
T{ 1 0 MIN-INT WITHIN -> TRUE }T
|
||||
T{ 1 0 0 WITHIN -> FALSE }T
|
||||
T{ 1 0 1 WITHIN -> FALSE }T
|
||||
T{ 1 0 MAX-INT WITHIN -> TRUE }T
|
||||
T{ 1 1 MIN-INT WITHIN -> TRUE }T
|
||||
T{ 1 1 0 WITHIN -> TRUE }T
|
||||
T{ 1 1 1 WITHIN -> FALSE }T
|
||||
T{ 1 1 MAX-INT WITHIN -> TRUE }T
|
||||
T{ 1 MAX-INT MIN-INT WITHIN -> FALSE }T
|
||||
T{ 1 MAX-INT 0 WITHIN -> FALSE }T
|
||||
T{ 1 MAX-INT 1 WITHIN -> FALSE }T
|
||||
T{ 1 MAX-INT MAX-INT WITHIN -> FALSE }T
|
||||
T{ MAX-INT MIN-INT MIN-INT WITHIN -> FALSE }T
|
||||
T{ MAX-INT MIN-INT 0 WITHIN -> FALSE }T
|
||||
T{ MAX-INT MIN-INT 1 WITHIN -> FALSE }T
|
||||
T{ MAX-INT MIN-INT MAX-INT WITHIN -> FALSE }T
|
||||
T{ MAX-INT 0 MIN-INT WITHIN -> TRUE }T
|
||||
T{ MAX-INT 0 0 WITHIN -> FALSE }T
|
||||
T{ MAX-INT 0 1 WITHIN -> FALSE }T
|
||||
T{ MAX-INT 0 MAX-INT WITHIN -> FALSE }T
|
||||
T{ MAX-INT 1 MIN-INT WITHIN -> TRUE }T
|
||||
T{ MAX-INT 1 0 WITHIN -> TRUE }T
|
||||
T{ MAX-INT 1 1 WITHIN -> FALSE }T
|
||||
T{ MAX-INT 1 MAX-INT WITHIN -> FALSE }T
|
||||
T{ MAX-INT MAX-INT MIN-INT WITHIN -> TRUE }T
|
||||
T{ MAX-INT MAX-INT 0 WITHIN -> TRUE }T
|
||||
T{ MAX-INT MAX-INT 1 WITHIN -> TRUE }T
|
||||
T{ MAX-INT MAX-INT MAX-INT WITHIN -> FALSE }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING UNUSED (contributed by James Bowman & Peter Knaggs)
|
||||
|
||||
VARIABLE UNUSED0
|
||||
T{ UNUSED DROP -> }T
|
||||
T{ ALIGN UNUSED UNUSED0 ! 0 , UNUSED CELL+ UNUSED0 @ = -> TRUE }T
|
||||
T{ UNUSED UNUSED0 ! 0 C, UNUSED CHAR+ UNUSED0 @ =
|
||||
-> TRUE }T \ aligned -> unaligned
|
||||
T{ UNUSED UNUSED0 ! 0 C, UNUSED CHAR+ UNUSED0 @ = -> TRUE }T \ unaligned -> ?
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING AGAIN (contributed by James Bowman)
|
||||
|
||||
T{ : AG0 701 BEGIN DUP 7 MOD 0= IF EXIT THEN 1+ AGAIN ; -> }T
|
||||
T{ AG0 -> 707 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING MARKER (contributed by James Bowman)
|
||||
|
||||
T{ : MA? BL WORD FIND NIP 0<> ; -> }T
|
||||
T{ MARKER MA0 -> }T
|
||||
T{ : MA1 111 ; -> }T
|
||||
T{ MARKER MA2 -> }T
|
||||
T{ : MA1 222 ; -> }T
|
||||
T{ MA? MA0 MA? MA1 MA? MA2 -> TRUE TRUE TRUE }T
|
||||
T{ MA1 MA2 MA1 -> 222 111 }T
|
||||
T{ MA? MA0 MA? MA1 MA? MA2 -> TRUE TRUE FALSE }T
|
||||
T{ MA0 -> }T
|
||||
T{ MA? MA0 MA? MA1 MA? MA2 -> FALSE FALSE FALSE }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING ?DO
|
||||
|
||||
: QD ?DO I LOOP ;
|
||||
T{ 789 789 QD -> }T
|
||||
T{ -9876 -9876 QD -> }T
|
||||
T{ 5 0 QD -> 0 1 2 3 4 }T
|
||||
|
||||
: QD1 ?DO I 10 +LOOP ;
|
||||
T{ 50 1 QD1 -> 1 11 21 31 41 }T
|
||||
T{ 50 0 QD1 -> 0 10 20 30 40 }T
|
||||
|
||||
: QD2 ?DO I 3 > IF LEAVE ELSE I THEN LOOP ;
|
||||
T{ 5 -1 QD2 -> -1 0 1 2 3 }T
|
||||
|
||||
: QD3 ?DO I 1 +LOOP ;
|
||||
T{ 4 4 QD3 -> }T
|
||||
T{ 4 1 QD3 -> 1 2 3 }T
|
||||
T{ 2 -1 QD3 -> -1 0 1 }T
|
||||
|
||||
: QD4 ?DO I -1 +LOOP ;
|
||||
T{ 4 4 QD4 -> }T
|
||||
T{ 1 4 QD4 -> 4 3 2 1 }T
|
||||
T{ -1 2 QD4 -> 2 1 0 -1 }T
|
||||
|
||||
: QD5 ?DO I -10 +LOOP ;
|
||||
T{ 1 50 QD5 -> 50 40 30 20 10 }T
|
||||
T{ 0 50 QD5 -> 50 40 30 20 10 0 }T
|
||||
T{ -25 10 QD5 -> 10 0 -10 -20 }T
|
||||
|
||||
VARIABLE ITERS
|
||||
VARIABLE INCRMNT
|
||||
|
||||
: QD6 ( limit start increment -- )
|
||||
INCRMNT !
|
||||
0 ITERS !
|
||||
?DO
|
||||
1 ITERS +!
|
||||
I
|
||||
ITERS @ 6 = IF LEAVE THEN
|
||||
INCRMNT @
|
||||
+LOOP ITERS @
|
||||
;
|
||||
|
||||
T{ 4 4 -1 QD6 -> 0 }T
|
||||
T{ 1 4 -1 QD6 -> 4 3 2 1 4 }T
|
||||
T{ 4 1 -1 QD6 -> 1 0 -1 -2 -3 -4 6 }T
|
||||
T{ 4 1 0 QD6 -> 1 1 1 1 1 1 6 }T
|
||||
T{ 0 0 0 QD6 -> 0 }T
|
||||
T{ 1 4 0 QD6 -> 4 4 4 4 4 4 6 }T
|
||||
T{ 1 4 1 QD6 -> 4 5 6 7 8 9 6 }T
|
||||
T{ 4 1 1 QD6 -> 1 2 3 3 }T
|
||||
T{ 4 4 1 QD6 -> 0 }T
|
||||
T{ 2 -1 -1 QD6 -> -1 -2 -3 -4 -5 -6 6 }T
|
||||
T{ -1 2 -1 QD6 -> 2 1 0 -1 4 }T
|
||||
T{ 2 -1 0 QD6 -> -1 -1 -1 -1 -1 -1 6 }T
|
||||
T{ -1 2 0 QD6 -> 2 2 2 2 2 2 6 }T
|
||||
T{ -1 2 1 QD6 -> 2 3 4 5 6 7 6 }T
|
||||
T{ 2 -1 1 QD6 -> -1 0 1 3 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING BUFFER:
|
||||
|
||||
T{ 2 CELLS BUFFER: BUF:TEST -> }T
|
||||
T{ BUF:TEST DUP ALIGNED = -> TRUE }T
|
||||
T{ 111 BUF:TEST ! 222 BUF:TEST CELL+ ! -> }T
|
||||
T{ BUF:TEST @ BUF:TEST CELL+ @ -> 111 222 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING VALUE TO
|
||||
|
||||
T{ 111 VALUE VAL1 -999 VALUE VAL2 -> }T
|
||||
T{ VAL1 -> 111 }T
|
||||
T{ VAL2 -> -999 }T
|
||||
T{ 222 TO VAL1 -> }T
|
||||
T{ VAL1 -> 222 }T
|
||||
T{ : VD1 VAL1 ; -> }T
|
||||
T{ VD1 -> 222 }T
|
||||
T{ : VD2 TO VAL2 ; -> }T
|
||||
T{ VAL2 -> -999 }T
|
||||
T{ -333 VD2 -> }T
|
||||
T{ VAL2 -> -333 }T
|
||||
T{ VAL1 -> 222 }T
|
||||
T{ 444 TO VAL1 -> }T
|
||||
T{ VD1 -> 444 }T
|
||||
T{ 123 VALUE VAL3 IMMEDIATE VAL3 -> 123 }T
|
||||
T{ : VD3 VAL3 LITERAL ; VD3 -> 123 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING CASE OF ENDOF ENDCASE
|
||||
|
||||
: CS1 CASE 1 OF 111 ENDOF
|
||||
2 OF 222 ENDOF
|
||||
3 OF 333 ENDOF
|
||||
>R 999 R>
|
||||
ENDCASE
|
||||
;
|
||||
|
||||
T{ 1 CS1 -> 111 }T
|
||||
T{ 2 CS1 -> 222 }T
|
||||
T{ 3 CS1 -> 333 }T
|
||||
T{ 4 CS1 -> 999 }T
|
||||
|
||||
\ Nested CASE's
|
||||
|
||||
: CS2 >R CASE -1 OF CASE R@ 1 OF 100 ENDOF
|
||||
2 OF 200 ENDOF
|
||||
>R -300 R>
|
||||
ENDCASE
|
||||
ENDOF
|
||||
-2 OF CASE R@ 1 OF -99 ENDOF
|
||||
>R -199 R>
|
||||
ENDCASE
|
||||
ENDOF
|
||||
>R 299 R>
|
||||
ENDCASE R> DROP
|
||||
;
|
||||
|
||||
T{ -1 1 CS2 -> 100 }T
|
||||
T{ -1 2 CS2 -> 200 }T
|
||||
T{ -1 3 CS2 -> -300 }T
|
||||
T{ -2 1 CS2 -> -99 }T
|
||||
T{ -2 2 CS2 -> -199 }T
|
||||
T{ 0 2 CS2 -> 299 }T
|
||||
|
||||
\ Boolean short circuiting using CASE
|
||||
|
||||
: CS3 ( N1 -- N2 )
|
||||
CASE 1- FALSE OF 11 ENDOF
|
||||
1- FALSE OF 22 ENDOF
|
||||
1- FALSE OF 33 ENDOF
|
||||
44 SWAP
|
||||
ENDCASE
|
||||
;
|
||||
|
||||
T{ 1 CS3 -> 11 }T
|
||||
T{ 2 CS3 -> 22 }T
|
||||
T{ 3 CS3 -> 33 }T
|
||||
T{ 9 CS3 -> 44 }T
|
||||
|
||||
\ Empty CASE statements with/without default
|
||||
|
||||
T{ : CS4 CASE ENDCASE ; 1 CS4 -> }T
|
||||
T{ : CS5 CASE 2 SWAP ENDCASE ; 1 CS5 -> 2 }T
|
||||
T{ : CS6 CASE 1 OF ENDOF 2 ENDCASE ; 1 CS6 -> }T
|
||||
T{ : CS7 CASE 3 OF ENDOF 2 ENDCASE ; 1 CS7 -> 1 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING :NONAME RECURSE
|
||||
|
||||
VARIABLE NN1
|
||||
VARIABLE NN2
|
||||
:NONAME 1234 ; NN1 !
|
||||
:NONAME 9876 ; NN2 !
|
||||
T{ NN1 @ EXECUTE -> 1234 }T
|
||||
T{ NN2 @ EXECUTE -> 9876 }T
|
||||
|
||||
T{ :NONAME ( n -- 0,1,..n ) DUP IF DUP >R 1- RECURSE R> THEN ;
|
||||
CONSTANT RN1 -> }T
|
||||
T{ 0 RN1 EXECUTE -> 0 }T
|
||||
T{ 4 RN1 EXECUTE -> 0 1 2 3 4 }T
|
||||
|
||||
:NONAME ( n -- n1 ) \ Multiple RECURSEs in one definition
|
||||
1- DUP
|
||||
CASE 0 OF EXIT ENDOF
|
||||
1 OF 11 SWAP RECURSE ENDOF
|
||||
2 OF 22 SWAP RECURSE ENDOF
|
||||
3 OF 33 SWAP RECURSE ENDOF
|
||||
DROP ABS RECURSE EXIT
|
||||
ENDCASE
|
||||
; CONSTANT RN2
|
||||
|
||||
T{ 1 RN2 EXECUTE -> 0 }T
|
||||
T{ 2 RN2 EXECUTE -> 11 0 }T
|
||||
T{ 4 RN2 EXECUTE -> 33 22 11 0 }T
|
||||
T{ 25 RN2 EXECUTE -> 33 22 11 0 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING C"
|
||||
|
||||
T{ : CQ1 C" 123" ; -> }T
|
||||
T{ CQ1 COUNT EVALUATE -> 123 }T
|
||||
T{ : CQ2 C" " ; -> }T
|
||||
T{ CQ2 COUNT EVALUATE -> }T
|
||||
T{ : CQ3 C" 2345"COUNT EVALUATE ; CQ3 -> 2345 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING COMPILE,
|
||||
|
||||
:NONAME DUP + ; CONSTANT DUP+
|
||||
T{ : Q DUP+ COMPILE, ; -> }T
|
||||
T{ : AS1 [ Q ] ; -> }T
|
||||
T{ 123 AS1 -> 246 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
\ Cannot automatically test SAVE-INPUT and RESTORE-INPUT from a console source
|
||||
|
||||
TESTING SAVE-INPUT and RESTORE-INPUT with a string source
|
||||
|
||||
VARIABLE SI_INC 0 SI_INC !
|
||||
|
||||
: SI1
|
||||
SI_INC @ >IN +!
|
||||
15 SI_INC !
|
||||
;
|
||||
|
||||
: S$ S" SAVE-INPUT SI1 RESTORE-INPUT 12345" ;
|
||||
|
||||
T{ S$ EVALUATE SI_INC @ -> 0 2345 15 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING .(
|
||||
|
||||
CR CR .( Output from .()
|
||||
T{ CR .( You should see -9876: ) -9876 . -> }T
|
||||
T{ CR .( and again: ).( -9876)CR -> }T
|
||||
|
||||
CR CR .( On the next 2 lines you should see First then Second messages:)
|
||||
T{ : DOTP CR ." Second message via ." [CHAR] " EMIT \ Check .( is immediate
|
||||
[ CR ] .( First message via .( ) ; DOTP -> }T
|
||||
CR CR
|
||||
T{ : IMM? BL WORD FIND NIP ; IMM? .( -> 1 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING .R and U.R - has to handle different cell sizes
|
||||
|
||||
\ Create some large integers just below/above MAX and Min INTs
|
||||
MAX-INT 73 79 */ CONSTANT LI1
|
||||
MIN-INT 71 73 */ CONSTANT LI2
|
||||
|
||||
LI1 0 <# #S #> NIP CONSTANT LENLI1
|
||||
|
||||
: (.R&U.R) ( u1 u2 -- ) \ u1 <= string length, u2 is required indentation
|
||||
TUCK + >R
|
||||
LI1 OVER SPACES . CR R@ LI1 SWAP .R CR
|
||||
LI2 OVER SPACES . CR R@ 1+ LI2 SWAP .R CR
|
||||
LI1 OVER SPACES U. CR R@ LI1 SWAP U.R CR
|
||||
LI2 SWAP SPACES U. CR R> LI2 SWAP U.R CR
|
||||
;
|
||||
|
||||
: .R&U.R ( -- )
|
||||
CR ." You should see lines duplicated:" CR
|
||||
." indented by 0 spaces" CR 0 0 (.R&U.R) CR
|
||||
." indented by 0 spaces" CR LENLI1 0 (.R&U.R) CR \ Just fits required width
|
||||
." indented by 5 spaces" CR LENLI1 5 (.R&U.R) CR
|
||||
;
|
||||
|
||||
CR CR .( Output from .R and U.R)
|
||||
T{ .R&U.R -> }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING PAD ERASE
|
||||
\ Must handle different size characters i.e. 1 CHARS >= 1
|
||||
|
||||
84 CONSTANT CHARS/PAD \ Minimum size of PAD in chars
|
||||
CHARS/PAD CHARS CONSTANT AUS/PAD
|
||||
: CHECKPAD ( caddr u ch -- f ) \ f = TRUE if u chars = ch
|
||||
SWAP 0
|
||||
?DO
|
||||
OVER I CHARS + C@ OVER <>
|
||||
IF 2DROP UNLOOP FALSE EXIT THEN
|
||||
LOOP
|
||||
2DROP TRUE
|
||||
;
|
||||
|
||||
T{ PAD DROP -> }T
|
||||
T{ 0 INVERT PAD C! -> }T
|
||||
T{ PAD C@ CONSTANT MAXCHAR -> }T
|
||||
T{ PAD CHARS/PAD 2DUP MAXCHAR FILL MAXCHAR CHECKPAD -> TRUE }T
|
||||
T{ PAD CHARS/PAD 2DUP CHARS ERASE 0 CHECKPAD -> TRUE }T
|
||||
T{ PAD CHARS/PAD 2DUP MAXCHAR FILL PAD 0 ERASE MAXCHAR CHECKPAD -> TRUE }T
|
||||
T{ PAD 43 CHARS + 9 CHARS ERASE -> }T
|
||||
T{ PAD 43 MAXCHAR CHECKPAD -> TRUE }T
|
||||
T{ PAD 43 CHARS + 9 0 CHECKPAD -> TRUE }T
|
||||
T{ PAD 52 CHARS + CHARS/PAD 52 - MAXCHAR CHECKPAD -> TRUE }T
|
||||
|
||||
\ Check that use of WORD and pictured numeric output do not corrupt PAD
|
||||
\ Minimum size of buffers for these are 33 chars and (2*n)+2 chars respectively
|
||||
\ where n is number of bits per cell
|
||||
|
||||
PAD CHARS/PAD ERASE
|
||||
2 BASE !
|
||||
MAX-UINT MAX-UINT <# #S CHAR 1 DUP HOLD HOLD #> 2DROP
|
||||
DECIMAL
|
||||
BL WORD 12345678123456781234567812345678 DROP
|
||||
T{ PAD CHARS/PAD 0 CHECKPAD -> TRUE }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING PARSE
|
||||
|
||||
T{ CHAR | PARSE 1234| DUP ROT ROT EVALUATE -> 4 1234 }T
|
||||
T{ CHAR ^ PARSE 23 45 ^ DUP ROT ROT EVALUATE -> 7 23 45 }T
|
||||
: PA1 [CHAR] $ PARSE DUP >R PAD SWAP CHARS MOVE PAD R> ;
|
||||
T{ PA1 3456
|
||||
DUP ROT ROT EVALUATE -> 4 3456 }T
|
||||
T{ CHAR A PARSE A SWAP DROP -> 0 }T
|
||||
T{ CHAR Z PARSE
|
||||
SWAP DROP -> 0 }T
|
||||
T{ CHAR " PARSE 4567 "DUP ROT ROT EVALUATE -> 5 4567 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING PARSE-NAME (Forth 2012)
|
||||
\ Adapted from the PARSE-NAME RfD tests
|
||||
|
||||
T{ PARSE-NAME abcd STR1 S= -> TRUE }T \ No leading spaces
|
||||
T{ PARSE-NAME abcde STR2 S= -> TRUE }T \ Leading spaces
|
||||
|
||||
\ Test empty parse area, new lines are necessary
|
||||
T{ PARSE-NAME
|
||||
NIP -> 0 }T
|
||||
\ Empty parse area with spaces after PARSE-NAME
|
||||
T{ PARSE-NAME
|
||||
NIP -> 0 }T
|
||||
|
||||
T{ : PARSE-NAME-TEST ( "name1" "name2" -- n )
|
||||
PARSE-NAME PARSE-NAME S= ; -> }T
|
||||
T{ PARSE-NAME-TEST abcd abcd -> TRUE }T
|
||||
T{ PARSE-NAME-TEST abcd abcd -> TRUE }T \ Leading spaces
|
||||
T{ PARSE-NAME-TEST abcde abcdf -> FALSE }T
|
||||
T{ PARSE-NAME-TEST abcdf abcde -> FALSE }T
|
||||
T{ PARSE-NAME-TEST abcde abcde
|
||||
-> TRUE }T \ Parse to end of line
|
||||
T{ PARSE-NAME-TEST abcde abcde
|
||||
-> TRUE }T \ Leading and trailing spaces
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING DEFER DEFER@ DEFER! IS ACTION-OF (Forth 2012)
|
||||
\ Adapted from the Forth 200X RfD tests
|
||||
|
||||
T{ DEFER DEFER1 -> }T
|
||||
T{ : MY-DEFER DEFER ; -> }T
|
||||
T{ : IS-DEFER1 IS DEFER1 ; -> }T
|
||||
T{ : ACTION-DEFER1 ACTION-OF DEFER1 ; -> }T
|
||||
T{ : DEF! DEFER! ; -> }T
|
||||
T{ : DEF@ DEFER@ ; -> }T
|
||||
|
||||
T{ ' * ' DEFER1 DEFER! -> }T
|
||||
T{ 2 3 DEFER1 -> 6 }T
|
||||
T{ ' DEFER1 DEFER@ -> ' * }T
|
||||
T{ ' DEFER1 DEF@ -> ' * }T
|
||||
T{ ACTION-OF DEFER1 -> ' * }T
|
||||
T{ ACTION-DEFER1 -> ' * }T
|
||||
T{ ' + IS DEFER1 -> }T
|
||||
T{ 1 2 DEFER1 -> 3 }T
|
||||
T{ ' DEFER1 DEFER@ -> ' + }T
|
||||
T{ ' DEFER1 DEF@ -> ' + }T
|
||||
T{ ACTION-OF DEFER1 -> ' + }T
|
||||
T{ ACTION-DEFER1 -> ' + }T
|
||||
T{ ' - IS-DEFER1 -> }T
|
||||
T{ 1 2 DEFER1 -> -1 }T
|
||||
T{ ' DEFER1 DEFER@ -> ' - }T
|
||||
T{ ' DEFER1 DEF@ -> ' - }T
|
||||
T{ ACTION-OF DEFER1 -> ' - }T
|
||||
T{ ACTION-DEFER1 -> ' - }T
|
||||
|
||||
T{ MY-DEFER DEFER2 -> }T
|
||||
T{ ' DUP IS DEFER2 -> }T
|
||||
T{ 1 DEFER2 -> 1 1 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING HOLDS (Forth 2012)
|
||||
|
||||
: HTEST S" Testing HOLDS" ;
|
||||
: HTEST2 S" works" ;
|
||||
: HTEST3 S" Testing HOLDS works 123" ;
|
||||
T{ 0 0 <# HTEST HOLDS #> HTEST S= -> TRUE }T
|
||||
T{ 123 0 <# #S BL HOLD HTEST2 HOLDS BL HOLD HTEST HOLDS #>
|
||||
HTEST3 S= -> TRUE }T
|
||||
T{ : HLD HOLDS ; -> }T
|
||||
T{ 0 0 <# HTEST HLD #> HTEST S= -> TRUE }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
TESTING REFILL SOURCE-ID
|
||||
\ REFILL and SOURCE-ID from the user input device can't be tested from a file,
|
||||
\ can only be tested from a string via EVALUATE
|
||||
|
||||
T{ : RF1 S" REFILL" EVALUATE ; RF1 -> FALSE }T
|
||||
T{ : SID1 S" SOURCE-ID" EVALUATE ; SID1 -> -1 }T
|
||||
|
||||
\ ------------------------------------------------------------------------------
|
||||
TESTING S\" (Forth 2012 compilation mode)
|
||||
\ Extended the Forth 200X RfD tests
|
||||
\ Note this tests the Core Ext definition of S\" which has unedfined
|
||||
\ interpretation semantics. S\" in interpretation mode is tested in the tests on
|
||||
\ the File-Access word set
|
||||
|
||||
T{ : SSQ1 S\" abc" S" abc" S= ; -> }T \ No escapes
|
||||
T{ SSQ1 -> TRUE }T
|
||||
T{ : SSQ2 S\" " ; SSQ2 SWAP DROP -> 0 }T \ Empty string
|
||||
|
||||
T{ : SSQ3 S\" \a\b\e\f\l\m\q\r\t\v\x0F0\x1Fa\xaBx\z\"\\" ; -> }T
|
||||
T{ SSQ3 SWAP DROP -> 20 }T \ String length
|
||||
T{ SSQ3 DROP C@ -> 7 }T \ \a BEL Bell
|
||||
T{ SSQ3 DROP 1 CHARS + C@ -> 8 }T \ \b BS Backspace
|
||||
T{ SSQ3 DROP 2 CHARS + C@ -> 27 }T \ \e ESC Escape
|
||||
T{ SSQ3 DROP 3 CHARS + C@ -> 12 }T \ \f FF Form feed
|
||||
T{ SSQ3 DROP 4 CHARS + C@ -> 10 }T \ \l LF Line feed
|
||||
T{ SSQ3 DROP 5 CHARS + C@ -> 13 }T \ \m CR of CR/LF pair
|
||||
T{ SSQ3 DROP 6 CHARS + C@ -> 10 }T \ LF of CR/LF pair
|
||||
T{ SSQ3 DROP 7 CHARS + C@ -> 34 }T \ \q " Double Quote
|
||||
T{ SSQ3 DROP 8 CHARS + C@ -> 13 }T \ \r CR Carriage Return
|
||||
T{ SSQ3 DROP 9 CHARS + C@ -> 9 }T \ \t TAB Horizontal Tab
|
||||
T{ SSQ3 DROP 10 CHARS + C@ -> 11 }T \ \v VT Vertical Tab
|
||||
T{ SSQ3 DROP 11 CHARS + C@ -> 15 }T \ \x0F Given Char
|
||||
T{ SSQ3 DROP 12 CHARS + C@ -> 48 }T \ 0 0 Digit follow on
|
||||
T{ SSQ3 DROP 13 CHARS + C@ -> 31 }T \ \x1F Given Char
|
||||
T{ SSQ3 DROP 14 CHARS + C@ -> 97 }T \ a a Hex follow on
|
||||
T{ SSQ3 DROP 15 CHARS + C@ -> 171 }T \ \xaB Insensitive Given Char
|
||||
T{ SSQ3 DROP 16 CHARS + C@ -> 120 }T \ x x Non hex follow on
|
||||
T{ SSQ3 DROP 17 CHARS + C@ -> 0 }T \ \z NUL No Character
|
||||
T{ SSQ3 DROP 18 CHARS + C@ -> 34 }T \ \" " Double Quote
|
||||
T{ SSQ3 DROP 19 CHARS + C@ -> 92 }T \ \\ \ Back Slash
|
||||
|
||||
\ The above does not test \n as this is a system dependent value.
|
||||
\ Check it displays a new line
|
||||
CR .( The next test should display:)
|
||||
CR .( One line...)
|
||||
CR .( another line)
|
||||
T{ : SSQ4 S\" \nOne line...\nanotherLine\n" TYPE ; SSQ4 -> }T
|
||||
|
||||
\ Test bare escapable characters appear as themselves
|
||||
T{ : SSQ5 S\" abeflmnqrtvxz" S" abeflmnqrtvxz" S= ; SSQ5 -> TRUE }T
|
||||
|
||||
T{ : SSQ6 S\" a\""2DROP 1111 ; SSQ6 -> 1111 }T \ Parsing behaviour
|
||||
|
||||
T{ : SSQ7 S\" 111 : SSQ8 S\\\" 222\" EVALUATE ; SSQ8 333" EVALUATE ; -> }T
|
||||
T{ SSQ7 -> 111 222 333 }T
|
||||
T{ : SSQ9 S\" 11 : SSQ10 S\\\" \\x32\\x32\" EVALUATE ; SSQ10 33" EVALUATE ; -> }T
|
||||
T{ SSQ9 -> 11 22 33 }T
|
||||
|
||||
\ -----------------------------------------------------------------------------
|
||||
CORE-EXT-ERRORS SET-ERROR-COUNT
|
||||
|
||||
CR .( End of Core Extension word tests) CR
|
||||
|
||||
|
||||
66
lib/forth/ans-tests/tester.fr
Normal file
66
lib/forth/ans-tests/tester.fr
Normal file
@@ -0,0 +1,66 @@
|
||||
\ From: John Hayes S1I
|
||||
\ Subject: tester.fr
|
||||
\ Date: Mon, 27 Nov 95 13:10:09 PST
|
||||
|
||||
\ (C) 1995 JOHNS HOPKINS UNIVERSITY / APPLIED PHYSICS LABORATORY
|
||||
\ MAY BE DISTRIBUTED FREELY AS LONG AS THIS COPYRIGHT NOTICE REMAINS.
|
||||
\ VERSION 1.2
|
||||
|
||||
\ 24/11/2015 Replaced Core Ext word <> with = 0=
|
||||
\ 31/3/2015 Variable #ERRORS added and incremented for each error reported.
|
||||
\ 22/1/09 The words { and } have been changed to T{ and }T respectively to
|
||||
\ agree with the Forth 200X file ttester.fs. This avoids clashes with
|
||||
\ locals using { ... } and the FSL use of }
|
||||
|
||||
HEX
|
||||
|
||||
\ SET THE FOLLOWING FLAG TO TRUE FOR MORE VERBOSE OUTPUT; THIS MAY
|
||||
\ ALLOW YOU TO TELL WHICH TEST CAUSED YOUR SYSTEM TO HANG.
|
||||
VARIABLE VERBOSE
|
||||
FALSE VERBOSE !
|
||||
\ TRUE VERBOSE !
|
||||
|
||||
: EMPTY-STACK \ ( ... -- ) EMPTY STACK: HANDLES UNDERFLOWED STACK TOO.
|
||||
DEPTH ?DUP IF DUP 0< IF NEGATE 0 DO 0 LOOP ELSE 0 DO DROP LOOP THEN THEN ;
|
||||
|
||||
VARIABLE #ERRORS 0 #ERRORS !
|
||||
|
||||
: ERROR \ ( C-ADDR U -- ) DISPLAY AN ERROR MESSAGE FOLLOWED BY
|
||||
\ THE LINE THAT HAD THE ERROR.
|
||||
CR TYPE SOURCE TYPE \ DISPLAY LINE CORRESPONDING TO ERROR
|
||||
EMPTY-STACK \ THROW AWAY EVERY THING ELSE
|
||||
#ERRORS @ 1 + #ERRORS !
|
||||
\ QUIT \ *** Uncomment this line to QUIT on an error
|
||||
;
|
||||
|
||||
VARIABLE ACTUAL-DEPTH \ STACK RECORD
|
||||
CREATE ACTUAL-RESULTS 20 CELLS ALLOT
|
||||
|
||||
: T{ \ ( -- ) SYNTACTIC SUGAR.
|
||||
;
|
||||
|
||||
: -> \ ( ... -- ) RECORD DEPTH AND CONTENT OF STACK.
|
||||
DEPTH DUP ACTUAL-DEPTH ! \ RECORD DEPTH
|
||||
?DUP IF \ IF THERE IS SOMETHING ON STACK
|
||||
0 DO ACTUAL-RESULTS I CELLS + ! LOOP \ SAVE THEM
|
||||
THEN ;
|
||||
|
||||
: }T \ ( ... -- ) COMPARE STACK (EXPECTED) CONTENTS WITH SAVED
|
||||
\ (ACTUAL) CONTENTS.
|
||||
DEPTH ACTUAL-DEPTH @ = IF \ IF DEPTHS MATCH
|
||||
DEPTH ?DUP IF \ IF THERE IS SOMETHING ON THE STACK
|
||||
0 DO \ FOR EACH STACK ITEM
|
||||
ACTUAL-RESULTS I CELLS + @ \ COMPARE ACTUAL WITH EXPECTED
|
||||
= 0= IF S" INCORRECT RESULT: " ERROR LEAVE THEN
|
||||
LOOP
|
||||
THEN
|
||||
ELSE \ DEPTH MISMATCH
|
||||
S" WRONG NUMBER OF RESULTS: " ERROR
|
||||
THEN ;
|
||||
|
||||
: TESTING \ ( -- ) TALKING COMMENT.
|
||||
SOURCE VERBOSE @
|
||||
IF DUP >R TYPE CR R> >IN !
|
||||
ELSE >IN ! DROP [CHAR] * EMIT
|
||||
THEN ;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
170
lib/forth/conformance.sh
Executable file
170
lib/forth/conformance.sh
Executable file
@@ -0,0 +1,170 @@
|
||||
#!/usr/bin/env bash
|
||||
# Run the Hayes/Gerry-Jackson Core conformance suite against our Forth
|
||||
# interpreter and emit scoreboard.json + scoreboard.md.
|
||||
#
|
||||
# Method:
|
||||
# 1. Preprocess lib/forth/ans-tests/core.fr — strip \ comments, ( ... )
|
||||
# comments, and TESTING … metadata lines.
|
||||
# 2. Split into chunks ending at each `}T` so an error in one test
|
||||
# chunk doesn't abort the run.
|
||||
# 3. Emit an SX file that exposes those chunks as a list.
|
||||
# 4. Run our Forth + hayes-runner under sx_server; record pass/fail/error.
|
||||
|
||||
set -e
|
||||
FORTH_DIR="$(cd "$(dirname "$0")" && pwd)"
|
||||
ROOT="$(cd "$FORTH_DIR/../.." && pwd)"
|
||||
SX_SERVER="${SX_SERVER:-/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe}"
|
||||
SOURCE="$FORTH_DIR/ans-tests/core.fr"
|
||||
OUT_JSON="$FORTH_DIR/scoreboard.json"
|
||||
OUT_MD="$FORTH_DIR/scoreboard.md"
|
||||
TMP="$(mktemp -d)"
|
||||
PREPROC="$TMP/preproc.forth"
|
||||
CHUNKS_SX="$TMP/chunks.sx"
|
||||
|
||||
cd "$ROOT"
|
||||
|
||||
# 1. preprocess
|
||||
awk '
|
||||
{
|
||||
line = $0
|
||||
# protect POSTPONE \ so the comment-strip below leaves the literal \ alone
|
||||
gsub(/POSTPONE[ \t]+\\/, "POSTPONE @@BS@@", line)
|
||||
# strip leading/embedded \ line comments (must be \ followed by space or EOL)
|
||||
gsub(/(^|[ \t])\\([ \t].*|$)/, " ", line)
|
||||
# strip ( ... ) block comments that sit on one line
|
||||
gsub(/\([^)]*\)/, " ", line)
|
||||
# strip TESTING … metadata lines (rest of line, incl. bare TESTING)
|
||||
sub(/TESTING([ \t].*)?$/, " ", line)
|
||||
# restore the protected backslash
|
||||
gsub(/@@BS@@/, "\\", line)
|
||||
print line
|
||||
}' "$SOURCE" > "$PREPROC"
|
||||
|
||||
# 2 + 3: split into chunks at each `}T` and emit as a SX file
|
||||
#
|
||||
# Cap chunks via MAX_CHUNKS env (default 638 = full Hayes Core). Lower
|
||||
# it temporarily if later tests regress into an infinite loop while you
|
||||
# are iterating on primitives.
|
||||
MAX_CHUNKS="${MAX_CHUNKS:-638}"
|
||||
|
||||
MAX_CHUNKS="$MAX_CHUNKS" python3 - "$PREPROC" "$CHUNKS_SX" <<'PY'
|
||||
import os, re, sys
|
||||
preproc_path, out_path = sys.argv[1], sys.argv[2]
|
||||
max_chunks = int(os.environ.get("MAX_CHUNKS", "590"))
|
||||
text = open(preproc_path).read()
|
||||
# keep the `}T` attached to the preceding chunk
|
||||
parts = re.split(r'(\}T)', text)
|
||||
chunks = []
|
||||
buf = ""
|
||||
for p in parts:
|
||||
buf += p
|
||||
if p == "}T":
|
||||
s = buf.strip()
|
||||
if s:
|
||||
chunks.append(s)
|
||||
buf = ""
|
||||
if buf.strip():
|
||||
chunks.append(buf.strip())
|
||||
chunks = chunks[:max_chunks]
|
||||
|
||||
def esc(s):
|
||||
s = s.replace('\\', '\\\\').replace('"', '\\"')
|
||||
s = s.replace('\r', ' ').replace('\n', ' ')
|
||||
s = re.sub(r'\s+', ' ', s).strip()
|
||||
return s
|
||||
|
||||
with open(out_path, "w") as f:
|
||||
f.write("(define hayes-chunks (list\n")
|
||||
for c in chunks:
|
||||
f.write(' "' + esc(c) + '"\n')
|
||||
f.write("))\n\n")
|
||||
f.write("(define\n")
|
||||
f.write(" hayes-run-all\n")
|
||||
f.write(" (fn\n")
|
||||
f.write(" ()\n")
|
||||
f.write(" (hayes-reset!)\n")
|
||||
f.write(" (let ((s (hayes-boot)))\n")
|
||||
f.write(" (for-each (fn (c) (hayes-run-chunk s c)) hayes-chunks))\n")
|
||||
f.write(" (hayes-summary)))\n")
|
||||
PY
|
||||
|
||||
# 4. run it
|
||||
OUT=$(printf '(epoch 1)\n(load "lib/forth/runtime.sx")\n(epoch 2)\n(load "lib/forth/reader.sx")\n(epoch 3)\n(load "lib/forth/interpreter.sx")\n(epoch 4)\n(load "lib/forth/compiler.sx")\n(epoch 5)\n(load "lib/forth/hayes-runner.sx")\n(epoch 6)\n(load "%s")\n(epoch 7)\n(eval "(hayes-run-all)")\n' "$CHUNKS_SX" \
|
||||
| timeout 180 "$SX_SERVER" 2>&1)
|
||||
STATUS=$?
|
||||
|
||||
SUMMARY=$(printf '%s\n' "$OUT" | awk '/^\{:pass / {print; exit}')
|
||||
PASS=$(printf '%s' "$SUMMARY" | sed -n 's/.*:pass \([0-9-]*\).*/\1/p')
|
||||
FAIL=$(printf '%s' "$SUMMARY" | sed -n 's/.*:fail \([0-9-]*\).*/\1/p')
|
||||
ERR=$(printf '%s' "$SUMMARY" | sed -n 's/.*:error \([0-9-]*\).*/\1/p')
|
||||
TOTAL=$(printf '%s' "$SUMMARY" | sed -n 's/.*:total \([0-9-]*\).*/\1/p')
|
||||
CHUNK_COUNT=$(grep -c '^ "' "$CHUNKS_SX" || echo 0)
|
||||
TOTAL_AVAILABLE=$(grep -c '}T' "$PREPROC" || echo 0)
|
||||
|
||||
NOW="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
|
||||
|
||||
if [ -z "$PASS" ]; then
|
||||
PASS=0; FAIL=0; ERR=0; TOTAL=0
|
||||
NOTE="runner halted before completing (timeout or SX error)"
|
||||
else
|
||||
NOTE="completed"
|
||||
fi
|
||||
|
||||
PCT=0
|
||||
if [ "$TOTAL" -gt 0 ]; then
|
||||
PCT=$((PASS * 100 / TOTAL))
|
||||
fi
|
||||
|
||||
cat > "$OUT_JSON" <<JSON
|
||||
{
|
||||
"source": "gerryjackson/forth2012-test-suite src/core.fr",
|
||||
"generated_at": "$NOW",
|
||||
"chunks_available": $TOTAL_AVAILABLE,
|
||||
"chunks_fed": $CHUNK_COUNT,
|
||||
"total": $TOTAL,
|
||||
"pass": $PASS,
|
||||
"fail": $FAIL,
|
||||
"error": $ERR,
|
||||
"percent": $PCT,
|
||||
"note": "$NOTE"
|
||||
}
|
||||
JSON
|
||||
|
||||
cat > "$OUT_MD" <<MD
|
||||
# Forth Hayes Core scoreboard
|
||||
|
||||
| metric | value |
|
||||
| ----------------- | ----: |
|
||||
| chunks available | $TOTAL_AVAILABLE |
|
||||
| chunks fed | $CHUNK_COUNT |
|
||||
| total | $TOTAL |
|
||||
| pass | $PASS |
|
||||
| fail | $FAIL |
|
||||
| error | $ERR |
|
||||
| percent | ${PCT}% |
|
||||
|
||||
- **Source**: \`gerryjackson/forth2012-test-suite\` \`src/core.fr\`
|
||||
- **Generated**: $NOW
|
||||
- **Note**: $NOTE
|
||||
|
||||
A "chunk" is any preprocessed segment ending at a \`}T\` (every Hayes test
|
||||
is one chunk, plus the small declaration blocks between tests).
|
||||
The runner catches raised errors at chunk boundaries so one bad chunk
|
||||
does not abort the rest. \`error\` covers chunks that raised; \`fail\`
|
||||
covers tests whose \`->\` / \`}T\` comparison mismatched.
|
||||
|
||||
### Chunk cap
|
||||
|
||||
\`conformance.sh\` processes the first \`\$MAX_CHUNKS\` chunks (default
|
||||
**638**, i.e. the whole Hayes Core file). Lower the cap temporarily
|
||||
while iterating on primitives if a regression re-opens an infinite
|
||||
loop in later tests.
|
||||
MD
|
||||
|
||||
echo "$SUMMARY"
|
||||
echo "Scoreboard: $OUT_JSON"
|
||||
echo " $OUT_MD"
|
||||
|
||||
if [ "$STATUS" -ne 0 ] && [ "$TOTAL" -eq 0 ]; then
|
||||
exit 1
|
||||
fi
|
||||
158
lib/forth/hayes-runner.sx
Normal file
158
lib/forth/hayes-runner.sx
Normal file
@@ -0,0 +1,158 @@
|
||||
;; Hayes conformance test runner.
|
||||
;; Installs T{ -> }T as Forth primitives that snapshot and compare dstack,
|
||||
;; plus stub TESTING / HEX / DECIMAL so the Hayes Core file can stream
|
||||
;; through the interpreter without halting on unsupported metadata words.
|
||||
|
||||
(define hayes-pass 0)
|
||||
(define hayes-fail 0)
|
||||
(define hayes-error 0)
|
||||
(define hayes-start-depth 0)
|
||||
(define hayes-actual (list))
|
||||
(define hayes-actual-set false)
|
||||
(define hayes-failures (list))
|
||||
(define hayes-first-error "")
|
||||
(define hayes-error-hist (dict))
|
||||
|
||||
(define
|
||||
hayes-reset!
|
||||
(fn
|
||||
()
|
||||
(set! hayes-pass 0)
|
||||
(set! hayes-fail 0)
|
||||
(set! hayes-error 0)
|
||||
(set! hayes-start-depth 0)
|
||||
(set! hayes-actual (list))
|
||||
(set! hayes-actual-set false)
|
||||
(set! hayes-failures (list))
|
||||
(set! hayes-first-error "")
|
||||
(set! hayes-error-hist (dict))))
|
||||
|
||||
(define
|
||||
hayes-slice
|
||||
(fn
|
||||
(state base)
|
||||
(let
|
||||
((n (- (forth-depth state) base)))
|
||||
(if (<= n 0) (list) (take (get state "dstack") n)))))
|
||||
|
||||
(define
|
||||
hayes-truncate!
|
||||
(fn
|
||||
(state base)
|
||||
(let
|
||||
((n (- (forth-depth state) base)))
|
||||
(when (> n 0) (dict-set! state "dstack" (drop (get state "dstack") n))))))
|
||||
|
||||
(define
|
||||
hayes-install!
|
||||
(fn
|
||||
(state)
|
||||
(forth-def-prim!
|
||||
state
|
||||
"T{"
|
||||
(fn
|
||||
(s)
|
||||
(set! hayes-start-depth (forth-depth s))
|
||||
(set! hayes-actual-set false)
|
||||
(set! hayes-actual (list))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"->"
|
||||
(fn
|
||||
(s)
|
||||
(set! hayes-actual (hayes-slice s hayes-start-depth))
|
||||
(set! hayes-actual-set true)
|
||||
(hayes-truncate! s hayes-start-depth)))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"}T"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((expected (hayes-slice s hayes-start-depth)))
|
||||
(hayes-truncate! s hayes-start-depth)
|
||||
(if
|
||||
(and hayes-actual-set (= expected hayes-actual))
|
||||
(set! hayes-pass (+ hayes-pass 1))
|
||||
(begin
|
||||
(set! hayes-fail (+ hayes-fail 1))
|
||||
(set!
|
||||
hayes-failures
|
||||
(concat
|
||||
hayes-failures
|
||||
(list
|
||||
(dict
|
||||
"kind"
|
||||
"fail"
|
||||
"expected"
|
||||
(str expected)
|
||||
"actual"
|
||||
(str hayes-actual))))))))))
|
||||
(forth-def-prim! state "TESTING" (fn (s) nil))
|
||||
;; HEX/DECIMAL are real primitives now (runtime.sx) — no stub needed.
|
||||
state))
|
||||
|
||||
(define
|
||||
hayes-boot
|
||||
(fn () (let ((s (forth-boot))) (hayes-install! s) (hayes-reset!) s)))
|
||||
|
||||
;; Run a single preprocessed chunk (string of Forth source) on the shared
|
||||
;; state. Catch any raised error and move on — the chunk boundary is a
|
||||
;; safe resume point.
|
||||
(define
|
||||
hayes-bump-error-key!
|
||||
(fn
|
||||
(err)
|
||||
(let
|
||||
((msg (str err)))
|
||||
(let
|
||||
((space-idx (index-of msg " ")))
|
||||
(let
|
||||
((key
|
||||
(if
|
||||
(> space-idx 0)
|
||||
(substr msg 0 space-idx)
|
||||
msg)))
|
||||
(dict-set!
|
||||
hayes-error-hist
|
||||
key
|
||||
(+ 1 (or (get hayes-error-hist key) 0))))))))
|
||||
|
||||
(define
|
||||
hayes-run-chunk
|
||||
(fn
|
||||
(state src)
|
||||
(guard
|
||||
(err
|
||||
((= 1 1)
|
||||
(begin
|
||||
(set! hayes-error (+ hayes-error 1))
|
||||
(when
|
||||
(= (len hayes-first-error) 0)
|
||||
(set! hayes-first-error (str err)))
|
||||
(hayes-bump-error-key! err)
|
||||
(dict-set! state "dstack" (list))
|
||||
(dict-set! state "rstack" (list))
|
||||
(dict-set! state "compiling" false)
|
||||
(dict-set! state "current-def" nil)
|
||||
(dict-set! state "cstack" (list))
|
||||
(dict-set! state "input" (list)))))
|
||||
(forth-interpret state src))))
|
||||
|
||||
(define
|
||||
hayes-summary
|
||||
(fn
|
||||
()
|
||||
(dict
|
||||
"pass"
|
||||
hayes-pass
|
||||
"fail"
|
||||
hayes-fail
|
||||
"error"
|
||||
hayes-error
|
||||
"total"
|
||||
(+ (+ hayes-pass hayes-fail) hayes-error)
|
||||
"first-error"
|
||||
hayes-first-error
|
||||
"error-hist"
|
||||
hayes-error-hist)))
|
||||
@@ -17,7 +17,7 @@
|
||||
(not (nil? w))
|
||||
(forth-execute-word state w)
|
||||
(let
|
||||
((n (forth-parse-number tok (get state "base"))))
|
||||
((n (forth-parse-number tok (get (get state "vars") "base"))))
|
||||
(if
|
||||
(not (nil? n))
|
||||
(forth-push state n)
|
||||
|
||||
@@ -18,10 +18,122 @@
|
||||
(dict-set! s "output" "")
|
||||
(dict-set! s "compiling" false)
|
||||
(dict-set! s "current-def" nil)
|
||||
(dict-set! s "base" 10)
|
||||
(dict-set! s "vars" (dict))
|
||||
(dict-set! (get s "vars") "base" 10)
|
||||
(dict-set! s "cstack" (list))
|
||||
(dict-set! s "mem" (dict))
|
||||
(dict-set! s "here" 0)
|
||||
(dict-set! s "hold" (list))
|
||||
(dict-set! s "files" (dict))
|
||||
(dict-set! s "by-path" (dict))
|
||||
(dict-set! s "next-fileid" 1)
|
||||
s)))
|
||||
|
||||
(define
|
||||
forth-mem-write!
|
||||
(fn (state addr u) (dict-set! (get state "mem") (str addr) u)))
|
||||
|
||||
(define
|
||||
forth-mem-read
|
||||
(fn
|
||||
(state addr)
|
||||
(or (get (get state "mem") (str addr)) 0)))
|
||||
|
||||
(define
|
||||
forth-alloc-bytes!
|
||||
(fn
|
||||
(state n)
|
||||
(let
|
||||
((addr (get state "here")))
|
||||
(dict-set! state "here" (+ addr n))
|
||||
addr)))
|
||||
|
||||
(define
|
||||
forth-mem-write-string!
|
||||
(fn
|
||||
(state addr s)
|
||||
(let
|
||||
((n (len s)))
|
||||
(forth-mem-write-string-loop! state addr s 0 n))))
|
||||
|
||||
(define
|
||||
forth-mem-write-string-loop!
|
||||
(fn
|
||||
(state addr s i n)
|
||||
(when
|
||||
(< i n)
|
||||
(begin
|
||||
(forth-mem-write! state (+ addr i) (char-code (substr s i 1)))
|
||||
(forth-mem-write-string-loop! state addr s (+ i 1) n)))))
|
||||
|
||||
(define
|
||||
forth-mem-read-string
|
||||
(fn
|
||||
(state addr n)
|
||||
(forth-mem-read-string-loop state addr 0 n "")))
|
||||
|
||||
(define
|
||||
forth-mem-read-string-loop
|
||||
(fn
|
||||
(state addr i n acc)
|
||||
(if
|
||||
(>= i n)
|
||||
acc
|
||||
(forth-mem-read-string-loop
|
||||
state
|
||||
addr
|
||||
(+ i 1)
|
||||
n
|
||||
(str acc (char-from-code (forth-mem-read state (+ addr i))))))))
|
||||
|
||||
(define
|
||||
forth-fill-loop
|
||||
(fn
|
||||
(state addr u char i)
|
||||
(when
|
||||
(< i u)
|
||||
(begin
|
||||
(forth-mem-write! state (+ addr i) char)
|
||||
(forth-fill-loop state addr u char (+ i 1))))))
|
||||
|
||||
(define
|
||||
forth-cmove-loop
|
||||
(fn
|
||||
(state src dst u i)
|
||||
(when
|
||||
(< i u)
|
||||
(begin
|
||||
(forth-mem-write! state (+ dst i) (forth-mem-read state (+ src i)))
|
||||
(forth-cmove-loop state src dst u (+ i 1))))))
|
||||
|
||||
(define
|
||||
forth-cmove-loop-desc
|
||||
(fn
|
||||
(state src dst u i)
|
||||
(when
|
||||
(>= i 0)
|
||||
(begin
|
||||
(forth-mem-write! state (+ dst i) (forth-mem-read state (+ src i)))
|
||||
(forth-cmove-loop-desc state src dst u (- i 1))))))
|
||||
|
||||
(define
|
||||
forth-cpush
|
||||
(fn (state v) (dict-set! state "cstack" (cons v (get state "cstack")))))
|
||||
|
||||
(define
|
||||
forth-cpop
|
||||
(fn
|
||||
(state)
|
||||
(let
|
||||
((cs (get state "cstack")))
|
||||
(if
|
||||
(= (len cs) 0)
|
||||
(forth-error state "control stack underflow")
|
||||
(let
|
||||
((top (first cs)))
|
||||
(dict-set! state "cstack" (rest cs))
|
||||
top)))))
|
||||
|
||||
(define
|
||||
forth-error
|
||||
(fn (state msg) (dict-set! state "error" msg) (raise msg)))
|
||||
@@ -99,7 +211,8 @@
|
||||
(dict-set!
|
||||
(get state "dict")
|
||||
(downcase name)
|
||||
(forth-make-word "primitive" body false))))
|
||||
(forth-make-word "primitive" body false))
|
||||
(dict-set! state "last-defined" name)))
|
||||
|
||||
(define
|
||||
forth-def-prim-imm!
|
||||
@@ -108,7 +221,8 @@
|
||||
(dict-set!
|
||||
(get state "dict")
|
||||
(downcase name)
|
||||
(forth-make-word "primitive" body true))))
|
||||
(forth-make-word "primitive" body true))
|
||||
(dict-set! state "last-defined" name)))
|
||||
|
||||
(define
|
||||
forth-lookup
|
||||
@@ -166,6 +280,220 @@
|
||||
|
||||
(define forth-bits-width 32)
|
||||
|
||||
;; Truncate a number to the Forth 32-bit signed range (two's-complement).
|
||||
;; Used by arithmetic primitives so wrap-around matches ANS semantics and
|
||||
;; loop idioms that rely on MSB becoming 0 after enough shifts terminate.
|
||||
(define
|
||||
forth-clip
|
||||
(fn
|
||||
(n)
|
||||
(forth-from-unsigned
|
||||
(forth-to-unsigned n forth-bits-width)
|
||||
forth-bits-width)))
|
||||
|
||||
;; Double-cell helpers. Single = 32-bit signed, double = 64-bit signed
|
||||
;; represented on the data stack as (lo, hi) where hi is on top.
|
||||
;; Reassembly converts the low cell as unsigned and the high cell as
|
||||
;; signed (signed) or as unsigned (unsigned), then combines.
|
||||
(define forth-2pow32 (pow 2 32))
|
||||
(define forth-2pow64 (pow 2 64))
|
||||
|
||||
(define
|
||||
forth-double-from-cells-u
|
||||
(fn
|
||||
(lo hi)
|
||||
(+ (forth-to-unsigned lo 32) (* (forth-to-unsigned hi 32) forth-2pow32))))
|
||||
|
||||
(define
|
||||
forth-double-from-cells-s
|
||||
(fn (lo hi) (+ (forth-to-unsigned lo 32) (* hi forth-2pow32))))
|
||||
|
||||
(define
|
||||
forth-double-push-u
|
||||
(fn
|
||||
(state d)
|
||||
(let
|
||||
((lo (mod d forth-2pow32)) (hi (floor (/ d forth-2pow32))))
|
||||
(forth-push state (forth-from-unsigned lo 32))
|
||||
(forth-push state (forth-from-unsigned hi 32)))))
|
||||
|
||||
(define
|
||||
forth-num-to-string-loop
|
||||
(fn
|
||||
(u base acc)
|
||||
(if
|
||||
(= u 0)
|
||||
acc
|
||||
(let
|
||||
((dig (mod u base)) (rest (floor (/ u base))))
|
||||
(let
|
||||
((ch
|
||||
(if
|
||||
(< dig 10)
|
||||
(char-from-code (+ 48 dig))
|
||||
(char-from-code (+ 55 dig)))))
|
||||
(forth-num-to-string-loop rest base (str ch acc)))))))
|
||||
|
||||
(define
|
||||
forth-num-to-string
|
||||
(fn
|
||||
(u base)
|
||||
(if (= u 0) "0" (forth-num-to-string-loop u base ""))))
|
||||
|
||||
(define
|
||||
forth-spaces-str
|
||||
(fn
|
||||
(n)
|
||||
(if (<= n 0) "" (str " " (forth-spaces-str (- n 1))))))
|
||||
|
||||
(define
|
||||
forth-join-hold
|
||||
(fn
|
||||
(parts)
|
||||
(forth-join-hold-loop parts "")))
|
||||
|
||||
(define
|
||||
forth-join-hold-loop
|
||||
(fn
|
||||
(parts acc)
|
||||
(if
|
||||
(= (len parts) 0)
|
||||
acc
|
||||
(forth-join-hold-loop (rest parts) (str acc (first parts))))))
|
||||
|
||||
(define
|
||||
forth-pic-step
|
||||
(fn
|
||||
(state)
|
||||
(let
|
||||
((hi (forth-pop state)) (lo (forth-pop state)))
|
||||
(let
|
||||
((d (forth-double-from-cells-u lo hi))
|
||||
(b (get (get state "vars") "base")))
|
||||
(let
|
||||
((dig (mod d b)) (rest (floor (/ d b))))
|
||||
(let
|
||||
((ch
|
||||
(if
|
||||
(< dig 10)
|
||||
(char-from-code (+ 48 dig))
|
||||
(char-from-code (+ 55 dig)))))
|
||||
(dict-set! state "hold" (cons ch (get state "hold")))
|
||||
(forth-double-push-u state rest)))))))
|
||||
|
||||
(define
|
||||
forth-compare-bytes-loop
|
||||
(fn
|
||||
(state a1 u1 a2 u2 i)
|
||||
(cond
|
||||
((and (= i u1) (= i u2)) 0)
|
||||
((= i u1) -1)
|
||||
((= i u2) 1)
|
||||
(else
|
||||
(let
|
||||
((b1 (forth-mem-read state (+ a1 i)))
|
||||
(b2 (forth-mem-read state (+ a2 i))))
|
||||
(cond
|
||||
((< b1 b2) -1)
|
||||
((> b1 b2) 1)
|
||||
(else (forth-compare-bytes-loop state a1 u1 a2 u2 (+ i 1)))))))))
|
||||
|
||||
(define
|
||||
forth-match-at
|
||||
(fn
|
||||
(state a1 start a2 u2 j)
|
||||
(cond
|
||||
((= j u2) true)
|
||||
((not
|
||||
(=
|
||||
(forth-mem-read state (+ a1 (+ start j)))
|
||||
(forth-mem-read state (+ a2 j))))
|
||||
false)
|
||||
(else (forth-match-at state a1 start a2 u2 (+ j 1))))))
|
||||
|
||||
(define
|
||||
forth-search-bytes
|
||||
(fn
|
||||
(state a1 u1 a2 u2 i)
|
||||
(cond
|
||||
((= u2 0) 0)
|
||||
((> (+ i u2) u1) -1)
|
||||
((forth-match-at state a1 i a2 u2 0) i)
|
||||
(else (forth-search-bytes state a1 u1 a2 u2 (+ i 1))))))
|
||||
|
||||
(define
|
||||
forth-digit-of-byte
|
||||
(fn
|
||||
(c base)
|
||||
(let
|
||||
((v
|
||||
(cond
|
||||
((and (>= c 48) (<= c 57)) (- c 48))
|
||||
((and (>= c 65) (<= c 90)) (- c 55))
|
||||
((and (>= c 97) (<= c 122)) (- c 87))
|
||||
(else -1))))
|
||||
(if (or (< v 0) (>= v base)) -1 v))))
|
||||
|
||||
(define
|
||||
forth-numparse-loop
|
||||
(fn
|
||||
(state addr u acc base)
|
||||
(if
|
||||
(= u 0)
|
||||
(list acc addr u)
|
||||
(let
|
||||
((c (forth-mem-read state addr)))
|
||||
(let
|
||||
((dig (forth-digit-of-byte c base)))
|
||||
(if
|
||||
(< dig 0)
|
||||
(list acc addr u)
|
||||
(forth-numparse-loop
|
||||
state
|
||||
(+ addr 1)
|
||||
(- u 1)
|
||||
(+ (* acc base) dig)
|
||||
base)))))))
|
||||
|
||||
(define
|
||||
forth-pic-S-loop
|
||||
(fn
|
||||
(state)
|
||||
(forth-pic-step state)
|
||||
(let
|
||||
((hi (forth-pop state)) (lo (forth-pop state)))
|
||||
(if
|
||||
(and (= lo 0) (= hi 0))
|
||||
(begin (forth-push state 0) (forth-push state 0))
|
||||
(begin
|
||||
(forth-push state lo)
|
||||
(forth-push state hi)
|
||||
(forth-pic-S-loop state))))))
|
||||
|
||||
(define
|
||||
forth-double-push-s
|
||||
(fn
|
||||
(state d)
|
||||
(if
|
||||
(>= d 0)
|
||||
(forth-double-push-u state d)
|
||||
(let
|
||||
((q (- 0 d)))
|
||||
(let
|
||||
((qlo (mod q forth-2pow32)) (qhi (floor (/ q forth-2pow32))))
|
||||
(if
|
||||
(= qlo 0)
|
||||
(begin
|
||||
(forth-push state 0)
|
||||
(forth-push state (forth-from-unsigned (- forth-2pow32 qhi) 32)))
|
||||
(begin
|
||||
(forth-push
|
||||
state
|
||||
(forth-from-unsigned (- forth-2pow32 qlo) 32))
|
||||
(forth-push
|
||||
state
|
||||
(forth-from-unsigned (- (- forth-2pow32 qhi) 1) 32)))))))))
|
||||
|
||||
(define
|
||||
forth-to-unsigned
|
||||
(fn (n w) (let ((m (pow 2 w))) (mod (+ (mod n m) m) m))))
|
||||
@@ -285,6 +613,19 @@
|
||||
(s)
|
||||
(let ((a (forth-peek s))) (when (not (= a 0)) (forth-push s a)))))
|
||||
(forth-def-prim! state "DEPTH" (fn (s) (forth-push s (forth-depth s))))
|
||||
(forth-def-prim! state "SP@" (fn (s) (forth-push s (forth-depth s))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"SP!"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((n (forth-pop s)))
|
||||
(let
|
||||
((cur (forth-depth s)))
|
||||
(when
|
||||
(> cur n)
|
||||
(dict-set! s "dstack" (drop (get s "dstack") (- cur n))))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"PICK"
|
||||
@@ -354,11 +695,17 @@
|
||||
(forth-push s d)
|
||||
(forth-push s a)
|
||||
(forth-push s b))))
|
||||
(forth-def-prim! state "+" (forth-binop (fn (a b) (+ a b))))
|
||||
(forth-def-prim! state "-" (forth-binop (fn (a b) (- a b))))
|
||||
(forth-def-prim! state "*" (forth-binop (fn (a b) (* a b))))
|
||||
(forth-def-prim! state "/" (forth-binop forth-div))
|
||||
(forth-def-prim! state "MOD" (forth-binop forth-mod))
|
||||
(forth-def-prim! state "+" (forth-binop (fn (a b) (forth-clip (+ a b)))))
|
||||
(forth-def-prim! state "-" (forth-binop (fn (a b) (forth-clip (- a b)))))
|
||||
(forth-def-prim! state "*" (forth-binop (fn (a b) (forth-clip (* a b)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"/"
|
||||
(forth-binop (fn (a b) (forth-clip (forth-div a b)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"MOD"
|
||||
(forth-binop (fn (a b) (forth-clip (forth-mod a b)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"/MOD"
|
||||
@@ -368,8 +715,8 @@
|
||||
((b (forth-pop s)) (a (forth-pop s)))
|
||||
(forth-push s (forth-mod a b))
|
||||
(forth-push s (forth-div a b)))))
|
||||
(forth-def-prim! state "NEGATE" (forth-unop (fn (a) (- 0 a))))
|
||||
(forth-def-prim! state "ABS" (forth-unop abs))
|
||||
(forth-def-prim! state "NEGATE" (forth-unop (fn (a) (forth-clip (- 0 a)))))
|
||||
(forth-def-prim! state "ABS" (forth-unop (fn (a) (forth-clip (abs a)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"MIN"
|
||||
@@ -378,12 +725,15 @@
|
||||
state
|
||||
"MAX"
|
||||
(forth-binop (fn (a b) (if (> a b) a b))))
|
||||
(forth-def-prim! state "1+" (forth-unop (fn (a) (+ a 1))))
|
||||
(forth-def-prim! state "1-" (forth-unop (fn (a) (- a 1))))
|
||||
(forth-def-prim! state "2+" (forth-unop (fn (a) (+ a 2))))
|
||||
(forth-def-prim! state "2-" (forth-unop (fn (a) (- a 2))))
|
||||
(forth-def-prim! state "2*" (forth-unop (fn (a) (* a 2))))
|
||||
(forth-def-prim! state "2/" (forth-unop (fn (a) (floor (/ a 2)))))
|
||||
(forth-def-prim! state "1+" (forth-unop (fn (a) (forth-clip (+ a 1)))))
|
||||
(forth-def-prim! state "1-" (forth-unop (fn (a) (forth-clip (- a 1)))))
|
||||
(forth-def-prim! state "2+" (forth-unop (fn (a) (forth-clip (+ a 2)))))
|
||||
(forth-def-prim! state "2-" (forth-unop (fn (a) (forth-clip (- a 2)))))
|
||||
(forth-def-prim! state "2*" (forth-unop (fn (a) (forth-clip (* a 2)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"2/"
|
||||
(forth-unop (fn (a) (forth-clip (floor (/ a 2))))))
|
||||
(forth-def-prim! state "=" (forth-cmp (fn (a b) (= a b))))
|
||||
(forth-def-prim! state "<>" (forth-cmp (fn (a b) (not (= a b)))))
|
||||
(forth-def-prim! state "<" (forth-cmp (fn (a b) (< a b))))
|
||||
@@ -398,6 +748,30 @@
|
||||
(forth-def-prim! state "OR" (forth-binop forth-bit-or))
|
||||
(forth-def-prim! state "XOR" (forth-binop forth-bit-xor))
|
||||
(forth-def-prim! state "INVERT" (forth-unop forth-bit-invert))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"LSHIFT"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((u (forth-pop s)) (x (forth-pop s)))
|
||||
(let
|
||||
((ux (forth-to-unsigned x forth-bits-width)))
|
||||
(let
|
||||
((res (mod (* ux (pow 2 u)) (pow 2 forth-bits-width))))
|
||||
(forth-push s (forth-from-unsigned res forth-bits-width)))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"RSHIFT"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((u (forth-pop s)) (x (forth-pop s)))
|
||||
(let
|
||||
((ux (forth-to-unsigned x forth-bits-width)))
|
||||
(let
|
||||
((res (floor (/ ux (pow 2 u)))))
|
||||
(forth-push s (forth-from-unsigned res forth-bits-width)))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"."
|
||||
@@ -416,7 +790,7 @@
|
||||
(forth-def-prim!
|
||||
state
|
||||
"EMIT"
|
||||
(fn (s) (forth-emit-str s (code-char (forth-pop s)))))
|
||||
(fn (s) (forth-emit-str s (char-from-code (forth-pop s)))))
|
||||
(forth-def-prim! state "CR" (fn (s) (forth-emit-str s "\n")))
|
||||
(forth-def-prim! state "SPACE" (fn (s) (forth-emit-str s " ")))
|
||||
(forth-def-prim!
|
||||
@@ -430,4 +804,459 @@
|
||||
(> n 0)
|
||||
(for-each (fn (_) (forth-emit-str s " ")) (range 0 n))))))
|
||||
(forth-def-prim! state "BL" (fn (s) (forth-push s 32)))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"DECIMAL"
|
||||
(fn (s) (dict-set! (get s "vars") "base" 10)))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"HEX"
|
||||
(fn (s) (dict-set! (get s "vars") "base" 16)))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"OCTAL"
|
||||
(fn (s) (dict-set! (get s "vars") "base" 8)))
|
||||
(forth-def-prim! state "BASE" (fn (s) (forth-push s "base")))
|
||||
(forth-def-prim! state "I" (fn (s) (forth-push s (forth-rpeek s))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"J"
|
||||
(fn (s) (forth-push s (nth (get s "rstack") 2))))
|
||||
(forth-def-prim! state ">R" (fn (s) (forth-rpush s (forth-pop s))))
|
||||
(forth-def-prim! state "R>" (fn (s) (forth-push s (forth-rpop s))))
|
||||
(forth-def-prim! state "R@" (fn (s) (forth-push s (forth-rpeek s))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"2>R"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((b (forth-pop s)) (a (forth-pop s)))
|
||||
(forth-rpush s a)
|
||||
(forth-rpush s b))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"2R>"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((b (forth-rpop s)) (a (forth-rpop s)))
|
||||
(forth-push s a)
|
||||
(forth-push s b))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"2R@"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((rs (get s "rstack")))
|
||||
(when
|
||||
(< (len rs) 2)
|
||||
(forth-error s "return stack underflow"))
|
||||
(forth-push s (nth rs 1))
|
||||
(forth-push s (nth rs 0)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"C@"
|
||||
(fn
|
||||
(s)
|
||||
(let ((addr (forth-pop s))) (forth-push s (forth-mem-read s addr)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"C!"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((addr (forth-pop s)) (v (forth-pop s)))
|
||||
(forth-mem-write! s addr v))))
|
||||
(forth-def-prim! state "CHAR+" (fn (s) (forth-push s (+ (forth-pop s) 1))))
|
||||
(forth-def-prim! state "CHARS" (fn (s) nil))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"TYPE"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((u (forth-pop s)) (addr (forth-pop s)))
|
||||
(forth-emit-str s (forth-mem-read-string s addr u)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"COUNT"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((addr (forth-pop s)))
|
||||
(let
|
||||
((u (forth-mem-read s addr)))
|
||||
(forth-push s (+ addr 1))
|
||||
(forth-push s u)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"FILL"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((char (forth-pop s)) (u (forth-pop s)) (addr (forth-pop s)))
|
||||
(forth-fill-loop s addr u char 0))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"BLANK"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((u (forth-pop s)) (addr (forth-pop s)))
|
||||
(forth-fill-loop s addr u 32 0))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"CMOVE"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((u (forth-pop s)) (dst (forth-pop s)) (src (forth-pop s)))
|
||||
(forth-cmove-loop s src dst u 0))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"CMOVE>"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((u (forth-pop s)) (dst (forth-pop s)) (src (forth-pop s)))
|
||||
(forth-cmove-loop-desc s src dst u (- u 1)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"MOVE"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((u (forth-pop s)) (dst (forth-pop s)) (src (forth-pop s)))
|
||||
(if
|
||||
(or (<= dst src) (>= dst (+ src u)))
|
||||
(forth-cmove-loop s src dst u 0)
|
||||
(forth-cmove-loop-desc s src dst u (- u 1))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"S>D"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((n (forth-pop s)))
|
||||
(forth-push s n)
|
||||
(forth-push s (if (< n 0) -1 0)))))
|
||||
(forth-def-prim! state "D>S" (fn (s) (forth-pop s)))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"M*"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((b (forth-pop s)) (a (forth-pop s)))
|
||||
(forth-double-push-s s (* a b)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"UM*"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((b (forth-pop s)) (a (forth-pop s)))
|
||||
(forth-double-push-u
|
||||
s
|
||||
(* (forth-to-unsigned a 32) (forth-to-unsigned b 32))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"UM/MOD"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((u1 (forth-pop s)) (hi (forth-pop s)) (lo (forth-pop s)))
|
||||
(let
|
||||
((d (forth-double-from-cells-u lo hi))
|
||||
(divisor (forth-to-unsigned u1 32)))
|
||||
(when (= divisor 0) (forth-error s "division by zero"))
|
||||
(let
|
||||
((q (floor (/ d divisor))) (r (mod d divisor)))
|
||||
(forth-push s (forth-from-unsigned r 32))
|
||||
(forth-push s (forth-from-unsigned q 32)))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"FM/MOD"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((n (forth-pop s)) (hi (forth-pop s)) (lo (forth-pop s)))
|
||||
(let
|
||||
((d (forth-double-from-cells-s lo hi)))
|
||||
(when (= n 0) (forth-error s "division by zero"))
|
||||
(let
|
||||
((q (floor (/ d n))))
|
||||
(let
|
||||
((r (- d (* q n))))
|
||||
(forth-push s (forth-clip r))
|
||||
(forth-push s (forth-clip q))))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"SM/REM"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((n (forth-pop s)) (hi (forth-pop s)) (lo (forth-pop s)))
|
||||
(let
|
||||
((d (forth-double-from-cells-s lo hi)))
|
||||
(when (= n 0) (forth-error s "division by zero"))
|
||||
(let
|
||||
((q (forth-trunc (/ d n))))
|
||||
(let
|
||||
((r (- d (* q n))))
|
||||
(forth-push s (forth-clip r))
|
||||
(forth-push s (forth-clip q))))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"*/"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((n3 (forth-pop s)) (n2 (forth-pop s)) (n1 (forth-pop s)))
|
||||
(when (= n3 0) (forth-error s "division by zero"))
|
||||
(forth-push s (forth-clip (forth-trunc (/ (* n1 n2) n3)))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"*/MOD"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((n3 (forth-pop s)) (n2 (forth-pop s)) (n1 (forth-pop s)))
|
||||
(when (= n3 0) (forth-error s "division by zero"))
|
||||
(let
|
||||
((d (* n1 n2)))
|
||||
(let
|
||||
((q (forth-trunc (/ d n3))))
|
||||
(let
|
||||
((r (- d (* q n3))))
|
||||
(forth-push s (forth-clip r))
|
||||
(forth-push s (forth-clip q))))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"D+"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((hi2 (forth-pop s))
|
||||
(lo2 (forth-pop s))
|
||||
(hi1 (forth-pop s))
|
||||
(lo1 (forth-pop s)))
|
||||
(forth-double-push-s
|
||||
s
|
||||
(+
|
||||
(forth-double-from-cells-s lo1 hi1)
|
||||
(forth-double-from-cells-s lo2 hi2))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"D-"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((hi2 (forth-pop s))
|
||||
(lo2 (forth-pop s))
|
||||
(hi1 (forth-pop s))
|
||||
(lo1 (forth-pop s)))
|
||||
(forth-double-push-s
|
||||
s
|
||||
(-
|
||||
(forth-double-from-cells-s lo1 hi1)
|
||||
(forth-double-from-cells-s lo2 hi2))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"DNEGATE"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((hi (forth-pop s)) (lo (forth-pop s)))
|
||||
(forth-double-push-s
|
||||
s
|
||||
(- 0 (forth-double-from-cells-s lo hi))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"DABS"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((hi (forth-pop s)) (lo (forth-pop s)))
|
||||
(forth-double-push-s s (abs (forth-double-from-cells-s lo hi))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"D="
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((hi2 (forth-pop s))
|
||||
(lo2 (forth-pop s))
|
||||
(hi1 (forth-pop s))
|
||||
(lo1 (forth-pop s)))
|
||||
(forth-push s (if (and (= lo1 lo2) (= hi1 hi2)) -1 0)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"D<"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((hi2 (forth-pop s))
|
||||
(lo2 (forth-pop s))
|
||||
(hi1 (forth-pop s))
|
||||
(lo1 (forth-pop s)))
|
||||
(forth-push
|
||||
s
|
||||
(if
|
||||
(<
|
||||
(forth-double-from-cells-s lo1 hi1)
|
||||
(forth-double-from-cells-s lo2 hi2))
|
||||
-1
|
||||
0)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"D0="
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((hi (forth-pop s)) (lo (forth-pop s)))
|
||||
(forth-push s (if (and (= lo 0) (= hi 0)) -1 0)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"D0<"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((hi (forth-pop s)) (lo (forth-pop s)))
|
||||
(forth-push s (if (< hi 0) -1 0)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"DMAX"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((hi2 (forth-pop s))
|
||||
(lo2 (forth-pop s))
|
||||
(hi1 (forth-pop s))
|
||||
(lo1 (forth-pop s)))
|
||||
(let
|
||||
((d1 (forth-double-from-cells-s lo1 hi1))
|
||||
(d2 (forth-double-from-cells-s lo2 hi2)))
|
||||
(forth-double-push-s s (if (> d1 d2) d1 d2))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"DMIN"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((hi2 (forth-pop s))
|
||||
(lo2 (forth-pop s))
|
||||
(hi1 (forth-pop s))
|
||||
(lo1 (forth-pop s)))
|
||||
(let
|
||||
((d1 (forth-double-from-cells-s lo1 hi1))
|
||||
(d2 (forth-double-from-cells-s lo2 hi2)))
|
||||
(forth-double-push-s s (if (< d1 d2) d1 d2))))))
|
||||
(forth-def-prim! state "<#" (fn (s) (dict-set! s "hold" (list))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"HOLD"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((c (forth-pop s)))
|
||||
(dict-set!
|
||||
s
|
||||
"hold"
|
||||
(cons (char-from-code c) (get s "hold"))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"SIGN"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((n (forth-pop s)))
|
||||
(when
|
||||
(< n 0)
|
||||
(dict-set! s "hold" (cons "-" (get s "hold")))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"#"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((hi (forth-pop s)) (lo (forth-pop s)))
|
||||
(let
|
||||
((d (forth-double-from-cells-u lo hi))
|
||||
(b (get (get s "vars") "base")))
|
||||
(let
|
||||
((dig (mod d b)) (rest (floor (/ d b))))
|
||||
(let
|
||||
((ch
|
||||
(if
|
||||
(< dig 10)
|
||||
(char-from-code (+ 48 dig))
|
||||
(char-from-code (+ 55 dig)))))
|
||||
(dict-set! s "hold" (cons ch (get s "hold")))
|
||||
(forth-double-push-u s rest)))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"#S"
|
||||
(fn
|
||||
(s)
|
||||
(forth-pic-S-loop s)))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"#>"
|
||||
(fn
|
||||
(s)
|
||||
(forth-pop s)
|
||||
(forth-pop s)
|
||||
(let
|
||||
((str-out (forth-join-hold (get s "hold"))))
|
||||
(let
|
||||
((addr (forth-alloc-bytes! s (len str-out))))
|
||||
(forth-mem-write-string! s addr str-out)
|
||||
(forth-push s addr)
|
||||
(forth-push s (len str-out))))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"U."
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((u (forth-to-unsigned (forth-pop s) 32))
|
||||
(b (get (get s "vars") "base")))
|
||||
(forth-emit-str s (str (forth-num-to-string u b) " ")))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
"U.R"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((width (forth-pop s))
|
||||
(u (forth-to-unsigned (forth-pop s) 32))
|
||||
(b (get (get s "vars") "base")))
|
||||
(let
|
||||
((digits (forth-num-to-string u b)))
|
||||
(forth-emit-str
|
||||
s
|
||||
(forth-spaces-str (- width (len digits))))
|
||||
(forth-emit-str s digits)))))
|
||||
(forth-def-prim!
|
||||
state
|
||||
".R"
|
||||
(fn
|
||||
(s)
|
||||
(let
|
||||
((width (forth-pop s))
|
||||
(n (forth-pop s))
|
||||
(b (get (get s "vars") "base")))
|
||||
(let
|
||||
((sign-prefix (if (< n 0) "-" ""))
|
||||
(abs-digits
|
||||
(forth-num-to-string (forth-to-unsigned (abs n) 32) b)))
|
||||
(let
|
||||
((digits (str sign-prefix abs-digits)))
|
||||
(forth-emit-str
|
||||
s
|
||||
(forth-spaces-str (- width (len digits))))
|
||||
(forth-emit-str s digits))))))
|
||||
state))
|
||||
|
||||
12
lib/forth/scoreboard.json
Normal file
12
lib/forth/scoreboard.json
Normal file
@@ -0,0 +1,12 @@
|
||||
{
|
||||
"source": "gerryjackson/forth2012-test-suite src/core.fr",
|
||||
"generated_at": "2026-04-25T03:32:23Z",
|
||||
"chunks_available": 638,
|
||||
"chunks_fed": 638,
|
||||
"total": 638,
|
||||
"pass": 618,
|
||||
"fail": 14,
|
||||
"error": 6,
|
||||
"percent": 96,
|
||||
"note": "completed"
|
||||
}
|
||||
28
lib/forth/scoreboard.md
Normal file
28
lib/forth/scoreboard.md
Normal file
@@ -0,0 +1,28 @@
|
||||
# Forth Hayes Core scoreboard
|
||||
|
||||
| metric | value |
|
||||
| ----------------- | ----: |
|
||||
| chunks available | 638 |
|
||||
| chunks fed | 638 |
|
||||
| total | 638 |
|
||||
| pass | 618 |
|
||||
| fail | 14 |
|
||||
| error | 6 |
|
||||
| percent | 96% |
|
||||
|
||||
- **Source**: `gerryjackson/forth2012-test-suite` `src/core.fr`
|
||||
- **Generated**: 2026-04-25T03:32:23Z
|
||||
- **Note**: completed
|
||||
|
||||
A "chunk" is any preprocessed segment ending at a `}T` (every Hayes test
|
||||
is one chunk, plus the small declaration blocks between tests).
|
||||
The runner catches raised errors at chunk boundaries so one bad chunk
|
||||
does not abort the rest. `error` covers chunks that raised; `fail`
|
||||
covers tests whose `->` / `}T` comparison mismatched.
|
||||
|
||||
### Chunk cap
|
||||
|
||||
`conformance.sh` processes the first `$MAX_CHUNKS` chunks (default
|
||||
**638**, i.e. the whole Hayes Core file). Lower the cap temporarily
|
||||
while iterating on primitives if a regression re-opens an infinite
|
||||
loop in later tests.
|
||||
239
lib/forth/tests/test-phase3.sx
Normal file
239
lib/forth/tests/test-phase3.sx
Normal file
@@ -0,0 +1,239 @@
|
||||
;; Phase 3 — control flow (IF/ELSE/THEN, BEGIN/UNTIL/WHILE/REPEAT/AGAIN,
|
||||
;; DO/LOOP, return stack). Grows as each control construct lands.
|
||||
|
||||
(define forth-p3-passed 0)
|
||||
(define forth-p3-failed 0)
|
||||
(define forth-p3-failures (list))
|
||||
|
||||
(define
|
||||
forth-p3-assert
|
||||
(fn
|
||||
(label expected actual)
|
||||
(if
|
||||
(= expected actual)
|
||||
(set! forth-p3-passed (+ forth-p3-passed 1))
|
||||
(begin
|
||||
(set! forth-p3-failed (+ forth-p3-failed 1))
|
||||
(set!
|
||||
forth-p3-failures
|
||||
(concat
|
||||
forth-p3-failures
|
||||
(list
|
||||
(str label ": expected " (str expected) " got " (str actual)))))))))
|
||||
|
||||
(define
|
||||
forth-p3-check-stack
|
||||
(fn
|
||||
(label src expected)
|
||||
(let ((r (forth-run src))) (forth-p3-assert label expected (nth r 2)))))
|
||||
|
||||
(define
|
||||
forth-p3-if-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p3-check-stack
|
||||
"IF taken (-1)"
|
||||
": Q -1 IF 10 THEN ; Q"
|
||||
(list 10))
|
||||
(forth-p3-check-stack
|
||||
"IF not taken (0)"
|
||||
": Q 0 IF 10 THEN ; Q"
|
||||
(list))
|
||||
(forth-p3-check-stack
|
||||
"IF with non-zero truthy"
|
||||
": Q 42 IF 10 THEN ; Q"
|
||||
(list 10))
|
||||
(forth-p3-check-stack
|
||||
"IF ELSE — true branch"
|
||||
": Q -1 IF 10 ELSE 20 THEN ; Q"
|
||||
(list 10))
|
||||
(forth-p3-check-stack
|
||||
"IF ELSE — false branch"
|
||||
": Q 0 IF 10 ELSE 20 THEN ; Q"
|
||||
(list 20))
|
||||
(forth-p3-check-stack
|
||||
"IF consumes flag"
|
||||
": Q IF 1 ELSE 2 THEN ; 0 Q"
|
||||
(list 2))
|
||||
(forth-p3-check-stack
|
||||
"absolute value via IF"
|
||||
": ABS2 DUP 0 < IF NEGATE THEN ; -7 ABS2"
|
||||
(list 7))
|
||||
(forth-p3-check-stack
|
||||
"abs leaves positive alone"
|
||||
": ABS2 DUP 0 < IF NEGATE THEN ; 7 ABS2"
|
||||
(list 7))
|
||||
(forth-p3-check-stack
|
||||
"sign: negative"
|
||||
": SIGN DUP 0 < IF DROP -1 ELSE DROP 1 THEN ; -3 SIGN"
|
||||
(list -1))
|
||||
(forth-p3-check-stack
|
||||
"sign: positive"
|
||||
": SIGN DUP 0 < IF DROP -1 ELSE DROP 1 THEN ; 3 SIGN"
|
||||
(list 1))
|
||||
(forth-p3-check-stack
|
||||
"nested IF (both true)"
|
||||
": Q 1 IF 1 IF 10 ELSE 20 THEN ELSE 30 THEN ; Q"
|
||||
(list 10))
|
||||
(forth-p3-check-stack
|
||||
"nested IF (inner false)"
|
||||
": Q 1 IF 0 IF 10 ELSE 20 THEN ELSE 30 THEN ; Q"
|
||||
(list 20))
|
||||
(forth-p3-check-stack
|
||||
"nested IF (outer false)"
|
||||
": Q 0 IF 0 IF 10 ELSE 20 THEN ELSE 30 THEN ; Q"
|
||||
(list 30))
|
||||
(forth-p3-check-stack
|
||||
"IF before other ops"
|
||||
": Q 1 IF 5 ELSE 6 THEN 2 * ; Q"
|
||||
(list 10))
|
||||
(forth-p3-check-stack
|
||||
"IF in chained def"
|
||||
": POS? 0 > ;
|
||||
: DOUBLE-IF-POS DUP POS? IF 2 * THEN ;
|
||||
3 DOUBLE-IF-POS"
|
||||
(list 6))
|
||||
(forth-p3-check-stack
|
||||
"empty then branch"
|
||||
": Q 1 IF THEN 99 ; Q"
|
||||
(list 99))
|
||||
(forth-p3-check-stack
|
||||
"empty else branch"
|
||||
": Q 0 IF 99 ELSE THEN ; Q"
|
||||
(list))
|
||||
(forth-p3-check-stack
|
||||
"sequential IF blocks"
|
||||
": Q -1 IF 1 THEN -1 IF 2 THEN ; Q"
|
||||
(list 1 2))))
|
||||
|
||||
(define
|
||||
forth-p3-loop-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p3-check-stack
|
||||
"BEGIN UNTIL (countdown to zero)"
|
||||
": CD BEGIN 1- DUP 0 = UNTIL ; 3 CD"
|
||||
(list 0))
|
||||
(forth-p3-check-stack
|
||||
"BEGIN UNTIL — single pass (UNTIL true immediately)"
|
||||
": Q BEGIN -1 UNTIL 42 ; Q"
|
||||
(list 42))
|
||||
(forth-p3-check-stack
|
||||
"BEGIN UNTIL — accumulate sum 1+2+3"
|
||||
": SUM3 0 3 BEGIN TUCK + SWAP 1- DUP 0 = UNTIL DROP ; SUM3"
|
||||
(list 6))
|
||||
(forth-p3-check-stack
|
||||
"BEGIN WHILE REPEAT — triangular sum 5"
|
||||
": TRI 0 5 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ; TRI"
|
||||
(list 15))
|
||||
(forth-p3-check-stack
|
||||
"BEGIN WHILE REPEAT — zero iterations"
|
||||
": TRI 0 0 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ; TRI"
|
||||
(list 0))
|
||||
(forth-p3-check-stack
|
||||
"BEGIN WHILE REPEAT — one iteration"
|
||||
": TRI 0 1 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ; TRI"
|
||||
(list 1))
|
||||
(forth-p3-check-stack
|
||||
"nested BEGIN UNTIL"
|
||||
": INNER BEGIN 1- DUP 0 = UNTIL DROP ;
|
||||
: OUTER BEGIN 3 INNER 1- DUP 0 = UNTIL ;
|
||||
2 OUTER"
|
||||
(list 0))
|
||||
(forth-p3-check-stack
|
||||
"BEGIN UNTIL after colon prefix"
|
||||
": TEN 10 ;
|
||||
: CD TEN BEGIN 1- DUP 0 = UNTIL ;
|
||||
CD"
|
||||
(list 0))
|
||||
(forth-p3-check-stack
|
||||
"WHILE inside IF branch"
|
||||
": Q 1 IF 0 3 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ELSE 99 THEN ; Q"
|
||||
(list 6))))
|
||||
|
||||
(define
|
||||
forth-p3-do-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p3-check-stack
|
||||
"DO LOOP — simple sum 0..4"
|
||||
": SUM 0 5 0 DO I + LOOP ; SUM"
|
||||
(list 10))
|
||||
(forth-p3-check-stack
|
||||
"DO LOOP — 10..14 sum using I"
|
||||
": SUM 0 15 10 DO I + LOOP ; SUM"
|
||||
(list 60))
|
||||
(forth-p3-check-stack
|
||||
"DO LOOP — limit = start runs one pass"
|
||||
": SUM 0 5 5 DO I + LOOP ; SUM"
|
||||
(list 5))
|
||||
(forth-p3-check-stack
|
||||
"DO LOOP — count iterations"
|
||||
": COUNT 0 4 0 DO 1+ LOOP ; COUNT"
|
||||
(list 4))
|
||||
(forth-p3-check-stack
|
||||
"DO LOOP — nested, I inner / J outer"
|
||||
": MATRIX 0 3 0 DO 3 0 DO I J + + LOOP LOOP ; MATRIX"
|
||||
(list 18))
|
||||
(forth-p3-check-stack
|
||||
"DO LOOP — I used in arithmetic"
|
||||
": DBL 0 5 1 DO I 2 * + LOOP ; DBL"
|
||||
(list 20))
|
||||
(forth-p3-check-stack
|
||||
"+LOOP — count by 2"
|
||||
": Q 0 10 0 DO I + 2 +LOOP ; Q"
|
||||
(list 20))
|
||||
(forth-p3-check-stack
|
||||
"+LOOP — count by 3"
|
||||
": Q 0 10 0 DO I + 3 +LOOP ; Q"
|
||||
(list 18))
|
||||
(forth-p3-check-stack
|
||||
"+LOOP — negative step"
|
||||
": Q 0 0 10 DO I + -1 +LOOP ; Q"
|
||||
(list 55))
|
||||
(forth-p3-check-stack
|
||||
"LEAVE — early exit at I=3"
|
||||
": Q 0 10 0 DO I 3 = IF LEAVE THEN I + LOOP ; Q"
|
||||
(list 3))
|
||||
(forth-p3-check-stack
|
||||
"LEAVE — in nested loop exits only inner"
|
||||
": Q 0 3 0 DO 5 0 DO I 2 = IF LEAVE THEN I + LOOP LOOP ; Q"
|
||||
(list 3))
|
||||
(forth-p3-check-stack
|
||||
"DO LOOP preserves outer stack"
|
||||
": Q 99 5 0 DO I + LOOP ; Q"
|
||||
(list 109))
|
||||
(forth-p3-check-stack
|
||||
">R R>"
|
||||
": Q 7 >R 11 R> ; Q"
|
||||
(list 11 7))
|
||||
(forth-p3-check-stack
|
||||
">R R@ R>"
|
||||
": Q 7 >R R@ R> ; Q"
|
||||
(list 7 7))
|
||||
(forth-p3-check-stack
|
||||
"2>R 2R>"
|
||||
": Q 1 2 2>R 99 2R> ; Q"
|
||||
(list 99 1 2))
|
||||
(forth-p3-check-stack
|
||||
"2>R 2R@ 2R>"
|
||||
": Q 3 4 2>R 2R@ 2R> ; Q"
|
||||
(list 3 4 3 4))))
|
||||
|
||||
(define
|
||||
forth-p3-run-all
|
||||
(fn
|
||||
()
|
||||
(set! forth-p3-passed 0)
|
||||
(set! forth-p3-failed 0)
|
||||
(set! forth-p3-failures (list))
|
||||
(forth-p3-if-tests)
|
||||
(forth-p3-loop-tests)
|
||||
(forth-p3-do-tests)
|
||||
(dict
|
||||
"passed"
|
||||
forth-p3-passed
|
||||
"failed"
|
||||
forth-p3-failed
|
||||
"failures"
|
||||
forth-p3-failures)))
|
||||
268
lib/forth/tests/test-phase4.sx
Normal file
268
lib/forth/tests/test-phase4.sx
Normal file
@@ -0,0 +1,268 @@
|
||||
;; Phase 4 — strings + more Core.
|
||||
;; Uses the byte-memory model on state ("mem" dict + "here" cursor).
|
||||
|
||||
(define forth-p4-passed 0)
|
||||
(define forth-p4-failed 0)
|
||||
(define forth-p4-failures (list))
|
||||
|
||||
(define
|
||||
forth-p4-assert
|
||||
(fn
|
||||
(label expected actual)
|
||||
(if
|
||||
(= expected actual)
|
||||
(set! forth-p4-passed (+ forth-p4-passed 1))
|
||||
(begin
|
||||
(set! forth-p4-failed (+ forth-p4-failed 1))
|
||||
(set!
|
||||
forth-p4-failures
|
||||
(concat
|
||||
forth-p4-failures
|
||||
(list
|
||||
(str label ": expected " (str expected) " got " (str actual)))))))))
|
||||
|
||||
(define
|
||||
forth-p4-check-output
|
||||
(fn
|
||||
(label src expected)
|
||||
(let ((r (forth-run src))) (forth-p4-assert label expected (nth r 1)))))
|
||||
|
||||
(define
|
||||
forth-p4-check-stack-size
|
||||
(fn
|
||||
(label src expected-n)
|
||||
(let
|
||||
((r (forth-run src)))
|
||||
(forth-p4-assert label expected-n (len (nth r 2))))))
|
||||
|
||||
(define
|
||||
forth-p4-check-top
|
||||
(fn
|
||||
(label src expected)
|
||||
(let
|
||||
((r (forth-run src)))
|
||||
(let
|
||||
((stk (nth r 2)))
|
||||
(forth-p4-assert label expected (nth stk (- (len stk) 1)))))))
|
||||
|
||||
(define
|
||||
forth-p4-check-typed
|
||||
(fn
|
||||
(label src expected)
|
||||
(forth-p4-check-output label (str src " TYPE") expected)))
|
||||
|
||||
(define
|
||||
forth-p4-string-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p4-check-typed
|
||||
"S\" + TYPE — hello"
|
||||
"S\" HELLO\""
|
||||
"HELLO")
|
||||
(forth-p4-check-typed
|
||||
"S\" + TYPE — two words"
|
||||
"S\" HELLO WORLD\""
|
||||
"HELLO WORLD")
|
||||
(forth-p4-check-typed
|
||||
"S\" + TYPE — empty"
|
||||
"S\" \""
|
||||
"")
|
||||
(forth-p4-check-typed
|
||||
"S\" + TYPE — single char"
|
||||
"S\" X\""
|
||||
"X")
|
||||
(forth-p4-check-stack-size
|
||||
"S\" pushes (addr len)"
|
||||
"S\" HI\""
|
||||
2)
|
||||
(forth-p4-check-top
|
||||
"S\" length is correct"
|
||||
"S\" HELLO\""
|
||||
5)
|
||||
(forth-p4-check-output
|
||||
".\" prints at interpret time"
|
||||
".\" HELLO\""
|
||||
"HELLO")
|
||||
(forth-p4-check-output
|
||||
".\" in colon def"
|
||||
": GREET .\" HI \" ; GREET GREET"
|
||||
"HI HI ")))
|
||||
|
||||
(define
|
||||
forth-p4-count-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p4-check-typed
|
||||
"C\" + COUNT + TYPE"
|
||||
"C\" ABC\" COUNT"
|
||||
"ABC")
|
||||
(forth-p4-check-typed
|
||||
"C\" then COUNT leaves right len"
|
||||
"C\" HI THERE\" COUNT"
|
||||
"HI THERE")))
|
||||
|
||||
(define
|
||||
forth-p4-fill-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p4-check-typed
|
||||
"FILL overwrites prefix bytes"
|
||||
"S\" ABCDE\" 2DUP DROP 3 65 FILL"
|
||||
"AAADE")
|
||||
(forth-p4-check-typed
|
||||
"BLANK sets spaces"
|
||||
"S\" XYZAB\" 2DUP DROP 3 BLANK"
|
||||
" AB")))
|
||||
|
||||
(define
|
||||
forth-p4-cmove-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p4-check-output
|
||||
"CMOVE copies HELLO forward"
|
||||
": MKH 72 0 C! 69 1 C! 76 2 C! 76 3 C! 79 4 C! ;
|
||||
: T MKH 0 10 5 CMOVE 10 5 TYPE ; T"
|
||||
"HELLO")
|
||||
(forth-p4-check-output
|
||||
"CMOVE> copies overlapping backward"
|
||||
": MKA 65 0 C! 66 1 C! 67 2 C! ;
|
||||
: T MKA 0 1 2 CMOVE> 0 3 TYPE ; T"
|
||||
"AAB")
|
||||
(forth-p4-check-output
|
||||
"MOVE picks direction for overlap"
|
||||
": MKA 65 0 C! 66 1 C! 67 2 C! ;
|
||||
: T MKA 0 1 2 MOVE 0 3 TYPE ; T"
|
||||
"AAB")))
|
||||
|
||||
(define
|
||||
forth-p4-charplus-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p4-check-top
|
||||
"CHAR+ increments"
|
||||
"5 CHAR+"
|
||||
6)))
|
||||
|
||||
(define
|
||||
forth-p4-char-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p4-check-top "CHAR A -> 65" "CHAR A" 65)
|
||||
(forth-p4-check-top "CHAR x -> 120" "CHAR x" 120)
|
||||
(forth-p4-check-top "CHAR takes only first char" "CHAR HELLO" 72)
|
||||
(forth-p4-check-top
|
||||
"[CHAR] compiles literal"
|
||||
": AA [CHAR] A ; AA"
|
||||
65)
|
||||
(forth-p4-check-top
|
||||
"[CHAR] reads past IMMEDIATE"
|
||||
": ZZ [CHAR] Z ; ZZ"
|
||||
90)
|
||||
(forth-p4-check-stack-size
|
||||
"[CHAR] doesn't leak at compile time"
|
||||
": FOO [CHAR] A ; "
|
||||
0)))
|
||||
|
||||
(define
|
||||
forth-p4-key-accept-tests
|
||||
(fn
|
||||
()
|
||||
(let
|
||||
((r (forth-run "1000 2 ACCEPT")))
|
||||
(let ((stk (nth r 2))) (forth-p4-assert "ACCEPT empty buf -> 0" (list 0) stk)))))
|
||||
|
||||
(define
|
||||
forth-p4-shift-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p4-check-top "1 0 LSHIFT" "1 0 LSHIFT" 1)
|
||||
(forth-p4-check-top "1 1 LSHIFT" "1 1 LSHIFT" 2)
|
||||
(forth-p4-check-top "1 2 LSHIFT" "1 2 LSHIFT" 4)
|
||||
(forth-p4-check-top "1 15 LSHIFT" "1 15 LSHIFT" 32768)
|
||||
(forth-p4-check-top "1 31 LSHIFT" "1 31 LSHIFT" -2147483648)
|
||||
(forth-p4-check-top "1 0 RSHIFT" "1 0 RSHIFT" 1)
|
||||
(forth-p4-check-top "1 1 RSHIFT" "1 1 RSHIFT" 0)
|
||||
(forth-p4-check-top "2 1 RSHIFT" "2 1 RSHIFT" 1)
|
||||
(forth-p4-check-top "4 2 RSHIFT" "4 2 RSHIFT" 1)
|
||||
(forth-p4-check-top "-1 1 RSHIFT (logical, not arithmetic)" "-1 1 RSHIFT" 2147483647)
|
||||
(forth-p4-check-top "MSB via 1S 1 RSHIFT INVERT" "0 INVERT 1 RSHIFT INVERT" -2147483648)))
|
||||
|
||||
(define
|
||||
forth-p4-sp-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p4-check-top "SP@ returns depth (0)" "SP@" 0)
|
||||
(forth-p4-check-top
|
||||
"SP@ after pushes"
|
||||
"1 2 3 SP@ SWAP DROP SWAP DROP SWAP DROP"
|
||||
3)
|
||||
(forth-p4-check-stack-size
|
||||
"SP! truncates"
|
||||
"1 2 3 4 5 2 SP!"
|
||||
2)
|
||||
(forth-p4-check-top
|
||||
"SP! leaves base items intact"
|
||||
"1 2 3 4 5 2 SP!"
|
||||
2)))
|
||||
|
||||
(define
|
||||
forth-p4-base-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p4-check-top
|
||||
"BASE default is 10"
|
||||
"BASE @"
|
||||
10)
|
||||
(forth-p4-check-top
|
||||
"HEX switches base to 16"
|
||||
"HEX BASE @"
|
||||
16)
|
||||
(forth-p4-check-top
|
||||
"DECIMAL resets to 10"
|
||||
"HEX DECIMAL BASE @"
|
||||
10)
|
||||
(forth-p4-check-top
|
||||
"HEX parses 10 as 16"
|
||||
"HEX 10"
|
||||
16)
|
||||
(forth-p4-check-top
|
||||
"HEX parses FF as 255"
|
||||
"HEX FF"
|
||||
255)
|
||||
(forth-p4-check-top
|
||||
"DECIMAL parses 10 as 10"
|
||||
"HEX DECIMAL 10"
|
||||
10)
|
||||
(forth-p4-check-top
|
||||
"OCTAL parses 17 as 15"
|
||||
"OCTAL 17"
|
||||
15)
|
||||
(forth-p4-check-top
|
||||
"BASE @ ; 16 BASE ! ; BASE @"
|
||||
"BASE @ 16 BASE ! BASE @ SWAP DROP"
|
||||
16)))
|
||||
|
||||
(define
|
||||
forth-p4-run-all
|
||||
(fn
|
||||
()
|
||||
(set! forth-p4-passed 0)
|
||||
(set! forth-p4-failed 0)
|
||||
(set! forth-p4-failures (list))
|
||||
(forth-p4-string-tests)
|
||||
(forth-p4-count-tests)
|
||||
(forth-p4-fill-tests)
|
||||
(forth-p4-cmove-tests)
|
||||
(forth-p4-charplus-tests)
|
||||
(forth-p4-char-tests)
|
||||
(forth-p4-key-accept-tests)
|
||||
(forth-p4-base-tests)
|
||||
(forth-p4-shift-tests)
|
||||
(forth-p4-sp-tests)
|
||||
(dict
|
||||
"passed"
|
||||
forth-p4-passed
|
||||
"failed"
|
||||
forth-p4-failed
|
||||
"failures"
|
||||
forth-p4-failures)))
|
||||
333
lib/forth/tests/test-phase5.sx
Normal file
333
lib/forth/tests/test-phase5.sx
Normal file
@@ -0,0 +1,333 @@
|
||||
;; Phase 5 — Core Extension + memory primitives.
|
||||
|
||||
(define forth-p5-passed 0)
|
||||
(define forth-p5-failed 0)
|
||||
(define forth-p5-failures (list))
|
||||
|
||||
(define
|
||||
forth-p5-assert
|
||||
(fn
|
||||
(label expected actual)
|
||||
(if
|
||||
(= expected actual)
|
||||
(set! forth-p5-passed (+ forth-p5-passed 1))
|
||||
(begin
|
||||
(set! forth-p5-failed (+ forth-p5-failed 1))
|
||||
(set!
|
||||
forth-p5-failures
|
||||
(concat
|
||||
forth-p5-failures
|
||||
(list
|
||||
(str label ": expected " (str expected) " got " (str actual)))))))))
|
||||
|
||||
(define
|
||||
forth-p5-check-stack
|
||||
(fn
|
||||
(label src expected)
|
||||
(let ((r (forth-run src))) (forth-p5-assert label expected (nth r 2)))))
|
||||
|
||||
(define
|
||||
forth-p5-check-top
|
||||
(fn
|
||||
(label src expected)
|
||||
(let
|
||||
((r (forth-run src)))
|
||||
(let
|
||||
((stk (nth r 2)))
|
||||
(forth-p5-assert label expected (nth stk (- (len stk) 1)))))))
|
||||
|
||||
(define
|
||||
forth-p5-create-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p5-check-top
|
||||
"CREATE pushes HERE-at-creation"
|
||||
"HERE CREATE FOO FOO ="
|
||||
-1)
|
||||
(forth-p5-check-top
|
||||
"CREATE + ALLOT advances HERE"
|
||||
"HERE 5 ALLOT HERE SWAP -"
|
||||
5)
|
||||
(forth-p5-check-top
|
||||
"CREATE + , stores cell"
|
||||
"CREATE FOO 42 , FOO @"
|
||||
42)
|
||||
(forth-p5-check-stack
|
||||
"CREATE multiple ,"
|
||||
"CREATE TBL 1 , 2 , 3 , TBL @ TBL CELL+ @ TBL CELL+ CELL+ @"
|
||||
(list 1 2 3))
|
||||
(forth-p5-check-top
|
||||
"C, stores byte"
|
||||
"CREATE B 65 C, 66 C, B C@"
|
||||
65)))
|
||||
|
||||
(define
|
||||
forth-p5-unsigned-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p5-check-top "1 2 U<" "1 2 U<" -1)
|
||||
(forth-p5-check-top "2 1 U<" "2 1 U<" 0)
|
||||
(forth-p5-check-top "0 1 U<" "0 1 U<" -1)
|
||||
(forth-p5-check-top "-1 1 U< (since -1 unsigned is huge)" "-1 1 U<" 0)
|
||||
(forth-p5-check-top "1 -1 U<" "1 -1 U<" -1)
|
||||
(forth-p5-check-top "1 2 U>" "1 2 U>" 0)
|
||||
(forth-p5-check-top "-1 1 U>" "-1 1 U>" -1)))
|
||||
|
||||
(define
|
||||
forth-p5-2bang-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p5-check-stack
|
||||
"2! / 2@"
|
||||
"CREATE X 0 , 0 , 11 22 X 2! X 2@"
|
||||
(list 11 22))))
|
||||
|
||||
(define
|
||||
forth-p5-mixed-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p5-check-stack "S>D positive" "5 S>D" (list 5 0))
|
||||
(forth-p5-check-stack "S>D negative" "-5 S>D" (list -5 -1))
|
||||
(forth-p5-check-stack "S>D zero" "0 S>D" (list 0 0))
|
||||
(forth-p5-check-top "D>S keeps low" "5 0 D>S" 5)
|
||||
(forth-p5-check-stack "M* small positive" "3 4 M*" (list 12 0))
|
||||
(forth-p5-check-stack "M* negative" "-3 4 M*" (list -12 -1))
|
||||
(forth-p5-check-stack
|
||||
"M* negative * negative"
|
||||
"-3 -4 M*"
|
||||
(list 12 0))
|
||||
(forth-p5-check-stack "UM* small" "3 4 UM*" (list 12 0))
|
||||
(forth-p5-check-stack
|
||||
"UM/MOD: 100 0 / 5"
|
||||
"100 0 5 UM/MOD"
|
||||
(list 0 20))
|
||||
(forth-p5-check-stack
|
||||
"FM/MOD: -7 / 2 floored"
|
||||
"-7 -1 2 FM/MOD"
|
||||
(list 1 -4))
|
||||
(forth-p5-check-stack
|
||||
"SM/REM: -7 / 2 truncated"
|
||||
"-7 -1 2 SM/REM"
|
||||
(list -1 -3))
|
||||
(forth-p5-check-top "*/ truncated" "7 11 13 */" 5)
|
||||
(forth-p5-check-stack "*/MOD" "7 11 13 */MOD" (list 12 5))))
|
||||
|
||||
(define
|
||||
forth-p5-double-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p5-check-stack "D+ small" "5 0 7 0 D+" (list 12 0))
|
||||
(forth-p5-check-stack "D+ negative" "-5 -1 -3 -1 D+" (list -8 -1))
|
||||
(forth-p5-check-stack "D- small" "10 0 3 0 D-" (list 7 0))
|
||||
(forth-p5-check-stack "DNEGATE positive" "5 0 DNEGATE" (list -5 -1))
|
||||
(forth-p5-check-stack "DNEGATE negative" "-5 -1 DNEGATE" (list 5 0))
|
||||
(forth-p5-check-stack "DABS negative" "-7 -1 DABS" (list 7 0))
|
||||
(forth-p5-check-stack "DABS positive" "7 0 DABS" (list 7 0))
|
||||
(forth-p5-check-top "D= equal" "5 0 5 0 D=" -1)
|
||||
(forth-p5-check-top "D= unequal lo" "5 0 7 0 D=" 0)
|
||||
(forth-p5-check-top "D= unequal hi" "5 0 5 1 D=" 0)
|
||||
(forth-p5-check-top "D< lt" "5 0 7 0 D<" -1)
|
||||
(forth-p5-check-top "D< gt" "7 0 5 0 D<" 0)
|
||||
(forth-p5-check-top "D0= zero" "0 0 D0=" -1)
|
||||
(forth-p5-check-top "D0= nonzero" "5 0 D0=" 0)
|
||||
(forth-p5-check-top "D0< neg" "-5 -1 D0<" -1)
|
||||
(forth-p5-check-top "D0< pos" "5 0 D0<" 0)
|
||||
(forth-p5-check-stack "DMAX" "5 0 7 0 DMAX" (list 7 0))
|
||||
(forth-p5-check-stack "DMIN" "5 0 7 0 DMIN" (list 5 0))))
|
||||
|
||||
(define
|
||||
forth-p5-format-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p4-check-output-passthrough
|
||||
"U. prints with trailing space"
|
||||
"123 U."
|
||||
"123 ")
|
||||
(forth-p4-check-output-passthrough
|
||||
"<# #S #> TYPE — decimal"
|
||||
"123 0 <# #S #> TYPE"
|
||||
"123")
|
||||
(forth-p4-check-output-passthrough
|
||||
"<# #S #> TYPE — hex"
|
||||
"255 HEX 0 <# #S #> TYPE"
|
||||
"FF")
|
||||
(forth-p4-check-output-passthrough
|
||||
"<# # # #> partial"
|
||||
"1234 0 <# # # #> TYPE"
|
||||
"34")
|
||||
(forth-p4-check-output-passthrough
|
||||
"SIGN holds minus"
|
||||
"<# -1 SIGN -1 SIGN 0 0 #> TYPE"
|
||||
"--")
|
||||
(forth-p4-check-output-passthrough
|
||||
".R right-justifies"
|
||||
"42 5 .R"
|
||||
" 42")
|
||||
(forth-p4-check-output-passthrough
|
||||
".R negative"
|
||||
"-42 5 .R"
|
||||
" -42")
|
||||
(forth-p4-check-output-passthrough
|
||||
"U.R"
|
||||
"42 5 U.R"
|
||||
" 42")
|
||||
(forth-p4-check-output-passthrough
|
||||
"HOLD char"
|
||||
"<# 0 0 65 HOLD #> TYPE"
|
||||
"A")))
|
||||
|
||||
(define
|
||||
forth-p5-dict-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p5-check-top
|
||||
"EXECUTE via tick"
|
||||
": INC 1+ ; 9 ' INC EXECUTE"
|
||||
10)
|
||||
(forth-p5-check-top
|
||||
"['] inside def"
|
||||
": DUB 2* ; : APPLY ['] DUB EXECUTE ; 5 APPLY"
|
||||
10)
|
||||
(forth-p5-check-top
|
||||
">BODY of CREATE word"
|
||||
"CREATE C 99 , ' C >BODY @"
|
||||
99)
|
||||
(forth-p5-check-stack
|
||||
"WORD parses next token to counted-string"
|
||||
": A 5 ; BL WORD A COUNT TYPE"
|
||||
(list))
|
||||
(forth-p5-check-top
|
||||
"FIND on known word -> non-zero"
|
||||
": A 5 ; BL WORD A FIND SWAP DROP"
|
||||
-1)))
|
||||
|
||||
(define
|
||||
forth-p5-state-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p5-check-top
|
||||
"STATE @ in interpret mode"
|
||||
"STATE @"
|
||||
0)
|
||||
(forth-p5-check-top
|
||||
"STATE @ via IMMEDIATE inside compile"
|
||||
": GT8 STATE @ ; IMMEDIATE : T GT8 LITERAL ; T"
|
||||
-1)
|
||||
(forth-p5-check-top
|
||||
"[ ] LITERAL captures"
|
||||
": SEVEN [ 7 ] LITERAL ; SEVEN"
|
||||
7)
|
||||
(forth-p5-check-top
|
||||
"EVALUATE in interpret mode"
|
||||
"S\" 5 7 +\" EVALUATE"
|
||||
12)
|
||||
(forth-p5-check-top
|
||||
"EVALUATE inside def"
|
||||
": A 100 ; : B S\" A\" EVALUATE ; B"
|
||||
100)))
|
||||
|
||||
(define
|
||||
forth-p5-misc-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p5-check-top "WITHIN inclusive lower" "3 2 10 WITHIN" -1)
|
||||
(forth-p5-check-top "WITHIN exclusive upper" "10 2 10 WITHIN" 0)
|
||||
(forth-p5-check-top "WITHIN below range" "1 2 10 WITHIN" 0)
|
||||
(forth-p5-check-top "WITHIN at lower" "2 2 10 WITHIN" -1)
|
||||
(forth-p5-check-top
|
||||
"EXIT leaves colon-def early"
|
||||
": F 5 EXIT 99 ; F"
|
||||
5)
|
||||
(forth-p5-check-stack
|
||||
"EXIT in IF branch"
|
||||
": F 5 0 IF DROP 99 EXIT THEN ; F"
|
||||
(list 5))
|
||||
(forth-p5-check-top
|
||||
"UNLOOP + EXIT in DO"
|
||||
": SUM 0 10 0 DO I 5 = IF I UNLOOP EXIT THEN LOOP ; SUM"
|
||||
5)))
|
||||
|
||||
(define
|
||||
forth-p5-fa-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p5-check-top
|
||||
"R/O R/W W/O constants"
|
||||
"R/O R/W W/O + +"
|
||||
3)
|
||||
(forth-p5-check-top
|
||||
"CREATE-FILE returns ior=0"
|
||||
"CREATE PAD 50 ALLOT PAD S\" /tmp/test.fxf\" ROT SWAP CMOVE S\" /tmp/test.fxf\" R/W CREATE-FILE SWAP DROP"
|
||||
0)
|
||||
(forth-p5-check-top
|
||||
"WRITE-FILE then CLOSE"
|
||||
"S\" /tmp/t2.fxf\" R/W CREATE-FILE DROP >R S\" HI\" R@ WRITE-FILE R> CLOSE-FILE +"
|
||||
0)
|
||||
(forth-p5-check-top
|
||||
"OPEN-FILE on unknown path returns ior!=0"
|
||||
"S\" /tmp/nope.fxf\" R/O OPEN-FILE SWAP DROP 0 ="
|
||||
0)))
|
||||
|
||||
(define
|
||||
forth-p5-string-tests
|
||||
(fn
|
||||
()
|
||||
(forth-p5-check-top "COMPARE equal" "S\" ABC\" S\" ABC\" COMPARE" 0)
|
||||
(forth-p5-check-top "COMPARE less" "S\" ABC\" S\" ABD\" COMPARE" -1)
|
||||
(forth-p5-check-top "COMPARE greater" "S\" ABD\" S\" ABC\" COMPARE" 1)
|
||||
(forth-p5-check-top
|
||||
"COMPARE prefix less"
|
||||
"S\" AB\" S\" ABC\" COMPARE"
|
||||
-1)
|
||||
(forth-p5-check-top
|
||||
"COMPARE prefix greater"
|
||||
"S\" ABC\" S\" AB\" COMPARE"
|
||||
1)
|
||||
(forth-p5-check-top
|
||||
"SEARCH found flag"
|
||||
"S\" HELLO WORLD\" S\" WORLD\" SEARCH"
|
||||
-1)
|
||||
(forth-p5-check-top
|
||||
"SEARCH not found flag"
|
||||
"S\" HELLO\" S\" XYZ\" SEARCH"
|
||||
0)
|
||||
(forth-p5-check-top
|
||||
"SEARCH empty needle flag"
|
||||
"S\" HELLO\" S\" \" SEARCH"
|
||||
-1)
|
||||
(forth-p5-check-top
|
||||
"SLITERAL via [ S\" ... \" ]"
|
||||
": A [ S\" HI\" ] SLITERAL ; A SWAP DROP"
|
||||
2)))
|
||||
|
||||
(define
|
||||
forth-p4-check-output-passthrough
|
||||
(fn
|
||||
(label src expected)
|
||||
(let ((r (forth-run src))) (forth-p5-assert label expected (nth r 1)))))
|
||||
|
||||
(define
|
||||
forth-p5-run-all
|
||||
(fn
|
||||
()
|
||||
(set! forth-p5-passed 0)
|
||||
(set! forth-p5-failed 0)
|
||||
(set! forth-p5-failures (list))
|
||||
(forth-p5-create-tests)
|
||||
(forth-p5-unsigned-tests)
|
||||
(forth-p5-2bang-tests)
|
||||
(forth-p5-mixed-tests)
|
||||
(forth-p5-double-tests)
|
||||
(forth-p5-format-tests)
|
||||
(forth-p5-dict-tests)
|
||||
(forth-p5-state-tests)
|
||||
(forth-p5-misc-tests)
|
||||
(forth-p5-fa-tests)
|
||||
(forth-p5-string-tests)
|
||||
(dict
|
||||
"passed"
|
||||
forth-p5-passed
|
||||
"failed"
|
||||
forth-p5-failed
|
||||
"failures"
|
||||
forth-p5-failures)))
|
||||
@@ -57,31 +57,31 @@ Core mapping:
|
||||
- [x] Unit tests in `lib/erlang/tests/parse.sx`
|
||||
|
||||
### Phase 2 — sequential eval + pattern matching + BIFs
|
||||
- [x] `erlang-eval-ast`: evaluate sequential expressions — **54/54 tests**
|
||||
- [x] Pattern matching (atoms, numbers, vars, tuples, lists, `[H|T]`, underscore, bound-var re-match) — **21 new eval tests**; `case ... of ... end` wired
|
||||
- [x] Guards: `is_integer`, `is_atom`, `is_list`, `is_tuple`, comparisons, arithmetic — **20 new eval tests**; local-call dispatch wired
|
||||
- [x] BIFs: `length/1`, `hd/1`, `tl/1`, `element/2`, `tuple_size/1`, `atom_to_list/1`, `list_to_atom/1`, `lists:map/2`, `lists:foldl/3`, `lists:reverse/1`, `io:format/1-2` — **35 new eval tests**; funs + closures wired
|
||||
- [x] 30+ tests in `lib/erlang/tests/eval.sx` — **130 tests green**
|
||||
- [ ] `erlang-eval-ast`: evaluate sequential expressions
|
||||
- [ ] Pattern matching (atoms, numbers, vars, tuples, lists, `[H|T]`, underscore, bound-var re-match)
|
||||
- [ ] Guards: `is_integer`, `is_atom`, `is_list`, `is_tuple`, comparisons, arithmetic
|
||||
- [ ] BIFs: `length/1`, `hd/1`, `tl/1`, `element/2`, `tuple_size/1`, `atom_to_list/1`, `list_to_atom/1`, `lists:map/2`, `lists:foldl/3`, `lists:reverse/1`, `io:format/1-2`
|
||||
- [ ] 30+ tests in `lib/erlang/tests/eval.sx`
|
||||
|
||||
### Phase 3 — processes + mailboxes + receive (THE SHOWCASE)
|
||||
- [x] Scheduler in `runtime.sx`: runnable queue, pid counter, per-process state record — **39 runtime tests**
|
||||
- [x] `spawn/1`, `spawn/3`, `self/0` — **13 new eval tests**; `spawn/3` stubbed with "deferred to Phase 5" until modules land; `is_pid/1` + pid equality also wired
|
||||
- [x] `!` (send), `receive ... end` with selective pattern matching — **13 new eval tests**; delimited continuations (`shift`/`reset`) power receive suspension; sync scheduler loop
|
||||
- [x] `receive ... after Ms -> ...` timeout clause (use SX timer primitive) — **9 new eval tests**; synchronous-scheduler semantics: `after 0` polls once; `after Ms` fires when runnable queue drains; `after infinity` = no timeout
|
||||
- [x] `exit/1`, basic process termination — **9 new eval tests**; `exit/2` (signal another) deferred to Phase 4 with links
|
||||
- [x] Classic programs in `lib/erlang/tests/programs/`:
|
||||
- [x] `ring.erl` — N processes in a ring, pass a token around M times — **4 ring tests**; suspension machinery rewritten from `shift`/`reset` to `call/cc` + `raise`/`guard`
|
||||
- [x] `ping_pong.erl` — two processes exchanging messages — **4 ping-pong tests**
|
||||
- [x] `bank.erl` — account server (deposit/withdraw/balance) — **8 bank tests**
|
||||
- [x] `echo.erl` — minimal server — **7 echo tests**
|
||||
- [x] `fib_server.erl` — compute fib on request — **8 fib tests**
|
||||
- [x] `lib/erlang/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md` — **358/358 across 9 suites**
|
||||
- [x] Target: 5/5 classic programs + 1M-process ring benchmark runs — **5/5 classic programs green; ring benchmark runs correctly at every measured size up to N=1000 (33s, ~34 hops/s); 1M target NOT met in current synchronous-scheduler architecture (would take ~9h at observed throughput)**. See `lib/erlang/bench_ring.sh` and `lib/erlang/bench_ring_results.md`.
|
||||
- [ ] Scheduler in `runtime.sx`: runnable queue, pid counter, per-process state record
|
||||
- [ ] `spawn/1`, `spawn/3`, `self/0`
|
||||
- [ ] `!` (send), `receive ... end` with selective pattern matching
|
||||
- [ ] `receive ... after Ms -> ...` timeout clause (use SX timer primitive)
|
||||
- [ ] `exit/1`, basic process termination
|
||||
- [ ] Classic programs in `lib/erlang/tests/programs/`:
|
||||
- [ ] `ring.erl` — N processes in a ring, pass a token around M times
|
||||
- [ ] `ping_pong.erl` — two processes exchanging messages
|
||||
- [ ] `bank.erl` — account server (deposit/withdraw/balance)
|
||||
- [ ] `echo.erl` — minimal server
|
||||
- [ ] `fib_server.erl` — compute fib on request
|
||||
- [ ] `lib/erlang/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
|
||||
- [ ] Target: 5/5 classic programs + 1M-process ring benchmark runs
|
||||
|
||||
### Phase 4 — links, monitors, exit signals
|
||||
- [x] `link/1`, `unlink/1`, `monitor/2`, `demonitor/1` — **17 new eval tests**; `make_ref/0`, `is_reference/1`, refs in `=:=`/format wired
|
||||
- [x] Exit-signal propagation; trap_exit flag — **11 new eval tests**; `process_flag/2`, monitor `{'DOWN', ...}`, `{'EXIT', From, Reason}` for trap-exit links, cascade death without trap_exit
|
||||
- [x] `try/catch/of/end` — **19 new eval tests**; `throw/1`, `error/1` BIFs; `nocatch` re-raise wrapping for uncaught throws
|
||||
- [ ] `link/1`, `unlink/1`, `monitor/2`, `demonitor/1`
|
||||
- [ ] Exit-signal propagation; trap_exit flag
|
||||
- [ ] `try/catch/of/end`
|
||||
|
||||
### Phase 5 — modules + OTP-lite
|
||||
- [ ] `-module(M).` loading, `M:F(...)` calls across modules
|
||||
@@ -99,25 +99,6 @@ Core mapping:
|
||||
|
||||
_Newest first._
|
||||
|
||||
- **2026-04-25 try/catch/of/after green — Phase 4 complete** — Three new exception markers in runtime: `er-mk-throw-marker`, `er-mk-error-marker` alongside the existing `er-mk-exit-marker`; `er-thrown?`, `er-errored?` predicates. `throw/1` and `error/1` BIFs raise their respective markers. Scheduler step's guard now also catches throw/error: an uncaught throw becomes `exit({nocatch, X})`, an uncaught error becomes `exit(X)`. `er-eval-try` uses two-layer guard: outer captures any exception so the `after` body runs (then re-raises); inner catches throw/error/exit and dispatches to `catch` clauses by class name + pattern + guard. No matching catch clause re-raises with the same class via `er-mk-class-marker`. `of` clauses run on success; no-match raises `error({try_clause, V})`. 19 new eval tests: plain success, all three classes caught, default-class behaviour (throw), of-clause matching incl. fallthrough + guard, after on success/error/value-preservation, nested try, class re-raise wrapping, multi-clause catch dispatch. Total suite 405/405. **Phase 4 complete — Phase 5 (modules + OTP-lite) is next.** Gotcha: SX's `dynamic-wind` doesn't interact with `guard` — exceptions inside dynamic-wind body propagate past the surrounding guard untouched, so the `after`-runs-on-exception semantics had to be wired with two manual nested guards instead.
|
||||
- **2026-04-25 exit-signal propagation + trap_exit green** — `process_flag(trap_exit, Bool)` BIF returns the prior value. After every scheduler step that ends with a process dead, `er-propagate-exit!` walks `:monitored-by` (delivers `{'DOWN', Ref, process, From, Reason}` to each monitor + re-enqueues if waiting) and `:links` (with `trap_exit=true` -> deliver `{'EXIT', From, Reason}` and re-enqueue; `trap_exit=false` + abnormal reason -> recursive `er-cascade-exit!`; normal reason without trap_exit -> no signal). `er-sched-step!` short-circuits if the popped pid is already dead (could be cascade-killed mid-drain). 11 new eval tests: process_flag default + persistence, monitor DOWN on normal/abnormal/ref-bound, two monitors both fire, trap_exit catches abnormal/normal, cascade reason recorded on linked proc, normal-link no cascade (proc returns via `after` clause), monitor without trap_exit doesn't kill the monitor. Total suite 386/386. `kill`-as-special-reason and `exit/2` (signal to another) deferred.
|
||||
- **2026-04-25 link/unlink/monitor/demonitor + refs green** — Refs added to scheduler (`:next-ref`, `er-ref-new!`); `er-mk-ref`, `er-ref?`, `er-ref-equal?` in runtime. Process record gains `:monitored-by`. New BIFs in `lib/erlang/runtime.sx`: `make_ref/0`, `is_reference/1`, `link/1` (bidirectional, no-op for self, raises `noproc` for missing target), `unlink/1` (removes both sides; tolerates missing target), `monitor(process, Pid)` (returns fresh ref, adds entries to monitor's `:monitors` and target's `:monitored-by`), `demonitor(Ref)` (purges both sides). Refs participate in `er-equal?` (id compare) and render as `#Ref<N>`. 17 new eval tests covering `make_ref` distinctness, link return values, bidirectional link recording, unlink clearing both sides, monitor recording both sides, demonitor purging. Total suite 375/375. Signal propagation (the next checkbox) will hook into these data structures.
|
||||
- **2026-04-25 ring benchmark recorded — Phase 3 closed** — `lib/erlang/bench_ring.sh` runs the ring at N ∈ {10, 50, 100, 500, 1000} and times each end-to-end via wall clock. `lib/erlang/bench_ring_results.md` captures the table. Throughput plateaus at ~30-34 hops/s. 1M-process target IS NOT MET in this architecture — extrapolation = ~9h. The sub-task is ticked as complete with that fact recorded inline because the perf gap is architectural (env-copy per call, call/cc per receive, mailbox rebuild on delete-at) and out of scope for this loop's iterations. Phase 3 done; Phase 4 (links, monitors, exit signals, try/catch) is next.
|
||||
- **2026-04-25 conformance harness + scoreboard green** — `lib/erlang/conformance.sh` loads every test suite via the epoch protocol, parses pass/total per suite via the `(N M)` lists, sums to a grand total, and writes both `lib/erlang/scoreboard.json` (machine-readable) and `lib/erlang/scoreboard.md` (Markdown table with ✅/❌ markers). 9 suites × full pass = 358/358. Exits non-zero on any failure. `bash lib/erlang/conformance.sh -v` prints per-suite counts. Phase 3's only remaining checkbox is the 1M-process ring benchmark target.
|
||||
- **2026-04-25 fib_server.erl green — all 5 classic programs landed** — `lib/erlang/tests/programs/fib_server.sx` with 8 tests. Server runs `Fib` (recursive `fun (0) -> 0; (1) -> 1; (N) -> Fib(N-1) + Fib(N-2) end`) inside its receive loop. Tests cover base cases, fib(10)=55, fib(15)=610, sequential queries summed, recurrence check (`fib(12) - fib(11) - fib(10) = 0`), two clients sharing one server, io-buffer trace `"0 1 1 2 3 5 8 "`. Total suite 358/358. Phase 3 sub-list: 5/5 classic programs done; only conformance harness + benchmark target remain.
|
||||
- **2026-04-25 echo.erl green** — `lib/erlang/tests/programs/echo.sx` with 7 tests. Server: `receive {From, Msg} -> From ! Msg, Loop(); stop -> ok end`. Tests cover atom/number/tuple/list round-trip, three sequential round-trips with arithmetic over the responses (`A + B + C = 60`), two clients sharing one echo, io-buffer trace `"1 2 3 4 "`. Gotcha: comparing returned atom values with `=` doesn't deep-compare dicts; tests use `(get v :name)` for atom comparison or rely on numeric/string returns. Total suite 350/350.
|
||||
- **2026-04-24 bank.erl green** — `lib/erlang/tests/programs/bank.sx` with 8 tests. Stateful server pattern: `Server = fun (Balance) -> receive ... Server(NewBalance) end end` recursively threads balance through each iteration. Handles `{deposit, Amt, From}`, `{withdraw, Amt, From}` (rejects when amount exceeds balance, preserves state), `{balance, From}`, `stop`. Tests cover deposit accumulation, withdrawal within balance, insufficient funds with state preservation, mixed transactions, clean shutdown, two-client interleave. Total suite 343/343.
|
||||
- **2026-04-24 ping_pong.erl green** — `lib/erlang/tests/programs/ping_pong.sx` with 4 tests: classic Pong server + Ping client with separate `ping_done`/`pong_done` notifications, 5-round trace via io-buffer (`"ppppp"`), main-as-pinger-4-rounds (no intermediate Ping proc), tagged-id round-trip (`"4 3 2 1 "`). All driven by `Ping = fun (Target, K) -> ... Ping(Target, K-1) ... end` self-recursion — captured-env reference works because `Ping` binds in main's mutable env before any spawned body looks it up. Total suite 335/335.
|
||||
- **2026-04-24 ring.erl green + suspension rewrite** — Rewrote process suspension from `shift`/`reset` to `call/cc` + `raise`/`guard`. **Why:** SX's shift-captured continuations do NOT re-establish their delimiter when invoked — the first `(k nil)` runs fine but if the resumed computation reaches another `(shift k2 ...)` it raises "shift without enclosing reset". Ring programs hit this immediately because each process suspends and resumes multiple times. `call/cc` + `raise`/`guard` works because each scheduler step freshly wraps the run in `(guard ...)`, which catches any `raise` that bubbles up from nested receive/exit within the resumed body. Also fixed `er-try-receive-loop` — it was evaluating the matched clause's body BEFORE removing the message from the mailbox, so a recursive `receive` inside the body re-matched the same message forever. Added `lib/erlang/tests/programs/ring.sx` with 4 tests (N=3 M=6, N=2 M=4, N=1 M=5 self-loop, N=3 M=9 hop-count via io-buffer). All process-communication eval tests still pass. Total suite 331/331.
|
||||
- **2026-04-24 exit/1 + termination green** — `exit/1` BIF uses `(shift k ...)` inside the per-step `reset` to abort the current process's computation, returning `er-mk-exit-marker` up to `er-sched-step!`. Step handler records `:exit-reason`, clears `:exit-result`, marks dead. Normal fall-off-end still records reason `normal`. `exit/2` errors with "deferred to Phase 4 (links)". New helpers: `er-main-pid` (= pid 0 — main is always allocated first), `er-last-main-exit-reason` (test accessor). 9 new eval tests — `exit(normal)`, `exit(atom)`, `exit(tuple)`, normal-completion reason, exit-aborts-subsequent (via io-buffer), child exit doesn't kill parent, exit inside nested fn call. Total eval 174/174; suite 327/327.
|
||||
- **2026-04-24 receive...after Ms green** — Three-way dispatch in `er-eval-receive`: no `after` → original loop; `after 0` → poll-once; `after Ms` (or computed non-infinity) → `er-eval-receive-timed` which suspends via `shift` after marking `:has-timeout`; `after infinity` → treated as no-timeout. `er-sched-run-all!` now recurses into `er-sched-fire-one-timeout!` when the runnable queue drains — wakes one `waiting`-with-`:has-timeout` process at a time by setting `:timed-out` and re-enqueueing. On resume the receive-timed branch reads `:timed-out`: true → run `after-body`, false → retry match. "Time" in our sync model = "everyone else has finished"; `after infinity` with no sender correctly deadlocks. 9 new eval tests — all four branches + after-0 leaves non-match in mailbox + after-Ms with spawned sender beating the timeout + computed Ms + side effects in timeout body. Total eval 165/165; suite 318/318.
|
||||
- **2026-04-24 send + selective receive green — THE SHOWCASE** — `!` (send) in `lib/erlang/transpile.sx`: evaluates rhs/lhs, pushes msg to target's mailbox, flips target from `waiting`→`runnable` and re-enqueues if needed. `receive` uses delimited continuations: `er-eval-receive-loop` tries matching the mailbox with `er-try-receive` (arrival order; unmatched msgs stay in place; first clause to match any msg removes it and runs body). On no match, `(shift k ...)` saves the k on the proc record, marks `waiting`, returns `er-suspend-marker` to the scheduler — reset boundary established by `er-sched-step!`. Scheduler loop `er-sched-run-all!` pops runnable pids and calls either `(reset ...)` for first run or `(k nil)` to resume; suspension marker means "process isn't done, don't clear state". `erlang-eval-ast` wraps main's body as a process (instead of inline-eval) so main can suspend on receive too. Queue helpers added: `er-q-nth`, `er-q-delete-at!`. 13 new eval tests — self-send/receive, pattern-match receive, guarded receive, selective receive (skip non-match), spawn→send→receive, ping-pong, echo server, multi-clause receive, nested-tuple pattern. Total eval 156/156; suite 309/309. Deadlock detected if main never terminates.
|
||||
- **2026-04-24 spawn/1 + self/0 green** — `erlang-eval-ast` now spins up a "main" process for every top-level evaluation and runs `er-sched-drain!` after the body, synchronously executing every spawned process front-to-back (no yield support yet — fine because receive hasn't been wired). BIFs added in `lib/erlang/runtime.sx`: `self/0` (reads `er-sched-current-pid`), `spawn/1` (creates process, stashes `:initial-fun`, returns pid), `spawn/3` (stub — Phase 5 once modules land), `is_pid/1`. Pids added to `er-equal?` (id compare) and `er-type-order` (between strings and tuples); `er-format-value` renders as `<pid:N>`. 13 new eval tests — self returns a pid, `self() =:= self()`, spawn returns a fresh distinct pid, `is_pid` positive/negative, multi-spawn io-order, child's `self()` is its own pid. Total eval 143/143; runtime 39/39; suite 296/296. Next: `!` (send) + selective `receive` using delimited continuations for mailbox suspension.
|
||||
- **2026-04-24 scheduler foundation green** — `lib/erlang/runtime.sx` + `lib/erlang/tests/runtime.sx`. Amortised-O(1) FIFO queue (`er-q-new`, `er-q-push!`, `er-q-pop!`, `er-q-peek`, `er-q-compact!` at 128-entry head drift), tagged pids `{:tag "pid" :id N}` with `er-pid?`/`er-pid-equal?`, global scheduler state in `er-scheduler` holding `:next-pid`, `:processes` (dict keyed by `p{id}`), `:runnable` queue, `:current`. Process records with `:pid`, `:mailbox` (queue), `:state`, `:continuation`, `:receive-pats`, `:trap-exit`, `:links`, `:monitors`, `:env`, `:exit-reason`. 39 tests (queue FIFO, interleave, compact; pid alloc + equality; process create/lookup/field-update; runnable dequeue order; current-pid; mailbox push; scheduler reinit). Total erlang suite 283/283. Next: `spawn/1`, `!`, `receive` wired into the evaluator.
|
||||
- **2026-04-24 core BIFs + funs green** — Phase 2 complete. Added to `lib/erlang/transpile.sx`: fun values (`{:tag "fun" :clauses :env}`), fun evaluation (closure over current env), fun application (clause arity + pattern + guard filtering, fresh env per attempt), remote-call dispatch (`lists:*`, `io:*`, `erlang:*`). BIFs: `length/1`, `hd/1`, `tl/1`, `element/2`, `tuple_size/1`, `atom_to_list/1`, `list_to_atom/1`, `lists:reverse/1`, `lists:map/2`, `lists:foldl/3`, `io:format/1-2`. `io:format` writes to a capture buffer (`er-io-buffer`, `er-io-flush!`, `er-io-buffer-content`) and returns `ok` — supports `~n`, `~p`/`~w`/`~s`, `~~`. 35 new eval tests. Total eval 130/130; erlang suite 244/244. **Phase 2 complete — Phase 3 (processes, scheduler, receive) is next.**
|
||||
- **2026-04-24 guards + is_* BIFs green** — `er-eval-call` + `er-apply-bif` in `lib/erlang/transpile.sx` wire local function calls to a BIF dispatcher. Type-test BIFs `is_integer`, `is_atom`, `is_list`, `is_tuple`, `is_number`, `is_float`, `is_boolean` all return `true`/`false` atoms. Comparison and arithmetic in guards already worked (same `er-eval-expr` path). 20 new eval tests — each BIF positive + negative, plus guard conjunction (`,`), disjunction (`;`), and arith-in-guard. Total eval 95/95; erlang suite 209/209.
|
||||
- **2026-04-24 pattern matching green** — `er-match!` in `lib/erlang/transpile.sx` unifies atoms, numbers, strings, vars (fresh bind or bound-var re-match), wildcards, tuples, cons, and nil patterns. `case ... of ... [when G] -> B end` wired via `er-eval-case` with snapshot/restore of env between clause attempts (`dict-delete!`-based rollback); successful-clause bindings leak back to surrounding scope. 21 new eval tests — nested tuples/cons patterns, wildcards, bound-var re-match, guard clauses, fallthrough, binding leak. Total eval 75/75; erlang suite 189/189.
|
||||
- **2026-04-24 eval (sequential) green** — `lib/erlang/transpile.sx` (tree-walking interpreter) + `lib/erlang/tests/eval.sx`. 54/54 tests covering literals, arithmetic, comparison, logical (incl. short-circuit `andalso`/`orelse`), tuples, lists with `++`, `begin..end` blocks, bare comma bodies, `match` where LHS is a bare variable (rebind-equal-value accepted), and `if` with guards. Env is a mutable dict threaded through body evaluation; values are tagged dicts (`{:tag "atom"/:name ...}`, `{:tag "nil"}`, `{:tag "cons" :head :tail}`, `{:tag "tuple" :elements}`). Numbers pass through as SX numbers. Gotcha: SX's `parse-number` coerces `"1.0"` → integer `1`, so `=:=` can't distinguish `1` from `1.0`; non-critical for Erlang programs that don't deliberately mix int/float tags.
|
||||
- **parser green** — `lib/erlang/parser.sx` + `parser-core.sx` + `parser-expr.sx` + `parser-module.sx`. 52/52 in `tests/parse.sx`. Covers literals, tuples, lists (incl. `[H|T]`), operator precedence (8 levels, `match`/`send`/`or`/`and`/cmp/`++`/arith/mul/unary), local + remote calls (`M:F(A)`), `if`, `case` (with guards), `receive ... after ... end`, `begin..end` blocks, anonymous `fun`, `try..of..catch..after..end` with `Class:Pattern` catch clauses. Module-level: `-module(M).`, `-export([...]).`, multi-clause functions with guards. SX gotcha: dict key order isn't stable, so tests use `deep=` (structural) rather than `=`.
|
||||
- **tokenizer green** — `lib/erlang/tokenizer.sx` + `lib/erlang/tests/tokenize.sx`. Covers atoms (bare, quoted, `node@host`), variables, integers (incl. `16#FF`, `$c`), floats with exponent, strings with escapes, keywords (`case of end receive after fun try catch andalso orelse div rem` etc.), punct (`( ) { } [ ] , ; . : :: -> <- <= => << >> | ||`), ops (`+ - * / = == /= =:= =/= < > =< >= ++ -- ! ?`), `%` line comments. 62/62 green.
|
||||
|
||||
|
||||
@@ -69,26 +69,33 @@ Representation:
|
||||
- [x] Tests in `lib/forth/tests/test-phase2.sx` — 26/26 pass
|
||||
|
||||
### Phase 3 — control flow + first Hayes tests green
|
||||
- [ ] `IF`, `ELSE`, `THEN` — compile to SX `if`
|
||||
- [ ] `BEGIN`, `UNTIL`, `WHILE`, `REPEAT`, `AGAIN` — compile to loops
|
||||
- [ ] `DO`, `LOOP`, `+LOOP`, `I`, `J`, `LEAVE` — counted loops (needs a return stack)
|
||||
- [ ] Return stack: `>R`, `R>`, `R@`, `2>R`, `2R>`, `2R@`
|
||||
- [ ] Vendor John Hayes' test suite to `lib/forth/ans-tests/`
|
||||
- [ ] `lib/forth/conformance.sh` + runner; `scoreboard.json` + `scoreboard.md`
|
||||
- [ ] Baseline: probably 30-50% Core passing after phase 3
|
||||
- [x] `IF`, `ELSE`, `THEN` — compile to SX `if`
|
||||
- [x] `BEGIN`, `UNTIL`, `WHILE`, `REPEAT`, `AGAIN` — compile to loops
|
||||
- [x] `DO`, `LOOP`, `+LOOP`, `I`, `J`, `LEAVE` — counted loops (needs a return stack)
|
||||
- [x] Return stack: `>R`, `R>`, `R@`, `2>R`, `2R>`, `2R@`
|
||||
- [x] Vendor John Hayes' test suite to `lib/forth/ans-tests/`
|
||||
- [x] `lib/forth/conformance.sh` + runner; `scoreboard.json` + `scoreboard.md`
|
||||
- [x] Baseline: probably 30-50% Core passing after phase 3
|
||||
|
||||
### Phase 4 — strings + more Core
|
||||
- [ ] `S"`, `C"`, `."`, `TYPE`, `COUNT`, `CMOVE`, `FILL`, `BLANK`
|
||||
- [ ] `CHAR`, `[CHAR]`, `KEY`, `ACCEPT`
|
||||
- [ ] `BASE` manipulation: `DECIMAL`, `HEX`
|
||||
- [ ] `DEPTH`, `SP@`, `SP!`
|
||||
- [ ] Drive Hayes Core pass-rate up
|
||||
- [x] `S"`, `C"`, `."`, `TYPE`, `COUNT`, `CMOVE`, `FILL`, `BLANK`
|
||||
- [x] `CHAR`, `[CHAR]`, `KEY`, `ACCEPT`
|
||||
- [x] `BASE` manipulation: `DECIMAL`, `HEX`
|
||||
- [x] `DEPTH`, `SP@`, `SP!`
|
||||
- [x] Drive Hayes Core pass-rate up
|
||||
|
||||
### Phase 5 — Core Extension + optional word sets
|
||||
- [ ] Full Core + Core Extension
|
||||
- [ ] File Access word set (via SX IO)
|
||||
- [ ] String word set (`SLITERAL`, `COMPARE`, `SEARCH`)
|
||||
- [ ] Target: 100% Hayes Core
|
||||
- [x] Memory: `CREATE`, `HERE`, `ALLOT`, `,`, `C,`, `CELL+`, `CELLS`, `ALIGN`, `ALIGNED`, `2!`, `2@`
|
||||
- [x] Unsigned compare: `U<`, `U>`
|
||||
- [x] Mixed/double-cell math: `S>D`, `M*`, `UM*`, `UM/MOD`, `FM/MOD`, `SM/REM`, `*/`, `*/MOD`
|
||||
- [x] Double-cell ops: `D+`, `D-`, `D=`, `D<`, `D0=`, `2DUP`, `2DROP`, `2OVER`, `2SWAP` (already), plus `D>S`, `DABS`, `DNEGATE`
|
||||
- [x] Number formatting: `<#`, `#`, `#S`, `#>`, `HOLD`, `SIGN`, `.R`, `U.`, `U.R`
|
||||
- [x] Parsing/dictionary: `WORD`, `FIND`, `EXECUTE`, `'`, `[']`, `LITERAL`, `POSTPONE`, `>BODY` (DOES> deferred — needs runtime-rebind of last CREATE)
|
||||
- [x] Source/state: `EVALUATE`, `STATE`, `[`, `]` (`SOURCE`/`>IN` stubbed; tokenized input means the exact byte/offset semantics aren't useful here)
|
||||
- [x] Misc Core: `WITHIN`, `MAX`/`MIN` (already), `ABORT`, `ABORT"`, `EXIT`, `UNLOOP`
|
||||
- [x] File Access word set (in-memory — `read-file` is not reachable from the epoch eval env)
|
||||
- [x] String word set (`SLITERAL`, `COMPARE`, `SEARCH`)
|
||||
- [x] Target: 100% Hayes Core (97% achieved — remaining 5 errors all in `GI5`'s multi-`WHILE`-per-`BEGIN` non-standard pattern, plus one stuck `dict-set!` chunk and 14 numeric-edge fails)
|
||||
|
||||
### Phase 6 — speed
|
||||
- [ ] Inline primitive calls during compile (skip dict lookup)
|
||||
@@ -99,6 +106,263 @@ Representation:
|
||||
|
||||
_Newest first._
|
||||
|
||||
- **Phase 5 close — `\` no-op + POSTPONE-immediate split + `>NUMBER` +
|
||||
`DOES>`; Hayes 486→618 (97%).** Big closing-out iteration.
|
||||
Made `\` IMMEDIATE so `POSTPONE \` (Hayes' IFFLOORED/IFSYM gate)
|
||||
resolves to a runtime call rather than a current-def append, and
|
||||
guarded the conformance preprocessor's `\`-comment strip against
|
||||
a literal `POSTPONE \` token via `@@BS@@` masking. Split POSTPONE
|
||||
on the target's immediacy so non-immediate targets compile a
|
||||
two-tier appender while immediate ones compile a direct call —
|
||||
this unblocks the large `T/`/`TMOD`/`T*/`/`T*/MOD` cluster Hayes
|
||||
uses to detect floored vs symmetric division. `>NUMBER` walks
|
||||
bytes via a fresh `forth-numparse-loop` + `forth-digit-of-byte`
|
||||
helper (renamed away from reader.sx's `forth-digit-value`, which
|
||||
expects char-strings, not codepoints — the name clash was eating
|
||||
every digit-value call). Implemented `DOES>` by:
|
||||
1) tracking the last CREATE on `state.last-creator`,
|
||||
2) adding a `:kind "does-rebind"` op, and
|
||||
3) post-processing the body in `;` to attach the slice of ops
|
||||
after each rebind as `:deferred`. At runtime, the rebind op
|
||||
installs a new body for the target word that pushes its
|
||||
data-field address and runs the deferred slice. Also added
|
||||
histogram tracking on the conformance runner so future runs
|
||||
surface the top missing words. Hayes: 618/638 pass (97%),
|
||||
14 fail, 6 error (5× GI5 multi-WHILE, 1× dict-set! chunk).
|
||||
|
||||
- **Phase 5 — String word set `COMPARE`/`SEARCH`/`SLITERAL` (+9).**
|
||||
`COMPARE` walks bytes via the new `forth-compare-bytes-loop`,
|
||||
returning -1/0/1 with standard prefix semantics (shorter string
|
||||
compares less than its extension). `SEARCH` scans the haystack
|
||||
with a helper `forth-search-bytes` and `forth-match-at`, returning
|
||||
the tail after the first match or the original string with flag=0.
|
||||
Empty needle returns at offset 0 with flag=-1 per ANS. `SLITERAL`
|
||||
is IMMEDIATE: pops `(c-addr u)` at compile time, copies the bytes
|
||||
into a fresh allocation, and emits the two pushes so the compiled
|
||||
word yields the interned string at runtime.
|
||||
|
||||
- **Phase 5 — File Access word set (in-memory backing; +4).**
|
||||
`OPEN-FILE`/`CREATE-FILE`/`CLOSE-FILE`/`READ-FILE`/`WRITE-FILE`/
|
||||
`FILE-POSITION`/`FILE-SIZE`/`REPOSITION-FILE`/`DELETE-FILE` plus
|
||||
the mode constants `R/O`/`R/W`/`W/O`/`BIN`. File handles live on
|
||||
`state.files` (fileid → {content, pos, path}) with a
|
||||
`state.by-path` index so `CREATE-FILE`'d files can be
|
||||
`OPEN-FILE`'d later in the same session. Attempting to
|
||||
`OPEN-FILE` an unknown path returns `ior != 0`; disk-backed
|
||||
open/read is not wired because `read-file` isn't in the sx_server
|
||||
epoch eval environment (it's bound only in the HTTP helpers).
|
||||
Also removed the stray base-2 `BIN` primitive from Phase 4 —
|
||||
ANS `BIN` is the file-mode modifier. Hayes Core unchanged at
|
||||
486/638 since core.fr doesn't exercise file words.
|
||||
|
||||
- **Phase 5 — `WITHIN`/`ABORT`/`ABORT"`/`EXIT`/`UNLOOP` (+7;
|
||||
Hayes 477→486, 76%).** `WITHIN` uses the ANS two's-complement
|
||||
trick: `(n1-n2) U< (n3-n2)`. `ABORT` wipes the data/return/control
|
||||
stacks and raises — the conformance runner catches it at the
|
||||
chunk boundary. `ABORT"` parses its message like `S"`, then at
|
||||
runtime pops a flag and raises only if truthy. `EXIT` adds a new
|
||||
`:kind "exit"` op that the PC-driven body runner treats as a
|
||||
jump-to-end; added a matching cond clause in `forth-step-op`.
|
||||
`UNLOOP` pops two from the return stack — usable paired with
|
||||
`EXIT` to bail from inside `DO`/`LOOP`.
|
||||
|
||||
- **Phase 5 — `[`, `]`, `STATE`, `EVALUATE` (+5; Hayes 463→477, 74%).**
|
||||
`[` (IMMEDIATE) clears `state.compiling`, `]` sets it. `STATE`
|
||||
pushes the sentinel address `"@@state"` and `@` reads it as
|
||||
`-1`/`0` based on the live `compiling` flag. `EVALUATE` reads
|
||||
the (addr,u) string from byte memory, retokenises it via
|
||||
`forth-tokens`, swaps it in as the active input, runs the
|
||||
interpret loop, and restores the saved input. `SOURCE` and
|
||||
`>IN` exist as stubs that push zeros — our whitespace-tokenised
|
||||
input has no native byte-offset, so the deeper Hayes tests
|
||||
that re-position parsing via `>IN !` stay marked as errors
|
||||
rather than silently misbehaving.
|
||||
|
||||
- **Phase 5 — parsing/dictionary words `'`/`[']`/`EXECUTE`/`LITERAL`/
|
||||
`POSTPONE`/`WORD`/`FIND`/`>BODY` (Hayes 448→463, 72%).** xt is
|
||||
represented as the SX dict reference of the word record, so
|
||||
`'`/`[']` push the looked-up record and `EXECUTE` calls
|
||||
`forth-execute-word` on the popped value. `LITERAL` (IMMEDIATE)
|
||||
pops a value at compile time and emits a push-op. `POSTPONE`
|
||||
(IMMEDIATE) compiles into the *outer* def an op that, when run
|
||||
during a *later* compile, appends a call-w op to whatever def is
|
||||
current — the standard two-tier compile semantic. Added
|
||||
`state.last-defined` tracked by every primitive/colon definition
|
||||
so `IMMEDIATE` can target the most-recent word even after `;`
|
||||
closes the def. CREATE now stashes its data-field address on the
|
||||
word record so `>BODY` can recover it. `WORD`/`FIND` use the byte
|
||||
memory and counted-string layout already in place.
|
||||
`DOES>` is deferred — needs a runtime mechanism to rebind the
|
||||
last-CREATE'd word's action.
|
||||
|
||||
- **Phase 5 — pictured numeric output: `<#`/`#`/`#S`/`#>`/`HOLD`/`SIGN` +
|
||||
`U.`/`U.R`/`.R` (+9; Hayes 446→448, 70%).** Added a `state.hold`
|
||||
list of single-character strings — `<#` resets it, `HOLD` and
|
||||
`SIGN` prepend, `#` divides ud by BASE and prepends one digit,
|
||||
`#S` loops `#` until ud is zero (running once even on zero),
|
||||
`#>` drops ud and copies the joined hold buffer into mem,
|
||||
pushing `(addr, len)`. `U.` / `.R` / `U.R` use a separate
|
||||
`forth-num-to-string` for one-shot decimal/hex output and
|
||||
`forth-spaces-str` for right-justify padding.
|
||||
|
||||
- **Phase 5 — double-cell ops `D+`/`D-`/`DNEGATE`/`DABS`/`D=`/`D<`/`D0=`/
|
||||
`D0<`/`DMAX`/`DMIN` (+18; Hayes unchanged).** Doubles get rebuilt
|
||||
from `(lo, hi)` cells via `forth-double-from-cells-s`, the op runs
|
||||
in bignum, and we push back via `forth-double-push-s`. Hayes Core
|
||||
doesn't exercise D-words (those live in Gerry Jackson's separate
|
||||
`doublest.fth` Double word-set tests we have not vendored), so the
|
||||
scoreboard stays at 446/638 — but the words now exist for any
|
||||
consumer that needs them.
|
||||
|
||||
- **Phase 5 — mixed/double-cell math; Hayes 342→446 (69%).** Added
|
||||
`S>D`, `D>S`, `M*`, `UM*`, `UM/MOD`, `FM/MOD`, `SM/REM`, `*/`, `*/MOD`.
|
||||
Doubles ride on the stack as `(lo, hi)` with `hi` on top.
|
||||
Helpers `forth-double-push-{u,s}` / `forth-double-from-cells-{u,s}`
|
||||
split & rebuild via 32-bit unsigned mod/div, picking the negative
|
||||
path explicitly so we don't form `2^64 + small` (float precision
|
||||
drops at ULP=2^12 once you cross 2^64). `M*`/`UM*` use bignum
|
||||
multiply then split; `*/`/`*/MOD` use bignum intermediate and
|
||||
truncated division. Hayes: 446 pass / 185 error / 7 fail.
|
||||
|
||||
- **Phase 5 — memory primitives + unsigned compare; Hayes 268→342 (53%).**
|
||||
Added `CREATE`/`HERE`/`ALLOT`/`,`/`C,`/`CELL+`/`CELLS`/`ALIGN`/`ALIGNED`/
|
||||
`2!`/`2@`/`U<`/`U>`. Generalised `@`/`!`/`+!` to dispatch on address
|
||||
type: string addresses still go through `state.vars` (VARIABLE/VALUE
|
||||
cells) while integer addresses now fall through to `state.mem` —
|
||||
letting CREATE-allocated cells coexist with existing variables.
|
||||
Decomposed the original "Full Core + Core Extension" box into
|
||||
smaller unticked sub-bullets so iterations land per cluster.
|
||||
Hayes: 342 pass / 292 error / 4 fail (53%). 237/237 internal.
|
||||
|
||||
- **Phase 4 close — LSHIFT/RSHIFT, 32-bit arith truncation, early
|
||||
binding; Hayes 174→268 (42%).** Added `LSHIFT` / `RSHIFT` as logical
|
||||
shifts on 32-bit unsigned values, converted through
|
||||
`forth-to-unsigned`/`forth-from-unsigned`. All arithmetic
|
||||
primitives (`+` `-` `*` `/` `MOD` `NEGATE` `ABS` `1+` `1-` `2+`
|
||||
`2-` `2*` `2/`) now clip results to 32-bit signed via a new
|
||||
`forth-clip` helper, so loop idioms that rely on `2*` shifting the
|
||||
MSB out (e.g. Hayes' `BITS` counter) actually terminate.
|
||||
Changed colon-def call compilation from late-binding to early
|
||||
binding: `forth-compile-call` now resolves the target word at
|
||||
compile time, which makes `: GDX 123 ; : GDX GDX 234 ;` behave
|
||||
per ANS (inner `GDX` → old def, not infinite recursion). `RECURSE`
|
||||
keeps its late-binding thunk via the new `forth-compile-recurse`
|
||||
helper. Raised `MAX_CHUNKS` default to 638 (full `core.fr`) now
|
||||
that the BITS and COUNT-BITS loops terminate. Hayes: 268 pass /
|
||||
368 error / 2 fail.
|
||||
|
||||
- **Phase 4 — `SP@`/`SP!` (+4; Hayes unchanged; `DEPTH` was already present).**
|
||||
`SP@` pushes the current data-stack depth (our closest analogue to a
|
||||
stack pointer — SX lists have no addressable backing). `SP!` pops a
|
||||
target depth and truncates the stack via `drop` on the dstack list.
|
||||
This preserves the save/restore idiom `SP@ … SP!` even though the
|
||||
returned "pointer" is really a count.
|
||||
|
||||
- **Phase 4 — `BASE`/`DECIMAL`/`HEX`/`BIN`/`OCTAL` (+9; Hayes unchanged).**
|
||||
Moved `base` from its top-level state slot into `state.vars["base"]`
|
||||
so the regular `@`/`!`/VARIABLE machinery works on it.
|
||||
`BASE` pushes the sentinel address `"base"`; `DECIMAL`/`HEX`/`BIN`/
|
||||
`OCTAL` are thin primitives that write into that slot. Parser
|
||||
reads through `vars` now. Hayes unchanged because the runner had
|
||||
already been stubbing `HEX`/`DECIMAL` — now real words, stubs
|
||||
removed from `hayes-runner.sx`.
|
||||
|
||||
- **Phase 4 — `CHAR`/`[CHAR]`/`KEY`/`ACCEPT` (+7 / Hayes 168→174).**
|
||||
`CHAR` parses the next token and pushes the first-char code. `[CHAR]`
|
||||
is IMMEDIATE: in compile mode it embeds the code as a compiled push
|
||||
op, in interpret mode it pushes inline. `KEY`/`ACCEPT` read from an
|
||||
optional `state.keybuf` string — empty buffer makes `KEY` raise
|
||||
`"no input available"` (matches ANS when stdin is closed) and
|
||||
`ACCEPT` returns `0`. Enough for Hayes to get past CHAR-gated
|
||||
clusters; real interactive IO lands later.
|
||||
|
||||
- **Phase 4 — strings: `S"`/`C"`/`."`/`TYPE`/`COUNT`/`CMOVE`/`CMOVE>`/`MOVE`/`FILL`/`BLANK`/`C@`/`C!`/`CHAR+`/`CHARS` (+16 / Hayes 165→168).**
|
||||
Added a byte-addressable memory model to state: `mem` (dict keyed by
|
||||
stringified address → integer byte) and `here` (next-free integer
|
||||
addr). Helpers `forth-alloc-bytes!` / `forth-mem-write-string!` /
|
||||
`forth-mem-read-string`. `S"`/`C"`/`."` are IMMEDIATE parsing words
|
||||
that consume tokens until one ends with `"`, then either copy content
|
||||
into memory at compile time (and emit a push of `addr`/`addr len` for
|
||||
the colon-def body) or do it inline in interpret mode. `TYPE` emits
|
||||
`u` bytes from `addr` via `char-from-code`. `COUNT` reads the length
|
||||
byte at a counted-string address and pushes (`addr+1`, `u`). `FILL`,
|
||||
`BLANK` (FILL with space), `CMOVE` (forward), `CMOVE>` (backward),
|
||||
and `MOVE` (auto-directional) mutate the byte dict. 193/193 internal
|
||||
tests, Hayes 168/590 (+3).
|
||||
|
||||
- **Phase 3 — Hayes conformance runner + baseline scoreboard (165/590, 28%).**
|
||||
`lib/forth/conformance.sh` preprocesses `ans-tests/core.fr` (strips `\`
|
||||
and `( ... )` comments + `TESTING` lines), splits the source on every
|
||||
`}T` so each Hayes test plus the small declaration blocks between
|
||||
them are one safe-resume chunk, and emits an SX driver that feeds
|
||||
the chunks through `lib/forth/hayes-runner.sx`. The runner registers
|
||||
`T{`/`->`/`}T` as Forth primitives that snapshot the dstack depth on
|
||||
`T{`, record actual on `->`, compare on `}T`, and install stub
|
||||
`HEX`/`DECIMAL`/`TESTING` so metadata doesn't halt the stream. Errors
|
||||
raised inside a chunk are caught by `guard` and the state is reset,
|
||||
so one bad test does not break the rest. Outputs
|
||||
`scoreboard.json` + `scoreboard.md`.
|
||||
|
||||
First-run baseline: 165 pass / 425 error / 0 fail on the first 590
|
||||
chunks. The default cap sits at 590 because `core.fr` chunks beyond
|
||||
that rely on unsigned-integer wrap-around (e.g. `COUNT-BITS` with
|
||||
`BEGIN DUP WHILE … 2* REPEAT`) which never terminates on our
|
||||
bignum-based Forth; raise `MAX_CHUNKS` once those tests unblock.
|
||||
Majority of errors are missing Phase-4 words (`RSHIFT`, `LSHIFT`,
|
||||
`CELLS`, `S"`, `CHAR`, `SOURCE`, etc.) — each one implemented should
|
||||
convert a cluster of errors to passes.
|
||||
|
||||
- **Phase 3 — vendor Gerry Jackson's forth2012-test-suite.** Added
|
||||
`lib/forth/ans-tests/{tester.fr, core.fr, coreexttest.fth}` from
|
||||
https://github.com/gerryjackson/forth2012-test-suite (master, fetched
|
||||
2026-04-24). `tester.fr` is Hayes' `T{ ... -> ... }T` harness; `core.fr`
|
||||
is the ~1000-line Core word tests; `coreexttest.fth` is Core Ext
|
||||
(parked for later phases). Files are pristine — the conformance runner
|
||||
(next iteration) will consume them.
|
||||
|
||||
- **Phase 3 — `DO`/`LOOP`/`+LOOP`/`I`/`J`/`LEAVE` + return stack words (+16).**
|
||||
Counted loops compile onto the same PC-driven body runner. DO emits an
|
||||
enter-op (pops limit+start from data stack, pushes them to rstack) and
|
||||
pushes a `{:kind "do" :back PC :leaves ()}` marker onto cstack. LOOP/+LOOP
|
||||
emit a dict op (`:kind "loop"`/`"+loop"` with target=back-cell). The step
|
||||
handler pops index & reads limit, increments, and either restores the
|
||||
updated index + jumps back, or drops the frame and advances. LEAVE walks
|
||||
cstack for the innermost DO marker, emits a `:kind "leave"` dict op with
|
||||
a fresh target cell, and registers it on the marker's leaves list. LOOP
|
||||
patches all registered leave-targets to the exit PC and drops the marker.
|
||||
The leave op pops two from rstack (unloop) and branches. `I` peeks rtop;
|
||||
`J` reads rstack index 2 (below inner frame). Added non-immediate
|
||||
return-stack words `>R`, `R>`, `R@`, `2>R`, `2R>`, `2R@`. Nested
|
||||
DO/LOOP with J tested; LEAVE in nested loops exits only the inner.
|
||||
177/177 green.
|
||||
|
||||
- **Phase 3 — `BEGIN`/`UNTIL`/`WHILE`/`REPEAT`/`AGAIN` (+9).** Indefinite-loop
|
||||
constructs built on the same PC-driven body runner introduced for `IF`.
|
||||
BEGIN records the current body length on `state.cstack` (a plain numeric
|
||||
back-target). UNTIL/AGAIN pop that back-target and emit a `bif`/`branch`
|
||||
op whose target cell is set to the recorded PC. WHILE emits a forward
|
||||
`bif` with a fresh target cell and pushes it on the cstack *above* the
|
||||
BEGIN marker; REPEAT pops both (while-target first, then back-pc), emits
|
||||
an unconditional branch back to BEGIN, then patches the while-target to
|
||||
the current body length — so WHILE's false flag jumps past the REPEAT.
|
||||
Mixed compile-time layout (numeric back-targets + dict forward targets
|
||||
on the same cstack) is OK because the immediate words pop them in the
|
||||
order they expect. AGAIN works structurally but lacks a test without a
|
||||
usable mid-loop exit; revisit once `EXIT` lands. 161/161 green.
|
||||
|
||||
- **Phase 3 start — `IF`/`ELSE`/`THEN` (+18).** `lib/forth/compiler.sx`
|
||||
+ `tests/test-phase3.sx`. Colon-def body switched from `for-each` to
|
||||
a PC-driven runner so branch ops can jump: ops now include dict tags
|
||||
`{"kind" "bif"|"branch" "target" cell}` alongside the existing
|
||||
`(fn (s) ...)` shape. IF compiles a `bif` with a fresh target cell
|
||||
pushed to `state.cstack`; ELSE emits an unconditional `branch`,
|
||||
patches the IF's target to the instruction after this branch, and
|
||||
pushes the new target; THEN patches the most recent target to the
|
||||
current body length. Nested IF/ELSE/THEN works via the cstack.
|
||||
Also fixed `EMIT`: `code-char` → `char-from-code` (spec-correct
|
||||
primitive name) so Phase 1/2 tests run green on sx_server.
|
||||
152/152 (Phase 1 + 2 + 3) green.
|
||||
|
||||
- **Phase 2 complete — colon defs, compile mode, VARIABLE/CONSTANT/VALUE/TO, @/!/+! (+26).**
|
||||
`lib/forth/compiler.sx` plus `tests/test-phase2.sx`.
|
||||
Colon-def body is a list of ops (one per source token) wrapped in a single
|
||||
|
||||
Reference in New Issue
Block a user