6445f461bb
The dashboard's missing-portable category is now EMPTY (was 35 when the issue was filed; this session's io/leaf work had already landed most of them). The final seven: - extenders — ctx-capturing clojure.core fn over the protocol type-registry: the type-tags implementing a protocol, as symbols; nil when none - find-keyword — keyword: jolt keywords have no intern table, so it always finds (babashka makes the same call) - inst-ms* — the raw Inst method; one inst representation, so = inst-ms - read+string — over the 50-io readers, which now expose :buf and :fill-fn; returns [form exact-text-consumed], EOF throws or yields [eof-value ""] with the 3-arity, works for string AND stdin readers - with-local-vars — fresh free-standing var cells (__local-var seam) bound as locals; var-get/var-set work on any cell - with-open — canonical recursive expansion closing through the __close seam: a map-like value's :close fn or a host file (no .close interop here); nested closes run inner-first, finally runs on throw - with-precision — body evaluates with precision/:rounding accepted and ignored (doubles, no BigDecimal context) — documented divergence 30 new spec rows (test/spec/missing-vars-spec.janet); coverage.md regenerated: implemented+tested 426 -> 433, missing-portable 7 -> 0. Gate: jpm exit 0, all tests passed.
129 lines
4.3 KiB
Clojure
129 lines
4.3 KiB
Clojure
;; clojure.core — IO tier: the *in* reader family (jolt-0d9).
|
|
;;
|
|
;; *in* is a dynamic var holding a READER: a plain map whose two ops close
|
|
;; over their source — :read-line-fn (next line, newline
|
|
;; stripped, nil at EOF) and :read-fn (next FORM, advancing past exactly that
|
|
;; form; the eof sentinel at end of input). The default *in* reads real stdin
|
|
;; through the host seam __stdin-read-line, with a shared leftover buffer so
|
|
;; read and read-line interleave; with-in-str rebinds *in* to a string reader
|
|
;; over one atom-held buffer, so (read) consumes its form and a following
|
|
;; (read-line) returns the REST of that line — as in Clojure.
|
|
;;
|
|
;; Forms are parsed by the host seam __parse-next (one form + the rest of the
|
|
;; string, nil when only whitespace remains). Known wart shared with that
|
|
;; contract: input that is only a comment reads as nil rather than EOF.
|
|
|
|
(def ^:private reader-eof :jolt/reader-eof)
|
|
|
|
(defn __string-reader
|
|
"A reader over string s (the with-in-str expansion calls this)."
|
|
[s]
|
|
(let [buf (atom s)]
|
|
{:buf buf
|
|
:fill-fn nil
|
|
:read-line-fn
|
|
(fn []
|
|
(let [cur @buf]
|
|
(when (pos? (count cur))
|
|
(let [i (str-find "\n" cur)]
|
|
(if (nil? i)
|
|
(do (reset! buf "") cur)
|
|
(do (reset! buf (subs cur (inc i))) (subs cur 0 i)))))))
|
|
:read-fn
|
|
(fn []
|
|
(let [r (__parse-next @buf)]
|
|
(if (nil? r)
|
|
reader-eof
|
|
(do (reset! buf (nth r 1)) (nth r 0)))))}))
|
|
|
|
;; Real stdin, with a leftover buffer shared by read and read-line: read may
|
|
;; pull a whole line to parse a form and must hand the remainder to the next
|
|
;; read/read-line.
|
|
(def ^:private stdin-buf (atom ""))
|
|
|
|
(def ^:dynamic *in*
|
|
{:buf stdin-buf
|
|
:fill-fn (fn []
|
|
(let [line (__stdin-read-line)]
|
|
(if (nil? line)
|
|
false
|
|
(do (swap! stdin-buf (fn [b] (str b line "\n"))) true))))
|
|
:read-line-fn
|
|
(fn []
|
|
(let [cur @stdin-buf]
|
|
(if (pos? (count cur))
|
|
(let [i (str-find "\n" cur)]
|
|
(if (nil? i)
|
|
(do (reset! stdin-buf "") cur)
|
|
(do (reset! stdin-buf (subs cur (inc i))) (subs cur 0 i))))
|
|
(__stdin-read-line))))
|
|
:read-fn
|
|
(fn []
|
|
(loop []
|
|
(let [r (__parse-next @stdin-buf)]
|
|
(if (nil? r)
|
|
(let [line (__stdin-read-line)]
|
|
(if (nil? line)
|
|
reader-eof
|
|
(do (swap! stdin-buf (fn [b] (str b line "\n"))) (recur))))
|
|
(do (reset! stdin-buf (nth r 1)) (nth r 0))))))})
|
|
|
|
(defn read-line
|
|
"Reads the next line from the stream that is the current value of *in*.
|
|
Returns nil at EOF."
|
|
[]
|
|
((:read-line-fn *in*)))
|
|
|
|
(defn read
|
|
"Reads the next object from stream (defaults to *in*). At EOF, throws —
|
|
or returns eof-value when eof-error? is false."
|
|
([] (read *in*))
|
|
([stream]
|
|
(let [v ((:read-fn stream))]
|
|
(if (= v reader-eof)
|
|
(throw (ex-info "EOF while reading" {}))
|
|
v)))
|
|
([stream eof-error? eof-value]
|
|
(let [v ((:read-fn stream))]
|
|
(if (= v reader-eof)
|
|
(if eof-error? (throw (ex-info "EOF while reading" {})) eof-value)
|
|
v))))
|
|
|
|
(defmacro with-in-str
|
|
"Evaluates body with *in* bound to a fresh reader over string s."
|
|
[s & body]
|
|
`(binding [*in* (__string-reader ~s)]
|
|
~@body))
|
|
|
|
;; Like read, and also returns the exact text consumed for the form (leading
|
|
;; whitespace included). On EOF: throws, or returns [eof-value ""] when
|
|
;; eof-error? is false.
|
|
(defn read+string
|
|
([] (read+string *in*))
|
|
([stream] (read+string stream true nil))
|
|
([stream eof-error? eof-value]
|
|
(let [buf (get stream :buf)
|
|
fill (get stream :fill-fn)]
|
|
(loop []
|
|
(let [s (deref buf)
|
|
r (__parse-next s)]
|
|
(if (nil? r)
|
|
(if (and fill (fill))
|
|
(recur)
|
|
(if eof-error?
|
|
(throw (ex-info "EOF while reading" {}))
|
|
[eof-value ""]))
|
|
(do (reset! buf (nth r 1))
|
|
[(nth r 0) (subs s 0 (- (count s) (count (nth r 1))))])))))))
|
|
|
|
(defn line-seq
|
|
"Returns the lines of text from rdr as a lazy sequence of strings, as by
|
|
read-line. (Jolt extension kept from the old kernel stub: a plain string
|
|
splits into its lines.)"
|
|
[rdr]
|
|
(if (string? rdr)
|
|
(seq (str-split "\n" rdr))
|
|
(lazy-seq
|
|
(let [line ((:read-line-fn rdr))]
|
|
(when line
|
|
(cons line (line-seq rdr)))))))
|