32d2028559
Audit of the janet.*/jolt.interop/STM corpus cases vs Chez equivalents: the Janet FFI-bridge cases (janet/string, janet/type, janet.math/sqrt, janet.string/ascii- upper) test functionality already covered by PORTABLE corpus cases (str 29, type 9, sqrt 3, upper-case 9), so they're safe to delete in Phase 5. Two needed a Chez equivalent so they pass instead of being lost: - clojure.lang.LockingTransaction/isRunning -> false (no STM on jolt). - line-seq: the corpus case used janet/spit setup but was the SOLE line-seq coverage (0 other cases). Ported janet/spit->spit, and added a native Chez line-seq (drain a jhost io/reader + split on newline; no trailing empty line) that delegates a Janet map-reader to the overlay version. zero-Janet 2694->2696, prelude floor 2648; self-host + Janet gate + JVM cert green. jolt-cf1q.7 jolt-0obq
79 lines
4.7 KiB
Scheme
79 lines
4.7 KiB
Scheme
;; post-prelude overrides (jolt-9ziu) — loaded AFTER the assembled clojure.core
|
|
;; prelude, so these win over the overlay's own def-var!.
|
|
;;
|
|
;; A few clojure.core predicates are implemented in the overlay by inspecting a
|
|
;; Janet-host tagged value's :jolt/type key (e.g. (get x :jolt/type)). That key
|
|
;; doesn't exist for Chez-native representations: a jolt char is a Scheme char,
|
|
;; an atom is a Chez record. The overlay's def-var! loads after rt.ss, so it
|
|
;; clobbers the correct native shims (predicates.ss / atoms.ss) with versions
|
|
;; that return false on every Chez value. Re-assert the native versions here.
|
|
;;
|
|
;; (Long-term these predicates want a host-neutral implementation that calls a
|
|
;; host primitive instead of reading :jolt/type; until then this is the Chez-host
|
|
;; override.)
|
|
(def-var! "clojure.core" "char?" jolt-char-pred?)
|
|
(def-var! "clojure.core" "atom?" jolt-atom?)
|
|
;; atom watches/validators: the overlay drives these via jolt.host/ref-put! on a
|
|
;; Janet table (get a :watches), which a Chez atom record is not — re-assert the
|
|
;; native versions (defined in atoms.ss), and swap!/reset! notify+validate there.
|
|
(def-var! "clojure.core" "add-watch" jolt-add-watch)
|
|
(def-var! "clojure.core" "remove-watch" jolt-remove-watch)
|
|
(def-var! "clojure.core" "set-validator!" jolt-set-validator!)
|
|
(def-var! "clojure.core" "get-validator" jolt-get-validator)
|
|
;; volatiles: a Chez volatile is a jvol record, but the overlay vreset!/vswap!/
|
|
;; volatile? drive it via jolt.host/ref-put!+get / :jolt/type (tagged-table only).
|
|
;; Override with the native versions (defined in natives-xform.ss).
|
|
(def-var! "clojure.core" "vreset!" jolt-vreset!)
|
|
(def-var! "clojure.core" "vswap!" jolt-vswap!)
|
|
(def-var! "clojure.core" "volatile?" jolt-volatile-pred?)
|
|
;; bound?: the overlay reads (get v :root) — nil on a Chez var-cell record, so it
|
|
;; would wrongly report every var unbound. Native version (defined in vars.ss).
|
|
(def-var! "clojure.core" "bound?" jolt-bound?)
|
|
;; uuid?/random-uuid/parse-uuid/tagged-literal? are overlay (read :jolt/type or
|
|
;; build tagged tables) — re-assert the native versions (defined in natives-misc.ss).
|
|
(def-var! "clojure.core" "uuid?" jolt-uuid-pred?)
|
|
(def-var! "clojure.core" "random-uuid" jolt-random-uuid)
|
|
(def-var! "clojure.core" "parse-uuid" jolt-parse-uuid)
|
|
(def-var! "clojure.core" "tagged-literal?" jolt-tagged-literal-pred?)
|
|
;; ns-name: the overlay reads (get ns :name) — nil on a jns namespace record.
|
|
;; Native version (defined in ns.ss) returns the namespace's name symbol.
|
|
(def-var! "clojure.core" "ns-name" jolt-ns-name)
|
|
;; concurrency (jolt-byjr): the overlay's future-done?/future-cancelled?/realized?
|
|
;; read a Janet future-map's :cached/:cancelled keys, and promise/deliver are a
|
|
;; non-blocking atom shim. A Chez future/promise is a record, and we want JVM
|
|
;; (blocking, shared-heap) semantics — re-assert the native versions. realized?
|
|
;; wraps the overlay (which still handles delay/lazy-seq/atom) for non-futures.
|
|
(def-var! "clojure.core" "future-done?" jolt-native-future-done?)
|
|
(def-var! "clojure.core" "future-cancelled?" jolt-native-future-cancelled?)
|
|
(def-var! "clojure.core" "future?" jolt-future?)
|
|
(def-var! "clojure.core" "promise" jolt-promise-new)
|
|
(def-var! "clojure.core" "deliver" jolt-deliver)
|
|
;; agents: the overlay (50-io) is a synchronous shim (agent = atom, send applies
|
|
;; immediately). Re-assert the native async agents (per-agent serialized worker),
|
|
;; matching the JVM. await/restart-agent are new (the overlay has neither).
|
|
(def-var! "clojure.core" "agent" jolt-agent-new)
|
|
(def-var! "clojure.core" "agent?" jolt-agent?)
|
|
(def-var! "clojure.core" "send" jolt-agent-send)
|
|
(def-var! "clojure.core" "send-off" jolt-agent-send)
|
|
(def-var! "clojure.core" "await" jolt-agent-await)
|
|
(def-var! "clojure.core" "agent-error" jolt-agent-error)
|
|
(def-var! "clojure.core" "restart-agent" jolt-agent-restart)
|
|
(def-var! "clojure.core" "deref" jolt-deref)
|
|
(let ((overlay-realized? (var-deref "clojure.core" "realized?")))
|
|
(def-var! "clojure.core" "realized?"
|
|
(lambda (x)
|
|
(if (or (jolt-future? x) (jolt-promise? x) (jolt-delay? x))
|
|
(jolt-conc-realized? x)
|
|
(jolt-invoke overlay-realized? x)))))
|
|
;; clojure.edn/read over a reader: the overlay edn.clj drain-reader uses janet/type;
|
|
;; the native Chez version (io.ss) drains the jhost reader instead (jolt-uicd/jolt-7t3l).
|
|
(def-var! "clojure.edn" "read"
|
|
(case-lambda
|
|
((reader) (chez-edn-read reader))
|
|
((opts reader) (chez-edn-read reader))))
|
|
;; line-seq: a jhost reader (io/reader result) -> drain+split; a map-reader (the
|
|
;; overlay's :read-line-fn model, e.g. with-in-str) -> the overlay version.
|
|
(let ((overlay-line-seq (var-deref "clojure.core" "line-seq")))
|
|
(def-var! "clojure.core" "line-seq"
|
|
(lambda (rdr)
|
|
(if (reader-jhost? rdr) (chez-line-seq rdr) (jolt-invoke overlay-line-seq rdr)))))
|